chewy 0.8.4 → 0.9.0

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

@@ -18,7 +18,7 @@ if defined?(::Kaminari)
     specify { expect(search.total_pages).to eq(0) }
 
     context do
-      let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      let(:data) { Array.new(10) { |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 { allow(::Kaminari.config).to receive_messages(default_per_page: 3) }
@@ -41,7 +41,7 @@ if defined?(::Kaminari)
 
       describe '#total_count' do
         specify { expect(search.per(4).page(1).total_count).to eq(10) }
-        specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+        specify { expect(search.filter(numeric_range: { age: { gt: 20 } }).limit(3).total_count).to eq(8) }
       end
 
       describe '#load' do

data/spec/chewy/query/pagination/will_paginage_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 if defined?(::WillPaginate)
   describe Chewy::Query::Pagination::WillPaginate do
     before { Chewy.massacre }
@@ -16,10 +15,10 @@ if defined?(::WillPaginate)
 
     let(:search) { ProductsIndex.order(:age) }
 
-    specify { expect(search.total_pages).to eq(1) } #defaults to 1 on will_paginate
+    specify { expect(search.total_pages).to eq(1) } # defaults to 1 on will_paginate
 
     context do
-      let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      let(:data) { Array.new(10) { |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 { allow(::WillPaginate).to receive_messages(per_page: 3) }
@@ -30,7 +29,7 @@ if defined?(::WillPaginate)
         specify { expect(search.page(2).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[3..5]) }
       end
 
-      describe "#paginate" do
+      describe '#paginate' do
         specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..7]) }
         specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..5]) }
         specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..4]) }
@@ -44,7 +43,7 @@ if defined?(::WillPaginate)
 
       describe '#total_entries' do
         specify { expect(search.paginate(page: 1, per_page: 4).total_entries).to eq(10) }
-        specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_entries).to eq(8) }
+        specify { expect(search.filter(numeric_range: { age: { gt: 20 } }).limit(3).total_entries).to eq(8) }
       end
 
       describe '#load' do
@@ -52,8 +51,8 @@ if defined?(::WillPaginate)
         specify { expect(search.paginate(per_page: 2, page: 3).load.first.age).to eq(50) }
         specify { expect(search.paginate(per_page: 2, page: 3).load.page(2).load.first.age).to eq(30) }
 
-        specify { expect(search.paginate(per_page:4, page:1).load.total_count).to eq(10) }
-        specify { expect(search.paginate(per_page:2, page:3).load.total_pages).to eq(5) }
+        specify { expect(search.paginate(per_page: 4, page: 1).load.total_count).to eq(10) }
+        specify { expect(search.paginate(per_page: 2, page: 3).load.total_pages).to eq(5) }
       end
     end
   end

data/spec/chewy/query/pagination_spec.rb

@@ -17,14 +17,14 @@ describe Chewy::Query::Pagination do
   specify { expect(search.total_count).to eq(0) }
 
   context do
-    let(:data) { 10.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    let(:data) { Array.new(10) { |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) }) }
 
     describe '#total_count' do
       specify { expect(search.total_count).to eq(10) }
       specify { expect(search.limit(5).total_count).to eq(10) }
-      specify { expect(search.filter(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+      specify { expect(search.filter(range: { age: { gt: 20 } }).limit(3).total_count).to eq(8) }
     end
 
     describe '#load' do
@@ -32,5 +32,4 @@ describe Chewy::Query::Pagination do
       specify { expect(search.limit(5).load.total_count).to eq(10) }
     end
   end
-
 end

data/spec/chewy/query_spec.rb

@@ -20,9 +20,9 @@ describe Chewy::Query do
   end
 
   context 'integration' do
-    let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-    let(:cities) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
-    let(:countries) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+    let(:products) { Array.new(3) { |i| { id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next }.stringify_keys! } }
+    let(:cities) { Array.new(3) { |i| { id: i.next.to_s }.stringify_keys! } }
+    let(:countries) { Array.new(3) { |i| { id: i.next.to_s }.stringify_keys! } }
     before do
       ProductsIndex::Product.import!(products.map { |h| double(h) })
       ProductsIndex::City.import!(cities.map { |h| double(h) })
@@ -33,19 +33,20 @@ describe Chewy::Query do
     specify { expect(subject.first._data).to be_a Hash }
     specify { expect(subject.limit(6).count).to eq(6) }
     specify { expect(subject.offset(6).count).to eq(3) }
-    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._data['_source']['name']).to eq('Name3') }
+    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._data['_source']['name']).to eq('Name3') }
     specify { expect(subject.types(:product).count).to eq(3) }
     specify { expect(subject.types(:product, :country).count).to eq(6) }
-    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.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) }
     specify { expect(subject.search_type(:count).count).to eq(0) }
     specify { expect(subject.search_type(:count).total).to eq(9) }
   end
 
   describe '#==' do
-    let(:data) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    let(:data) { Array.new(3) { |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) }) }
 
     specify { expect(subject.query(match: 'hello')).to eq(subject.query(match: 'hello')) }
@@ -95,6 +96,7 @@ describe Chewy::Query do
     specify { expect(subject.limit(10)).not_to eq(subject) }
     specify { expect(subject.limit(10).criteria.request_options).to include(size: 10) }
     specify { expect { subject.limit(10) }.not_to change { subject.criteria.request_options } }
+    specify { expect(subject.limit { 20 / 2 }.criteria.request_body[:body]).to include(size: 10) }
   end
 
   describe '#offset' do
@@ -102,6 +104,15 @@ describe Chewy::Query do
     specify { expect(subject.offset(10)).not_to eq(subject) }
     specify { expect(subject.offset(10).criteria.request_options).to include(from: 10) }
     specify { expect { subject.offset(10) }.not_to change { subject.criteria.request_options } }
+    specify { expect(subject.offset { 20 / 2 }.criteria.request_body[:body]).to include(from: 10) }
+  end
+
+  describe '#track_scores' do
+    specify { expect(subject.track_scores(true)).to be_a described_class }
+    specify { expect(subject.track_scores(true)).not_to eq(subject) }
+    specify { expect(subject.track_scores(true).criteria.request_options).to include(track_scores: true) }
+    specify { expect { subject.track_scores(true) }.not_to change { subject.criteria.request_options } }
+    specify { expect(subject.track_scores(false).criteria.request_body[:body]).to include(track_scores: false) }
   end
 
   describe '#script_fields' do
@@ -114,64 +125,82 @@ describe Chewy::Query do
   describe '#script_score' do
     specify { expect(subject.script_score('23')).to be_a described_class }
     specify { expect(subject.script_score('23')).not_to eq(subject) }
-    specify { expect(subject.script_score('23').criteria.scores).to eq([ { script_score: { script: '23' } } ]) }
+    specify { expect(subject.script_score('23').criteria.scores).to eq([{ script_score: { script: '23' } }]) }
     specify { expect { subject.script_score('23') }.not_to change { subject.criteria.scores } }
-    specify { expect(subject.script_score('23 * factor', params: { factor: 0.5}).criteria.scores).to eq([{ script_score: { script: '23 * factor', params: { factor: 0.5} } }]) }
+    specify { expect(subject.script_score('23 * factor', params: { factor: 0.5 }).criteria.scores).to eq([{ script_score: { script: '23 * factor', params: { factor: 0.5 } } }]) }
   end
 
   describe '#boost_factor' do
     specify { expect(subject.boost_factor('23')).to be_a described_class }
     specify { expect(subject.boost_factor('23')).not_to eq(subject) }
-    specify { expect(subject.boost_factor('23').criteria.scores).to eq([ { boost_factor: 23  } ]) }
+    specify { expect(subject.boost_factor('23').criteria.scores).to eq([{ boost_factor: 23 }]) }
     specify { expect { subject.boost_factor('23') }.not_to change { subject.criteria.scores } }
-    specify { expect(subject.boost_factor('23', filter: { foo: :bar}).criteria.scores).to eq([{ boost_factor: 23, filter: { foo: :bar } }]) }
+    specify { expect(subject.boost_factor('23', filter: { foo: :bar }).criteria.scores).to eq([{ boost_factor: 23, filter: { foo: :bar } }]) }
+  end
+
+  describe '#weight' do
+    specify { expect(subject.weight('23')).to be_a described_class }
+    specify { expect(subject.weight('23')).not_to eq(subject) }
+    specify { expect(subject.weight('23').criteria.scores).to eq([{ weight: 23 }]) }
+    specify { expect { subject.weight('23') }.not_to change { subject.criteria.scores } }
+    specify { expect(subject.weight('23', filter: { foo: :bar }).criteria.scores).to eq([{ weight: 23, filter: { foo: :bar } }]) }
   end
 
   describe '#random_score' do
     specify { expect(subject.random_score('23')).to be_a described_class }
     specify { expect(subject.random_score('23')).not_to eq(subject) }
-    specify { expect(subject.random_score('23').criteria.scores).to eq([ { random_score: { seed: 23 } } ]) }
+    specify { expect(subject.random_score('23').criteria.scores).to eq([{ random_score: { seed: 23 } }]) }
     specify { expect { subject.random_score('23') }.not_to change { subject.criteria.scores } }
-    specify { expect(subject.random_score('23', filter: { foo: :bar}).criteria.scores).to eq([{ random_score: { seed: 23 }, filter: { foo: :bar } }]) }
+    specify { expect(subject.random_score('23', filter: { foo: :bar }).criteria.scores).to eq([{ random_score: { seed: 23 }, filter: { foo: :bar } }]) }
   end
 
   describe '#field_value_score' do
     specify { expect(subject.field_value_factor(field: :boost)).to be_a described_class }
     specify { expect(subject.field_value_factor(field: :boost)).not_to eq(subject) }
-    specify { expect(subject.field_value_factor(field: :boost).criteria.scores).to eq([ { field_value_factor: { field: :boost } } ]) }
+    specify { expect(subject.field_value_factor(field: :boost).criteria.scores).to eq([{ field_value_factor: { field: :boost } }]) }
     specify { expect { subject.field_value_factor(field: :boost) }.not_to change { subject.criteria.scores } }
-    specify { expect(subject.field_value_factor({ field: :boost }, filter: { foo: :bar}).criteria.scores).to eq([{ field_value_factor: { field: :boost }, filter: { foo: :bar } }]) }
+    specify { expect(subject.field_value_factor({ field: :boost }, filter: { foo: :bar }).criteria.scores).to eq([{ field_value_factor: { field: :boost }, filter: { foo: :bar } }]) }
   end
 
   describe '#decay' do
     specify { expect(subject.decay(:gauss, :field)).to be_a described_class }
     specify { expect(subject.decay(:gauss, :field)).not_to eq(subject) }
-    specify { expect(subject.decay(:gauss, :field).criteria.scores).to eq([ {
-      gauss: {
-        field: {}
-      }
-    }]) }
+    specify do
+      expect(subject.decay(:gauss, :field).criteria.scores).to eq([{
+                                                                    gauss: {
+                                                                      field: {}
+                                                                    }
+                                                                  }])
+    end
     specify { expect { subject.decay(:gauss, :field) }.not_to change { subject.criteria.scores } }
-    specify {
+    specify do
       expect(subject.decay(:gauss, :field,
-                    origin: '11, 12',
-                    scale: '2km',
-                    offset: '5km',
-                    decay: 0.4,
-                    filter: { foo: :bar }).criteria.scores).to eq([
-        {
-          gauss: {
-            field: {
-              origin: '11, 12',
-              scale: '2km',
-              offset: '5km',
-              decay: 0.4
-            }
-          },
-          filter: { foo: :bar }
-        }
-      ])
-    }
+        origin: '11, 12',
+        scale: '2km',
+        offset: '5km',
+        decay: 0.4,
+        filter: { foo: :bar }).criteria.scores).to eq([
+          {
+            gauss: {
+              field: {
+                origin: '11, 12',
+                scale: '2km',
+                offset: '5km',
+                decay: 0.4
+              }
+            },
+            filter: { foo: :bar }
+          }
+        ])
+    end
+  end
+
+  describe '#preference' do
+    specify { expect(subject.preference(:_primary)).to be_a described_class }
+    specify { expect(subject.preference(:_primary)).not_to eq(subject) }
+    specify { expect(subject.preference(:_primary).criteria.search_options).to include(preference: :_primary) }
+    specify { expect { subject.preference(:_primary) }.not_to change { subject.criteria.search_options } }
+    specify { expect(subject.preference(:_primary).criteria.request_body).to include(preference: :_primary) }
   end
 
   describe '#facets' do
@@ -182,24 +211,24 @@ describe Chewy::Query do
 
     specify do
       skip_on_version_gte('2.0')
-      expect(subject.facets(term: {field: 'hello'})).to be_a described_class
+      expect(subject.facets(term: { field: 'hello' })).to be_a described_class
     end
     specify do
       skip_on_version_gte('2.0')
-      expect(subject.facets(term: {field: 'hello'})).not_to eq(subject)
+      expect(subject.facets(term: { field: 'hello' })).not_to eq(subject)
     end
     specify do
       skip_on_version_gte('2.0')
-      expect(subject.facets(term: {field: 'hello'}).criteria.facets).to include(term: {field: 'hello'})
+      expect(subject.facets(term: { field: 'hello' }).criteria.facets).to include(term: { field: 'hello' })
     end
     specify do
       skip_on_version_gte('2.0')
-      expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets }
+      expect { subject.facets(term: { field: 'hello' }) }.not_to change { subject.criteria.facets }
     end
 
     context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
+      let(:cities) { Array.new(10) { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
 
       before do
         stub_index(:cities) do
@@ -217,28 +246,25 @@ describe Chewy::Query do
       end
       specify do
         skip_on_version_gte('2.0')
-        expect(CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets).to eq({
-          'ratings' => {
-            '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
-            'terms' => [
-              {'term' => 0, 'count' => 4},
-              {'term' => 2, 'count' => 3},
-              {'term' => 1, 'count' => 3}
-            ]
-          }
-        })
+        expect(CitiesIndex.facets(ratings: { terms: { field: 'rating' } }).facets).to eq('ratings' => {
+                                                                                           '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
+                                                                                           'terms' => [
+                                                                                             { 'term' => 0, 'count' => 4 },
+                                                                                             { 'term' => 2, 'count' => 3 },
+                                                                                             { 'term' => 1, 'count' => 3 }
+                                                                                           ]
+                                                                                         })
       end
     end
   end
 
   describe '#aggregations' do
-    specify { expect(subject.aggregations(aggregation1: {field: 'hello'})).to be_a described_class }
-    specify { expect(subject.aggregations(aggregation1: {field: 'hello'})).not_to eq(subject) }
-    specify { expect(subject.aggregations(aggregation1: {field: 'hello'}).criteria.aggregations).to include(aggregation1: {field: 'hello'}) }
-    specify { expect { subject.aggregations(aggregation1: {field: 'hello'}) }.not_to change { subject.criteria.aggregations } }
+    specify { expect(subject.aggregations(aggregation1: { field: 'hello' })).to be_a described_class }
+    specify { expect(subject.aggregations(aggregation1: { field: 'hello' })).not_to eq(subject) }
+    specify { expect(subject.aggregations(aggregation1: { field: 'hello' }).criteria.aggregations).to include(aggregation1: { field: 'hello' }) }
+    specify { expect { subject.aggregations(aggregation1: { field: 'hello' }) }.not_to change { subject.criteria.aggregations } }
 
     context 'when requesting a named aggregation' do
-
       before do
         stub_index(:products) do
           define_type :product do
@@ -292,23 +318,25 @@ describe Chewy::Query do
           end
         end
 
-        it "is the aggregation definition that was last defined" do
+        it 'is the aggregation definition that was last defined' do
           expect(subject.aggregations(:named_agg).criteria.aggregations).to include(named_agg: { avg: { field: 'comments.rating' } })
         end
 
-        context "when the fully qualified aggregation name is provided" do
-          specify { expect(subject
-                               .aggregations("products#product.named_agg")
+        context 'when the fully qualified aggregation name is provided' do
+          specify do
+            expect(subject
+                               .aggregations('products#product.named_agg')
                                .criteria
                                .aggregations)
-                        .to include({ "products#product.named_agg" => { avg: { field: 'title.subfield1' } } }) }
+              .to include('products#product.named_agg' => { avg: { field: 'title.subfield1' } })
+          end
         end
       end
     end
 
     context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
+      let(:cities) { Array.new(10) { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
 
       context do
         before do
@@ -322,25 +350,27 @@ describe Chewy::Query do
         before { CitiesIndex::City.import! cities }
 
         specify { expect(CitiesIndex.aggregations).to eq({}) }
-        specify { expect(CitiesIndex.aggregations(ratings: {terms: {field: 'rating'}})
+        specify do
+          expect(CitiesIndex.aggregations(ratings: { terms: { field: 'rating' } })
           .aggregations['ratings']['buckets'].map { |h| h.slice('key', 'doc_count') }).to eq([
-          { 'key' => 0, 'doc_count' => 4 },
-          { 'key' => 1, 'doc_count' => 3 },
-          { 'key' => 2, 'doc_count' => 3 }
-        ]) }
+            { 'key' => 0, 'doc_count' => 4 },
+            { 'key' => 1, 'doc_count' => 3 },
+            { 'key' => 2, 'doc_count' => 3 }
+          ])
+        end
       end
     end
   end
 
   describe '#suggest' do
-    specify { subject.suggest(name1: {text: 'hello', term: {field: 'name'}}) }
-    specify { expect(subject.suggest(name1: {text: 'hello'})).not_to eq(subject) }
-    specify { expect(subject.suggest(name1: {text: 'hello'}).criteria.suggest).to include(name1: {text: 'hello'}) }
-    specify { expect { subject.suggest(name1: {text: 'hello'}) }.not_to change { subject.criteria.suggest } }
+    specify { subject.suggest(name1: { text: 'hello', term: { field: 'name' } }) }
+    specify { expect(subject.suggest(name1: { text: 'hello' })).not_to eq(subject) }
+    specify { expect(subject.suggest(name1: { text: 'hello' }).criteria.suggest).to include(name1: { text: 'hello' }) }
+    specify { expect { subject.suggest(name1: { text: 'hello' }) }.not_to change { subject.criteria.suggest } }
 
     context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}" } }
+      let(:cities) { Array.new(10) { |i| City.create! id: i + 1, name: "name#{i}" } }
 
       context do
         before do
@@ -354,26 +384,25 @@ describe Chewy::Query do
         before { CitiesIndex::City.import! cities }
 
         specify { expect(CitiesIndex.suggest).to eq({}) }
-        specify { expect(CitiesIndex.suggest(name: {text: 'name', term: {field: 'name'}}).suggest).to eq({
-          'name' => [
-            {'text' => 'name', 'offset' => 0, 'length' => 4, 'options' => [
-                {'text' => 'name0', 'score' => 0.75, 'freq' => 1},
-                {'text' => 'name1', 'score' => 0.75, 'freq' => 1},
-                {'text' => 'name2', 'score' => 0.75, 'freq' => 1},
-                {'text' => 'name3', 'score' => 0.75, 'freq' => 1},
-                {'text' => 'name4', 'score' => 0.75, 'freq' => 1}
-              ]
-            }
-          ] })
-        }
+        specify do
+          expect(CitiesIndex.suggest(name: { text: 'name', term: { field: 'name' } }).suggest).to eq('name' => [
+            { 'text' => 'name', 'offset' => 0, 'length' => 4, 'options' => [
+              { 'text' => 'name0', 'score' => 0.75, 'freq' => 1 },
+              { 'text' => 'name1', 'score' => 0.75, 'freq' => 1 },
+              { 'text' => 'name2', 'score' => 0.75, 'freq' => 1 },
+              { 'text' => 'name3', 'score' => 0.75, 'freq' => 1 },
+              { 'text' => 'name4', 'score' => 0.75, 'freq' => 1 }
+            ] }
+          ])
+        end
       end
     end
   end
 
   describe '#delete_all' do
-    let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-    let(:cities) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
-    let(:countries) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+    let(:products) { Array.new(3) { |i| { id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next }.stringify_keys! } }
+    let(:cities) { Array.new(3) { |i| { id: i.next.to_s }.stringify_keys! } }
+    let(:countries) { Array.new(3) { |i| { id: i.next.to_s }.stringify_keys! } }
 
     before do
       ProductsIndex::Product.import!(products.map { |h| double(h) })
@@ -383,46 +412,51 @@ describe Chewy::Query do
 
     specify do
       skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect {
-        subject.query(match: {name: 'name3'}).delete_all
-        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(8)
+      expect do
+        subject.query(match: { name: 'name3' }).delete_all
+        Chewy.client.indices.refresh(index: 'products')
+      end.to change { ProductsIndex.total }.from(9).to(8)
     end
     specify do
       skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect {
+      expect do
         subject.filter { age == [10, 20] }.delete_all
-        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total_count }.from(9).to(7)
+        Chewy.client.indices.refresh(index: 'products')
+      end.to change { ProductsIndex.total_count }.from(9).to(7)
     end
     specify do
       skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect {
+      expect do
         subject.types(:product).delete_all
-        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex::Product.total_entries }.from(3).to(0)
+        Chewy.client.indices.refresh(index: 'products')
+      end.to change { ProductsIndex::Product.total_entries }.from(3).to(0)
     end
     specify do
       skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect {
+      expect do
         ProductsIndex.delete_all
-        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(0)
+        Chewy.client.indices.refresh(index: 'products')
+      end.to change { ProductsIndex.total }.from(9).to(0)
     end
     specify do
       skip_on_plugin_missing_from_version('delete-by-query', '2.0')
-      expect {
+      expect do
         ProductsIndex::City.delete_all
-        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(6)
+        Chewy.client.indices.refresh(index: 'products')
+      end.to change { ProductsIndex.total }.from(9).to(6)
     end
 
     specify do
       skip_on_version_lt('2.0')
-      expect(Chewy.client.nodes).to receive(:info).and_return({"nodes" => {"a" => {"plugins" => {"name" => "hello"}}}})
-      expect { ProductsIndex.delete_all }.to raise_error(Chewy::PluginMissing).with_message("install delete-by-query plugin")
+      expect(Chewy.client.nodes).to receive(:info).and_return('nodes' => { 'a' => { 'plugins' => { 'name' => 'hello' } } })
+      expect { ProductsIndex.delete_all }.to raise_error(Chewy::PluginMissing).with_message('install delete-by-query plugin')
     end
   end
 
   describe '#find' do
-    let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-    let(:cities) { 1.times.map { |i| {id: '4'}.stringify_keys! } }
-    let(:countries) { 1.times.map { |i| {id: '4'}.stringify_keys! } }
+    let(:products) { Array.new(3) { |i| { id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next }.stringify_keys! } }
+    let(:cities) { Array.new(1) { { id: '4' }.stringify_keys! } }
+    let(:countries) { Array.new(1) { { id: '4' }.stringify_keys! } }
 
     before do
       ProductsIndex::Product.import!(products.map { |h| double(h) })
@@ -444,6 +478,29 @@ describe Chewy::Query do
     specify { expect { subject.find([10, 20]) }.to raise_error Chewy::DocumentNotFound }
   end
 
+  describe '#exists?' do
+    let(:data) { Array.new(10) { |i| { id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next } } }
+
+    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
+
+    specify { expect(subject.exists?).to eq true }
+    specify { expect(subject.limit(5).exists?).to eq true }
+    specify { expect(subject.filter(range: { age: { gt: 20 } }).limit(3).exists?).to eq true }
+    specify { expect(subject.filter(range: { age: { lt: 0 } }).exists?).to eq false }
+  end
+
+  describe '#unlimited' do
+    let(:data_length) { 10 }
+    let(:data) { Array.new(data_length) { |i| { id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next } } }
+
+    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
+
+    specify { expect(subject.unlimited.count).to eq data_length }
+    specify { expect(subject.offset(5).unlimited.count).to eq data_length }
+    specify { expect(subject.limit(1).unlimited.count).to eq data_length }
+    specify { expect(subject.unlimited.limit(1).count).to eq 1 }
+  end
+
   describe '#none' do
     specify { expect(subject.none).to be_a described_class }
     specify { expect(subject.none).not_to eq(subject) }
@@ -473,25 +530,29 @@ describe Chewy::Query do
   end
 
   describe '#filter' do
-    specify { expect(subject.filter(term: {field: 'hello'})).to be_a described_class }
-    specify { expect(subject.filter(term: {field: 'hello'})).not_to eq(subject) }
-    specify { expect { subject.filter(term: {field: 'hello'}) }.not_to change { subject.criteria.filters } }
-    specify { expect(subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters)
-      .to eq([{term: {field: 'hello'}}, {term: {field: 'world'}}]) }
+    specify { expect(subject.filter(term: { field: 'hello' })).to be_a described_class }
+    specify { expect(subject.filter(term: { field: 'hello' })).not_to eq(subject) }
+    specify { expect { subject.filter(term: { field: 'hello' }) }.not_to change { subject.criteria.filters } }
+    specify do
+      expect(subject.filter([{ term: { field: 'hello' } }, { term: { field: 'world' } }]).criteria.filters)
+        .to eq([{ term: { field: 'hello' } }, { term: { field: 'world' } }])
+    end
 
-    specify { expect { subject.filter{ name == 'John' } }.not_to change { subject.criteria.filters } }
-    specify { expect(subject.filter{ name == 'John' }.criteria.filters).to eq([{term: {'name' => 'John'}}]) }
+    specify { expect { subject.filter { name == 'John' } }.not_to change { subject.criteria.filters } }
+    specify { expect(subject.filter { name == 'John' }.criteria.filters).to eq([{ term: { 'name' => 'John' } }]) }
   end
 
   describe '#post_filter' do
-    specify { expect(subject.post_filter(term: {field: 'hello'})).to be_a described_class }
-    specify { expect(subject.post_filter(term: {field: 'hello'})).not_to eq(subject) }
-    specify { expect { subject.post_filter(term: {field: 'hello'}) }.not_to change { subject.criteria.post_filters } }
-    specify { expect(subject.post_filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.post_filters)
-      .to eq([{term: {field: 'hello'}}, {term: {field: 'world'}}]) }
+    specify { expect(subject.post_filter(term: { field: 'hello' })).to be_a described_class }
+    specify { expect(subject.post_filter(term: { field: 'hello' })).not_to eq(subject) }
+    specify { expect { subject.post_filter(term: { field: 'hello' }) }.not_to change { subject.criteria.post_filters } }
+    specify do
+      expect(subject.post_filter([{ term: { field: 'hello' } }, { term: { field: 'world' } }]).criteria.post_filters)
+        .to eq([{ term: { field: 'hello' } }, { term: { field: 'world' } }])
+    end
 
-    specify { expect { subject.post_filter{ name == 'John' } }.not_to change { subject.criteria.post_filters } }
-    specify { expect(subject.post_filter{ name == 'John' }.criteria.post_filters).to eq([{term: {'name' => 'John'}}]) }
+    specify { expect { subject.post_filter { name == 'John' } }.not_to change { subject.criteria.post_filters } }
+    specify { expect(subject.post_filter { name == 'John' }.criteria.post_filters).to eq([{ term: { 'name' => 'John' } }]) }
   end
 
   describe '#order' do
@@ -501,9 +562,9 @@ describe Chewy::Query do
 
     specify { expect(subject.order(:field).criteria.sort).to eq([:field]) }
     specify { expect(subject.order([:field1, :field2]).criteria.sort).to eq([:field1, :field2]) }
-    specify { expect(subject.order(field: :asc).criteria.sort).to eq([{field: :asc}]) }
-    specify { expect(subject.order({field1: :asc, field2: :desc}).criteria.sort).to eq([{field1: :asc}, {field2: :desc}]) }
-    specify { expect(subject.order({field1: {order: :asc}, field2: :desc}).order([:field3], :field4).criteria.sort).to eq([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
+    specify { expect(subject.order(field: :asc).criteria.sort).to eq([{ field: :asc }]) }
+    specify { expect(subject.order(field1: :asc, field2: :desc).criteria.sort).to eq([{ field1: :asc }, { field2: :desc }]) }
+    specify { expect(subject.order(field1: { order: :asc }, field2: :desc).order([:field3], :field4).criteria.sort).to eq([{ field1: { order: :asc } }, { field2: :desc }, :field3, :field4]) }
   end
 
   describe '#reorder' do
@@ -521,8 +582,8 @@ describe Chewy::Query do
     specify { expect(subject.only(:field)).not_to eq(subject) }
     specify { expect { subject.only(:field) }.not_to change { subject.criteria.fields } }
 
-    specify { expect(subject.only(:field1, :field2).criteria.fields).to match_array(['field1', 'field2']) }
-    specify { expect(subject.only([:field1, :field2]).only(:field3).criteria.fields).to match_array(['field1', 'field2', 'field3']) }
+    specify { expect(subject.only(:field1, :field2).criteria.fields).to match_array(%w(field1 field2)) }
+    specify { expect(subject.only([:field1, :field2]).only(:field3).criteria.fields).to match_array(%w(field1 field2 field3)) }
   end
 
   describe '#only!' do
@@ -530,7 +591,7 @@ describe Chewy::Query do
     specify { expect(subject.only!(:field)).not_to eq(subject) }
     specify { expect { subject.only!(:field) }.not_to change { subject.criteria.fields } }
 
-    specify { expect(subject.only!(:field1, :field2).criteria.fields).to match_array(['field1', 'field2']) }
+    specify { expect(subject.only!(:field1, :field2).criteria.fields).to match_array(%w(field1 field2)) }
     specify { expect(subject.only!([:field1, :field2]).only!(:field3).criteria.fields).to match_array(['field3']) }
     specify { expect(subject.only([:field1, :field2]).only!(:field3).criteria.fields).to match_array(['field3']) }
   end
@@ -541,8 +602,8 @@ describe Chewy::Query do
     specify { expect { subject.types(:product) }.not_to change { subject.criteria.types } }
 
     specify { expect(subject.types(:user).criteria.types).to eq(['user']) }
-    specify { expect(subject.types(:product, :city).criteria.types).to match_array(['product', 'city']) }
-    specify { expect(subject.types([:product, :city]).types(:country).criteria.types).to match_array(['product', 'city', 'country']) }
+    specify { expect(subject.types(:product, :city).criteria.types).to match_array(%w(product city)) }
+    specify { expect(subject.types([:product, :city]).types(:country).criteria.types).to match_array(%w(product city country)) }
   end
 
   describe '#types!' do
@@ -551,31 +612,33 @@ describe Chewy::Query do
     specify { expect { subject.types!(:product) }.not_to change { subject.criteria.types } }
 
     specify { expect(subject.types!(:user).criteria.types).to eq(['user']) }
-    specify { expect(subject.types!(:product, :city).criteria.types).to match_array(['product', 'city']) }
+    specify { expect(subject.types!(:product, :city).criteria.types).to match_array(%w(product city)) }
     specify { expect(subject.types!([:product, :city]).types!(:country).criteria.types).to match_array(['country']) }
     specify { expect(subject.types([:product, :city]).types!(:country).criteria.types).to match_array(['country']) }
   end
 
   describe '#search_type' do
-    specify { expect(subject.search_type(:count).options).to include(search_type: :count) }
+    specify { expect(subject.search_type(:count).criteria.search_options).to include(search_type: :count) }
   end
 
   describe '#aggregations' do
-    specify { expect(subject.aggregations(attribute: {terms: {field: 'attribute'}})).to be_a described_class }
-    specify { expect(subject.aggregations(attribute: {terms: {field: 'attribute'}})).not_to eq(subject) }
-    specify { expect(subject.aggregations(attribute: {terms: {field: 'attribute'}}).criteria.request_body[:body]).to include(aggregations: {attribute: {terms: {field: 'attribute'}}}) }
+    specify { expect(subject.aggregations(attribute: { terms: { field: 'attribute' } })).to be_a described_class }
+    specify { expect(subject.aggregations(attribute: { terms: { field: 'attribute' } })).not_to eq(subject) }
+    specify { expect(subject.aggregations(attribute: { terms: { field: 'attribute' } }).criteria.request_body[:body]).to include(aggregations: { attribute: { terms: { field: 'attribute' } } }) }
   end
 
   describe '#merge' do
     let(:query) { described_class.new(ProductsIndex) }
 
-    specify { expect(subject.filter { name == 'name' }.merge(query.filter { age == 42 }).criteria.filters)
-      .to eq([{term: {'name' => 'name'}}, {term: {'age' => 42}}]) }
+    specify do
+      expect(subject.filter { name == 'name' }.merge(query.filter { age == 42 }).criteria.filters)
+        .to eq([{ term: { 'name' => 'name' } }, { term: { 'age' => 42 } }])
+    end
   end
 
   describe '#to_a', :orm do
     before { stub_model(:city) }
-    let(:cities) { 3.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i } }
+    let(:cities) { Array.new(3) { |i| City.create! id: i + 1, name: "name#{i}", rating: i } }
 
     context do
       before do
@@ -583,7 +646,7 @@ describe Chewy::Query do
           define_type :city do
             field :name
             field :rating, type: 'integer'
-            field :nested, type: 'object', value: ->{ {name: name} }
+            field :nested, type: 'object', value: -> { { name: name } }
           end
         end
       end
@@ -593,17 +656,17 @@ describe Chewy::Query do
       specify { expect(CitiesIndex.order(:rating).first).to be_a CitiesIndex::City }
       specify { expect(CitiesIndex.order(:rating).first.name).to eq('name0') }
       specify { expect(CitiesIndex.order(:rating).first.rating).to eq(0) }
-      specify { expect(CitiesIndex.order(:rating).first.nested).to eq({'name' => 'name0'}) }
+      specify { expect(CitiesIndex.order(:rating).first.nested).to eq('name' => 'name0') }
       specify { expect(CitiesIndex.order(:rating).first.id).to eq(cities.first.id.to_s) }
 
       specify { expect(CitiesIndex.order(:rating).only(:name).first.name).to eq('name0') }
       specify { expect(CitiesIndex.order(:rating).only(:name).first.rating).to be_nil }
-      specify { expect(CitiesIndex.order(:rating).only(:nested).first.nested).to eq({'name' => 'name0'}) }
+      specify { expect(CitiesIndex.order(:rating).only(:nested).first.nested).to eq('name' => 'name0') }
 
       specify { expect(CitiesIndex.order(:rating).first._score).to be_nil }
       specify { expect(CitiesIndex.all.first._score).to be > 0 }
-      specify { expect(CitiesIndex.query(match: {name: 'name0'}).first._score).to be > 0 }
-      specify { expect(CitiesIndex.query(match: {name: 'name0'}).took).to be >= 0 }
+      specify { expect(CitiesIndex.query(match: { name: 'name0' }).first._score).to be > 0 }
+      specify { expect(CitiesIndex.query(match: { name: 'name0' }).took).to be >= 0 }
 
       specify { expect(CitiesIndex.order(:rating).first._explanation).to be_nil }
       specify { expect(CitiesIndex.order(:rating).explain.first._explanation).to be_present }
@@ -613,10 +676,10 @@ describe Chewy::Query do
       before do
         stub_index(:cities) do
           define_type :city do
-            root _source: {enabled: false} do
+            root _source: { enabled: false } do
               field :name
               field :rating, type: 'integer'
-              field :nested, type: 'object', value: ->{ {name: name} }
+              field :nested, type: 'object', value: -> { { name: name } }
             end
           end
         end