reviews_index_query_spec.rb

require 'spec_helper'

describe ReviewsIndexQuery do

  let(:user)     { create(:user) }
  let(:facility) { user.facility }

  let(:p1)       { create(:patient,
                           facility: facility,
                           mrn: '111',
                           unit: 'A',
                           first_name: 'A',
                           last_name: '1') }

  let(:p2)       { create(:patient,
                           facility: facility,
                           mrn: '222',
                           unit: 'A',
                           first_name: 'B',
                           last_name: '2') }

  let(:p3)       { create(:patient,
                           facility: facility,
                           mrn: '333',
                           unit: 'B',
                           first_name: 'C',
                           last_name: '3') }

  let(:m1)       { create(:measure, facility: facility, name: 'm1') }
  let(:m2)       { create(:measure, facility: facility, name: 'm2') }
  let(:m3)       { create(:measure, facility: facility, name: 'n3')}

  def patients
    [p1, p2, p3]
  end

  before(:each) do
    create(:survey, patient: p1, measure_ids: [m1.id])
    create(:survey, patient: p2, measure_ids: [m2.id])
    create(:survey, patient: p3, measure_ids: [m3.id])

    facility.update_attribute(:units, ['A', 'B'])
  end

  def query(user, params)
    ReviewsIndexQuery.new(user, params).run
  end

  def params(overrides={})
    {
      'sEcho'          => '1',
      'iColumns'       => '7',
      'sColumns'       => 'name,measures,mrn,unit,location,reviews_count,last_reviewed_at,actions',
      'iDisplayStart'  => '0',
      'iDisplayLength' => '3',
      'iSortingCols'   => '0'
    }.merge(overrides)
  end

  describe 'scoping' do
    it 'scopes to user' do
      patients.each { |p| expect(query(user, params)).to include p }
    end

    it 'excludes for alien' do
      alien = create(:user)
      expect(query(alien, params)).to be_empty
    end
  end

  context 'patients without surveys' do
    before(:each) do
      p1.survey.destroy
    end

    it 'excludes patients without measures' do
      expect(query(user, params)).to eq [p2, p3]
    end
  end

  context 'discharged patients' do
    before(:each) do
      TrashService.new(p1).trash
    end

    it 'excludes discharged patients' do
      expect(query(user, params)).to eq [p2, p3]
    end
  end

  describe 'sorting' do

    describe 'default ordering' do
      before(:each) do
        p1.update_column(:last_name, 'ZZZZZZZZ')
        p2.update_column(:last_name, 'ZZZZZZZZ')

        p1.update_column(:first_name, 'B')
        p2.update_column(:first_name, 'A')
      end

      it 'sorts by name' do
        results = query(user, params)
        expect(results).to eq [p3, p2, p1]
      end
    end

    describe 'by one column' do
      let(:base) { { 'iSortingCols' => '1', 'iSortCol_0' => '2' } }

      it 'sorts in ascending order' do
        results = query(user, params(base.merge('sSortDir_0' => 'asc')))
        expect(results).to eq [p1, p2, p3]
      end

      it 'sorts in descending order' do
        results = query(user, params(base.merge('sSortDir_0' => 'desc')))
        expect(results).to eq [p3, p2, p1]
      end
    end

    describe 'by multiple columns' do
      let(:base) { { 'iSortingCols' => '2', 'iSortCol_0' => '3', 'iSortCol_1' => '2' } }

      it 'sorts properly' do
        results = query(user, params(base.merge('sSortDir_0' => 'asc', 'sSortDir_1' => 'desc')))
        expect(results).to eq [p2, p1, p3]
      end
    end

    describe 'by name' do
      let(:base) { { 'iSortingCols' => '1', 'iSortCol_0' => '0' } }

      it 'works' do
        results = query(user, params(base.merge('sSortDir_0' => 'desc')))
        expect(results).to eq [p3, p2, p1]
      end
    end

    describe 'by measures' do
      let(:base) { { 'iSortingCols' => '1', 'iSortCol_0' => '1' } }

      it 'works' do
        results = query(user, params(base.merge('sSortDir_0' => 'desc')))
        expect(results).to eq [p3, p2, p1]
      end
    end

  end

  describe 'pagination' do
    it 'gets the first page' do
      results = query(user, params.merge('iDisplayLength' => '1'))
      expect(results).to eq [p1]
    end

    it 'gets the second page' do
      results = query(user, params.merge('iDisplayLength' => '1', 'iDisplayStart' => '1'))
      expect(results).to eq [p2]
    end
  end

  describe 'filtering' do
    describe 'by mrn' do
      before(:each) do
        p1.update_column(:mrn, 'abc')
        p2.update_column(:mrn, 'cde')
      end

      it 'fitlers (case-insensitive)' do
        results = query(user, params('sSearch_2' => 'AbC')).to_a
        expect(results).to eq [p1]
      end

      describe 'counting' do
        let(:q) { PatientsIndexQuery.new(user, params.merge('sSearch_2' => 'c')) }

        it 'counts total records' do
          expect(q.total).to eq 3
        end

        it 'counts filtered records' do
          expect(q.total_filtered).to eq 2
        end
      end
    end

    describe 'by name' do
      it 'filters by first name' do
        results = query(user, params.merge('sSearch_0' => 'A')).to_a
        expect(results).to eq [p1]
      end
      
      it 'filters by last name' do
        results = query(user, params.merge('sSearch_0' => '3')).to_a
        expect(results).to eq [p3]
      end

      it 'filters by full name' do
        results = query(user, params.merge('sSearch_0' => '2, B')).to_a
        expect(results).to eq [p2]
      end
    end

    describe 'by measures' do

      it 'filters exactly' do
        results = query(user, params('sSearch_1' => 'm2')).to_a
        expect(results).to eq [p2]
      end

      it 'filters by a partial match (case-insensitive)' do
        results = query(user, params('sSearch_1' => 'm')).to_a
        expect(results).to eq [p1, p2]
      end

      context 'with reviews' do
        let(:r1) { build(:review_without_review_measures, user: user, patient: p1) }
        let(:r2) { build(:review_without_review_measures, user: user, patient: p2) }

        before(:each) do
          r1.review_measures << build(:review_measure, review: r1, measure: m2)
          r2.review_measures << build(:review_measure, review: r2, measure: m1)

          [r1, r2].each do |review|
            review.save!
          end
        end

        it 'filters by measure name' do
          results = query(user, params('sSearch_1' => 'm2')).to_a
          expect(results).to eq [p1]
        end

        it 'filters by last review date' do
          results = query(user, params('sSearch_6' => '2001')).to_a
          expect(results).to be_empty
        end
      end
    end
  end

  describe 'filtering access by unit' do
    it 'shows all patients by default' do
      expect(query(user, params)).to eq [p1, p2, p3]
    end

    it 'filters by unit when available' do
      user.active_facility_role.update_attribute(:units, ['A'])
      expect(query(user, params)).to eq [p1, p2]
    end
  end

end