chewy 7.2.1 → 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
@@ -494,32 +507,43 @@ describe Chewy::Index::Import do
       it_behaves_like 'importing'
     end
 
-    context 'with progressbar output' do
-      let(:mocked_progressbar) { Struct.new(:progress, :total).new(0, 100) }
-
-      it 'imports tracks progress in a single batch' do
-        expect(ProgressBar).to receive(:create).and_return(mocked_progressbar)
-        expect(mocked_progressbar).to receive(:progress).at_least(:once).and_call_original
-        expect(CitiesIndex).to receive(:import_parallel).and_call_original
-
-        CitiesIndex.import(parallel: 1, progressbar: true)
+    context 'with parent-child relationship' do
+      before do
+        stub_model(:comment)
+        stub_index(:comments) do
+          index_scope Comment
+          field :content
+          field :comment_type, type: :join, relations: {question: %i[answer comment], answer: :vote}, join: {type: :comment_type, id: :commented_id}
+        end
+      end
 
-        expect(mocked_progressbar.progress).to eq(3)
-        expect(mocked_progressbar.total).to eq(3)
+      let!(:comments) do
+        [
+          Comment.create!(id: 1, content: 'Where is Nemo?', comment_type: :question),
+          Comment.create!(id: 2, content: 'Here.', comment_type: :answer, commented_id: 1),
+          Comment.create!(id: 3, content: 'There!', comment_type: :answer, commented_id: 1),
+          Comment.create!(id: 4, content: 'Yes, he is here.', comment_type: :vote, commented_id: 2)
+        ]
       end
 
-      it 'imports tracks progress in many batches' do
-        expect(ProgressBar).to receive(:create).and_return(mocked_progressbar)
-        expect(mocked_progressbar).to receive(:progress).at_least(:once).and_call_original
-        expect(CitiesIndex).to receive(:import_parallel).and_call_original
+      def imported_comments
+        CommentsIndex.all.map do |comment|
+          comment.attributes.except('_score', '_explanation')
+        end
+      end
 
-        batches = City.pluck(:id).map { |id| [id] }
-        expect(CitiesIndex.adapter).to receive(:import_references).and_return(batches)
+      it 'imports parent and children' do
+        CommentsIndex.import!(comments.map(&:id))
 
-        CitiesIndex.import(parallel: 3, progressbar: true)
+        expect(imported_comments).to match_array([
+          {'id' => '1', 'content' => 'Where is Nemo?', 'comment_type' => 'question'},
+          {'id' => '2', 'content' => 'Here.', 'comment_type' => {'name' => 'answer', 'parent' => 1}},
+          {'id' => '3', 'content' => 'There!', 'comment_type' => {'name' => 'answer', 'parent' => 1}},
+          {'id' => '4', 'content' => 'Yes, he is here.', 'comment_type' => {'name' => 'vote', 'parent' => 2}}
+        ])
 
-        expect(mocked_progressbar.progress).to eq(3)
-        expect(mocked_progressbar.total).to eq(3)
+        answer_ids = CommentsIndex.query(has_parent: {parent_type: 'question', query: {match: {content: 'Where'}}}).pluck(:_id)
+        expect(answer_ids).to match_array(%w[2 3])
       end
     end
   end
@@ -535,9 +559,7 @@ describe Chewy::Index::Import do
         end
       end
 
-      specify do
-        expect { CitiesIndex.import!(dummy_cities) }.to raise_error Chewy::ImportFailed
-      end
+      specify { expect { CitiesIndex.import!(dummy_cities) }.to raise_error Chewy::ImportFailed }
     end
   end
 
@@ -545,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,11 @@ 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
+  end
 
   before do
     Chewy.massacre
@@ -22,6 +26,112 @@ describe :minitest_helper do
     end
   end
 
+  describe 'mock_elasticsearch_response' do
+    let(:hits) do
+      [
+        {
+          '_index' => 'dummies',
+          '_type' => '_doc',
+          '_id' => '2',
+          '_score' => 3.14,
+          '_source' => source
+        }
+      ]
+    end
+
+    let(:source) { {'name' => 'some_name', id: '2'} }
+    let(:sources) { [source] }
+
+    context 'mocks by raw response' do
+      let(:raw_response) do
+        {
+          'took' => 4,
+          'timed_out' => false,
+          '_shards' => {
+            'total' => 1,
+            'successful' => 1,
+            'skipped' => 0,
+            'failed' => 0
+          },
+          'hits' => {
+            'total' => {
+              'value' => 1,
+              'relation' => 'eq'
+            },
+            'max_score' => 1.0,
+            'hits' => hits
+          }
+        }
+      end
+
+      specify do
+        mock_elasticsearch_response(DummiesIndex, raw_response) do
+          expect(DummiesIndex.query({}).hits).to eq(hits)
+        end
+      end
+    end
+
+    context 'mocks by response sources' do
+      specify do
+        mock_elasticsearch_response_sources(DummiesIndex, sources) do
+          expect(DummiesIndex.query({}).hits).to eq(hits)
+        end
+      end
+    end
+  end
+
+  describe 'assert correct elasticsearch query' do
+    let(:query) do
+      DummiesIndex.filter.should { multi_match foo: 'bar' }.filter { match foo: 'bar' }
+    end
+
+    let(:expected_query) do
+      {
+        index: ['dummies'],
+        body: {
+          query: {
+            bool: {
+              filter: {
+                bool: {
+                  must: {
+                    match: {foo: 'bar'}
+                  },
+                  should: {
+                    multi_match: {foo: 'bar'}
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+
+    context 'will be built' do
+      specify do
+        expect { assert_elasticsearch_query(query, expected_query) }.not_to raise_error
+      end
+    end
+
+    context 'will not be built' do
+      let(:unexpected_query) do
+        {
+          index: ['what?'],
+          body: {}
+        }
+      end
+
+      let(:unexpected_query_error_message) do
+        'got {:index=>["dummies"], :body=>{:query=>{:bool=>{:filter=>{:bool=>{:must=>{:match=>{:foo=>"bar"}}, :should=>{:multi_match=>{:foo=>"bar"}}}}}}}} instead of expected query.'
+      end
+
+      specify do
+        expect { assert_elasticsearch_query(query, unexpected_query) }
+          .to raise_error(RuntimeError, unexpected_query_error_message)
+      end
+    end
+  end
+
   context 'assert_indexes' do
     specify 'doesn\'t fail when index updates correctly' do
       expect 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