chewy 5.0.0 → 7.0.1

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

@@ -72,18 +72,20 @@ describe Chewy::Search::Parameters do
   describe '#merge!' do
     let(:first) { described_class.new(offset: 10, order: 'foo') }
     let(:second) { described_class.new(limit: 20, offset: 20, order: 'bar') }
+    let(:first_clone) { first.clone }
+    let(:second_clone) { second.clone }
 
     specify do
       expect { first.merge!(second) }.to change { first.clone }
         .to(described_class.new(limit: 20, offset: 20, order: %w[foo bar]))
     end
-    specify { expect { first.merge!(second) }.not_to change { second.clone } }
+    specify { expect { first.merge!(second) }.not_to change { second_clone } }
 
     specify do
       expect { second.merge!(first) }.to change { second.clone }
         .to(described_class.new(limit: 20, offset: 10, order: %w[bar foo]))
     end
-    specify { expect { second.merge!(first) }.not_to change { first.clone } }
+    specify { expect { second.merge!(first) }.not_to change { first_clone } }
 
     context 'spawns new storages for the merge' do
       let(:names) { %i[limit offset order] }
@@ -100,7 +102,22 @@ describe Chewy::Search::Parameters do
     subject { described_class.new(offset: 10, order: 'foo') }
 
     specify { expect(subject.render).to eq(body: {from: 10, sort: ['foo']}) }
-    specify { expect(described_class.new.render).to eq({}) }
+    specify { expect(described_class.new.render).to eq(body: {}) }
+
+    context do
+      subject { described_class.new(request_cache: true) }
+      specify { expect(subject.render).to eq(body: {}, request_cache: true) }
+    end
+
+    context do
+      subject { described_class.new(search_type: 'query_then_fetch') }
+      specify { expect(subject.render).to eq(body: {}, search_type: 'query_then_fetch') }
+    end
+
+    context do
+      subject { described_class.new(allow_partial_search_results: true) }
+      specify { expect(subject.render).to eq(body: {}, allow_partial_search_results: true) }
+    end
 
     context do
       subject { described_class.new(query: {foo: 'bar'}, filter: {moo: 'baz'}) }
@@ -124,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=>["product", "city", "country"], :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=>["product", "city", "country"], :body=>{:size=>10}}>')
+        .to eq('<ProductsIndex::Query {:index=>["products"], :type=>["product"], :body=>{:size=>10}}>')
     end
   end
 
@@ -151,13 +149,20 @@ describe Chewy::Search::Request do
   end
 
   describe '#request_cache' do
-    specify { expect(subject.request_cache(true).render[:body]).to include(request_cache: true) }
-    specify { expect(subject.request_cache(true).request_cache(false).render[:body]).to include(request_cache: false) }
-    specify { expect(subject.request_cache(true).request_cache(nil).render[:body]).to be_blank }
+    specify { expect(subject.request_cache(true).render).to include(request_cache: true) }
+    specify { expect(subject.request_cache(true).request_cache(false).render).to include(request_cache: false) }
+    specify { expect(subject.request_cache(true).request_cache(nil).render[:request_cache]).to be_blank }
     specify { expect { subject.request_cache(true) }.not_to change { subject.render } }
   end
 
-  %i[search_type preference timeout].each do |name|
+  describe '#search_type' do
+    specify { expect(subject.search_type('foo').render).to include(search_type: 'foo') }
+    specify { expect(subject.search_type('foo').search_type('bar').render).to include(search_type: 'bar') }
+    specify { expect(subject.search_type('foo').search_type(nil).render[:search_type]).to be_blank }
+    specify { expect { subject.search_type('foo') }.not_to change { subject.render } }
+  end
+
+  %i[preference timeout].each do |name|
     describe "##{name}" do
       specify { expect(subject.send(name, :foo).render[:body]).to include(name => 'foo') }
       specify { expect(subject.send(name, :foo).send(name, :bar).render[:body]).to include(name => 'bar') }
@@ -218,10 +223,18 @@ describe Chewy::Search::Request do
     specify { expect { subject.docvalue_fields(:foo) }.not_to change { subject.render } }
   end
 
+  describe '#indices' do
+    specify { expect(described_class.new(:products).render[:index]).to eq(%w[products]) }
+    specify { expect(subject.indices(:cities).render[:index]).to eq(%w[cities products]) }
+    specify { expect(subject.indices(CitiesIndex, :whatever).render[:index]).to eq(%w[cities products whatever]) }
+    specify { expect(subject.indices([CitiesIndex, :products]).render[:index]).to eq(%w[cities products]) }
+    specify { expect { subject.indices(:cities) }.not_to change { subject.render } }
+  end
+
   describe '#types' do
     specify { expect(subject.types(:product).render[:type]).to contain_exactly('product') }
-    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
@@ -263,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) } }
@@ -278,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
 
@@ -372,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
 
@@ -391,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) }
-
-      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) }
+    context 'mixed indexes' do
+      subject { described_class.new(CitiesIndex, ProductsIndex) }
 
-      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
@@ -412,12 +420,14 @@ describe Chewy::Search::Request do
           outer_payload = payload
         end
         subject.query(match: {name: 'name3'}).to_a
+        request = {index: ['products'], type: %w[product], body: {query: {match: {name: 'name3'}}}}
+        request[:rest_total_hits_as_int] = true if Chewy::Runtime.version >= '7.0.0'
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], body: {query: {match: {name: 'name3'}}}},
-          type: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country],
-          types: [ProductsIndex::Product, ProductsIndex::City, ProductsIndex::Country]
+          request: request,
+          type: ProductsIndex::Product,
+          types: [ProductsIndex::Product]
         )
       end
     end
@@ -429,10 +439,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: {
@@ -454,7 +467,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
 
@@ -474,8 +487,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) }
@@ -514,7 +526,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 }
@@ -527,7 +539,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 }
 
@@ -560,7 +572,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 }
@@ -577,15 +589,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
 
@@ -616,24 +628,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
@@ -644,9 +644,9 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], 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
 
@@ -659,11 +659,44 @@ describe Chewy::Search::Request do
         expect(outer_payload).to eq(
           index: ProductsIndex,
           indexes: [ProductsIndex],
-          request: {index: ['products'], type: %w[product city country], 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

data/spec/chewy/search/response_spec.rb

@@ -7,12 +7,13 @@ describe Chewy::Search::Response, :orm do
     stub_model(:city)
     stub_model(:country)
 
-    stub_index(:places) do
+    stub_index(:cities) do
       define_type City do
         field :name
         field :rating, type: 'integer'
       end
-
+    end
+    stub_index(:countries) do
       define_type Country do
         field :name
         field :rating, type: 'integer'
@@ -20,15 +21,18 @@ describe Chewy::Search::Response, :orm do
     end
   end
 
-  before { PlacesIndex.import!(cities: cities, countries: countries) }
+  before do
+    CitiesIndex.import!(cities: cities)
+    CountriesIndex.import!(countries)
+  end
 
   let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
   let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
 
-  let(:request) { Chewy::Search::Request.new(PlacesIndex).order(:rating) }
+  let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating) }
   let(:raw_response) { request.send(:perform) }
   let(:load_options) { {} }
-  let(:loader) { Chewy::Search::Loader.new(indexes: [PlacesIndex], **load_options) }
+  let(:loader) { Chewy::Search::Loader.new(indexes: [CitiesIndex, CountriesIndex], **load_options) }
   subject { described_class.new(raw_response, loader) }
 
   describe '#hits' do
@@ -59,7 +63,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.max_score).to be_nil }
 
     context do
-      let(:request) { Chewy::Search::Request.new(PlacesIndex).query(range: {rating: {lte: 42}}) }
+      let(:request) { Chewy::Search::Request.new(CitiesIndex).query(range: {rating: {lte: 42}}) }
       specify { expect(subject.max_score).to eq(1.0) }
     end
   end
@@ -69,10 +73,13 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex)
+        Chewy::Search::Request.new(CitiesIndex)
           .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}})
       end
-      specify { expect(subject.took).to be > 100 }
+      specify do
+        pending
+        expect(subject.took).to be > 100
+      end
     end
   end
 
@@ -81,10 +88,13 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex)
+        Chewy::Search::Request.new(CitiesIndex)
           .query(script: {script: {inline: 'sleep(100); true', lang: 'groovy'}}).timeout('10ms')
       end
-      specify { expect(subject.timed_out?).to eq(true) }
+      specify do
+        pending
+        expect(subject.timed_out?).to eq(true)
+      end
     end
   end
 
@@ -93,7 +103,7 @@ describe Chewy::Search::Response, :orm do
 
     context do
       let(:request) do
-        Chewy::Search::Request.new(PlacesIndex).suggest(
+        Chewy::Search::Request.new(CitiesIndex).suggest(
           my_suggestion: {
             text: 'city country',
             term: {
@@ -117,7 +127,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.aggs).to eq({}) }
 
     context do
-      let(:request) { Chewy::Search::Request.new(PlacesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
+      let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).aggs(avg_rating: {avg: {field: :rating}}) }
       specify { expect(subject.aggs).to eq('avg_rating' => {'value' => 1.5}) }
     end
   end
@@ -127,7 +137,7 @@ describe Chewy::Search::Response, :orm do
     specify { expect(subject.wrappers).to have(4).items }
     specify do
       expect(subject.wrappers.map(&:class).uniq)
-        .to contain_exactly(PlacesIndex::City, PlacesIndex::Country)
+        .to contain_exactly(CitiesIndex::City, CountriesIndex::Country)
     end
     specify { expect(subject.wrappers.map(&:_data)).to eq(subject.hits) }
 
@@ -149,14 +159,14 @@ describe Chewy::Search::Response, :orm do
     context do
       let(:raw_response) do
         {'hits' => {'hits' => [
-          {'_index' => 'places',
+          {'_index' => 'cities',
            '_type' => 'city',
            '_id' => '1',
            '_score' => 1.3,
            '_source' => {'id' => 2, 'rating' => 0}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::City) }
+      specify { expect(subject.wrappers.first).to be_a(CitiesIndex::City) }
       specify { expect(subject.wrappers.first.id).to eq(2) }
       specify { expect(subject.wrappers.first.rating).to eq(0) }
       specify { expect(subject.wrappers.first._score).to eq(1.3) }
@@ -166,14 +176,14 @@ describe Chewy::Search::Response, :orm do
     context do
       let(:raw_response) do
         {'hits' => {'hits' => [
-          {'_index' => 'places',
+          {'_index' => 'countries',
            '_type' => 'country',
            '_id' => '2',
            '_score' => 1.2,
            '_explanation' => {foo: 'bar'}}
         ]}}
       end
-      specify { expect(subject.wrappers.first).to be_a(PlacesIndex::Country) }
+      specify { expect(subject.wrappers.first).to be_a(CountriesIndex::Country) }
       specify { expect(subject.wrappers.first.id).to eq('2') }
       specify { expect(subject.wrappers.first.rating).to be_nil }
       specify { expect(subject.wrappers.first._score).to eq(1.2) }