chewy 6.0.0 → 7.6.0

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,14 +10,14 @@ 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#city') { self }
+        update_index('cities') { self }
       end
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
     end
 
@@ -26,27 +26,27 @@ if defined?(::Sidekiq)
 
     specify do
       expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :sidekiq)
+        .not_to update_index(CitiesIndex, strategy: :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::City, strategy: :sidekiq)
+          .to update_index(CitiesIndex, strategy: :sidekiq)
           .and_reindex(city, other_city).only
       end
     end
 
     specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
+      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
     end
 
     specify do
       allow(Chewy).to receive(:disable_refresh_async).and_return(true)
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
+      expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
+      Chewy::Strategy::Sidekiq::Worker.new.perform('CitiesIndex', [city.id, other_city.id], suffix: '201601')
     end
   end
 end

data/spec/chewy/strategy_spec.rb

@@ -14,7 +14,10 @@ describe Chewy::Strategy do
   end
 
   describe '#push' do
-    specify { expect { strategy.push(:unexistant) }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
+    specify do
+      expect { strategy.push(:unexistant) }
+        .to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`")
+    end
 
     specify do
       expect { strategy.push(:atomic) }
@@ -35,7 +38,10 @@ describe Chewy::Strategy do
   end
 
   describe '#wrap' do
-    specify { expect { strategy.wrap(:unexistant) {} }.to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`") }
+    specify do
+      expect { strategy.wrap(:unexistant) {} }
+        .to raise_error(RuntimeError).with_message("Can't find update strategy `unexistant`")
+    end
 
     specify do
       expect do
@@ -49,11 +55,11 @@ describe Chewy::Strategy do
   context 'nesting', :orm do
     before do
       stub_model(:city) do
-        update_index('cities#city') { self }
+        update_index('cities') { self }
       end
 
       stub_index(:cities) do
-        define_type City
+        index_scope City
       end
     end
 
@@ -64,12 +70,12 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:bypass) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).not_to receive(:import!)
+        expect(CitiesIndex).not_to receive(:import!)
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
+        expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
     end
@@ -78,41 +84,39 @@ describe Chewy::Strategy do
       around { |example| Chewy.strategy(:urgent) { example.run } }
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).at_least(2).times
+        expect(CitiesIndex).to receive(:import!).at_least(2).times
         [city, other_city].map(&:save!)
       end
 
       specify do
-        expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id]).once
+        expect(CitiesIndex).to receive(:import!).with([city.id, other_city.id]).once
         Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
       end
 
       context 'hash passed to urgent' do
         before do
-          stub_index(:cities) do
-            define_type :city
-          end
+          stub_index(:cities)
 
           stub_model(:city) do
-            update_index('cities#city') { {name: name} }
+            update_index('cities') { {name: name} }
           end
         end
 
         specify do
           [city, other_city].map(&:save!)
-          expect(CitiesIndex::City.total_count).to eq(4)
+          expect(CitiesIndex.total_count).to eq(4)
         end
 
         context do
           before do
             stub_model(:city) do
-              update_index('cities#city') { {id: id.to_s, name: name} }
+              update_index('cities') { {id: id.to_s, name: name} }
             end
           end
 
           specify do
             [city, other_city].map(&:save!)
-            expect(CitiesIndex::City.total_count).to eq(2)
+            expect(CitiesIndex.total_count).to eq(2)
           end
         end
       end