chewy 6.0.0 → 7.6.0

data/spec/chewy/journal_spec.rb

@@ -13,14 +13,12 @@ describe Chewy::Journal do
           end
 
           stub_index("#{namespace}cities") do
-            define_type City do
-              default_import_options journal: true
-            end
+            index_scope City
+            default_import_options journal: true
           end
           stub_index("#{namespace}countries") do
-            define_type Country do
-              default_import_options journal: true
-            end
+            index_scope Country
+            default_import_options journal: true
           end
 
           Chewy.massacre
@@ -67,63 +65,54 @@ describe Chewy::Journal do
             expected_journal = [
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => ['3'].map(&Base64.method(:encode64)),
                 'created_at' => time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => %w[1 2].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'index',
                 'references' => %w[1 2 3].map(&Base64.method(:encode64)),
                 'created_at' => import_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}cities",
-                'type_name' => 'city',
                 'action' => 'index',
                 'references' => ['1'].map(&Base64.method(:encode64)),
                 'created_at' => update_time.utc.as_json
               },
               {
                 'index_name' => "#{namespace}countries",
-                'type_name' => 'country',
                 'action' => 'delete',
                 'references' => ['2'].map(&Base64.method(:encode64)),
                 'created_at' => destroy_time.utc.as_json
@@ -137,7 +126,7 @@ describe Chewy::Journal do
             expect(journal_entries.size).to eq 4
 
             # simulate lost data
-            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: "#{Chewy.settings[:prefix]}_cities", id: 1, refresh: true)
             expect(cities_index.count).to eq 1
 
             described_class.new.apply(time)
@@ -166,14 +155,12 @@ describe Chewy::Journal do
       end
 
       stub_index(:cities) do
-        define_type City do
-          default_import_options journal: true
-        end
+        index_scope City
+        default_import_options journal: true
       end
       stub_index(:countries) do
-        define_type Country do
-          default_import_options journal: true
-        end
+        index_scope Country
+        default_import_options journal: true
       end
     end
 
@@ -192,8 +179,8 @@ describe Chewy::Journal do
             Array.new(2) { |i| Country.create!(id: i + 1) }
 
             # simulate lost data
-            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
-            Chewy.client.delete(index: 'countries', type: 'country', id: 1, refresh: true)
+            Chewy.client.delete(index: 'cities', id: 1, refresh: true)
+            Chewy.client.delete(index: 'countries', id: 1, refresh: true)
             expect(CitiesIndex.all.to_a.length).to eq 1
             expect(CountriesIndex.all.to_a.length).to eq 1
 
@@ -203,7 +190,7 @@ describe Chewy::Journal do
             expect(CountriesIndex.all.to_a.length).to eq 1
 
             # Replay on both
-            Chewy.client.delete(index: 'cities', type: 'city', id: 1, refresh: true)
+            Chewy.client.delete(index: 'cities', id: 1, refresh: true)
             expect(CitiesIndex.all.to_a.length).to eq 1
             expect(described_class.new(CitiesIndex, CountriesIndex).apply(time)).to eq(4)
             expect(CitiesIndex.all.to_a.length).to eq 2
@@ -212,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::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
@@ -18,8 +22,112 @@ describe :minitest_helper do
 
   before do
     stub_index(:dummies) do
-      define_type :dummy do
-        root value: ->(_o) { {} }
+      root value: ->(_o) { {} }
+    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
@@ -27,45 +135,45 @@ describe :minitest_helper do
   context 'assert_indexes' do
     specify 'doesn\'t fail when index updates correctly' do
       expect do
-        assert_indexes DummiesIndex::Dummy do
-          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        assert_indexes DummiesIndex do
+          DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
         end
       end.to_not raise_error
     end
 
     specify 'fails when index doesn\'t update' do
       expect do
-        assert_indexes DummiesIndex::Dummy do
+        assert_indexes DummiesIndex do
         end
       end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
     end
 
     specify 'SearchIndexReceiver catches the indexes' do
-      receiver = assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      receiver = assert_indexes DummiesIndex do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
 
       expect(receiver).to be_a(SearchIndexReceiver)
 
       expect(
-        receiver.indexes_for(DummiesIndex::Dummy)
+        receiver.indexes_for(DummiesIndex)
                 .map { |index| index[:_id] }
       ).to match_array([41, 42])
     end
 
     specify 'Real index is bypassed when asserting' do
-      expect(DummiesIndex::Dummy).not_to receive(:bulk)
+      expect(DummiesIndex).not_to receive(:bulk)
 
-      assert_indexes DummiesIndex::Dummy do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      assert_indexes DummiesIndex do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
 
     specify 'Real index is allowed when asserting' do
-      expect(DummiesIndex::Dummy).to receive(:bulk)
+      expect(DummiesIndex).to receive(:bulk)
 
-      assert_indexes DummiesIndex::Dummy, bypass_actual_index: false do
-        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      assert_indexes DummiesIndex, bypass_actual_index: false do
+        DummiesIndex.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
       end
     end
   end

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -24,99 +24,97 @@ describe :search_index_receiver do
     SearchIndexReceiver.new
   end
 
+  let(:dummy_class) { Struct.new(:id) }
+
   before do
     stub_index(:dummies) do
-      define_type :fizz do
-        root value: ->(_o) { {} }
-      end
+      root value: ->(_o) { {} }
     end
 
     stub_index(:dummies2) do
-      define_type :buzz do
-        root value: ->(_o) { {} }
-      end
+      root value: ->(_o) { {} }
     end
   end
 
   context 'catch' do
     specify 'archives more than one type' do
-      receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), Dummies2Index::Buzz
-      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      receiver.catch search_request(2), DummiesIndex
+      receiver.catch search_request(3), Dummies2Index
+      expect(receiver.indexes.keys).to match_array([DummiesIndex, Dummies2Index])
     end
   end
 
   context 'indexes_for' do
     before do
-      receiver.catch search_request(2), DummiesIndex::Fizz
-      receiver.catch search_request(3), Dummies2Index::Buzz
+      receiver.catch search_request(2), DummiesIndex
+      receiver.catch search_request(3), Dummies2Index
     end
 
     specify 'returns indexes for a specific type' do
-      expect(parse_request(receiver.indexes_for(DummiesIndex::Fizz))).to match_array([1, 2])
+      expect(parse_request(receiver.indexes_for(DummiesIndex))).to match_array([1, 2])
     end
 
     specify 'returns only indexes for all types' do
       index_responses = receiver.indexes
-      expect(index_responses.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      expect(index_responses.keys).to match_array([DummiesIndex, Dummies2Index])
       expect(parse_request(index_responses.values.flatten)).to match_array([1, 2, 1, 2, 3])
     end
   end
 
   context 'deletes_for' do
     before do
-      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
-      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
+      receiver.catch search_request(2, verb: :delete), DummiesIndex
+      receiver.catch search_request(3, verb: :delete), Dummies2Index
     end
 
     specify 'returns deletes for a specific type' do
-      expect(receiver.deletes_for(Dummies2Index::Buzz)).to match_array([1, 2, 3])
+      expect(receiver.deletes_for(Dummies2Index)).to match_array([1, 2, 3])
     end
 
     specify 'returns only deletes for all types' do
       deletes = receiver.deletes
-      expect(deletes.keys).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      expect(deletes.keys).to match_array([DummiesIndex, Dummies2Index])
       expect(deletes.values.flatten).to match_array([1, 2, 1, 2, 3])
     end
   end
 
   context 'indexed?' do
     before do
-      receiver.catch search_request(1), DummiesIndex::Fizz
+      receiver.catch search_request(1), DummiesIndex
     end
 
     specify 'validates that an object was indexed' do
-      dummy = OpenStruct.new(id: 1)
-      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(true)
+      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)
-      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(false)
+      dummy = dummy_class.new(2)
+      expect(receiver.indexed?(dummy, DummiesIndex)).to be(false)
     end
   end
 
   context 'deleted?' do
     before do
-      receiver.catch search_request(1, verb: :delete), DummiesIndex::Fizz
+      receiver.catch search_request(1, verb: :delete), DummiesIndex
     end
 
     specify 'validates than an object was deleted' do
-      dummy = OpenStruct.new(id: 1)
-      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(true)
+      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)
-      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(false)
+      dummy = dummy_class.new(2)
+      expect(receiver.deleted?(dummy, DummiesIndex)).to be(false)
     end
   end
 
   context 'updated_indexes' do
     specify 'provides a list of indices updated' do
-      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
-      receiver.catch search_request(3, verb: :delete), Dummies2Index::Buzz
-      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, Dummies2Index::Buzz])
+      receiver.catch search_request(2, verb: :delete), DummiesIndex
+      receiver.catch search_request(3, verb: :delete), Dummies2Index
+      expect(receiver.updated_indexes).to match_array([DummiesIndex, Dummies2Index])
     end
   end
 end

data/spec/chewy/multi_search_spec.rb

@@ -13,10 +13,9 @@ describe Chewy::MultiSearch do
         aggs(country: {terms: {field: :country_id}})
       end
 
-      define_type City do
-        field :name, type: 'keyword'
-        field :country_id, type: 'keyword'
-      end
+      index_scope City
+      field :name, type: 'keyword'
+      field :country_id, type: 'keyword'
     end
   end
 
@@ -78,7 +77,7 @@ describe Chewy::MultiSearch do
         is_expected.to have(2).responses
         expect(responses[0]).to be_a(Chewy::Search::Response)
         expect(responses[1]).to be_a(Chewy::Search::Response)
-        expect(responses[1].wrappers).to all(be_a CitiesIndex::City)
+        expect(responses[1].wrappers).to all(be_a CitiesIndex)
       end
     end
   end