chewy 5.2.0 → 6.0.0

data/spec/chewy/rspec/update_index_spec.rb

@@ -4,7 +4,9 @@ describe :update_index do
   before do
     stub_index(:dummies) do
       define_type :dummy
-      define_type :dummy2
+    end
+    stub_index(:dummies2) do
+      define_type :dummy
     end
   end
 
@@ -13,19 +15,18 @@ describe :update_index do
     DummiesIndex.create!
   end
 
-  specify { expect {}.not_to update_index(DummiesIndex::Dummy) }
-  specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex::Dummy) }
+  specify { expect {}.not_to update_index(DummiesIndex) }
+  specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex) }
 
   specify do
-    expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex::Dummy) }
+    expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex) }
       .to fail_with(/Expected index .* not to be updated, but it was with/)
   end
 
   specify do
     expect do
       DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
-      DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
-    end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+    end.to update_index(DummiesIndex).and_reindex(41, 42).only
   end
 
   context do
@@ -33,7 +34,7 @@ describe :update_index do
       expect do
         expect do
           DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
-        end.not_to update_index(DummiesIndex::Dummy)
+        end.not_to update_index(DummiesIndex)
       end
     end
 
@@ -45,60 +46,60 @@ describe :update_index do
     specify do
       expect do
         DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
-        DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
-      end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
-        .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+        Dummies2Index::Dummy.bulk body: [{index: {_id: 43, data: {}}}]
+      end.to update_index(DummiesIndex).and_reindex(41, 42).only
+        .and update_index(Dummies2Index).and_reindex(43).only
     end
 
     context do
       let(:expectation) do
         expect do
           expect do
-            DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
-            .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+            Dummies2Index::Dummy.bulk body: [{index: {_id: 43, data: {}}}]
+          end.to update_index(DummiesIndex).and_reindex(41, 42).only
+            .and update_index(Dummies2Index).and_reindex(43).only
         end
       end
 
-      specify { expectation.to fail_matching 'Expected index `DummiesIndex::Dummy` to be updated' }
+      specify { expectation.to fail_matching 'Expected index `DummiesIndex` to be updated' }
     end
   end
 
   context '#only' do
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+        .to update_index(DummiesIndex).and_reindex(41, 42).only
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(41).only
+          .to update_index(DummiesIndex).and_reindex(41).only
       end
         .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(41, times: 2).only
+          .to update_index(DummiesIndex).and_reindex(41, times: 2).only
       end
         .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
     end
 
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only
+        .to update_index(DummiesIndex).and_delete(41, 42).only
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+          .to update_index(DummiesIndex).and_delete(41).only
       end
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41, times: 2).only
+          .to update_index(DummiesIndex).and_delete(41, times: 2).only
       end
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
     end
@@ -106,57 +107,57 @@ describe :update_index do
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(42).only
+          .to update_index(DummiesIndex).and_reindex(42).only
       end
         .to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also'
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex::Dummy).and_reindex(42).only
+          .to update_index(DummiesIndex).and_reindex(42).only
       end
         .to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also'
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+          .to update_index(DummiesIndex).and_delete(41).only
       end
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also'
     end
     specify do
       expect do
         expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}, {delete: {_id: 43}}] }
-          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+          .to update_index(DummiesIndex).and_delete(41).only
       end
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also'
     end
   end
 
   context '#and_reindex' do
-    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex::Dummy) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex) }
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(42)
+        .to update_index(DummiesIndex).and_reindex(42)
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42))
+        .to update_index(DummiesIndex).and_reindex(double(id: 42))
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42), double(id: 43))
+        .to update_index(DummiesIndex).and_reindex(double(id: 42), double(id: 43))
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex([double(id: 42), 43])
+        .to update_index(DummiesIndex).and_reindex([double(id: 42), 43])
     end
 
     specify do
       expect do
         expect do
           DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        end.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
+        end.to update_index(DummiesIndex).and_reindex([44, 43])
       end.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
     end
 
@@ -165,7 +166,7 @@ describe :update_index do
         expect do
           expect do
             DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(44, double(id: 47)) end
+          end.to update_index(DummiesIndex).and_reindex(44, double(id: 47)) end
       end
 
       specify { expectation.to fail_matching('Expected document with id `44` to be reindexed, but it was not') }
@@ -177,13 +178,13 @@ describe :update_index do
         expect do
           DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
           DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-        end.to update_index(DummiesIndex::Dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) end
+        end.to update_index(DummiesIndex).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) end
 
       specify do
         expect do
           expect do
             DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
+          end.to update_index(DummiesIndex).and_reindex(42, times: 3)
         end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
 
       context do
@@ -192,7 +193,7 @@ describe :update_index do
             expect do
               DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
               DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-            end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) end
+            end.to update_index(DummiesIndex).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `44` to be reindexed' }
@@ -206,18 +207,18 @@ describe :update_index do
       specify do
         expect do
           DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-        end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 2}) end
+        end.to update_index(DummiesIndex).and_reindex(42, with: {a: 2}) end
 
       specify do
         expect do
           DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
-        end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: '1', b: 2}) end
+        end.to update_index(DummiesIndex).and_reindex(42, with: {a: '1', b: 2}) end
 
       specify do
         expect do
           expect do
             DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 1})
+          end.to update_index(DummiesIndex).and_reindex(42, with: {a: 1})
         end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
 
       [
@@ -230,7 +231,7 @@ describe :update_index do
         specify do
           expect do
             DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
-          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) end
+          end.to update_index(DummiesIndex).and_reindex(42, with: with) end
       end
 
       [
@@ -244,7 +245,7 @@ describe :update_index do
           expect do
             expect do
               DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
-            end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with)
+            end.to update_index(DummiesIndex).and_reindex(42, with: with)
           end.to fail_matching('Expected document with id `42` to be reindexed') end
       end
 
@@ -253,7 +254,7 @@ describe :update_index do
           expect do
             expect do
               DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-            end.to update_index(DummiesIndex::Dummy).and_reindex(43, times: 2, with: {a: 2}) end
+            end.to update_index(DummiesIndex).and_reindex(43, times: 2, with: {a: 2}) end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
@@ -266,26 +267,26 @@ describe :update_index do
   context '#and_delete' do
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-        .to update_index(DummiesIndex::Dummy).and_reindex(42).and_delete(double(id: 43))
+        .to update_index(DummiesIndex).and_reindex(42).and_delete(double(id: 43))
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(id: 43))
+        .to update_index(DummiesIndex).and_delete(42).and_delete(double(id: 43))
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete(42, double(id: 43))
+        .to update_index(DummiesIndex).and_delete(42, double(id: 43))
     end
     specify do
       expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-        .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)])
+        .to update_index(DummiesIndex).and_delete([43, double(id: 42)])
     end
 
     context do
       let(:expectation) do
         expect do
           expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-            .to update_index(DummiesIndex::Dummy).and_reindex(43).and_delete(double(id: 42))
+            .to update_index(DummiesIndex).and_reindex(43).and_delete(double(id: 42))
         end
       end
 
@@ -297,7 +298,7 @@ describe :update_index do
       let(:expectation) do
         expect do
           expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
-            .to update_index(DummiesIndex::Dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3)
+            .to update_index(DummiesIndex).and_delete(44, times: 2).and_delete(double(id: 42), times: 3)
         end
       end
 

data/spec/chewy/runtime_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Runtime do
   describe '.version' do
     specify { expect(described_class.version).to be_a(described_class::Version) }
-    specify { expect(described_class.version).to be >= '2.4' }
-    specify { expect(described_class.version).to be < '6.0' }
+    specify { expect(described_class.version).to be >= '5.6' }
+    specify { expect(described_class.version).to be < '7.0' }
   end
 end

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

@@ -4,7 +4,6 @@ describe Chewy::Search::Parameters::Indices do
   before do
     stub_index(:first) do
       define_type :one
-      define_type :two
     end
 
     stub_index(:second) do
@@ -70,7 +69,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex
-      ).render).to eq(index: %w[first], type: %w[one two])
+      ).render).to eq(index: %w[first], type: %w[one])
     end
     specify do
       expect(described_class.new(
@@ -90,7 +89,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex, types: SecondIndex::Three
-      ).render).to eq(index: %w[first second], type: %w[one three two])
+      ).render).to eq(index: %w[first second], type: %w[one three])
     end
     specify do
       expect(described_class.new(
@@ -100,7 +99,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex, types: :whatever
-      ).render).to eq(index: %w[first], type: %w[one two])
+      ).render).to eq(index: %w[first], type: %w[one])
     end
     specify do
       expect(described_class.new(
@@ -130,7 +129,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex, types: [SecondIndex::Three, :whatever]
-      ).render).to eq(index: %w[first second], type: %w[one three two])
+      ).render).to eq(index: %w[first second], type: %w[one three])
     end
     specify do
       expect(described_class.new(
@@ -151,7 +150,7 @@ describe Chewy::Search::Parameters::Indices do
         .to eq(described_class.new(indices: SecondIndex, types: :whatever))
     end
     specify do
-      expect(described_class.new(indices: :first, types: %w[one two]))
+      expect(described_class.new(indices: :first, types: %w[one]))
         .to eq(described_class.new(indices: FirstIndex))
     end
     specify do
@@ -175,7 +174,7 @@ describe Chewy::Search::Parameters::Indices do
         indices: [FirstIndex, :whatever],
         types: [SecondIndex::Three, :whatever]
       ).types).to contain_exactly(
-        FirstIndex::One, FirstIndex::Two, SecondIndex::Three
+        FirstIndex::One, SecondIndex::Three
       )
     end
 

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

@@ -1,5 +1,5 @@
 require 'chewy/search/parameters/bool_storage_examples'
 
 describe Chewy::Search::Parameters::None do
-  it_behaves_like :bool_storage, query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}
+  it_behaves_like :bool_storage, query: {match_none: {}}
 end

data/spec/chewy/search/parameters_spec.rb

@@ -141,7 +141,7 @@ describe Chewy::Search::Parameters do
 
     context do
       subject { described_class.new(filter: {moo: 'baz'}, none: true) }
-      specify { expect(subject.render).to eq(body: {query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}}) }
+      specify { expect(subject.render).to eq(body: {query: {match_none: {}}}) }
     end
   end
 end

data/spec/chewy/search/request_spec.rb

@@ -10,17 +10,19 @@ describe Chewy::Search::Request do
         field :name
         field :age, type: :integer
       end
+    end
+
+    stub_index(:cities) do
       define_type :city do
         field :id, type: :integer
       end
+    end
+
+    stub_index(:countries) do
       define_type :country do
         field :id, type: :integer
       end
     end
-
-    stub_index(:cities) do
-      define_type :city
-    end
   end
 
   subject { described_class.new(ProductsIndex) }
@@ -30,11 +32,7 @@ describe Chewy::Search::Request do
     specify { expect(described_class.new(ProductsIndex)).not_to eq(described_class.new(CitiesIndex)) }
     specify { expect(described_class.new(ProductsIndex)).not_to eq(described_class.new(ProductsIndex, CitiesIndex)) }
     specify { expect(described_class.new(CitiesIndex, ProductsIndex)).to eq(described_class.new(ProductsIndex, CitiesIndex)) }
-    specify { expect(described_class.new(ProductsIndex::Product)).to eq(described_class.new(ProductsIndex::Product)) }
-    specify { expect(described_class.new(ProductsIndex::Product)).not_to eq(described_class.new(ProductsIndex::City)) }
-    specify { expect(described_class.new(ProductsIndex::Product)).not_to eq(described_class.new(ProductsIndex::Product, ProductsIndex::City)) }
-    specify { expect(described_class.new(ProductsIndex::City, ProductsIndex::Product)).to eq(described_class.new(ProductsIndex::Product, ProductsIndex::City)) }
-    specify { expect(described_class.new(ProductsIndex::City, CitiesIndex::City)).to eq(described_class.new(CitiesIndex::City, ProductsIndex::City)) }
+    specify { expect(described_class.new(ProductsIndex, CitiesIndex)).to eq(described_class.new(CitiesIndex, ProductsIndex)) }
 
     specify { expect(described_class.new(ProductsIndex).limit(10)).to eq(described_class.new(ProductsIndex).limit(10)) }
     specify { expect(described_class.new(ProductsIndex).limit(10)).not_to eq(described_class.new(ProductsIndex).limit(20)) }
@@ -48,7 +46,7 @@ describe Chewy::Search::Request do
       expect(subject.render)
         .to match(
           index: %w[products],
-          type: array_including(%w[product city country]),
+          type: array_including(%w[product]),
           body: {}
         )
     end
@@ -57,11 +55,11 @@ describe Chewy::Search::Request do
   describe '#inspect' do
     specify do
       expect(described_class.new(ProductsIndex).inspect)
-        .to eq('<Chewy::Search::Request {:index=>["products"], :type=>["city", "country", "product"], :body=>{}}>')
+        .to eq('<Chewy::Search::Request {:index=>["products"], :type=>["product"], :body=>{}}>')
     end
     specify do
       expect(ProductsIndex.limit(10).inspect)
-        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["city", "country", "product"], :body=>{:size=>10}}>')
+        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["product"], :body=>{:size=>10}}>')
     end
   end
 
@@ -235,9 +233,8 @@ describe Chewy::Search::Request do
 
   describe '#types' do
     specify { expect(subject.types(:product).render[:type]).to contain_exactly('product') }
-    specify { expect(described_class.new(ProductsIndex::City).types(ProductsIndex::Country).render[:type]).to match_array(%w[city country]) }
-    specify { expect(subject.types(%i[product city]).types(nil).render[:type]).to match_array(%w[product city]) }
-    specify { expect(subject.types(:product).types(:product, :city, :something).render[:type]).to match_array(%w[product city]) }
+    specify { expect(subject.types(%i[product city]).types(nil).render[:type]).to match_array(%w[product]) }
+    specify { expect(subject.types(:product).types(:product, :city, :something).render[:type]).to match_array(%w[product]) }
     specify { expect(subject.types(nil).render[:body]).to be_blank }
     specify { expect { subject.types(:product) }.not_to change { subject.render } }
   end
@@ -279,14 +276,16 @@ describe Chewy::Search::Request do
         define_type City do
           field :rating, type: 'integer'
         end
+      end
 
+      stub_index(:countries) do
         define_type Country do
           field :rating, type: 'integer'
         end
       end
     end
 
-    before { PlacesIndex.import!(cities: cities, countries: countries) }
+    before { PlacesIndex.import!(cities) }
 
     let(:cities) { Array.new(2) { |i| City.create!(rating: i) } }
     let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2) } }
@@ -294,14 +293,14 @@ describe Chewy::Search::Request do
     subject { described_class.new(PlacesIndex).order(:rating) }
 
     describe '#objects' do
-      specify { expect(subject.objects).to eq([*cities, *countries]) }
+      specify { expect(subject.objects).to eq([*cities]) }
       specify { expect(subject.objects.class).to eq(Array) }
     end
 
     describe '#load' do
-      specify { expect(subject.load(only: 'city')).to eq([*cities, *countries]) }
-      specify { expect(subject.load(only: 'city').map(&:class).uniq).to eq([PlacesIndex::City, PlacesIndex::Country]) }
-      specify { expect(subject.load(only: 'city').objects).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(only: 'city')).to eq([*cities]) }
+      specify { expect(subject.load(only: 'city').map(&:class).uniq).to eq([PlacesIndex::City]) }
+      specify { expect(subject.load(only: 'city').objects).to eq([*cities]) }
     end
   end
 
@@ -388,13 +387,13 @@ describe Chewy::Search::Request do
   end
 
   context 'integration' do
-    let(:products) { Array.new(3) { |i| {id: i.next.to_i, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-    let(:cities) { Array.new(3) { |i| {id: (i.next + 3).to_i}.stringify_keys! } }
-    let(:countries) { Array.new(3) { |i| {id: (i.next + 6).to_i}.stringify_keys! } }
+    let(:products_count) { 9 }
+    let(:products) { Array.new(products_count) { |i| {id: i.next.to_i, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    let(:cities) { Array.new(3) { |i| {id: (i.next + 9).to_i}.stringify_keys! } }
+    let(:countries) { Array.new(3) { |i| {id: (i.next + 12).to_i}.stringify_keys! } }
     before do
       ProductsIndex::Product.import!(products.map { |h| double(h) })
-      ProductsIndex::City.import!(cities.map { |h| double(h) })
-      ProductsIndex::Country.import!(countries.map { |h| double(h) })
+      CountriesIndex::Country.import!(countries.map { |h| double(h) })
       CitiesIndex::City.import!(cities.map { |h| double(h) })
     end
 
@@ -407,18 +406,11 @@ describe Chewy::Search::Request do
       specify { expect(subject.size).to eq(3) }
     end
 
-    context 'limited types' do
-      subject { described_class.new(ProductsIndex::City, ProductsIndex::Country) }
+    context 'mixed indexes' do
+      subject { described_class.new(CitiesIndex, ProductsIndex) }
 
-      specify { expect(subject.count).to eq(6) }
-      specify { expect(subject.size).to eq(6) }
-    end
-
-    context 'mixed types' do
-      subject { described_class.new(CitiesIndex, ProductsIndex::Product) }
-
-      specify { expect(subject.count).to eq(9) }
-      specify { expect(subject.size).to eq(9) }
+      specify { expect(subject.count).to eq(12) }
+      specify { expect(subject.size).to eq(10) } # pagination limit
     end
 
     context 'instrumentation' do
@@ -431,9 +423,9 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}},
-          type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
-          types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
+          request: {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}},
+          type: ProductsIndex::Product,
+          types: [ProductsIndex::Product]
         )
       end
     end
@@ -445,10 +437,13 @@ describe Chewy::Search::Request do
     describe '#highlight' do
       specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name).to eq('Name3') }
       specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name_highlight).to eq('<em>Name3</em>') }
+      specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name_highlights).to eq(['<em>Name3</em>']) }
       specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first._data['_source']['name']).to eq('Name3') }
     end
 
     describe '#suggest' do
+      let(:products_count) { 3 }
+
       specify do
         expect(subject.suggest(
           foo: {
@@ -470,7 +465,7 @@ describe Chewy::Search::Request do
     describe '#aggs' do
       specify do
         expect(subject.aggs(avg_age: {avg: {field: :age}}).aggs)
-          .to eq('avg_age' => {'value' => 20.0})
+          .to eq('avg_age' => {'value' => 50.0})
       end
     end
 
@@ -490,8 +485,7 @@ describe Chewy::Search::Request do
       specify { expect(subject.count).to eq(9) }
       specify { expect(subject.limit(6).count).to eq(9) }
       specify { expect(subject.offset(6).count).to eq(9) }
-      specify { expect(subject.types(:product, :something).count).to eq(3) }
-      specify { expect(subject.types(:product, :country).count).to eq(6) }
+      specify { expect(subject.indices(:products, CountriesIndex).count).to eq(12) }
       specify { expect(subject.filter(term: {age: 10}).count).to eq(1) }
       specify { expect(subject.query(term: {age: 10}).count).to eq(1) }
       specify { expect(subject.order(nil).count).to eq(9) }
@@ -530,7 +524,7 @@ describe Chewy::Search::Request do
       context do
         before { expect(Chewy.client).to receive(:search).once.and_call_original }
 
-        specify { expect(subject.first).to be_a(ProductsIndex::Country).and have_attributes(id: 9) }
+        specify { expect(subject.first).to be_a(ProductsIndex::Product).and have_attributes(id: 9) }
         specify { expect(subject.first(3).map(&:id)).to eq([9, 8, 7]) }
         specify { expect(subject.first(10).map(&:id)).to have(9).items }
         specify { expect(subject.limit(5).first(10).map(&:id)).to have(9).items }
@@ -543,7 +537,7 @@ describe Chewy::Search::Request do
           expect(Chewy.client).not_to receive(:search)
         end
 
-        specify { expect(subject.first).to be_a(ProductsIndex::Country).and have_attributes(id: 9) }
+        specify { expect(subject.first).to be_a(ProductsIndex::Product).and have_attributes(id: 9) }
         specify { expect(subject.first(3).map(&:id)).to eq([9, 8, 7]) }
         specify { expect(subject.first(10).map(&:id)).to have(9).items }
 
@@ -576,7 +570,7 @@ describe Chewy::Search::Request do
       specify { expect { subject.post_filter(match: {name: 'name2'}).find('1', '3') }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3' }
 
       context 'make sure it returns everything' do
-        let(:countries) { Array.new(6) { |i| {id: (i.next + 6).to_i}.stringify_keys! } }
+        let(:products_count) { 12 }
         before { expect(Chewy.client).not_to receive(:scroll) }
 
         specify { expect(subject.find((1..12).to_a)).to have(12).items }
@@ -593,15 +587,15 @@ describe Chewy::Search::Request do
 
     describe '#pluck' do
       specify { expect(subject.limit(5).pluck(:_id)).to eq(%w[1 2 3 4 5]) }
-      specify { expect(subject.limit(5).pluck(:_id, :age)).to eq([['1', 10], ['2', 20], ['3', 30], ['4', nil], ['5', nil]]) }
-      specify { expect(subject.limit(5).source(:name).pluck(:id, :age)).to eq([[1, 10], [2, 20], [3, 30], [4, nil], [5, nil]]) }
+      specify { expect(subject.limit(5).pluck(:_id, :age)).to eq([['1', 10], ['2', 20], ['3', 30], ['4', 40], ['5', 50]]) }
+      specify { expect(subject.limit(5).source(:name).pluck(:id, :age)).to eq([[1, 10], [2, 20], [3, 30], [4, 40], [5, 50]]) }
       specify do
         expect(subject.limit(5).pluck(:_index, :_type, :name)).to eq([
           %w[products product Name1],
           %w[products product Name2],
           %w[products product Name3],
-          ['products', 'city', nil],
-          ['products', 'city', nil]
+          %w[products product Name4],
+          %w[products product Name5]
         ])
       end
 
@@ -632,24 +626,12 @@ describe Chewy::Search::Request do
           Chewy.client.indices.refresh(index: 'products')
         end.to change { described_class.new(ProductsIndex).total_count }.from(9).to(7)
       end
-      specify do
-        expect do
-          subject.types(:product).delete_all
-          Chewy.client.indices.refresh(index: 'products')
-        end.to change { described_class.new(ProductsIndex::Product).total_entries }.from(3).to(0)
-      end
       specify do
         expect do
           subject.delete_all
           Chewy.client.indices.refresh(index: 'products')
         end.to change { described_class.new(ProductsIndex).total }.from(9).to(0)
       end
-      specify do
-        expect do
-          described_class.new(ProductsIndex::City).delete_all
-          Chewy.client.indices.refresh(index: 'products')
-        end.to change { described_class.new(ProductsIndex).total }.from(9).to(6)
-      end
 
       specify do
         outer_payload = nil
@@ -660,9 +642,9 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}, refresh: true},
-          type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
-          types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
+          request: {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}, refresh: true},
+          type: ProductsIndex::Product,
+          types: [ProductsIndex::Product]
         )
       end
 
@@ -675,11 +657,44 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[city country product], body: {query: {match: {name: 'name3'}}}, refresh: false},
-          type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
-          types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
+          request: {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}, refresh: false},
+          type: ProductsIndex::Product,
+          types: [ProductsIndex::Product]
         )
       end
     end
+
+    describe '#response=' do
+      let(:query) { ProductsIndex.limit(0) }
+      let(:raw_response) { Chewy.client.search(query.render) }
+
+      it 'wraps and assigns the raw response' do
+        query.response = raw_response
+        expect(query.response).to be_a(Chewy::Search::Response)
+      end
+    end
+
+    describe '#performed?' do
+      let(:query) { ProductsIndex.limit(0) }
+      let(:raw_response) { Chewy.client.search(query.render) }
+
+      it 'is false on a new query' do
+        expect(query.performed?).to eq(false)
+      end
+
+      it 'is true after the search request was issued' do
+        expect do
+          # The `response` method has a side effect of performing unperformed
+          # queries.
+          query.response
+        end.to change(query, :performed?).from(false).to(true)
+      end
+
+      it 'is true after assigning a raw response' do
+        expect do
+          query.response = raw_response
+        end.to change(query, :performed?).from(false).to(true)
+      end
+    end
   end
 end