has_helpers 5.0.2

data/spec/lib/has_helpers/data_migration/model_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::Model, type: :model do
+  describe "#klass" do
+    it "constantizes the class_name" do
+      stub_const("TestMigrationClass", Class.new)
+      model = described_class.new(class_name: "TestMigrationClass")
+
+      expect(model.klass).to eq(TestMigrationClass)
+    end
+
+    it "returns nil if class_name is invalid" do
+      model = described_class.new(class_name: "Invalid::ClassName")
+
+      expect(model.klass).to be_nil
+    end
+  end
+
+  describe "#exceeded_expected_duration?" do
+    let(:migration_class) { Class.new { def self.expected_duration; 60; end } }
+
+    before do
+      stub_const("TestMigrationClass", migration_class)
+    end
+
+    it "returns false if started_at is blank" do
+      model = described_class.new(class_name: "TestMigrationClass", started_at: nil)
+
+      expect(model.exceeded_expected_duration?).to be false
+    end
+
+    it "returns true if duration exceeded" do
+      model = described_class.new(
+        class_name: "TestMigrationClass",
+        started_at: 2.hours.ago
+      )
+
+      expect(model.exceeded_expected_duration?).to be true
+    end
+
+    it "returns false if duration not exceeded" do
+      model = described_class.new(
+        class_name: "TestMigrationClass",
+        started_at: 30.seconds.ago
+      )
+
+      expect(model.exceeded_expected_duration?).to be false
+    end
+  end
+end

data/spec/lib/has_helpers/data_migration/small_worker_spec.rb

@@ -0,0 +1,34 @@
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::SmallWorker, type: :job do
+  let(:dummy_class) do
+    Class.new do
+      def internal_run; end
+    end
+  end
+
+  let(:class_name) { "DummyMigrationClass" }
+
+  before do
+    stub_const(class_name, dummy_class)
+  end
+
+  it "calls internal_run on the given class" do
+    instance = instance_double(dummy_class)
+    allow(dummy_class).to receive(:new).and_return(instance)
+    expect(instance).to receive(:internal_run)
+
+    described_class.perform_now(class_name)
+  end
+
+  it "is enqueued in the data_migrations_small queue" do
+    expect(described_class.queue_name).to eq("data_migrations_small")
+  end
+
+  it "has concurrency limit configured" do
+    concurrency = described_class.good_job_concurrency_config
+
+    expect(concurrency[:perform_limit]).to eq(5)
+    expect(concurrency[:key]).to eq("data_migration-small")
+  end
+end

data/spec/lib/has_helpers/good_job/notification_alert_cleanup_worker_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe HasHelpers::GoodJob::NotificationAlertCleanupWorker, type: :job do
+  
+  describe '#perform' do
+    context 'when there are old alerts to clean up' do
+      let(:old_alerts_relation) { double('old_alerts_relation') }
+      let(:mock_alerts) { [double('alert1', id: 1), double('alert2', id: 2)] }
+      
+      before do
+        allow(HasHelpers::NotificationAlert).to receive(:where)
+          .with("created_at < ?", anything)
+          .and_return(old_alerts_relation)
+        
+        allow(old_alerts_relation).to receive(:count).and_return(2)
+        allow(old_alerts_relation).to receive(:find_in_batches).with(batch_size: 100)
+          .and_yield(mock_alerts)
+        
+        allow(HasHelpers::NotificationAlert).to receive(:where)
+          .with(id: [1, 2])
+          .and_return(double('delete_relation', delete_all: 2))
+        
+        allow(Rails.logger).to receive(:info)
+      end
+
+      it 'removes alerts older than 1 month' do
+        expect(HasHelpers::NotificationAlert).to receive(:where)
+          .with("created_at < ?", anything)
+        expect(old_alerts_relation).to receive(:find_in_batches).with(batch_size: 100)
+        expect(HasHelpers::NotificationAlert).to receive(:where)
+          .with(id: [1, 2])
+        
+        subject.perform
+      end
+
+      it 'logs the cleanup process' do
+        expect(Rails.logger).to receive(:info).with(/Starting cleanup/)
+        expect(Rails.logger).to receive(:info).with(/Found 2 notification alerts/)
+        expect(Rails.logger).to receive(:info).with(/Deleted batch of 2 notification alerts/)
+        expect(Rails.logger).to receive(:info).with(/Successfully cleaned up/)
+        
+        subject.perform
+      end
+    end
+
+    context 'when there are no old alerts' do
+      let(:empty_alerts_relation) { double('empty_alerts_relation') }
+      
+      before do
+        allow(HasHelpers::NotificationAlert).to receive(:where)
+          .with("created_at < ?", anything)
+          .and_return(empty_alerts_relation)
+        
+        allow(empty_alerts_relation).to receive(:count).and_return(0)
+        allow(Rails.logger).to receive(:info)
+      end
+
+      it 'does not remove any alerts' do
+        expect(empty_alerts_relation).not_to receive(:find_in_batches)
+        
+        subject.perform
+      end
+
+      it 'logs that no alerts were found' do
+        expect(Rails.logger).to receive(:info).with(/No old notification alerts found/)
+        
+        subject.perform
+      end
+    end
+
+    context 'when an error occurs' do
+      before do
+        allow(HasHelpers::NotificationAlert).to receive(:where)
+          .with("created_at < ?", anything)
+          .and_raise(StandardError.new("Database error"))
+        allow(Rails.logger).to receive(:error)
+      end
+
+      it 'logs the error and re-raises it' do
+        expect(Rails.logger).to receive(:error).with(/Error cleaning up notification alerts/)
+        expect(Rails.logger).to receive(:error).with(anything)
+        
+        expect { subject.perform }.to raise_error(StandardError, "Database error")
+      end
+    end
+  end
+end 

data/spec/lib/has_helpers/hash_accessors_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'rails_helper'
+
+describe ::HasHelpers::HashAccessors do
+  let(:klass) do
+    Class.new do
+      extend ::HasHelpers::HashAccessors
+      attr_accessor :settings, :colors
+
+      setting_attr_accessor :search_provider
+      hash_attr_accessor :header_bg, :header_font, :source => :colors
+    end
+  end
+  subject { klass.new }
+
+  context "accessor called when underlying store is nil" do
+    it "returns nil" do
+      expect(subject.search_provider).to be_nil
+    end
+
+    it "does NOT set the underlying store to an empty hash" do
+      subject.search_provider
+      expect(subject.settings).to be_nil
+    end
+  end
+
+  context "accessor assignment" do
+    it "should be set to the default store" do
+      subject.search_provider = :derp
+      expect(subject.settings).to eq({ "search_provider" => :derp })
+    end
+
+    it "should be set to the specified store" do
+      subject.header_bg = "#011134"
+      expect(subject.colors).to eq({ "header_bg" => "#011134" })
+    end
+
+    it "should remove key when set to nil" do
+      subject.header_bg = "#0123FF"
+      expect(subject.colors.keys).to include("header_bg")  # Assertion
+
+      subject.header_bg = nil
+      expect(subject.colors.keys).to_not include("header_bg")  # Assertion
+    end
+
+    it "should remove key when set to a blank value" do
+      subject.header_bg = "#0123FF"
+      expect(subject.colors.keys).to include("header_bg")  # Assertion
+
+      subject.header_bg = ""
+      expect(subject.colors.keys).to_not include("header_bg")  # Assertion
+    end
+  end
+
+  context "accessor reads" do
+    it "should work" do
+      subject.search_provider = :derp
+      expect(subject.search_provider).to eq(:derp)
+    end
+
+    it "should still work" do
+      subject.header_font = "#CCC"
+      expect(subject.header_font).to eq("#CCC")
+    end
+  end
+end

data/spec/lib/has_helpers/index_spec.rb

@@ -0,0 +1,442 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe ::HasHelpers::Index, elasticsearch: true do
+  describe ".search" do
+    before(:all) do
+      ::AdvisorIndex.reindex
+      ::FirmIndex.reindex
+      ::PolicyIndex.reindex
+      ::ContractIndex.reindex
+      @organization = ::FactoryBot.create(:organization)
+    end
+
+    let(:organization) { @organization }
+
+    def search_klass(klass, query, where: {}, results_only: true, show_inactive: nil)
+      searchkick_results = klass.search(query, where: { organization_id: organization.id, **where }, show_inactive: show_inactive)
+
+      results_only ? searchkick_results.results : searchkick_results
+    end
+
+    def search_advisors(*args, **options)
+      search_klass(::AdvisorIndex, *args, **options)
+    end
+
+    def search_firms(*args, **options)
+      search_klass(::FirmIndex, *args, **options)
+    end
+
+    def search_policies(*args, **options)
+      search_klass(::PolicyIndex, *args, **options)
+    end
+
+    def search_contracts(*args, **options)
+      search_klass(::ContractIndex, *args, **options)
+    end
+
+    context "scoped organization" do
+      before(:all) do
+        AdvisorIndex.clean!
+        @advisor1 = ::FactoryBot.create(:advisor, name: "Matt", code_name: "matthew", organization: @organization)
+        @advisor2 = ::FactoryBot.create(:advisor, name: "Matt", code_name: "foo")
+        AdvisorIndex.refresh
+      end
+
+      let(:advisor1) { @advisor1 }
+      let(:advisor2) { @advisor2 }
+
+      it "scopes the org id" do
+        results = search_advisors(advisor1.name).map(&:name)
+        expect(results).to contain_exactly(advisor1.name)
+      end
+
+      it "doesn't overwrite the org id filter when using a custom where" do
+        where = {
+          _and: [
+            {
+              _or: [
+                { code_name: advisor1.code_name },
+                { code_name: advisor2.code_name }
+              ]
+            }
+          ]
+        }
+
+        results = search_advisors(advisor1.name, where: where).map(&:name)
+        expect(results).to contain_exactly(advisor1.name)
+      end
+    end
+
+    it "doesn't error when searching" do
+      searchkick_results = search_advisors("abc" * 20, results_only: false)
+      aggregate_failures do
+        expect(searchkick_results.results).to be_empty
+        expect(searchkick_results.total_entries).to be 0
+        expect(searchkick_results.total_pages).to be 0
+      end
+    end
+
+    context "When the search term breaks up into tokens greater than the max ngram size" do
+      let(:advisor_name) { ::Faker::Alphanumeric.alpha(number: described_class::MAX_NGRAM_SIZE + 1) }
+      let!(:advisor) { ::FactoryBot.create(:advisor, name: advisor_name, organization: organization) }
+
+      it "finds results for exact matches" do
+        AdvisorIndex.refresh
+        where = { organization_id: organization.id }
+        search_result = ::AdvisorIndex.search(advisor_name, where: where).results.first
+        expect(search_result).not_to be_nil
+        expect(search_result.id.to_i).to eq(advisor.id.to_i)
+      end
+    end
+
+    context "at (@)" do
+      before(:all) do
+        AdvisorIndex.clean!
+        @advisor1 = ::FactoryBot.create(:advisor, name: "Matt", code_name: "marketing@gmail.com", organization: @organization)
+        @advisor2 = ::FactoryBot.create(:advisor, name: "Matt 2", code_name: "matt@gmail.com", organization: @organization)
+        @advisor3 = ::FactoryBot.create(:advisor, name: "Some A Email", organization: @organization)
+        @advisor4 = ::FactoryBot.create(:advisor, name: "Some Advisor", code_name: "advisor@someemail.com", organization: @organization)
+        AdvisorIndex.refresh
+      end
+
+      it "boosts when there is a classic match" do
+        results = search_advisors("matt@gmail").map(&:name)
+        expect(results).to eq [@advisor2.name, @advisor1.name]
+      end
+
+      it "boosts when there is a name match" do
+        results = search_advisors("matt").map(&:name)
+        expect(results).to eq [@advisor1.name, @advisor2.name]
+      end
+
+      it "finds matches using the standard tokenizer" do
+        results = search_advisors("matt gmail").map(&:name)
+        expect(results).to eq [@advisor2.name, @advisor1.name]
+      end
+
+      it "still prioritizes name matches when the query has multiple words" do
+        ::HasHelpers::Feature.activate!(:classic_name_search, @organization) # TODO Remove when the feature flag is removed.
+        results = search_advisors("some email").map(&:name)
+        expect(results).to eq [@advisor3.name, @advisor4.name]
+      end
+    end
+
+    context "hyphen (-)" do
+      before(:all) do
+        AdvisorIndex.clean!
+        @advisor = ::FactoryBot.create(:advisor, code_name: "0123456789", organization: @organization)
+        AdvisorIndex.refresh
+      end
+
+      it "partially matches" do
+        results = search_advisors("123456").map(&:name)
+        expect(results).to contain_exactly(@advisor.name)
+      end
+
+      it "removes dashes" do
+        results = search_advisors("123-456").map(&:name)
+        expect(results).to contain_exactly(@advisor.name)
+      end
+    end
+
+    context "ampersand (&)" do
+      before(:all) do
+        AdvisorIndex.clean!
+        ::FactoryBot.create(:advisor, name: "MM", organization: @organization)
+        ::FactoryBot.create(:advisor, name: "M&M", organization: @organization)
+
+        AdvisorIndex.refresh
+      end
+
+      it do
+        results = search_advisors("m&m").map(&:name)
+        expect(results).to eq ["M&M", "MM"]
+      end
+
+      it do
+        results = search_advisors("mm").map(&:name)
+        expect(results).to eq ["MM"]
+      end
+    end
+
+    context "analyzers" do
+      context "keyword_index" do
+        before(:all) do
+          ::FactoryBot.create(:advisor, name: "Bob", code_name: "MVP", organization: @organization)
+          ::FactoryBot.create(:advisor, name: "Jim Bob", code_name: "MVP", organization: @organization)
+
+          AdvisorIndex.refresh
+        end
+
+        it "finds an exact match with quotes" do
+          results = search_advisors('MVP "bob"').map(&:name)
+          expect(results).to contain_exactly("Bob")
+        end
+
+        it "works without quotes" do
+          results = search_advisors("MVP bob").map(&:name)
+          expect(results).to contain_exactly("Bob", "Jim Bob")
+        end
+      end
+
+      context "searchkick_word_middle_index" do
+        before(:all) do
+          @advisor = ::FactoryBot.create(:advisor, organization: @organization)
+
+          AdvisorIndex.refresh
+        end
+
+        let(:advisor) { @advisor }
+
+        shared_examples "advisor fragment search" do |args|
+          it "should match" do
+            results = search_advisors(advisor.name.slice(args[:fragment])).map(&:name)
+            expect(results).to contain_exactly(advisor.name)
+          end
+        end
+
+        it_should_behave_like "advisor fragment search", fragment: 0..-1
+        it_should_behave_like "advisor fragment search", fragment: 0..2
+        it_should_behave_like "advisor fragment search", fragment: 2..-2
+      end
+    end
+
+    context "Index search filter" do
+      before(:all) do
+        ::AdvisorIndex.clean!
+        ::FirmIndex.clean!
+        @active_advisor = ::FactoryBot.create(:advisor, organization: @organization)
+        @inactive_advisor = ::FactoryBot.create(:advisor, :inactive, organization: @organization)
+        @firm_with_unset_dates = ::FactoryBot.create(:firm, organization: @organization)
+        @firm_with_invalid_end_date = ::FactoryBot.create(:firm, :with_invalid_end_date, organization: @organization)
+        @firm_with_invalid_start_date = ::FactoryBot.create(:firm, :with_invalid_start_date, organization: @organization)
+        @invalid_firm = ::FactoryBot.create(:firm, :with_invalid_end_date, :with_invalid_start_date, organization: @organization)
+        @valid_firm = ::FactoryBot.create(:firm, :with_valid_dates, organization: @organization)
+        AdvisorIndex.refresh
+        FirmIndex.refresh
+      end
+
+      let(:active_advisor) { @active_advisor }
+      let(:inactive_advisor) { @inactive_advisor }
+      let(:firm_with_unset_dates) { @firm_with_unset_dates }
+      let(:firm_with_invalid_end_date) { @firm_with_invalid_end_date }
+      let(:firm_with_invalid_start_date) { @firm_with_invalid_start_date }
+      let(:invalid_firm) { @invalid_firm }
+      let(:valid_firm) { @valid_firm }
+
+      context "When the table has an is_inactive column" do
+        it "should return active records" do
+          results = search_advisors(active_advisor.name)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(active_advisor.id)
+        end
+
+        it "should not return inactive records if the show_inactive option is not set" do
+          results = search_advisors(inactive_advisor.name)
+          expect(results.count).to eq(0)
+        end
+
+        it "should return inactive records if the show_inactive option is set" do
+          results = search_advisors(inactive_advisor.name, show_inactive: true)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(inactive_advisor.id)
+        end
+      end
+
+      context "When the table has start_date and end_date columns" do
+        it "should not return results with an invalid start date if show_inactive is not set" do
+          results = search_firms(firm_with_invalid_start_date.name)
+          expect(results.count).to eq(0)
+
+          results = search_firms(invalid_firm.name)
+          expect(results.count).to eq(0)
+        end
+
+        it "should not return results with an invalid end_date if show_inactive is not set" do
+          results = search_firms(firm_with_invalid_end_date.name)
+          expect(results.count).to eq(0)
+
+          results = search_firms(invalid_firm.name)
+          expect(results.count).to eq(0)
+        end
+
+        it "should return results with valid dates" do
+          results = search_firms(valid_firm.name)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(valid_firm.id)
+        end
+
+        it "should return results with unset dates" do
+          results = search_firms(firm_with_unset_dates.name)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(firm_with_unset_dates.id)
+        end
+
+        it "should return results with invalid dates if the show_inactive option is set" do
+          results = search_firms(firm_with_invalid_end_date.name, show_inactive: true)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(firm_with_invalid_end_date.id)
+
+          results = search_firms(firm_with_invalid_start_date.name, show_inactive: true)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(firm_with_invalid_start_date.id)
+
+          results = search_firms(invalid_firm.name, show_inactive: true)
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(invalid_firm.id)
+        end
+      end
+
+      context "When the table does not have is_inactive, start_date, or end_date columns" do
+        before(:all) do
+          @policy = ::FactoryBot.create(:policy, name: "Arbitrary Policy", organization: @organization)
+          PolicyIndex.refresh
+        end
+
+        let(:policy) { @policy }
+
+        it "should not filter any results" do
+          results = search_policies("Arbitrary Policy")
+          expect(results.count).to eq(1)
+          expect(results.first[:_id].to_i).to eq(policy.id)
+        end
+      end
+    end
+
+    context "when an index has dependencies" do
+      let(:new_value) { ::Faker::Alphanumeric.alphanumeric(number: 7) }
+
+      context "when the index's dependencies specify dependent attributes" do
+
+        before(:all) do
+          ::ContractIndex.clean!
+          @demographic = ::FactoryBot.create(:demographic, organization: @organization)
+          @advisor = ::FactoryBot.create(:advisor, demographic:@demographic, organization: @organization)
+          @contract = ::FactoryBot.create(:contract, advisor:@advisor, organization: @organization)
+          ::ContractIndex.refresh
+        end
+
+        let(:contract) { @contract }
+        let(:advisor) { contract.advisor }
+        let(:advisor_demographic) { advisor.demographic }
+
+        it "should reindex when a dependent attribute is changed" do
+          allow(::Advisor).to receive(:find_by).with(id: advisor.id).and_return(advisor)
+          expect(advisor).to receive(:reindex)
+          contract.update!(writing_number: new_value)
+        end
+
+        it "should reindex when an attribute is changed in a dependency_inheritance" do
+          expect_any_instance_of(::Contract).to receive(:reindex)
+          advisor_demographic.update!(nickname: "nickname")
+        end
+
+        it "should not reindex when a non-dependent attribute is changed" do
+          allow(::Advisor).to receive(:find_by).with(id: advisor.id).and_return(advisor)
+          expect(advisor).not_to receive(:reindex)
+          contract.update!(note: new_value)
+        end
+
+        it "should not reindex when a non-dependent attribute is changed within a dependency_inheritance" do
+          allow(::Contract).to receive(:find_by).with(id: contract.id).and_return(contract)
+          expect(contract).not_to receive(:reindex)
+          advisor_demographic.update!(title: new_value)
+        end
+      end
+
+      context "when the index's dependencies specify a 'to' column" do
+        let!(:import) { ::FactoryBot.create(:import) }
+        let(:advisor) { import.advisor }
+
+        it "should use the 'to' column as the key to search for the record to reindex" do
+          allow(::Advisor).to receive(:find_by).with(import_key: advisor.import_key).and_return(advisor)
+          expect(advisor).to receive(:reindex)
+          import.update!(note: new_value)
+        end
+      end
+
+      context "when the index's dependencies specify a 'from' column" do
+        let!(:user) { ::FactoryBot.create(:user, :with_linked_advisor) }
+        let(:linked_advisor) { user.linked_advisor }
+
+        it "should use the 'from' column as the foreign key to get the record id" do
+          allow(::Advisor).to receive(:find_by).with(id: linked_advisor.id).and_return(linked_advisor)
+          expect(linked_advisor).to receive(:reindex)
+          user.update!(name: new_value)
+        end
+      end
+
+      context "when the index's dependencies don't have conditions" do
+        let!(:policy_note) { ::FactoryBot.create(:policy_note, organization: organization) }
+        let(:policy) { policy_note.policy }
+
+        it "should reindex whenever the dependency is updated" do
+          allow(::Policy).to receive(:find_by).with(id: policy.id).and_return(policy)
+          expect(policy).to receive(:reindex)
+          policy_note.update!(note: new_value)
+        end
+      end
+    end
+
+    context "when searching with keywords" do
+      before(:all) do
+        ::HasHelpers::Feature.activate!(:keyword_search, @organization) # TODO Remove when the feature flag is removed.
+        ::AdvisorIndex.clean!
+        @advisor1 = ::FactoryBot.create(:advisor, organization: @organization, code_name: "qwerty", npn: 102938475)
+        @advisor2 = ::FactoryBot.create(:advisor, organization: @organization, name: "qwerty", npn: 943152760)
+        @advisor3 = ::FactoryBot.create(:advisor, organization: @organization, code_name: "azerty", npn: 721906345)
+        string_length = ::HasHelpers::Index::MAX_NGRAM_SIZE + 1
+        code_name = ::Faker::Alphanumeric.alphanumeric(number: string_length)
+        name = ::Faker::Alphanumeric.alphanumeric(number: string_length)
+        @advisor4 = ::FactoryBot.create(:advisor, organization: @organization, code_name: code_name, name: name)
+
+        ::AdvisorIndex.refresh
+      end
+      let(:advisor1) { @advisor1 }
+      let(:advisor2) { @advisor2 }
+      let(:advisor3) { @advisor3 }
+      let(:advisor4) { @advisor4 }
+
+      it "should only search in the fields given" do
+        results = search_advisors("code_name:qwe").map(&:id)
+        expect(results.count).to eq(1)
+        expect(results.first).to eq(advisor1.id.to_s)
+      end
+
+      it "should handle integer columns as text" do
+        results = search_advisors("npn:102938475").map(&:id)
+        expect(results.count).to eq(1)
+        expect(results.first).to eq(advisor1.id.to_s)
+      end
+
+      it "should only return results that match all columns when searching multiple columns" do
+        results = search_advisors("code_name:erty").map(&:id)
+        expect(results.count).to eq(2)
+        expect(results).to contain_exactly(advisor1.id.to_s, advisor3.id.to_s)
+
+        results = search_advisors("code_name:erty npn:1029").map(&:id)
+        expect(results.count).to eq(1)
+        expect(results.first).to eq(advisor1.id.to_s)
+      end
+
+      it "doesn't treat queries with : characters as keyword queries when they aren't preceded by an actual field name" do
+        query_string = "non_existent_field:term"
+        expect(::HasHelpers::Index.is_keyword_query?(query_string)).to be false
+      end
+
+      it "should skip fields that aren't in the index" do
+        results = search_advisors("code_name:erty non_existent_field:term").map(&:id)
+        expect(results.count).to eq(2)
+        expect(results).to contain_exactly(advisor1.id.to_s, advisor3.id.to_s)
+      end
+
+      it "finds exact matches for terms that are longer than the max ngram size" do
+        results = search_advisors("code_name: #{advisor4.code_name} name:#{advisor4.name}").map(&:id)
+        expect(results.count).to eq(1)
+        expect(results.first).to eq(advisor4.id.to_s)
+      end
+    end
+  end
+end