chewy 7.2.4 → 7.6.0

data/spec/chewy/search/request_spec.rb

@@ -314,6 +314,18 @@ describe Chewy::Search::Request do
     end
   end
 
+  %i[collapse knn].each do |name|
+    describe "##{name}" do
+      specify { expect(subject.send(name, foo: {bar: 42}).render[:body]).to include(name => {'foo' => {bar: 42}}) }
+      specify do
+        expect(subject.send(name, foo: {bar: 42}).send(name, moo: {baz: 43}).render[:body])
+          .to include(name => {'moo' => {baz: 43}})
+      end
+      specify { expect(subject.send(name, foo: {bar: 42}).send(name, nil).render[:body]).to be_blank }
+      specify { expect { subject.send(name, foo: {bar: 42}) }.not_to change { subject.render } }
+    end
+  end
+
   describe '#docvalue_fields' do
     specify { expect(subject.docvalue_fields(:foo).render[:body]).to include(docvalue_fields: ['foo']) }
     specify do
@@ -807,6 +819,31 @@ describe Chewy::Search::Request do
           request: {index: ['products'], body: {query: {match: {name: 'name3'}}}, refresh: false}
         )
       end
+
+      it 'delete records asynchronously' do
+        outer_payload = nil
+        ActiveSupport::Notifications.subscribe('delete_query.chewy') do |_name, _start, _finish, _id, payload|
+          outer_payload = payload
+        end
+        subject.query(match: {name: 'name3'}).delete_all(
+          refresh: false,
+          wait_for_completion: false,
+          requests_per_second: 10.0,
+          scroll_size: 2000
+        )
+        expect(outer_payload).to eq(
+          index: ProductsIndex,
+          indexes: [ProductsIndex],
+          request: {
+            index: ['products'],
+            body: {query: {match: {name: 'name3'}}},
+            refresh: false,
+            wait_for_completion: false,
+            requests_per_second: 10.0,
+            scroll_size: 2000
+          }
+        )
+      end
     end
 
     describe '#response=' do

data/spec/chewy/search_spec.rb

@@ -48,6 +48,10 @@ describe Chewy::Search do
           filter { match name: "Name#{index}" }
         end
 
+        def self.by_rating_with_kwargs(value, options:) # rubocop:disable Lint/UnusedMethodArgument
+          filter { match rating: value }
+        end
+
         index_scope City
         field :name, type: 'keyword'
         field :rating, type: :integer
@@ -114,5 +118,10 @@ describe Chewy::Search do
     specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex]) }
     specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
     specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex]) }
+
+    specify 'supports keyword arguments' do
+      expect(CitiesIndex.by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+      expect(CitiesIndex.order(:name).by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+    end
   end
 end

data/spec/chewy/strategy/active_job_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if defined?(::ActiveJob)
+if defined?(ActiveJob)
   describe Chewy::Strategy::ActiveJob do
     around do |example|
       active_job_settings = Chewy.settings[:active_job]
@@ -9,12 +9,12 @@ if defined?(::ActiveJob)
       Chewy.settings[:active_job] = active_job_settings
     end
     before(:all) do
-      ::ActiveJob::Base.logger = Chewy.logger
+      ActiveJob::Base.logger = Chewy.logger
     end
     before do
-      ::ActiveJob::Base.queue_adapter = :test
-      ::ActiveJob::Base.queue_adapter.enqueued_jobs.clear
-      ::ActiveJob::Base.queue_adapter.performed_jobs.clear
+      ActiveJob::Base.queue_adapter = :test
+      ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+      ActiveJob::Base.queue_adapter.performed_jobs.clear
     end
 
     before do
@@ -39,7 +39,7 @@ if defined?(::ActiveJob)
       Chewy.strategy(:active_job) do
         [city, other_city].map(&:save!)
       end
-      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(enqueued_job[:job]).to eq(Chewy::Strategy::ActiveJob::Worker)
       expect(enqueued_job[:queue]).to eq('low')
     end
@@ -48,12 +48,12 @@ if defined?(::ActiveJob)
       Chewy.strategy(:active_job) do
         [city, other_city].map(&:save!)
       end
-      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(enqueued_job[:queue]).to eq('low')
     end
 
     specify do
-      ::ActiveJob::Base.queue_adapter = :inline
+      ActiveJob::Base.queue_adapter = :inline
       expect { [city, other_city].map(&:save!) }
         .to update_index(CitiesIndex, strategy: :active_job)
         .and_reindex(city, other_city).only

data/spec/chewy/strategy/atomic_no_refresh_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chewy::Strategy::AtomicNoRefresh, :orm do
+  around { |example| Chewy.strategy(:bypass) { example.run } }
+
+  before do
+    stub_model(:country) do
+      update_index('countries') { self }
+    end
+
+    stub_index(:countries) do
+      index_scope Country
+    end
+  end
+
+  let(:country) { Country.create!(name: 'hello', country_code: 'HL') }
+  let(:other_country) { Country.create!(name: 'world', country_code: 'WD') }
+
+  specify do
+    expect { [country, other_country].map(&:save!) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_reindex(country, other_country).only.no_refresh
+  end
+
+  specify do
+    expect { [country, other_country].map(&:destroy) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_delete(country, other_country).only.no_refresh
+  end
+
+  context do
+    before do
+      stub_index(:countries) do
+        index_scope Country
+        root id: -> { country_code }
+      end
+    end
+
+    specify do
+      expect { [country, other_country].map(&:save!) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect { [country, other_country].map(&:destroy) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_delete('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect do
+        country.save!
+        other_country.destroy
+      end
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL').and_delete('WD').only.no_refresh
+    end
+  end
+end

data/spec/chewy/strategy/delayed_sidekiq_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+if defined?(Sidekiq)
+  require 'sidekiq/testing'
+  require 'redis'
+
+  describe Chewy::Strategy::DelayedSidekiq do
+    around do |example|
+      Chewy.strategy(:bypass) { example.run }
+    end
+
+    before do
+      redis = Redis.new
+      allow(Sidekiq).to receive(:redis).and_yield(redis)
+      Sidekiq::Worker.clear_all
+      described_class.clear_timechunks!
+    end
+
+    before do
+      stub_model(:city) do
+        update_index('cities') { self }
+      end
+
+      stub_index(:cities) do
+        index_scope City
+      end
+    end
+
+    let(:city) { City.create!(name: 'hello') }
+    let(:other_city) { City.create!(name: 'world') }
+
+    it 'does not trigger immediate reindex due to it`s async nature' do
+      expect { [city, other_city].map(&:save!) }
+        .not_to update_index(CitiesIndex, strategy: :delayed_sidekiq)
+    end
+
+    it "respects 'refresh: false' options" do
+      allow(Chewy).to receive(:disable_refresh_async).and_return(true)
+      expect(CitiesIndex).to receive(:import!).with(match_array([city.id, other_city.id]), refresh: false)
+      scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id, other_city.id])
+      scheduler.postpone
+      Chewy::Strategy::DelayedSidekiq::Worker.drain
+    end
+
+    context 'with default config' do
+      it 'does schedule a job that triggers reindex with default options' do
+        Timecop.freeze do
+          expect(Sidekiq::Client).to receive(:push).with(
+            hash_including(
+              'queue' => 'chewy',
+              'at' => expected_at_time.to_i,
+              'class' => Chewy::Strategy::DelayedSidekiq::Worker,
+              'args' => ['CitiesIndex', an_instance_of(Integer)]
+            )
+          ).and_call_original
+
+          expect($stdout).not_to receive(:puts)
+
+          Sidekiq::Testing.inline! do
+            expect { [city, other_city].map(&:save!) }
+              .to update_index(CitiesIndex, strategy: :delayed_sidekiq)
+              .and_reindex(city, other_city).only
+          end
+        end
+      end
+
+      def expected_at_time
+        target = described_class::Scheduler::DEFAULT_LATENCY.seconds.from_now.to_i
+        target - (target % described_class::Scheduler::DEFAULT_LATENCY) + described_class::Scheduler::DEFAULT_MARGIN.seconds
+      end
+    end
+
+    context 'with custom config' do
+      before do
+        CitiesIndex.strategy_config(
+          delayed_sidekiq: {
+            reindex_wrapper: lambda { |&reindex|
+              puts 'hello'
+              reindex.call
+            },
+            margin: 5,
+            latency: 60
+          }
+        )
+      end
+
+      it 'respects :strategy_config options' do
+        Timecop.freeze do
+          expect(Sidekiq::Client).to receive(:push).with(
+            hash_including(
+              'queue' => 'chewy',
+              'at' => (60.seconds.from_now.change(sec: 0) + 5.seconds).to_i,
+              'class' => Chewy::Strategy::DelayedSidekiq::Worker,
+              'args' => ['CitiesIndex', an_instance_of(Integer)]
+            )
+          ).and_call_original
+
+          expect($stdout).to receive(:puts).with('hello') # check that reindex_wrapper works
+
+          Sidekiq::Testing.inline! do
+            expect { [city, other_city].map(&:save!) }
+              .to update_index(CitiesIndex, strategy: :delayed_sidekiq)
+              .and_reindex(city, other_city).only
+          end
+        end
+      end
+    end
+
+    context 'two reindex call within the timewindow' do
+      it 'accumulates all ids does the reindex one time' do
+        Timecop.freeze do
+          expect(CitiesIndex).to receive(:import!).with(match_array([city.id, other_city.id])).once
+          scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id])
+          scheduler.postpone
+          scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id])
+          scheduler.postpone
+          Chewy::Strategy::DelayedSidekiq::Worker.drain
+        end
+      end
+
+      context 'one call with update_fields another one without update_fields' do
+        it 'does reindex of all fields' do
+          Timecop.freeze do
+            expect(CitiesIndex).to receive(:import!).with(match_array([city.id, other_city.id])).once
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id], update_fields: ['name'])
+            scheduler.postpone
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id])
+            scheduler.postpone
+            Chewy::Strategy::DelayedSidekiq::Worker.drain
+          end
+        end
+      end
+
+      context 'both calls with different update fields' do
+        it 'deos reindex with union of fields' do
+          Timecop.freeze do
+            expect(CitiesIndex).to receive(:import!).with(match_array([city.id, other_city.id]), update_fields: %w[name description]).once
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id], update_fields: ['name'])
+            scheduler.postpone
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id], update_fields: ['description'])
+            scheduler.postpone
+            Chewy::Strategy::DelayedSidekiq::Worker.drain
+          end
+        end
+      end
+    end
+
+    context 'two calls within different timewindows' do
+      it 'does two separate reindexes' do
+        Timecop.freeze do
+          expect(CitiesIndex).to receive(:import!).with([city.id]).once
+          expect(CitiesIndex).to receive(:import!).with([other_city.id]).once
+          Timecop.travel(20.seconds.ago) do
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id])
+            scheduler.postpone
+          end
+          scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id])
+          scheduler.postpone
+          Chewy::Strategy::DelayedSidekiq::Worker.drain
+        end
+      end
+    end
+
+    context 'first call has update_fields' do
+      it 'does first reindex with the expected update_fields and second without update_fields' do
+        Timecop.freeze do
+          expect(CitiesIndex).to receive(:import!).with([city.id], update_fields: ['name']).once
+          expect(CitiesIndex).to receive(:import!).with([other_city.id]).once
+          Timecop.travel(20.seconds.ago) do
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id], update_fields: ['name'])
+            scheduler.postpone
+          end
+          scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id])
+          scheduler.postpone
+          Chewy::Strategy::DelayedSidekiq::Worker.drain
+        end
+      end
+    end
+
+    context 'both calls have update_fields option' do
+      it 'does both reindexes with their expected update_fields option' do
+        Timecop.freeze do
+          expect(CitiesIndex).to receive(:import!).with([city.id], update_fields: ['name']).once
+          expect(CitiesIndex).to receive(:import!).with([other_city.id], update_fields: ['description']).once
+          Timecop.travel(20.seconds.ago) do
+            scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [city.id], update_fields: ['name'])
+            scheduler.postpone
+          end
+          scheduler = Chewy::Strategy::DelayedSidekiq::Scheduler.new(CitiesIndex, [other_city.id], update_fields: ['description'])
+          scheduler.postpone
+          Chewy::Strategy::DelayedSidekiq::Worker.drain
+        end
+      end
+    end
+
+    describe '#clear_delayed_sidekiq_timechunks test helper' do
+      it 'clears redis from the timechunk sorted sets to avoid leak between tests' do
+        timechunks_set = -> { Sidekiq.redis { |redis| redis.zrange('chewy:delayed_sidekiq:CitiesIndex:timechunks', 0, -1) } }
+
+        expect { CitiesIndex.import!([1], strategy: :delayed_sidekiq) }
+          .to change { timechunks_set.call.size }.by(1)
+
+        expect { Chewy::Strategy::DelayedSidekiq.clear_timechunks! }
+          .to change { timechunks_set.call.size }.to(0)
+      end
+    end
+  end
+end

data/spec/chewy/strategy/lazy_sidekiq_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+if defined?(Sidekiq)
+  require 'sidekiq/testing'
+
+  describe Chewy::Strategy::LazySidekiq do
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
+    before { Sidekiq::Worker.clear_all }
+
+    context 'strategy' do
+      before do
+        stub_model(:city) do
+          update_index('cities') { self }
+        end
+
+        stub_index(:cities) do
+          index_scope City
+        end
+      end
+
+      let(:city) { City.create!(name: 'hello') }
+      let(:other_city) { City.create!(name: 'world') }
+
+      it 'does not update indices synchronously' do
+        expect { [city, other_city].map(&:save!) }
+          .not_to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+      end
+
+      it 'updates indices asynchronously on record save' do
+        expect(Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+          .and_call_original
+          .once
+        Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:save!) }
+            .to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+            .and_reindex(city, other_city).only
+        end
+      end
+
+      it 'updates indices asynchronously with falling back to sidekiq strategy on record destroy' do
+        expect(Sidekiq::Client).not_to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+        expect(Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::Sidekiq::Worker,
+                  'queue' => 'low',
+                  'args' => ['CitiesIndex', [city.id, other_city.id]]
+                ))
+          .and_call_original
+          .once
+        Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:destroy) }.to update_index(CitiesIndex, strategy: :sidekiq)
+        end
+      end
+
+      it 'calls Index#import!' do
+        allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+        expect(city).to receive(:run_chewy_callbacks).and_call_original
+        expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+        expect do
+          Sidekiq::Testing.inline! do
+            Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+          end
+        end.to update_index(CitiesIndex).and_reindex(city, other_city).only
+      end
+
+      context 'when Chewy.disable_refresh_async is true' do
+        before do
+          allow(Chewy).to receive(:disable_refresh_async).and_return(true)
+        end
+
+        it 'calls Index#import! with refresh false' do
+          allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+          expect(city).to receive(:run_chewy_callbacks).and_call_original
+          expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+          expect do
+            Sidekiq::Testing.inline! do
+              Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+            end
+          end.to update_index(CitiesIndex).and_reindex(city, other_city).only.no_refresh
+        end
+      end
+    end
+
+    context 'integration' do
+      around { |example| Sidekiq::Testing.inline! { example.run } }
+
+      let(:update_condition) { true }
+
+      before do
+        city_model
+        country_model
+
+        City.belongs_to :country
+        Country.has_many :cities
+
+        stub_index(:cities) do
+          index_scope City
+        end
+
+        stub_index(:countries) do
+          index_scope Country
+        end
+      end
+
+      context 'state dependent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { changes['country_id'] || previous_changes['country_id'] || country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_dependent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+            attr_accessor :state_dependent_update_condition
+          end
+        end
+
+        context 'city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: nil) }.not_to update_index('countries', strategy: :lazy_sidekiq)
+          end
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: country2) }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country2).only
+          end
+        end
+
+        context 'country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities, state_dependent_update_condition: update_condition)
+          end
+
+          it 'does not update index because state of attribute cannot be fetched' do
+            expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq)
+          end
+        end
+      end
+
+      context 'state independent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_independent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+          end
+        end
+
+        before do
+          allow_any_instance_of(Country).to receive(:state_independent_update_condition).and_return(update_condition)
+        end
+
+        context 'when city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          specify { expect { city.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.destroy }.not_to update_index('cities').and_reindex(city).only }
+          specify { expect { city.destroy }.to update_index('countries', strategy: :sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.update!(country: nil) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.update!(country: country2) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+        end
+
+        context 'when country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities)
+          end
+          specify { expect { country.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country).only }
+
+          specify { expect { country.destroy }.to update_index('cities', strategy: :sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.destroy }.not_to update_index('countries').and_reindex(country).only }
+
+          context 'when update condition is false' do
+            let(:update_condition) { false }
+            specify { expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-if defined?(::Sidekiq)
+if defined?(Sidekiq)
   require 'sidekiq/testing'
 
   describe Chewy::Strategy::Sidekiq do
@@ -10,7 +10,7 @@ if defined?(::Sidekiq)
       Chewy.strategy(:bypass) { example.run }
       Chewy.settings[:sidekiq] = sidekiq_settings
     end
-    before { ::Sidekiq::Worker.clear_all }
+    before { Sidekiq::Worker.clear_all }
     before do
       stub_model(:city) do
         update_index('cities') { self }
@@ -30,8 +30,8 @@ if defined?(::Sidekiq)
     end
 
     specify do
-      expect(::Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
-      ::Sidekiq::Testing.inline! do
+      expect(Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
+      Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }
           .to update_index(CitiesIndex, strategy: :sidekiq)
           .and_reindex(city, other_city).only

data/spec/chewy_spec.rb

@@ -57,18 +57,21 @@ describe Chewy do
 
     before do
       Chewy.current[:chewy_client] = nil
-      allow(Chewy).to receive_messages(configuration: {transport_options: {proc: faraday_block}})
+    end
+
+    specify do
+      expect(Chewy).to receive_messages(configuration: {transport_options: {proc: faraday_block}})
 
-      allow(::Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*_args, &passed_block|
+      expect(Elasticsearch::Client).to receive(:new).with(expected_client_config) do |*_args, &passed_block|
         # RSpec's `with(..., &block)` was used previously, but doesn't actually do
         # any verification of the passed block (even of its presence).
         expect(passed_block.source_location).to eq(faraday_block.source_location)
 
         mock_client
       end
-    end
 
-    its(:client) { is_expected.to eq(mock_client) }
+      expect(Chewy.client).to be_a(Chewy::ElasticClient)
+    end
 
     after { Chewy.current[:chewy_client] = initial_client }
   end

data/spec/spec_helper.rb

@@ -9,7 +9,7 @@ require 'rspec/collection_matchers'
 
 require 'timecop'
 
-Kaminari::Hooks.init if defined?(::Kaminari::Hooks)
+Kaminari::Hooks.init if defined?(Kaminari::Hooks)
 
 require 'support/fail_helpers'
 require 'support/class_helpers'