chewy 7.2.4 → 7.6.0

data/spec/chewy/index/import_spec.rb

@@ -60,6 +60,19 @@ describe Chewy::Index::Import do
         CitiesIndex.import(dummy_city)
       end
     end
+
+    context 'skip journal creation on import' do
+      before do
+        Chewy::Stash::Journal.create!
+        Chewy.config.settings[:skip_journal_creation_on_import] = true
+      end
+      after { Chewy.config.settings[:skip_journal_creation_on_import] = nil }
+
+      specify do
+        expect(Chewy::Stash::Journal).not_to receive(:create!)
+        CitiesIndex.import(dummy_city, journal: true)
+      end
+    end
   end
 
   shared_examples 'importing' do
@@ -202,8 +215,8 @@ describe Chewy::Index::Import do
           payload = subscribe_notification
           import dummy_cities, batch_size: 2
           expect(payload).to eq(index: CitiesIndex,
-            errors: {index: {mapper_parsing_exception => %w[1 2 3]}},
-            import: {index: 3})
+                                errors: {index: {mapper_parsing_exception => %w[1 2 3]}},
+                                import: {index: 3})
         end
       end
     end
@@ -554,7 +567,7 @@ describe Chewy::Index::Import do
     before do
       stub_index(:cities) do
         crutch :names do |collection|
-          collection.map { |o| [o.name, "#{o.name}42"] }.to_h
+          collection.to_h { |o| [o.name, "#{o.name}42"] }
         end
         field :name, value: ->(o, c) { c.names[o.name] }
         field :rating

data/spec/chewy/index/observe/active_record_methods_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::ActiveRecordMethods do
+  describe '.update_index' do
+    before { stub_model(:city) }
+
+    it 'initializes chewy callbacks when first update_index is evaluated' do
+      expect(City).to receive(:initialize_chewy_callbacks).once
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+    end
+
+    it 'adds chewy callbacks to model' do
+      expect(City.chewy_callbacks.count).to eq(0)
+
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+
+      expect(City.chewy_callbacks.count).to eq(2)
+    end
+  end
+
+  describe 'callbacks' do
+    before { stub_model(:city) { update_index 'cities', :self } }
+    before { stub_index(:cities) { index_scope City } }
+    before { allow(Chewy).to receive(:use_after_commit_callbacks).and_return(use_after_commit_callbacks) }
+
+    let(:city) do
+      Chewy.strategy(:bypass) do
+        City.create!
+      end
+    end
+
+    shared_examples 'handles callbacks correctly' do
+      it 'handles callbacks with strategy for possible lazy evaluation on save!' do
+        Chewy.strategy(:urgent) do
+          expect(city).to receive(:update_chewy_indices).and_call_original
+          expect(Chewy.strategy.current).to receive(:update_chewy_indices).with(city)
+          expect(city).not_to receive(:run_chewy_callbacks)
+
+          city.save!
+        end
+      end
+
+      it 'runs callbacks at the moment on destroy' do
+        Chewy.strategy(:urgent) do
+          expect(city).not_to receive(:update_chewy_indices)
+          expect(Chewy.strategy.current).not_to receive(:update_chewy_indices)
+          expect(city).to receive(:run_chewy_callbacks)
+
+          city.destroy
+        end
+      end
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is true' do
+      let(:use_after_commit_callbacks) { true }
+
+      include_examples 'handles callbacks correctly'
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is false' do
+      let(:use_after_commit_callbacks) { false }
+
+      include_examples 'handles callbacks correctly'
+    end
+  end
+end

data/spec/chewy/index/observe/callback_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::Callback do
+  subject(:callback) { described_class.new(executable) }
+
+  before do
+    stub_model(:city) do
+      attr_accessor :population
+    end
+  end
+
+  let(:city) { City.create!(population: 100) }
+
+  describe '#call' do
+    context 'when executable is has arity 0' do
+      let(:executable) { -> { population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    context 'when executable is has arity 1' do
+      let(:executable) { ->(record) { record.population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    describe 'filters' do
+      let(:executable) { ->(_) {} }
+
+      describe 'if' do
+        subject(:callback) { described_class.new(executable, if: filter) }
+
+        shared_examples 'an if filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an if filter'
+        end
+      end
+
+      describe 'unless' do
+        subject(:callback) { described_class.new(executable, unless: filter) }
+
+        shared_examples 'an unless filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an unless filter'
+        end
+      end
+    end
+  end
+end

data/spec/chewy/index/observe_spec.rb

@@ -57,6 +57,9 @@ describe Chewy::Index::Observe do
       specify { expect { city.save! }.to update_index('cities').and_reindex(city).only }
       specify { expect { city.save! }.to update_index('countries').and_reindex(country1).only }
 
+      specify { expect { city.destroy }.to update_index('cities') }
+      specify { expect { city.destroy }.to update_index('countries').and_reindex(country1).only }
+
       specify { expect { city.update!(country: nil) }.to update_index('cities').and_reindex(city).only }
       specify { expect { city.update!(country: nil) }.to update_index('countries').and_reindex(country1).only }
 
@@ -78,9 +81,13 @@ describe Chewy::Index::Observe do
       specify { expect { country.save! }.to update_index('cities').and_reindex(country.cities).only }
       specify { expect { country.save! }.to update_index('countries').and_reindex(country).only }
 
+      specify { expect { country.destroy }.to update_index('cities').and_reindex(country.cities).only }
+      specify { expect { country.destroy }.to update_index('countries') }
+
       context 'conditional update' do
         let(:update_condition) { false }
         specify { expect { country.save! }.not_to update_index('cities') }
+        specify { expect { country.destroy }.not_to update_index('cities') }
       end
     end
   end
@@ -97,6 +104,16 @@ describe Chewy::Index::Observe do
           end
         end
       end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.not_to update_index('cities')
+          end
+        end
+      end
     end
 
     context do
@@ -111,6 +128,16 @@ describe Chewy::Index::Observe do
           end
         end
       end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.to update_index('cities')
+          end
+        end
+      end
     end
   end
 end

data/spec/chewy/journal_spec.rb

@@ -199,59 +199,23 @@ describe Chewy::Journal do
         end
       end
 
-      context 'retries' do
-        let(:time) { Time.now.to_i }
-        before do
-          Timecop.freeze
-          Chewy.strategy(:urgent)
-          City.create!(id: 1)
-        end
-
-        after do
-          Chewy.strategy.pop
-          Timecop.return
-        end
-
-        specify 'journal was cleaned after the first call' do
-          expect(Chewy::Stash::Journal).to receive(:entries).exactly(2).and_call_original
-          expect(described_class.new.apply(time)).to eq(1)
-        end
-
-        context 'endless journal' do
-          let(:count_of_checks) { 10 } # default
-          let!(:journal_entries) do
-            record = Chewy::Stash::Journal.entries(time).first
-            Array.new(count_of_checks) do |i|
-              Chewy::Stash::Journal.new(
-                record.attributes.merge(
-                  'created_at' => time.to_i + i,
-                  'references' => [i.to_s]
-                )
-              )
-            end
-          end
-
-          specify '10 retries by default' do
-            expect(Chewy::Stash::Journal)
-              .to receive(:entries).exactly(count_of_checks) { [journal_entries.shift].compact }
-            expect(described_class.new.apply(time)).to eq(10)
-          end
+      context 'when order is not preserved' do
+        let(:time) { Time.now }
 
-          specify 'with :once parameter set' do
-            expect(Chewy::Stash::Journal)
-              .to receive(:entries).exactly(1) { [journal_entries.shift].compact }
-            expect(described_class.new.apply(time, retries: 1)).to eq(1)
+        it 'paginates properly through all items' do
+          Chewy.strategy(:urgent) do
+            Timecop.travel(time + 1.minute) { City.create!(id: 2) }
+            Timecop.travel(time + 3.minute) { City.create!(id: 4) }
+            Timecop.travel(time + 2.minute) { City.create!(id: 1) }
+            Timecop.travel(time + 4.minute) { City.create!(id: 3) }
           end
 
-          context 'with retries parameter set' do
-            let(:retries) { 5 }
+          CitiesIndex.purge!
+          expect(CitiesIndex.all.to_a.length).to eq 0
 
-            specify do
-              expect(Chewy::Stash::Journal)
-                .to receive(:entries).exactly(retries) { [journal_entries.shift].compact }
-              expect(described_class.new.apply(time, retries: retries)).to eq(5)
-            end
-          end
+          # Replay on specific index
+          expect(described_class.new(CitiesIndex).apply(time, fetch_limit: 2)).to eq(4)
+          expect(CitiesIndex.all.to_a.map(&:id).sort).to eq([1, 2, 3, 4])
         end
       end
     end

data/spec/chewy/minitest/helpers_spec.rb

@@ -10,7 +10,7 @@ describe :minitest_helper do
     expect(haystack).to include(needle)
   end
 
-  include ::Chewy::Minitest::Helpers
+  include Chewy::Minitest::Helpers
 
   def assert_equal(expected, actual, message)
     raise message unless expected == actual
@@ -32,14 +32,14 @@ describe :minitest_helper do
         {
           '_index' => 'dummies',
           '_type' => '_doc',
-          '_id' => '1',
+          '_id' => '2',
           '_score' => 3.14,
           '_source' => source
         }
       ]
     end
 
-    let(:source) { {'name' => 'some_name'} }
+    let(:source) { {'name' => 'some_name', id: '2'} }
     let(:sources) { [source] }
 
     context 'mocks by raw response' do

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -24,6 +24,8 @@ describe :search_index_receiver do
     SearchIndexReceiver.new
   end
 
+  let(:dummy_class) { Struct.new(:id) }
+
   before do
     stub_index(:dummies) do
       root value: ->(_o) { {} }
@@ -82,12 +84,12 @@ describe :search_index_receiver do
     end
 
     specify 'validates that an object was indexed' do
-      dummy = OpenStruct.new(id: 1)
+      dummy = dummy_class.new(1)
       expect(receiver.indexed?(dummy, DummiesIndex)).to be(true)
     end
 
     specify 'doesn\'t validate than unindexed objects were indexed' do
-      dummy = OpenStruct.new(id: 2)
+      dummy = dummy_class.new(2)
       expect(receiver.indexed?(dummy, DummiesIndex)).to be(false)
     end
   end
@@ -98,12 +100,12 @@ describe :search_index_receiver do
     end
 
     specify 'validates than an object was deleted' do
-      dummy = OpenStruct.new(id: 1)
+      dummy = dummy_class.new(1)
       expect(receiver.deleted?(dummy, DummiesIndex)).to be(true)
     end
 
     specify 'doesn\'t validate than undeleted objects were deleted' do
-      dummy = OpenStruct.new(id: 2)
+      dummy = dummy_class.new(2)
       expect(receiver.deleted?(dummy, DummiesIndex)).to be(false)
     end
   end

data/spec/chewy/rake_helper_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'rake'
 
 describe Chewy::RakeHelper, :orm do
   before { Chewy.massacre }
@@ -104,10 +105,10 @@ Total: \\d+s\\Z
         expect { described_class.reset(only: [CitiesIndex], output: output) }
           .to update_index(CitiesIndex)
         expect(output.string).to include(
-          "############################################################\n"\
-          "WARN: You are risking to lose some changes during the reset.\n" \
-          "      Please consider enabling journaling.\n" \
-          '      See https://github.com/toptal/chewy#journaling'
+          "############################################################\n" \
+          "WARN: You are risking to lose some changes during the reset.\n      " \
+          "Please consider enabling journaling.\n      " \
+          'See https://github.com/toptal/chewy#journaling'
         )
       end
     end
@@ -426,6 +427,108 @@ Total: \\d+s\\Z
       described_class.journal_clean(except: CitiesIndex, output: output)
       expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 \\ACleaned up 1 journal entries
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    it 'executes asynchronously' do
+      output = StringIO.new
+      expect(Chewy.client).to receive(:delete_by_query).with(
+        {
+          body: {query: {match_all: {}}},
+          index: ['chewy_journal'],
+          refresh: false,
+          requests_per_second: 10.0,
+          scroll_size: 200,
+          wait_for_completion: false
+        }
+      ).and_call_original
+      described_class.journal_clean(
+        output: output,
+        delete_by_query_options: {
+          wait_for_completion: false,
+          requests_per_second: 10.0,
+          scroll_size: 200
+        }
+      )
+
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ATask to cleanup the journal has been created, [^\\n]*
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context 'execute "chewy:journal:clean" rake task' do
+      subject(:task) { Rake.application['chewy:journal:clean'] }
+      before do
+        Rake::DefaultLoader.new.load('lib/tasks/chewy.rake')
+        Rake::Task.define_task(:environment)
+      end
+      it 'does not raise error' do
+        expect { task.invoke }.to_not raise_error
+      end
+    end
+  end
+
+  describe '.create_missing_indexes!' do
+    before do
+      [CountriesIndex, Chewy::Stash::Specification].map(&:create!)
+
+      # To avoid flaky issues when previous specs were run
+      expect(Chewy::Index).to receive(:descendants).and_return(
+        [
+          UsersIndex,
+          CountriesIndex,
+          CitiesIndex,
+          Chewy::Stash::Specification,
+          Chewy::Stash::Journal
+        ]
+      )
+    end
+
+    specify do
+      output = StringIO.new
+      described_class.create_missing_indexes!(output: output)
+      expect(CitiesIndex.exists?).to be_truthy
+      expect(UsersIndex.exists?).to be_truthy
+      expect(Chewy::Stash::Journal.exists?).to be_falsey
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+UsersIndex index successfully created
+CitiesIndex index successfully created
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context 'when verbose' do
+      specify do
+        output = StringIO.new
+        described_class.create_missing_indexes!(output: output, env: {'VERBOSE' => '1'})
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+UsersIndex index successfully created
+CountriesIndex already exists, skipping
+CitiesIndex index successfully created
+Chewy::Stash::Specification already exists, skipping
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+
+    context 'when journaling is enabled' do
+      before { Chewy.config.settings[:journal] = true }
+      after { Chewy.config.settings.delete(:journal) }
+      specify do
+        described_class.create_missing_indexes!(output: StringIO.new)
+        expect(Chewy::Stash::Journal.exists?).to be_truthy
+      end
+    end
+  end
+
+  describe '.journal_create' do
+    specify do
+      output = StringIO.new
+      described_class.journal_create(output: output)
+      expect(Chewy::Stash::Journal.exists?).to be_truthy
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
 Total: \\d+s\\Z
       OUTPUT
     end
@@ -502,4 +605,52 @@ Total: \\d+s\\Z
       end
     end
   end
+
+  describe '.delete_by_query_options_from_env' do
+    subject(:options) { described_class.delete_by_query_options_from_env(env) }
+    let(:env) do
+      {
+        'WAIT_FOR_COMPLETION' => 'false',
+        'REQUESTS_PER_SECOND' => '10',
+        'SCROLL_SIZE' => '5000'
+      }
+    end
+
+    it 'parses the options' do
+      expect(options).to eq(
+        wait_for_completion: false,
+        requests_per_second: 10.0,
+        scroll_size: 5000
+      )
+    end
+
+    context 'with different boolean values' do
+      it 'parses the option correctly' do
+        %w[1 t true TRUE on ON].each do |v|
+          expect(described_class.delete_by_query_options_from_env({'WAIT_FOR_COMPLETION' => v}))
+            .to eq(wait_for_completion: true)
+        end
+
+        %w[0 f false FALSE off OFF].each do |v|
+          expect(described_class.delete_by_query_options_from_env({'WAIT_FOR_COMPLETION' => v}))
+            .to eq(wait_for_completion: false)
+        end
+      end
+    end
+
+    context 'with other env' do
+      let(:env) { {'SOME_ENV' => '123', 'REQUESTS_PER_SECOND' => '15'} }
+
+      it 'parses only the options' do
+        expect(options).to eq(requests_per_second: 15.0)
+      end
+    end
+  end
+
+  describe '.subscribed_task_stats' do
+    specify do
+      block_output = described_class.subscribed_task_stats(StringIO.new) { 'expected output' }
+      expect(block_output).to eq('expected output')
+    end
+  end
 end

data/spec/chewy/rspec/helpers_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe :rspec_helper do
-  include ::Chewy::Rspec::Helpers
+  include Chewy::Rspec::Helpers
 
   before do
     stub_model(:city)

data/spec/chewy/search/pagination/kaminari_examples.rb

@@ -24,7 +24,7 @@ shared_examples :kaminari do |request_base_class|
     let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
 
     before { ProductsIndex.import!(data.map { |h| double(h) }) }
-    before { allow(::Kaminari.config).to receive_messages(default_per_page: 3) }
+    before { allow(Kaminari.config).to receive_messages(default_per_page: 3) }
 
     describe '#per, #page' do
       specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }

data/spec/chewy/search/pagination/kaminari_spec.rb

@@ -6,7 +6,7 @@ describe Chewy::Search::Pagination::Kaminari do
       let(:data) { Array.new(12) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
 
       before { ProductsIndex.import!(data.map { |h| double(h) }) }
-      before { allow(::Kaminari.config).to receive_messages(default_per_page: 17) }
+      before { allow(Kaminari.config).to receive_messages(default_per_page: 17) }
 
       specify { expect(search.objects.class).to eq(Kaminari::PaginatableArray) }
       specify { expect(search.objects.total_count).to eq(12) }

data/spec/chewy/search/parameters/collapse_spec.rb

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/hash_storage_examples'
+
+describe Chewy::Search::Parameters::Collapse do
+  it_behaves_like :hash_storage, :collapse
+end

data/spec/chewy/search/parameters/knn_spec.rb

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/hash_storage_examples'
+
+describe Chewy::Search::Parameters::Knn do
+  it_behaves_like :hash_storage, :knn
+end