chewy 0.5.2 → 0.6.0

data/spec/chewy/query_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Query do
-  before do
-    Chewy.client.indices.delete index: '*'
-  end
+  before { Chewy.massacre }
 
   before do
     stub_index(:products) do
@@ -18,7 +16,7 @@ describe Chewy::Query do
   subject { described_class.new(ProductsIndex) }
 
   context 'unexistent index' do
-    specify { subject.to_a.should == [] }
+    specify { expect(subject.to_a).to eq([]) }
   end
 
   context 'integration' do
@@ -31,114 +29,114 @@ describe Chewy::Query do
       ProductsIndex::Country.import!(countries.map { |h| double(h) })
     end
 
-    specify { subject.count.should == 9 }
-    specify { subject.first._data.should be_a Hash }
-    specify { subject.limit(6).count.should == 6 }
-    specify { subject.offset(6).count.should == 3 }
-    specify { subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name.should == '<em>Name3</em>' }
-    specify { subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first._data['_source']['name'].should == 'Name3' }
-    specify { subject.types(:product).count.should == 3 }
-    specify { subject.types(:product, :country).count.should == 6 }
-    specify { subject.filter(term: {age: 10}).count.should == 1 }
-    specify { subject.query(term: {age: 10}).count.should == 1 }
+    specify { expect(subject.count).to eq(9) }
+    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('<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) }
   end
 
   describe '#==' do
     let(:data) { 3.times.map { |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 { subject.query(match: 'hello').should == subject.query(match: 'hello') }
-    specify { subject.query(match: 'hello').should_not == subject.query(match: 'world') }
-    specify { subject.limit(10).should == subject.limit(10) }
-    specify { subject.limit(10).should_not == subject.limit(11) }
-    specify { subject.limit(2).should == subject.limit(2).to_a }
+    specify { expect(subject.query(match: 'hello')).to eq(subject.query(match: 'hello')) }
+    specify { expect(subject.query(match: 'hello')).not_to eq(subject.query(match: 'world')) }
+    specify { expect(subject.limit(10)).to eq(subject.limit(10)) }
+    specify { expect(subject.limit(10)).not_to eq(subject.limit(11)) }
+    specify { expect(subject.limit(2)).to eq(subject.limit(2).to_a) }
   end
 
   describe '#query_mode' do
-    specify { subject.query_mode(:should).should be_a described_class }
-    specify { subject.query_mode(:should).should_not == subject }
-    specify { subject.query_mode(:should).criteria.options.should include(query_mode: :should) }
+    specify { expect(subject.query_mode(:should)).to be_a described_class }
+    specify { expect(subject.query_mode(:should)).not_to eq(subject) }
+    specify { expect(subject.query_mode(:should).criteria.options).to include(query_mode: :should) }
     specify { expect { subject.query_mode(:should) }.not_to change { subject.criteria.options } }
   end
 
   describe '#filter_mode' do
-    specify { subject.filter_mode(:or).should be_a described_class }
-    specify { subject.filter_mode(:or).should_not == subject }
-    specify { subject.filter_mode(:or).criteria.options.should include(filter_mode: :or) }
+    specify { expect(subject.filter_mode(:or)).to be_a described_class }
+    specify { expect(subject.filter_mode(:or)).not_to eq(subject) }
+    specify { expect(subject.filter_mode(:or).criteria.options).to include(filter_mode: :or) }
     specify { expect { subject.filter_mode(:or) }.not_to change { subject.criteria.options } }
   end
 
   describe '#post_filter_mode' do
-    specify { subject.post_filter_mode(:or).should be_a described_class }
-    specify { subject.post_filter_mode(:or).should_not == subject }
-    specify { subject.post_filter_mode(:or).criteria.options.should include(post_filter_mode: :or) }
+    specify { expect(subject.post_filter_mode(:or)).to be_a described_class }
+    specify { expect(subject.post_filter_mode(:or)).not_to eq(subject) }
+    specify { expect(subject.post_filter_mode(:or).criteria.options).to include(post_filter_mode: :or) }
     specify { expect { subject.post_filter_mode(:or) }.not_to change { subject.criteria.options } }
   end
 
   describe '#boost_mode' do
-    specify { subject.boost_mode(:replace).should be_a described_class }
-    specify { subject.boost_mode(:replace).should_not == subject }
-    specify { subject.boost_mode(:replace).criteria.options.should include(boost_mode: :replace) }
+    specify { expect(subject.boost_mode(:replace)).to be_a described_class }
+    specify { expect(subject.boost_mode(:replace)).not_to eq(subject) }
+    specify { expect(subject.boost_mode(:replace).criteria.options).to include(boost_mode: :replace) }
     specify { expect { subject.boost_mode(:replace) }.not_to change { subject.criteria.options } }
   end
 
   describe '#score_mode' do
-    specify { subject.score_mode(:first).should be_a described_class }
-    specify { subject.score_mode(:first).should_not == subject }
-    specify { subject.score_mode(:first).criteria.options.should include(score_mode: :first) }
+    specify { expect(subject.score_mode(:first)).to be_a described_class }
+    specify { expect(subject.score_mode(:first)).not_to eq(subject) }
+    specify { expect(subject.score_mode(:first).criteria.options).to include(score_mode: :first) }
     specify { expect { subject.score_mode(:first) }.not_to change { subject.criteria.options } }
   end
 
   describe '#limit' do
-    specify { subject.limit(10).should be_a described_class }
-    specify { subject.limit(10).should_not == subject }
-    specify { subject.limit(10).criteria.request_options.should include(size: 10) }
+    specify { expect(subject.limit(10)).to be_a described_class }
+    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 } }
   end
 
   describe '#offset' do
-    specify { subject.offset(10).should be_a described_class }
-    specify { subject.offset(10).should_not == subject }
-    specify { subject.offset(10).criteria.request_options.should include(from: 10) }
+    specify { expect(subject.offset(10)).to be_a described_class }
+    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 } }
   end
 
   describe '#script_score' do
-    specify { subject.script_score('23').should be_a described_class }
-    specify { subject.script_score('23').should_not == subject }
-    specify { subject.script_score('23').criteria.scores.should == [ { script_score: { script: '23' } } ] }
+    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') }.not_to change { subject.criteria.scores } }
-    specify { subject.script_score('23', filter: { foo: :bar}).criteria.scores.should == [{ script_score: { script: '23' }, filter: { foo: :bar } }] }
+    specify { expect(subject.script_score('23', filter: { foo: :bar}).criteria.scores).to eq([{ script_score: { script: '23' }, filter: { foo: :bar } }]) }
   end
 
   describe '#boost_factor' do
-    specify { subject.boost_factor('23').should be_a described_class }
-    specify { subject.boost_factor('23').should_not == subject }
-    specify { subject.boost_factor('23').criteria.scores.should == [ { boost_factor: 23  } ] }
+    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') }.not_to change { subject.criteria.scores } }
-    specify { subject.boost_factor('23', filter: { foo: :bar}).criteria.scores.should == [{ 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 '#random_score' do
-    specify { subject.random_score('23').should be_a described_class }
-    specify { subject.random_score('23').should_not == subject }
-    specify { subject.random_score('23').criteria.scores.should == [ { random_score: { seed: 23 } } ] }
+    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') }.not_to change { subject.criteria.scores } }
-    specify { subject.random_score('23', filter: { foo: :bar}).criteria.scores.should == [{ 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 { subject.field_value_factor(field: :boost).should be_a described_class }
-    specify { subject.field_value_factor(field: :boost).should_not == subject }
-    specify { subject.field_value_factor(field: :boost).criteria.scores.should == [ { field_value_factor: { field: :boost } } ] }
+    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) }.not_to change { subject.criteria.scores } }
-    specify { subject.field_value_factor({ field: :boost }, filter: { foo: :bar}).criteria.scores.should == [{ 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 { subject.decay(:gauss, :field).should be_a described_class }
-    specify { subject.decay(:gauss, :field).should_not == subject }
-    specify { subject.decay(:gauss, :field).criteria.scores.should == [ {
+    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: {
           origin: 0,
@@ -147,15 +145,15 @@ describe Chewy::Query do
           decay: 0.1
         }
       }
-    }] }
+    }]) }
     specify { expect { subject.decay(:gauss, :field) }.not_to change { subject.criteria.scores } }
     specify {
-      subject.decay(:gauss, :field,
+      expect(subject.decay(:gauss, :field,
                     origin: '11, 12',
                     scale: '2km',
                     offset: '5km',
                     decay: 0.4,
-                    filter: { foo: :bar }).criteria.scores.should == [
+                    filter: { foo: :bar }).criteria.scores).to eq([
         {
           gauss: {
             field: {
@@ -167,19 +165,19 @@ describe Chewy::Query do
           },
           filter: { foo: :bar }
         }
-      ]
+      ])
     }
   end
 
   describe '#facets' do
-    specify { subject.facets(term: {field: 'hello'}).should be_a described_class }
-    specify { subject.facets(term: {field: 'hello'}).should_not == subject }
-    specify { subject.facets(term: {field: 'hello'}).criteria.facets.should include(term: {field: 'hello'}) }
+    specify { expect(subject.facets(term: {field: 'hello'})).to be_a described_class }
+    specify { expect(subject.facets(term: {field: 'hello'})).not_to eq(subject) }
+    specify { expect(subject.facets(term: {field: 'hello'}).criteria.facets).to include(term: {field: 'hello'}) }
     specify { expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets } }
 
-    context 'results' do
+    context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}", rating: i % 3 } }
+      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
 
       before do
         stub_index(:cities) do
@@ -191,8 +189,8 @@ describe Chewy::Query do
 
       before { CitiesIndex::City.import! cities }
 
-      specify { CitiesIndex.facets.should == {} }
-      specify { CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets.should == {
+      specify { expect(CitiesIndex.facets).to eq({}) }
+      specify { expect(CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets).to eq({
         'ratings' => {
           '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
           'terms' => [
@@ -201,19 +199,19 @@ describe Chewy::Query do
             {'term' => 1, 'count' => 3}
           ]
         }
-      } }
+      }) }
     end
   end
 
   describe '#aggregations' do
-    specify { subject.aggregations(aggregation1: {field: 'hello'}).should be_a described_class }
-    specify { subject.aggregations(aggregation1: {field: 'hello'}).should_not == subject }
-    specify { subject.aggregations(aggregation1: {field: 'hello'}).criteria.aggregations.should include(aggregation1: {field: 'hello'}) }
+    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 'results' do
+    context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}", rating: i % 3 } }
+      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }
 
       context do
         before do
@@ -226,26 +224,26 @@ describe Chewy::Query do
 
         before { CitiesIndex::City.import! cities }
 
-        specify { CitiesIndex.aggregations.should == {} }
-        specify { CitiesIndex.aggregations(ratings: {terms: {field: 'rating'}})
-          .aggregations['ratings']['buckets'].map { |h| h.slice('key', 'doc_count') }.should == [
+        specify { expect(CitiesIndex.aggregations).to eq({}) }
+        specify { 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 }
-        ] }
+        ]) }
       end
     end
   end
 
   describe '#suggest' do
     specify { subject.suggest(name1: {text: 'hello', term: {field: 'name'}}) }
-    specify { subject.suggest(name1: {text: 'hello'}).should_not == subject }
+    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' do
+    context 'results', :orm do
       before { stub_model(:city) }
-      let(:cities) { 10.times.map { |i| City.create! name: "name#{i}" } }
+      let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}" } }
 
       context do
         before do
@@ -258,8 +256,8 @@ describe Chewy::Query do
 
         before { CitiesIndex::City.import! cities }
 
-        specify { CitiesIndex.suggest.should == {} }
-        specify { CitiesIndex.suggest(name: {text: 'name', term: {field: 'name'}}).suggest.should == {
+        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},
@@ -269,7 +267,7 @@ describe Chewy::Query do
                 {'text' => 'name4', 'score' => 0.75, 'freq' => 1}
               ]
             }
-          ] }
+          ] })
         }
       end
     end
@@ -286,140 +284,140 @@ describe Chewy::Query do
       ProductsIndex::Country.import!(countries.map { |h| double(h) })
     end
 
-    specify { expect { subject.query(match: {name: 'name3'}).delete_all }.to change { ProductsIndex.total_count }.from(9).to(8) }
+    specify { expect { subject.query(match: {name: 'name3'}).delete_all }.to change { ProductsIndex.total }.from(9).to(8) }
     specify { expect { subject.filter { age == [10, 20] }.delete_all }.to change { ProductsIndex.total_count }.from(9).to(7) }
-    specify { expect { subject.types(:product).delete_all }.to change { ProductsIndex::Product.total_count }.from(3).to(0) }
-    specify { expect { ProductsIndex.delete_all }.to change { ProductsIndex.total_count }.from(9).to(0) }
-    specify { expect { ProductsIndex::City.delete_all }.to change { ProductsIndex.total_count }.from(9).to(6) }
+    specify { expect { subject.types(:product).delete_all }.to change { ProductsIndex::Product.total_entries }.from(3).to(0) }
+    specify { expect { ProductsIndex.delete_all }.to change { ProductsIndex.total }.from(9).to(0) }
+    specify { expect { ProductsIndex::City.delete_all }.to change { ProductsIndex.total }.from(9).to(6) }
   end
 
   describe '#none' do
-    specify { subject.none.should be_a described_class }
-    specify { subject.none.should_not == subject }
-    specify { subject.none.criteria.should be_none }
+    specify { expect(subject.none).to be_a described_class }
+    specify { expect(subject.none).not_to eq(subject) }
+    specify { expect(subject.none.criteria).to be_none }
 
     context do
       before { expect_any_instance_of(described_class).not_to receive(:_response) }
 
-      specify { subject.none.to_a.should == [] }
-      specify { subject.query(match: 'hello').none.to_a.should == [] }
-      specify { subject.none.query(match: 'hello').to_a.should == [] }
+      specify { expect(subject.none.to_a).to eq([]) }
+      specify { expect(subject.query(match: 'hello').none.to_a).to eq([]) }
+      specify { expect(subject.none.query(match: 'hello').to_a).to eq([]) }
     end
   end
 
   describe '#strategy' do
-    specify { subject.strategy('query_first').should be_a described_class }
-    specify { subject.strategy('query_first').should_not == subject }
-    specify { subject.strategy('query_first').criteria.options.should include(strategy: 'query_first') }
+    specify { expect(subject.strategy('query_first')).to be_a described_class }
+    specify { expect(subject.strategy('query_first')).not_to eq(subject) }
+    specify { expect(subject.strategy('query_first').criteria.options).to include(strategy: 'query_first') }
     specify { expect { subject.strategy('query_first') }.not_to change { subject.criteria.options } }
   end
 
   describe '#query' do
-    specify { subject.query(match: 'hello').should be_a described_class }
-    specify { subject.query(match: 'hello').should_not == subject }
-    specify { subject.query(match: 'hello').criteria.queries.should include(match: 'hello') }
+    specify { expect(subject.query(match: 'hello')).to be_a described_class }
+    specify { expect(subject.query(match: 'hello')).not_to eq(subject) }
+    specify { expect(subject.query(match: 'hello').criteria.queries).to include(match: 'hello') }
     specify { expect { subject.query(match: 'hello') }.not_to change { subject.criteria.queries } }
   end
 
   describe '#filter' do
-    specify { subject.filter(term: {field: 'hello'}).should be_a described_class }
-    specify { subject.filter(term: {field: 'hello'}).should_not == subject }
+    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 { subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters
-      .should == [{term: {field: 'hello'}}, {term: {field: 'world'}}] }
+    specify { expect(subject.filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.filters)
+      .to eq([{term: {field: 'hello'}}, {term: {field: 'world'}}]) }
 
     specify { expect { subject.filter{ name == 'John' } }.not_to change { subject.criteria.filters } }
-    specify { subject.filter{ name == 'John' }.criteria.filters.should == [{term: {'name' => 'John'}}] }
+    specify { expect(subject.filter{ name == 'John' }.criteria.filters).to eq([{term: {'name' => 'John'}}]) }
   end
 
   describe '#post_filter' do
-    specify { subject.post_filter(term: {field: 'hello'}).should be_a described_class }
-    specify { subject.post_filter(term: {field: 'hello'}).should_not == subject }
+    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 { subject.post_filter([{term: {field: 'hello'}}, {term: {field: 'world'}}]).criteria.post_filters
-      .should == [{term: {field: 'hello'}}, {term: {field: 'world'}}] }
+    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{ name == 'John' } }.not_to change { subject.criteria.post_filters } }
-    specify { subject.post_filter{ name == 'John' }.criteria.post_filters.should == [{term: {'name' => 'John'}}] }
+    specify { expect(subject.post_filter{ name == 'John' }.criteria.post_filters).to eq([{term: {'name' => 'John'}}]) }
   end
 
   describe '#order' do
-    specify { subject.order(field: 'hello').should be_a described_class }
-    specify { subject.order(field: 'hello').should_not == subject }
+    specify { expect(subject.order(field: 'hello')).to be_a described_class }
+    specify { expect(subject.order(field: 'hello')).not_to eq(subject) }
     specify { expect { subject.order(field: 'hello') }.not_to change { subject.criteria.sort } }
 
-    specify { subject.order(:field).criteria.sort.should == [:field] }
-    specify { subject.order([:field1, :field2]).criteria.sort.should == [:field1, :field2] }
-    specify { subject.order(field: :asc).criteria.sort.should == [{field: :asc}] }
-    specify { subject.order({field1: {order: :asc}, field2: :desc}).order([:field3], :field4).criteria.sort.should == [{field1: {order: :asc}}, {field2: :desc}, :field3, :field4] }
+    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: {order: :asc}, field2: :desc}).order([:field3], :field4).criteria.sort).to eq([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
   end
 
   describe '#reorder' do
-    specify { subject.reorder(field: 'hello').should be_a described_class }
-    specify { subject.reorder(field: 'hello').should_not == subject }
+    specify { expect(subject.reorder(field: 'hello')).to be_a described_class }
+    specify { expect(subject.reorder(field: 'hello')).not_to eq(subject) }
     specify { expect { subject.reorder(field: 'hello') }.not_to change { subject.criteria.sort } }
 
-    specify { subject.order(:field1).reorder(:field2).criteria.sort.should == [:field2] }
-    specify { subject.order(:field1).reorder(:field2).order(:field3).criteria.sort.should == [:field2, :field3] }
-    specify { subject.order(:field1).reorder(:field2).reorder(:field3).criteria.sort.should == [:field3] }
+    specify { expect(subject.order(:field1).reorder(:field2).criteria.sort).to eq([:field2]) }
+    specify { expect(subject.order(:field1).reorder(:field2).order(:field3).criteria.sort).to eq([:field2, :field3]) }
+    specify { expect(subject.order(:field1).reorder(:field2).reorder(:field3).criteria.sort).to eq([:field3]) }
   end
 
   describe '#only' do
-    specify { subject.only(:field).should be_a described_class }
-    specify { subject.only(:field).should_not == subject }
+    specify { expect(subject.only(:field)).to be_a described_class }
+    specify { expect(subject.only(:field)).not_to eq(subject) }
     specify { expect { subject.only(:field) }.not_to change { subject.criteria.fields } }
 
-    specify { subject.only(:field1, :field2).criteria.fields.should =~ ['field1', 'field2'] }
-    specify { subject.only([:field1, :field2]).only(:field3).criteria.fields.should =~ ['field1', 'field2', 'field3'] }
+    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']) }
   end
 
   describe '#only!' do
-    specify { subject.only!(:field).should be_a described_class }
-    specify { subject.only!(:field).should_not == subject }
+    specify { expect(subject.only!(:field)).to be_a described_class }
+    specify { expect(subject.only!(:field)).not_to eq(subject) }
     specify { expect { subject.only!(:field) }.not_to change { subject.criteria.fields } }
 
-    specify { subject.only!(:field1, :field2).criteria.fields.should =~ ['field1', 'field2'] }
-    specify { subject.only!([:field1, :field2]).only!(:field3).criteria.fields.should =~ ['field3'] }
-    specify { subject.only([:field1, :field2]).only!(:field3).criteria.fields.should =~ ['field3'] }
+    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(['field3']) }
+    specify { expect(subject.only([:field1, :field2]).only!(:field3).criteria.fields).to match_array(['field3']) }
   end
 
   describe '#types' do
-    specify { subject.types(:product).should be_a described_class }
-    specify { subject.types(:product).should_not == subject }
+    specify { expect(subject.types(:product)).to be_a described_class }
+    specify { expect(subject.types(:product)).not_to eq(subject) }
     specify { expect { subject.types(:product) }.not_to change { subject.criteria.types } }
 
-    specify { subject.types(:user).criteria.types.should == ['user'] }
-    specify { subject.types(:product, :city).criteria.types.should =~ ['product', 'city'] }
-    specify { subject.types([:product, :city]).types(:country).criteria.types.should =~ ['product', 'city', 'country'] }
+    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']) }
   end
 
   describe '#types!' do
-    specify { subject.types!(:product).should be_a described_class }
-    specify { subject.types!(:product).should_not == subject }
+    specify { expect(subject.types!(:product)).to be_a described_class }
+    specify { expect(subject.types!(:product)).not_to eq(subject) }
     specify { expect { subject.types!(:product) }.not_to change { subject.criteria.types } }
 
-    specify { subject.types!(:user).criteria.types.should == ['user'] }
-    specify { subject.types!(:product, :city).criteria.types.should =~ ['product', 'city'] }
-    specify { subject.types!([:product, :city]).types!(:country).criteria.types.should =~ ['country'] }
-    specify { subject.types([:product, :city]).types!(:country).criteria.types.should =~ ['country'] }
+    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(['country']) }
+    specify { expect(subject.types([:product, :city]).types!(:country).criteria.types).to match_array(['country']) }
   end
 
   describe '#aggregations' do
-    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).should be_a described_class }
-    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).should_not == subject }
-    specify { subject.aggregations(attribute: {terms: {field: 'attribute'}}).criteria.request_body[:body].should 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 { subject.filter { name == 'name' }.merge(query.filter { age == 42 }).criteria.filters
-      .should == [{term: {'name' => 'name'}}, {term: {'age' => 42}}] }
+    specify { expect(subject.filter { name == 'name' }.merge(query.filter { age == 42 }).criteria.filters)
+      .to eq([{term: {'name' => 'name'}}, {term: {'age' => 42}}]) }
   end
 
-  describe '#to_a' do
+  describe '#to_a', :orm do
     before { stub_model(:city) }
-    let(:cities) { 3.times.map { |i| City.create! name: "name#{i}", rating: i } }
+    let(:cities) { 3.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i } }
 
     context do
       before do
@@ -434,22 +432,23 @@ describe Chewy::Query do
 
       before { CitiesIndex::City.import! cities }
 
-      specify { CitiesIndex.order(:rating).first.should be_a CitiesIndex::City }
-      specify { CitiesIndex.order(:rating).first.name.should == 'name0' }
-      specify { CitiesIndex.order(:rating).first.rating.should == 0 }
-      specify { CitiesIndex.order(:rating).first.nested.should == {'name' => 'name0'} }
-      specify { CitiesIndex.order(:rating).first.id.should == cities.first.id.to_s }
+      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.id).to eq(cities.first.id.to_s) }
 
-      specify { CitiesIndex.order(:rating).only(:name).first.name.should == 'name0' }
-      specify { CitiesIndex.order(:rating).only(:name).first.rating.should be_nil }
-      specify { CitiesIndex.order(:rating).only(:nested).first.nested.should == {'name' => 'name0'} }
+      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 { CitiesIndex.order(:rating).first._score.should be_nil }
-      specify { CitiesIndex.all.first._score.should be > 0 }
-      specify { CitiesIndex.query(match: {name: 'name0'}).first._score.should be > 0 }
+      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 { CitiesIndex.order(:rating).first._data['_explanation'].should be_nil }
-      specify { CitiesIndex.order(:rating).explain.first._data['_explanation'].should be_present }
+      specify { expect(CitiesIndex.order(:rating).first._explanation).to be_nil }
+      specify { expect(CitiesIndex.order(:rating).explain.first._explanation).to be_present }
     end
 
     context 'sourceless' do
@@ -466,10 +465,10 @@ describe Chewy::Query do
       end
       before { CitiesIndex::City.import! cities }
 
-      specify { CitiesIndex.order(:rating).first.should be_a CitiesIndex::City }
-      specify { CitiesIndex.order(:rating).first.name.should be_nil }
-      specify { CitiesIndex.order(:rating).first.rating.should be_nil }
-      specify { CitiesIndex.order(:rating).first.nested.should be_nil }
+      specify { expect(CitiesIndex.order(:rating).first).to be_a CitiesIndex::City }
+      specify { expect(CitiesIndex.order(:rating).first.name).to be_nil }
+      specify { expect(CitiesIndex.order(:rating).first.rating).to be_nil }
+      specify { expect(CitiesIndex.order(:rating).first.nested).to be_nil }
     end
   end
 end