chewy 7.1.0 → 7.2.0

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

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

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

@@ -2,14 +2,8 @@ require 'spec_helper'
 
 describe Chewy::Search::Parameters::Indices do
   before do
-    stub_index(:first) do
-      define_type :one
-    end
-
-    stub_index(:second) do
-      define_type :three
-    end
-
+    stub_index(:first)
+    stub_index(:second)
     stub_index(:third)
   end
 

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

@@ -10,7 +10,7 @@ describe Chewy::Search::Parameters::Order do
     specify { expect(described_class.new(42).value).to eq('42' => nil) }
     specify { expect(described_class.new([42, 43]).value).to eq('42' => nil, '43' => nil) }
     specify { expect(described_class.new(a: 1).value).to eq('a' => 1) }
-    specify { expect(described_class.new(['', 43, a: 1]).value).to eq('a' => 1, '43' => nil) }
+    specify { expect(described_class.new(['', 43, {a: 1}]).value).to eq('a' => 1, '43' => nil) }
   end
 
   describe '#replace!' do

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

@@ -4,19 +4,46 @@ shared_examples :query_storage do |param_name|
   subject { described_class.new(must: {foo: 'bar'}, should: {moo: 'baz'}) }
 
   describe '#initialize' do
-    specify { expect(described_class.new.value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(nil).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(foobar: {}).value.to_h).to eq(must: [{foobar: {}}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(must: {}, should: {}, must_not: {}).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
+    specify do
+      expect(described_class.new.value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(nil).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(foobar: {}).value.to_h)
+        .to eq(must: [{foobar: {}}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(must: {}, should: {}, must_not: {}).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
     specify do
       expect(described_class.new(must: {foo: 'bar'}, should: {foo: 'bar'}, foobar: {}).value.to_h)
         .to eq(must: [{foo: 'bar'}], should: [{foo: 'bar'}], must_not: [], minimum_should_match: nil)
     end
-    specify { expect(subject.value.to_h).to eq(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(proc { match foo: 'bar' }).value.to_h).to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(must: proc { match foo: 'bar' }).value.to_h).to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(minimum_should_match: 3).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: 3) }
-    specify { expect(described_class.new(must: {foo: 'bar'}, minimum_should_match: 3).value.to_h).to eq(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: 3) }
+    specify do
+      expect(subject.value.to_h)
+        .to eq(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(proc { match foo: 'bar' }).value.to_h)
+        .to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(must: proc { match foo: 'bar' }).value.to_h)
+        .to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(minimum_should_match: 3).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: 3)
+    end
+    specify do
+      expect(described_class.new(must: {foo: 'bar'}, minimum_should_match: 3).value.to_h)
+        .to eq(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: 3)
+    end
     specify do
       expect(described_class.new(must: [proc { match foo: 'bar' }, {moo: 'baz'}]).value.to_h)
         .to eq(must: [{match: {foo: 'bar'}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
@@ -73,14 +100,16 @@ shared_examples :query_storage do |param_name|
       expect { subject.and(moo: 'baz') }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
       expect { subject.and([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -93,7 +122,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.and(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     context do
@@ -113,14 +143,16 @@ shared_examples :query_storage do |param_name|
       expect { subject.or(moo: 'baz') }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               {moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
       expect { subject.or([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -133,7 +165,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.or(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               {bool: {should: {foo: 'bar'}}}], must_not: [], minimum_should_match: nil)
     end
 
     context do
@@ -160,7 +193,12 @@ shared_examples :query_storage do |param_name|
       expect { subject.not([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [{bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}}], minimum_should_match: nil)
+        .to(
+          must: [{foo: 'bar'}],
+          should: [{moo: 'baz'}],
+          must_not: [{bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}}],
+          minimum_should_match: nil
+        )
     end
 
     specify do
@@ -173,7 +211,11 @@ shared_examples :query_storage do |param_name|
       expect { subject.not(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [{bool: {should: {foo: 'bar'}}}], minimum_should_match: nil)
+        .to(
+          must: [{foo: 'bar'}], should: [{moo: 'baz'}],
+          must_not: [{bool: {should: {foo: 'bar'}}}],
+          minimum_should_match: nil
+        )
     end
 
     context do
@@ -223,7 +265,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.update!(must: proc { match foo: 'bar' }) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}, {match: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foo: 'bar'},
+                   {match: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -237,7 +280,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.update!(foobar: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}, {foobar: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foo: 'bar'},
+                   {foobar: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -279,7 +323,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.merge!(described_class.new(moo: 'baz')) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -292,7 +337,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.merge!(described_class.new(should: {foo: 'bar'})) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     context do

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

@@ -20,7 +20,10 @@ describe Chewy::Search::Parameters::SearchAfter do
   end
 
   describe '#merge!' do
-    specify { expect { subject.merge!(described_class.new(:baz)) }.to change { subject.value }.from([:foo, 42]).to([:baz]) }
+    specify do
+      expect { subject.merge!(described_class.new(:baz)) }
+        .to change { subject.value }.from([:foo, 42]).to([:baz])
+    end
     specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from([:foo, 42]) }
   end
 

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

@@ -12,8 +12,14 @@ describe Chewy::Search::Parameters::Source do
     specify { expect(described_class.new(true).value).to eq(includes: [], excludes: [], enabled: true) }
     specify { expect(described_class.new(a: 1).value).to eq(includes: [], excludes: [], enabled: true) }
     specify { expect(described_class.new(includes: :foo).value).to eq(includes: %w[foo], excludes: [], enabled: true) }
-    specify { expect(described_class.new(includes: :foo, excludes: 42).value).to eq(includes: %w[foo], excludes: %w[42], enabled: true) }
-    specify { expect(described_class.new(includes: :foo, excludes: 42, enabled: false).value).to eq(includes: %w[foo], excludes: %w[42], enabled: true) }
+    specify do
+      expect(described_class.new(includes: :foo, excludes: 42).value)
+        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
+    end
+    specify do
+      expect(described_class.new(includes: :foo, excludes: 42, enabled: false).value)
+        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
+    end
   end
 
   describe '#replace!' do

data/spec/chewy/search/parameters_spec.rb

@@ -55,7 +55,10 @@ describe Chewy::Search::Parameters do
     subject { described_class.new(limit: 10, offset: 20, order: :foo) }
 
     specify { expect { subject.only!([:limit]) }.to change { subject.clone }.to(described_class.new(limit: 10)) }
-    specify { expect { subject.only!(%i[offset order]) }.to change { subject.clone }.to(described_class.new(offset: 20, order: :foo)) }
+    specify do
+      expect { subject.only!(%i[offset order]) }
+        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
+    end
     specify { expect { subject.only!(%i[limit something]) }.to raise_error NameError }
     specify { expect { subject.only!([]) }.to raise_error ArgumentError }
   end
@@ -63,8 +66,14 @@ describe Chewy::Search::Parameters do
   describe '#except!' do
     subject { described_class.new(limit: 10, offset: 20, order: :foo) }
 
-    specify { expect { subject.except!([:limit]) }.to change { subject.clone }.to(described_class.new(offset: 20, order: :foo)) }
-    specify { expect { subject.except!(%i[offset order]) }.to change { subject.clone }.to(described_class.new(limit: 10)) }
+    specify do
+      expect { subject.except!([:limit]) }
+        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
+    end
+    specify do
+      expect { subject.except!(%i[offset order]) }
+        .to change { subject.clone }.to(described_class.new(limit: 10))
+    end
     specify { expect { subject.except!(%i[limit something]) }.to raise_error NameError }
     specify { expect { subject.except!([]) }.to raise_error ArgumentError }
   end

data/spec/chewy/search/query_proxy_spec.rb

@@ -8,41 +8,86 @@ describe Chewy::Search::QueryProxy do
 
   describe '#must' do
     specify { expect { subject.must }.to raise_error ArgumentError }
-    specify { expect(subject.must(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
-    specify { expect(subject.must { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
+    specify do
+      expect(subject.must(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
+    specify do
+      expect(subject.must(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
   end
 
   describe '#should' do
     specify { expect { subject.should }.to raise_error ArgumentError }
-    specify { expect(subject.should(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}}) }
-    specify { expect(subject.should { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}}) }
+    specify do
+      expect(subject.should(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}})
+    end
+    specify do
+      expect(subject.should(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}})
+    end
   end
 
   describe '#must_not' do
     specify { expect { subject.must_not }.to raise_error ArgumentError }
-    specify { expect(subject.must_not(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}}) }
-    specify { expect(subject.must_not { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}}) }
+    specify do
+      expect(subject.must_not(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
+    end
+    specify do
+      expect(subject.must_not(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
+    end
   end
 
   describe '#and' do
     specify { expect { subject.and }.to raise_error ArgumentError }
-    specify { expect(subject.and(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
-    specify { expect(subject.and { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
-    specify { expect(subject.and(scope).render[:body]).to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}}) }
+    specify do
+      expect(subject.and(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
+    specify do
+      expect(subject.and(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
+    specify do
+      expect(subject.and(scope).render[:body])
+        .to eq(query: {bool: {must: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}})
+    end
   end
 
   describe '#or' do
     specify { expect { subject.or }.to raise_error ArgumentError }
-    specify { expect(subject.or(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
-    specify { expect(subject.or { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}}) }
-    specify { expect(subject.or(scope).render[:body]).to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}}) }
+    specify do
+      expect(subject.or(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
+    specify do
+      expect(subject.or(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
+    end
+    specify do
+      expect(subject.or(scope).render[:body])
+        .to eq(query: {bool: {should: [{match: {foo: 'bar'}}, {bool: {must_not: {match: {foo: 'bar'}}}}]}})
+    end
   end
 
   describe '#not' do
     specify { expect { subject.not }.to raise_error ArgumentError }
-    specify { expect(subject.not(multi_match: {foo: 'bar'}).render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}}) }
-    specify { expect(subject.not { multi_match foo: 'bar' }.render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}}) }
-    specify { expect(subject.not(scope).render[:body]).to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {bool: {must_not: {match: {foo: 'bar'}}}}}}) }
+    specify do
+      expect(subject.not(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
+    end
+    specify do
+      expect(subject.not(multi_match: {foo: 'bar'}).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
+    end
+    specify do
+      expect(subject.not(scope).render[:body])
+        .to eq(query: {bool: {must: {match: {foo: 'bar'}}, must_not: {bool: {must_not: {match: {foo: 'bar'}}}}}})
+    end
   end
 
   describe '#minimum_should_match' do
@@ -53,7 +98,10 @@ describe Chewy::Search::QueryProxy do
         Chewy::Search::Request.new(ProductsIndex)
           .query.should(match: {foo: 'bar'})
       end
-      specify { expect(subject.minimum_should_match('100%').render[:body]).to eq(query: {bool: {should: {match: {foo: 'bar'}}, minimum_should_match: '100%'}}) }
+      specify do
+        expect(subject.minimum_should_match('100%').render[:body])
+          .to eq(query: {bool: {should: {match: {foo: 'bar'}}, minimum_should_match: '100%'}})
+      end
     end
 
     context do
@@ -62,7 +110,10 @@ describe Chewy::Search::QueryProxy do
           .query.should(match: {foo: 'bar'})
           .query.minimum_should_match(2)
       end
-      specify { expect(subject.minimum_should_match(nil).render[:body]).to eq(query: {bool: {should: {match: {foo: 'bar'}}}}) }
+      specify do
+        expect(subject.minimum_should_match(nil).render[:body])
+          .to eq(query: {bool: {should: {match: {foo: 'bar'}}}})
+      end
     end
   end
 end

data/spec/chewy/search/request_spec.rb

@@ -5,23 +5,17 @@ describe Chewy::Search::Request do
 
   before do
     stub_index(:products) do
-      define_type :product do
-        field :id, type: :integer
-        field :name
-        field :age, type: :integer
-      end
+      field :id, type: :integer
+      field :name
+      field :age, type: :integer
     end
 
     stub_index(:cities) do
-      define_type :city do
-        field :id, type: :integer
-      end
+      field :id, type: :integer
     end
 
     stub_index(:countries) do
-      define_type :country do
-        field :id, type: :integer
-      end
+      field :id, type: :integer
     end
   end
 
@@ -31,11 +25,17 @@ describe Chewy::Search::Request do
     specify { expect(described_class.new(ProductsIndex)).to eq(described_class.new(ProductsIndex)) }
     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, CitiesIndex)).to eq(described_class.new(CitiesIndex, ProductsIndex)) }
+    specify do
+      expect(described_class.new(CitiesIndex, ProductsIndex)).to eq(described_class.new(ProductsIndex, CitiesIndex))
+    end
+    specify do
+      expect(described_class.new(ProductsIndex, CitiesIndex)).to eq(described_class.new(CitiesIndex, ProductsIndex))
+    end
 
     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)) }
+    specify do
+      expect(described_class.new(ProductsIndex).limit(10)).not_to eq(described_class.new(ProductsIndex).limit(20))
+    end
 
     specify { expect(ProductsIndex.limit(10)).to eq(ProductsIndex.limit(10)) }
     specify { expect(ProductsIndex.limit(10)).not_to eq(CitiesIndex.limit(10)) }
@@ -64,50 +64,103 @@ describe Chewy::Search::Request do
 
   %i[query post_filter].each do |name|
     describe "##{name}" do
-      specify { expect(subject.send(name, match: {foo: 'bar'}).render[:body]).to include(name => {match: {foo: 'bar'}}) }
+      specify do
+        expect(subject.send(name, match: {foo: 'bar'}).render[:body])
+          .to include(name => {match: {foo: 'bar'}})
+      end
       specify { expect(subject.send(name, nil)).to be_a described_class }
-      specify { expect(subject.send(name) { match foo: 'bar' }.render[:body]).to include(name => {match: {foo: 'bar'}}) }
+      specify do
+        expect(subject.send(name) { match foo: 'bar' }.render[:body])
+          .to include(name => {match: {foo: 'bar'}})
+      end
       specify do
         expect(subject.send(name, match: {foo: 'bar'}).send(name) { multi_match foo: 'bar' }.render[:body])
           .to include(name => {bool: {must: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
       end
       specify { expect { subject.send(name, match: {foo: 'bar'}) }.not_to change { subject.render } }
       specify do
-        expect(subject.send(name).should(match: {foo: 'bar'}).send(name).must_not { multi_match foo: 'bar' }.render[:body])
-          .to include(name => {bool: {should: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
+        expect(
+          subject.send(name).should(match: {foo: 'bar'}).send(name).must_not { multi_match foo: 'bar' }.render[:body]
+        ).to include(name => {bool: {should: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}})
       end
 
       context do
         let(:other_scope) { subject.send(name).should { multi_match foo: 'bar' }.send(name) { match foo: 'bar' } }
 
         specify do
-          expect(subject.send(name).not(other_scope).render[:body])
-            .to include(name => {bool: {must_not: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}}}})
+          expect(
+            subject.send(name).not(other_scope).render[:body]
+          ).to include(
+            name => {
+              bool: {
+                must_not: {
+                  bool: {
+                    must: {match: {foo: 'bar'}},
+                    should: {multi_match: {foo: 'bar'}}
+                  }
+                }
+              }
+            }
+          )
         end
       end
     end
   end
 
   describe '#filter' do
-    specify { expect(subject.filter(match: {foo: 'bar'}).render[:body]).to include(query: {bool: {filter: {match: {foo: 'bar'}}}}) }
+    specify do
+      expect(subject.filter(match: {foo: 'bar'}).render[:body])
+        .to include(query: {bool: {filter: {match: {foo: 'bar'}}}})
+    end
     specify { expect(subject.filter(nil)).to be_a described_class }
-    specify { expect(subject.filter { match foo: 'bar' }.render[:body]).to include(query: {bool: {filter: {match: {foo: 'bar'}}}}) }
+    specify do
+      expect(subject.filter(match: {foo: 'bar'}).render[:body])
+        .to include(query: {bool: {filter: {match: {foo: 'bar'}}}})
+    end
     specify do
       expect(subject.filter(match: {foo: 'bar'}).filter { multi_match foo: 'bar' }.render[:body])
         .to include(query: {bool: {filter: [{match: {foo: 'bar'}}, {multi_match: {foo: 'bar'}}]}})
     end
     specify { expect { subject.filter(match: {foo: 'bar'}) }.not_to change { subject.render } }
     specify do
-      expect(subject.filter.should(match: {foo: 'bar'}).filter.must_not { multi_match foo: 'bar' }.render[:body])
-        .to include(query: {bool: {filter: {bool: {should: {match: {foo: 'bar'}}, must_not: {multi_match: {foo: 'bar'}}}}}})
+      expect(
+        subject.filter.should(match: {foo: 'bar'}).filter.must_not { multi_match foo: 'bar' }.render[:body]
+      ).to include(
+        query: {
+          bool: {
+            filter: {
+              bool: {
+                should: {match: {foo: 'bar'}},
+                must_not: {multi_match: {foo: 'bar'}}
+              }
+            }
+          }
+        }
+      )
     end
 
     context do
       let(:other_scope) { subject.filter.should { multi_match foo: 'bar' }.filter { match foo: 'bar' } }
 
       specify do
-        expect(subject.filter.not(other_scope).render[:body])
-          .to include(query: {bool: {filter: {bool: {must_not: {bool: {must: {match: {foo: 'bar'}}, should: {multi_match: {foo: 'bar'}}}}}}}})
+        expect(
+          subject.filter.not(other_scope).render[:body]
+        ).to include(
+          query: {
+            bool: {
+              filter: {
+                bool: {
+                  must_not: {
+                    bool: {
+                      must: {match: {foo: 'bar'}},
+                      should: {multi_match: {foo: 'bar'}}
+                    }
+                  }
+                }
+              }
+            }
+          }
+        )
       end
     end
   end
@@ -175,23 +228,53 @@ describe Chewy::Search::Request do
     specify { expect(subject.source(:foo, :bar).source(nil).render[:body]).to include(_source: %w[foo bar]) }
     specify { expect(subject.source(%i[foo bar]).source(nil).render[:body]).to include(_source: %w[foo bar]) }
     specify { expect(subject.source(excludes: :foo).render[:body]).to include(_source: {excludes: %w[foo]}) }
-    specify { expect(subject.source(excludes: :foo).source(excludes: %i[foo bar]).render[:body]).to include(_source: {excludes: %w[foo bar]}) }
-    specify { expect(subject.source(excludes: :foo).source(excludes: %i[foo bar]).render[:body]).to include(_source: {excludes: %w[foo bar]}) }
-    specify { expect(subject.source(excludes: :foo).source(:bar).render[:body]).to include(_source: {includes: %w[bar], excludes: %w[foo]}) }
+    specify do
+      expect(subject.source(excludes: :foo).source(excludes: %i[foo bar]).render[:body])
+        .to include(_source: {excludes: %w[foo bar]})
+    end
+    specify do
+      expect(subject.source(excludes: :foo).source(excludes: %i[foo bar]).render[:body])
+        .to include(_source: {excludes: %w[foo bar]})
+    end
+    specify do
+      expect(subject.source(excludes: :foo).source(:bar).render[:body])
+        .to include(_source: {includes: %w[bar], excludes: %w[foo]})
+    end
     specify { expect(subject.source(excludes: :foo).source(false).render[:body]).to include(_source: false) }
-    specify { expect(subject.source(excludes: :foo).source(false).source(excludes: :bar).render[:body]).to include(_source: {excludes: %w[foo bar]}) }
-    specify { expect(subject.source(excludes: :foo).source(false).source(true).render[:body]).to include(_source: {excludes: %w[foo]}) }
+    specify do
+      expect(subject.source(excludes: :foo).source(false).source(excludes: :bar).render[:body])
+        .to include(_source: {excludes: %w[foo bar]})
+    end
+    specify do
+      expect(subject.source(excludes: :foo).source(false).source(true).render[:body])
+        .to include(_source: {excludes: %w[foo]})
+    end
     specify { expect(subject.source(nil).render[:body]).to be_blank }
     specify { expect { subject.source(:foo) }.not_to change { subject.render } }
   end
 
   describe '#stored_fields' do
     specify { expect(subject.stored_fields(:foo).render[:body]).to include(stored_fields: ['foo']) }
-    specify { expect(subject.stored_fields(%i[foo bar]).stored_fields(nil).render[:body]).to include(stored_fields: %w[foo bar]) }
-    specify { expect(subject.stored_fields(:foo).stored_fields(:foo, :bar).render[:body]).to include(stored_fields: %w[foo bar]) }
-    specify { expect(subject.stored_fields(:foo).stored_fields(false).render[:body]).to include(stored_fields: '_none_') }
-    specify { expect(subject.stored_fields(:foo).stored_fields(false).stored_fields(:bar).render[:body]).to include(stored_fields: %w[foo bar]) }
-    specify { expect(subject.stored_fields(:foo).stored_fields(false).stored_fields(true).render[:body]).to include(stored_fields: %w[foo]) }
+    specify do
+      expect(subject.stored_fields(%i[foo bar]).stored_fields(nil).render[:body])
+        .to include(stored_fields: %w[foo bar])
+    end
+    specify do
+      expect(subject.stored_fields(:foo).stored_fields(:foo, :bar).render[:body])
+        .to include(stored_fields: %w[foo bar])
+    end
+    specify do
+      expect(subject.stored_fields(:foo).stored_fields(false).render[:body])
+        .to include(stored_fields: '_none_')
+    end
+    specify do
+      expect(subject.stored_fields(:foo).stored_fields(false).stored_fields(:bar).render[:body])
+        .to include(stored_fields: %w[foo bar])
+    end
+    specify do
+      expect(subject.stored_fields(:foo).stored_fields(false).stored_fields(true).render[:body])
+        .to include(stored_fields: %w[foo])
+    end
     specify { expect(subject.stored_fields(nil).render[:body]).to be_blank }
     specify { expect { subject.stored_fields(:foo) }.not_to change { subject.render } }
   end
@@ -199,8 +282,14 @@ describe Chewy::Search::Request do
   %i[script_fields highlight].each do |name|
     describe "##{name}" do
       specify { expect(subject.send(name, foo: {bar: 42}).render[:body]).to include(name => {'foo' => {bar: 42}}) }
-      specify { expect(subject.send(name, foo: {bar: 42}).send(name, moo: {baz: 43}).render[:body]).to include(name => {'foo' => {bar: 42}, 'moo' => {baz: 43}}) }
-      specify { expect(subject.send(name, foo: {bar: 42}).send(name, nil).render[:body]).to include(name => {'foo' => {bar: 42}}) }
+      specify do
+        expect(subject.send(name, foo: {bar: 42}).send(name, moo: {baz: 43}).render[:body])
+          .to include(name => {'foo' => {bar: 42}, 'moo' => {baz: 43}})
+      end
+      specify do
+        expect(subject.send(name, foo: {bar: 42}).send(name, nil).render[:body])
+          .to include(name => {'foo' => {bar: 42}})
+      end
       specify { expect { subject.send(name, foo: {bar: 42}) }.not_to change { subject.render } }
     end
   end
@@ -208,16 +297,28 @@ describe Chewy::Search::Request do
   %i[suggest aggs].each do |name|
     describe "##{name}" do
       specify { expect(subject.send(name, foo: {bar: 42}).render[:body]).to include(name => {'foo' => {bar: 42}}) }
-      specify { expect(subject.send(name, foo: {bar: 42}).send(name, moo: {baz: 43}).render[:body]).to include(name => {'foo' => {bar: 42}, 'moo' => {baz: 43}}) }
-      specify { expect(subject.send(name, foo: {bar: 42}).send(name, nil).render[:body]).to include(name => {'foo' => {bar: 42}}) }
+      specify do
+        expect(subject.send(name, foo: {bar: 42}).send(name, moo: {baz: 43}).render[:body])
+          .to include(name => {'foo' => {bar: 42}, 'moo' => {baz: 43}})
+      end
+      specify do
+        expect(subject.send(name, foo: {bar: 42}).send(name, nil).render[:body])
+          .to include(name => {'foo' => {bar: 42}})
+      end
       specify { expect { subject.send(name, foo: {bar: 42}) }.not_to change { subject.render } }
     end
   end
 
   describe '#docvalue_fields' do
     specify { expect(subject.docvalue_fields(:foo).render[:body]).to include(docvalue_fields: ['foo']) }
-    specify { expect(subject.docvalue_fields(%i[foo bar]).docvalue_fields(nil).render[:body]).to include(docvalue_fields: %w[foo bar]) }
-    specify { expect(subject.docvalue_fields(:foo).docvalue_fields(:foo, :bar).render[:body]).to include(docvalue_fields: %w[foo bar]) }
+    specify do
+      expect(subject.docvalue_fields(%i[foo bar]).docvalue_fields(nil).render[:body])
+        .to include(docvalue_fields: %w[foo bar])
+    end
+    specify do
+      expect(subject.docvalue_fields(:foo).docvalue_fields(:foo, :bar).render[:body])
+        .to include(docvalue_fields: %w[foo bar])
+    end
     specify { expect(subject.docvalue_fields(nil).render[:body]).to be_blank }
     specify { expect { subject.docvalue_fields(:foo) }.not_to change { subject.render } }
   end
@@ -232,14 +333,23 @@ describe Chewy::Search::Request do
 
   describe '#indices_boost' do
     specify { expect(subject.indices_boost(foo: 1.2).render[:body]).to include(indices_boost: [{'foo' => 1.2}]) }
-    specify { expect(subject.indices_boost(foo: 1.2).indices_boost(moo: 1.3).render[:body]).to include(indices_boost: [{'foo' => 1.2}, {'moo' => 1.3}]) }
-    specify { expect(subject.indices_boost(foo: 1.2).indices_boost(nil).render[:body]).to include(indices_boost: [{'foo' => 1.2}]) }
+    specify do
+      expect(subject.indices_boost(foo: 1.2).indices_boost(moo: 1.3).render[:body])
+        .to include(indices_boost: [{'foo' => 1.2}, {'moo' => 1.3}])
+    end
+    specify do
+      expect(subject.indices_boost(foo: 1.2).indices_boost(nil).render[:body])
+        .to include(indices_boost: [{'foo' => 1.2}])
+    end
     specify { expect { subject.indices_boost(foo: 1.2) }.not_to change { subject.render } }
   end
 
   describe '#rescore' do
     specify { expect(subject.rescore(foo: 42).render[:body]).to include(rescore: [{foo: 42}]) }
-    specify { expect(subject.rescore(foo: 42).rescore(moo: 43).render[:body]).to include(rescore: [{foo: 42}, {moo: 43}]) }
+    specify do
+      expect(subject.rescore(foo: 42).rescore(moo: 43).render[:body])
+        .to include(rescore: [{foo: 42}, {moo: 43}])
+    end
     specify { expect(subject.rescore(foo: 42).rescore(nil).render[:body]).to include(rescore: [{foo: 42}]) }
     specify { expect { subject.rescore(foo: 42) }.not_to change { subject.render } }
   end
@@ -253,7 +363,10 @@ describe Chewy::Search::Request do
 
   describe '#search_after' do
     specify { expect(subject.search_after(:foo, :bar).render[:body]).to include(search_after: %i[foo bar]) }
-    specify { expect(subject.search_after(%i[foo bar]).search_after(:baz).render[:body]).to include(search_after: [:baz]) }
+    specify do
+      expect(subject.search_after(%i[foo bar]).search_after(:baz).render[:body])
+        .to include(search_after: [:baz])
+    end
     specify { expect(subject.search_after(:foo).search_after(nil).render[:body]).to be_blank }
     specify { expect { subject.search_after(:foo) }.not_to change { subject.render } }
   end
@@ -264,15 +377,13 @@ describe Chewy::Search::Request do
       stub_model(:country)
 
       stub_index(:places) do
-        define_type City do
-          field :rating, type: 'integer'
-        end
+        index_scope City
+        field :rating, type: 'integer'
       end
 
       stub_index(:countries) do
-        define_type Country do
-          field :rating, type: 'integer'
-        end
+        index_scope Country
+        field :rating, type: 'integer'
       end
     end
 
@@ -290,7 +401,7 @@ describe Chewy::Search::Request do
 
     describe '#load' do
       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').map(&:class).uniq).to eq([PlacesIndex]) }
       specify { expect(subject.load(only: 'city').objects).to eq([*cities]) }
     end
   end
@@ -310,7 +421,9 @@ describe Chewy::Search::Request do
 
   context do
     let(:first_scope) { subject.query(foo: 'bar').filter.should(moo: 'baz').post_filter.must_not(boo: 'baf').limit(10) }
-    let(:second_scope) { subject.filter(foo: 'bar').post_filter.should(moo: 'baz').query.must_not(boo: 'baf').limit(20) }
+    let(:second_scope) do
+      subject.filter(foo: 'bar').post_filter.should(moo: 'baz').query.must_not(boo: 'baf').limit(20)
+    end
 
     describe '#and' do
       specify do
@@ -379,13 +492,17 @@ describe Chewy::Search::Request do
 
   context 'integration' do
     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(:products) do
+      Array.new(products_count) do |i|
+        {id: i.next.to_i, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys!
+      end
+    end
     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) })
-      CountriesIndex::Country.import!(countries.map { |h| double(h) })
-      CitiesIndex::City.import!(cities.map { |h| double(h) })
+      ProductsIndex.import!(products.map { |h| double(h) })
+      CountriesIndex.import!(countries.map { |h| double(h) })
+      CitiesIndex.import!(cities.map { |h| double(h) })
     end
 
     specify { expect(subject[0]._data).to be_a Hash }
@@ -425,9 +542,18 @@ 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') }
+      specify do
+        expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name_highlight)
+          .to eq('<em>Name3</em>')
+      end
+      specify do
+        expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name_highlights)
+          .to eq(['<em>Name3</em>'])
+      end
+      specify do
+        expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first._data['_source']['name'])
+          .to eq('Name3')
+      end
     end
 
     describe '#suggest' do
@@ -513,7 +639,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::Product).and have_attributes(id: 9) }
+        specify { expect(subject.first).to be_a(ProductsIndex).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 }
@@ -526,7 +652,7 @@ describe Chewy::Search::Request do
           expect(Chewy.client).not_to receive(:search)
         end
 
-        specify { expect(subject.first).to be_a(ProductsIndex::Product).and have_attributes(id: 9) }
+        specify { expect(subject.first).to be_a(ProductsIndex).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 }
 
@@ -547,16 +673,34 @@ describe Chewy::Search::Request do
     end
 
     describe '#find' do
-      specify { expect(subject.find('1')).to be_a(ProductsIndex::Product).and have_attributes(id: 1) }
-      specify { expect(subject.find { |w| w.id == 2 }).to be_a(ProductsIndex::Product).and have_attributes(id: 2) }
+      specify { expect(subject.find('1')).to be_a(ProductsIndex).and have_attributes(id: 1) }
+      specify { expect(subject.find { |w| w.id == 2 }).to be_a(ProductsIndex).and have_attributes(id: 2) }
       specify { expect(subject.limit(2).find('1', '3', '7').map(&:id)).to contain_exactly(1, 3, 7) }
       specify { expect(subject.find(1, 3, 7).map(&:id)).to contain_exactly(1, 3, 7) }
-      specify { expect { subject.find('1', '3', '42') }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 42' }
-      specify { expect { subject.find(1, 3, 42) }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 42' }
-      specify { expect { subject.query(match: {name: 'name3'}).find('1', '3') }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1' }
-      specify { expect { subject.query(match: {name: 'name2'}).find('1', '3') }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3' }
-      specify { expect { subject.filter(match: {name: 'name2'}).find('1', '3') }.to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3' }
-      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' }
+      specify do
+        expect { subject.find('1', '3', '42') }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 42'
+      end
+      specify do
+        expect { subject.find(1, 3, 42) }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 42'
+      end
+      specify do
+        expect { subject.query(match: {name: 'name3'}).find('1', '3') }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1'
+      end
+      specify do
+        expect { subject.query(match: {name: 'name2'}).find('1', '3') }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3'
+      end
+      specify do
+        expect { subject.filter(match: {name: 'name2'}).find('1', '3') }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3'
+      end
+      specify do
+        expect { subject.post_filter(match: {name: 'name2'}).find('1', '3') }
+          .to raise_error Chewy::DocumentNotFound, 'Could not find documents for ids: 1 and 3'
+      end
 
       context 'make sure it returns everything' do
         let(:products_count) { 12 }
@@ -570,14 +714,18 @@ describe Chewy::Search::Request do
         before { expect(Chewy.client).to receive(:scroll).once.and_call_original }
 
         specify { expect(subject.find((1..9).to_a)).to have(9).items }
-        specify { expect(subject.find((1..9).to_a)).to all be_a(Chewy::Type) }
+        specify { expect(subject.find((1..9).to_a)).to all be_a(Chewy::Index) }
       end
     end
 
     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', 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(:_id, :age)).to eq([['1', 10], ['2', 20], ['3', 30], ['4', 40], ['5', 50]])
+      end
+      specify do
+        expect(subject.limit(5).source(:name).pluck(:id, :age)).to eq([[1, 10], [2, 20], [3, 30], [4, 40], [5, 50]])
+      end
       specify do
         expect(subject.limit(5).pluck(:_index, :name)).to eq([
           %w[products Name1],