chewy 0.5.2 → 0.6.0

data/spec/chewy/query/filters_spec.rb

@@ -21,31 +21,31 @@ describe Chewy::Query::Filters do
 
   context 'outer scope' do
     let(:email) { 'email' }
-    specify { query { email }.should be_eql Field(:email) }
-    specify { query { o{email} }.should == 'email' }
+    specify { expect(query { email }).to be_eql Field(:email) }
+    specify { expect(query { o{email} }).to eq('email') }
   end
 
   context 'field' do
     let(:email) { 'email' }
-    specify { query { f(:email) }.should be_eql Field(:email) }
-    specify { query { f{ :email } }.should be_eql Field(:email) }
-    specify { query { f{ email } }.should be_eql Field(:email) }
-    specify { query { email }.should be_eql Field(:email) }
-    specify { query { emails.first }.should be_eql Field('emails.first') }
-    specify { query { emails.first.second }.should be_eql Field('emails.first.second') }
+    specify { expect(query { f(:email) }).to be_eql Field(:email) }
+    specify { expect(query { f{ :email } }).to be_eql Field(:email) }
+    specify { expect(query { f{ email } }).to be_eql Field(:email) }
+    specify { expect(query { email }).to be_eql Field(:email) }
+    specify { expect(query { emails.first }).to be_eql Field('emails.first') }
+    specify { expect(query { emails.first.second }).to be_eql Field('emails.first.second') }
   end
 
   context 'term' do
-    specify { query { email == 'email' }.should be_eql Equal(:email, 'email') }
-    specify { query { name != 'name' }.should be_eql Not(Equal(:name, 'name')) }
-    specify { query { email == ['email1', 'email2'] }.should be_eql Equal(:email, ['email1', 'email2']) }
-    specify { query { email != ['email1', 'email2'] }.should be_eql Not(Equal(:email, ['email1', 'email2'])) }
-    specify { query { email(execution: :bool) == ['email1', 'email2'] }
-      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
-    specify { query { email(:bool) == ['email1', 'email2'] }
-      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
-    specify { query { email(:b) == ['email1', 'email2'] }
-      .should be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    specify { expect(query { email == 'email' }).to be_eql Equal(:email, 'email') }
+    specify { expect(query { name != 'name' }).to be_eql Not(Equal(:name, 'name')) }
+    specify { expect(query { email == ['email1', 'email2'] }).to be_eql Equal(:email, ['email1', 'email2']) }
+    specify { expect(query { email != ['email1', 'email2'] }).to be_eql Not(Equal(:email, ['email1', 'email2'])) }
+    specify { expect(query { email(execution: :bool) == ['email1', 'email2'] })
+      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    specify { expect(query { email(:bool) == ['email1', 'email2'] })
+      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
+    specify { expect(query { email(:b) == ['email1', 'email2'] })
+      .to be_eql Equal(:email, ['email1', 'email2'], execution: :bool) }
   end
 
   context 'bool' do
@@ -63,111 +63,111 @@ describe Chewy::Query::Filters do
   end
 
   context 'exists' do
-    specify { query { email? }.should be_eql Exists(:email) }
-    specify { query { !!email? }.should be_eql Exists(:email) }
-    specify { query { emails.first? }.should be_eql Exists('emails.first') }
-    specify { query { !!emails.first? }.should be_eql Exists('emails.first') }
-    specify { query { emails != nil }.should be_eql Exists('emails') }
-    specify { query { !(emails == nil) }.should be_eql Exists('emails') }
+    specify { expect(query { email? }).to be_eql Exists(:email) }
+    specify { expect(query { !!email? }).to be_eql Exists(:email) }
+    specify { expect(query { emails.first? }).to be_eql Exists('emails.first') }
+    specify { expect(query { !!emails.first? }).to be_eql Exists('emails.first') }
+    specify { expect(query { emails != nil }).to be_eql Exists('emails') }
+    specify { expect(query { !(emails == nil) }).to be_eql Exists('emails') }
   end
 
   context 'missing' do
-    specify { query { !email }.should be_eql Missing(:email) }
-    specify { query { !email? }.should be_eql Missing(:email, null_value: true) }
-    specify { query { !emails.first }.should be_eql Missing('emails.first') }
-    specify { query { !emails.first? }.should be_eql Missing('emails.first', null_value: true) }
-    specify { query { emails == nil }.should be_eql Missing('emails', existence: false, null_value: true) }
-    specify { query { emails.first == nil }.should be_eql Missing('emails.first', existence: false, null_value: true) }
+    specify { expect(query { !email }).to be_eql Missing(:email) }
+    specify { expect(query { !email? }).to be_eql Missing(:email, null_value: true) }
+    specify { expect(query { !emails.first }).to be_eql Missing('emails.first') }
+    specify { expect(query { !emails.first? }).to be_eql Missing('emails.first', null_value: true) }
+    specify { expect(query { emails == nil }).to be_eql Missing('emails', existence: false, null_value: true) }
+    specify { expect(query { emails.first == nil }).to be_eql Missing('emails.first', existence: false, null_value: true) }
   end
 
   context 'range' do
-    specify { query { age > 42 }.should be_eql Range(:age, gt: 42) }
-    specify { query { age >= 42 }.should be_eql Range(:age, gt: 42, left_closed: true) }
-    specify { query { age < 42 }.should be_eql Range(:age, lt: 42) }
-    specify { query { age <= 42 }.should be_eql Range(:age, lt: 42, right_closed: true) }
+    specify { expect(query { age > 42 }).to be_eql Range(:age, gt: 42) }
+    specify { expect(query { age >= 42 }).to be_eql Range(:age, gt: 42, left_closed: true) }
+    specify { expect(query { age < 42 }).to be_eql Range(:age, lt: 42) }
+    specify { expect(query { age <= 42 }).to be_eql Range(:age, lt: 42, right_closed: true) }
 
-    specify { query { age == (30..42) }.should be_eql Range(:age, gt: 30, lt: 42) }
-    specify { query { age == [30..42] }.should be_eql Range(:age, gt: 30, lt: 42, left_closed: true, right_closed: true) }
-    specify { query { (age > 30) & (age < 42) }.should be_eql Range(:age, gt: 30, lt: 42) }
-    specify { query { (age > 30) & (age <= 42) }.should be_eql Range(:age, gt: 30, lt: 42, right_closed: true) }
-    specify { query { (age >= 30) & (age < 42) }.should be_eql Range(:age, gt: 30, lt: 42, left_closed: true) }
-    specify { query { (age >= 30) & (age <= 42) }.should be_eql Range(:age, gt: 30, lt: 42, right_closed: true, left_closed: true) }
-    specify { query { (age > 30) | (age < 42) }.should be_eql Or(Range(:age, gt: 30), Range(:age, lt: 42)) }
+    specify { expect(query { age == (30..42) }).to be_eql Range(:age, gt: 30, lt: 42) }
+    specify { expect(query { age == [30..42] }).to be_eql Range(:age, gt: 30, lt: 42, left_closed: true, right_closed: true) }
+    specify { expect(query { (age > 30) & (age < 42) }).to be_eql Range(:age, gt: 30, lt: 42) }
+    specify { expect(query { (age > 30) & (age <= 42) }).to be_eql Range(:age, gt: 30, lt: 42, right_closed: true) }
+    specify { expect(query { (age >= 30) & (age < 42) }).to be_eql Range(:age, gt: 30, lt: 42, left_closed: true) }
+    specify { expect(query { (age >= 30) & (age <= 42) }).to be_eql Range(:age, gt: 30, lt: 42, right_closed: true, left_closed: true) }
+    specify { expect(query { (age > 30) | (age < 42) }).to be_eql Or(Range(:age, gt: 30), Range(:age, lt: 42)) }
   end
 
   context 'prefix' do
-    specify { query { name =~ 'nam' }.should be_eql Prefix(:name, 'nam') }
-    specify { query { name !~ 'nam' }.should be_eql Not(Prefix(:name, 'nam')) }
+    specify { expect(query { name =~ 'nam' }).to be_eql Prefix(:name, 'nam') }
+    specify { expect(query { name !~ 'nam' }).to be_eql Not(Prefix(:name, 'nam')) }
   end
 
   context 'regexp' do
-    specify { query { name =~ /name/ }.should be_eql Regexp(:name, 'name') }
-    specify { query { name == /name/ }.should be_eql Regexp(:name, 'name') }
-    specify { query { name !~ /name/ }.should be_eql Not(Regexp(:name, 'name')) }
-    specify { query { name != /name/ }.should be_eql Not(Regexp(:name, 'name')) }
-    specify { query { name(:anystring, :intersection) =~ /name/ }.should be_eql Regexp(:name, 'name', flags: %w(anystring intersection)) }
+    specify { expect(query { name =~ /name/ }).to be_eql Regexp(:name, 'name') }
+    specify { expect(query { name == /name/ }).to be_eql Regexp(:name, 'name') }
+    specify { expect(query { name !~ /name/ }).to be_eql Not(Regexp(:name, 'name')) }
+    specify { expect(query { name != /name/ }).to be_eql Not(Regexp(:name, 'name')) }
+    specify { expect(query { name(:anystring, :intersection) =~ /name/ }).to be_eql Regexp(:name, 'name', flags: %w(anystring intersection)) }
   end
 
   context 'query' do
     let(:some_query) { 'some query' }
-    specify { query { q('some query') }.should be_eql Query('some query') }
-    specify { query { q{'some query'} }.should be_eql Query('some query') }
-    specify { query { q{ some_query } }.should be_eql Query('some query') }
+    specify { expect(query { q('some query') }).to be_eql Query('some query') }
+    specify { expect(query { q{'some query'} }).to be_eql Query('some query') }
+    specify { expect(query { q{ some_query } }).to be_eql Query('some query') }
   end
 
   context 'raw' do
     let(:raw_query) { {term: {name: 'name'}} }
-    specify { query { r(term: {name: 'name'}) }.should be_eql Raw(term: {name: 'name'}) }
-    specify { query { r{ {term: {name: 'name'}} } }.should be_eql Raw(term: {name: 'name'}) }
-    specify { query { r{ raw_query } }.should be_eql Raw(term: {name: 'name'}) }
+    specify { expect(query { r(term: {name: 'name'}) }).to be_eql Raw(term: {name: 'name'}) }
+    specify { expect(query { r{ {term: {name: 'name'}} } }).to be_eql Raw(term: {name: 'name'}) }
+    specify { expect(query { r{ raw_query } }).to be_eql Raw(term: {name: 'name'}) }
   end
 
   context 'script' do
     let(:some_script) { 'some script' }
-    specify { query { s('some script') }.should be_eql Script('some script') }
-    specify { query { s('some script', param1: 42) }.should be_eql Script('some script', param1: 42) }
-    specify { query { s{'some script'} }.should be_eql Script('some script') }
-    specify { query { s(param1: 42) { some_script } }.should be_eql Script('some script', param1: 42) }
+    specify { expect(query { s('some script') }).to be_eql Script('some script') }
+    specify { expect(query { s('some script', param1: 42) }).to be_eql Script('some script', param1: 42) }
+    specify { expect(query { s{'some script'} }).to be_eql Script('some script') }
+    specify { expect(query { s(param1: 42) { some_script } }).to be_eql Script('some script', param1: 42) }
   end
 
   context 'and or not' do
-    specify { query { (email == 'email') & (name == 'name') }
-      .should be_eql And(Equal(:email, 'email'), Equal(:name, 'name')) }
-    specify { query { (email == 'email') | (name == 'name') }
-      .should be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
-    specify { query { !(email == 'email') }.should be_eql Not(Equal(:email, 'email')) }
-
-    specify { query { (email == 'email') & (name == 'name') | (address != 'address') }
-      .should be_eql Or(
+    specify { expect(query { (email == 'email') & (name == 'name') })
+      .to be_eql And(Equal(:email, 'email'), Equal(:name, 'name')) }
+    specify { expect(query { (email == 'email') | (name == 'name') })
+      .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
+    specify { expect(query { !(email == 'email') }).to be_eql Not(Equal(:email, 'email')) }
+
+    specify { expect(query { (email == 'email') & (name == 'name') | (address != 'address') })
+      .to be_eql Or(
         And(
           Equal(:email, 'email'),
           Equal(:name, 'name')
         ),
         Not(Equal(:address, 'address'))
       ) }
-    specify { query { (email == 'email') & ((name == 'name') | (address != 'address')) }
-      .should be_eql And(
+    specify { expect(query { (email == 'email') & ((name == 'name') | (address != 'address')) })
+      .to be_eql And(
         Equal(:email, 'email'),
         Or(
           Equal(:name, 'name'),
           Not(Equal(:address, 'address')),
         )
       ) }
-    specify { query { (email == 'email') & ((name == 'name') & (address != 'address')) }
-      .should be_eql And(
+    specify { expect(query { (email == 'email') & ((name == 'name') & (address != 'address')) })
+      .to be_eql And(
         Equal(:email, 'email'),
         Equal(:name, 'name'),
         Not(Equal(:address, 'address')),
       ) }
-    specify { query { ((email == 'email') | (name == 'name')) | (address != 'address') }
-      .should be_eql Or(
+    specify { expect(query { ((email == 'email') | (name == 'name')) | (address != 'address') })
+      .to be_eql Or(
         Equal(:email, 'email'),
         Equal(:name, 'name'),
         Not(Equal(:address, 'address')),
       ) }
-    specify { query { !((email == 'email') | (name == 'name')) }
-      .should be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name'))) }
-    specify { query { !!((email == 'email') | (name == 'name')) }
-      .should be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
+    specify { expect(query { !((email == 'email') | (name == 'name')) })
+      .to be_eql Not(Or(Equal(:email, 'email'), Equal(:name, 'name'))) }
+    specify { expect(query { !!((email == 'email') | (name == 'name')) })
+      .to be_eql Or(Equal(:email, 'email'), Equal(:name, 'name')) }
   end
 end

data/spec/chewy/query/loading_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Chewy::Query::Loading do
-  before { Chewy.client.indices.delete index: '*' }
+describe Chewy::Query::Loading, :orm do
+  before { Chewy.massacre }
 
   before do
     stub_model(:city)
@@ -17,6 +17,7 @@ describe Chewy::Query::Loading do
         define_type City do
           field :rating, type: 'integer', value: ->(o){ o.rating }
         end
+
         define_type Country do
           field :rating, type: 'integer', value: ->(o){ o.rating }
         end
@@ -26,30 +27,60 @@ describe Chewy::Query::Loading do
     before { PlacesIndex.import!(cities: cities, countries: countries) }
 
     describe '#load' do
-      specify { PlacesIndex.order(:rating).limit(6).load.total_count.should == 12 }
-      specify { PlacesIndex.order(:rating).limit(6).load.should =~ cities.first(3) + countries.first(3) }
-
-      specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } })
-        .should =~ cities.first(2) + countries.first(3) + [nil] }
-      specify { PlacesIndex.limit(6).load(city: { scope: ->{ where('rating < 2') } }).order(:rating)
-        .should =~ cities.first(2) + countries.first(3) + [nil] }
-      specify { PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') })
-        .should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
-      specify { PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') })
-        .should =~ cities.first(2) + countries.first(3) + [nil] }
+      specify { expect(PlacesIndex.order(:rating).limit(6).load.total_count).to eq(12) }
+      specify { expect(PlacesIndex.order(:rating).limit(6).load).to match_array(cities.first(3) + countries.first(3)) }
+
+      context 'mongoid', :mongoid do
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where(:rating.lt => 2) } }).order(:rating))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where(:rating.lt => 2) }))
+          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where(:rating.lt => 2) }))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+      end
+
+      context 'active record', :active_record do
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: ->{ where('rating < 2') } }))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify { expect(PlacesIndex.limit(6).load(city: { scope: ->{ where('rating < 2') } }).order(:rating))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(scope: ->{ where('rating < 2') }))
+          .to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).load(city: { scope: City.where('rating < 2') }))
+          .to match_array(cities.first(2) + countries.first(3) + [nil]) }
+      end
     end
 
     describe '#preload' do
-      specify { PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where('rating < 2') })
-        .map(&:_object).should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
-      specify { PlacesIndex.limit(6).preload(scope: ->{ where('rating < 2') }).order(:rating)
-        .map(&:_object).should =~ cities.first(2) + countries.first(2) + [nil] * 2 }
-      specify { PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where('rating < 2') })
-        .map(&:_object).should =~ cities.first(2) + [nil] * 4 }
-      specify { PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where('rating < 2') })
-        .map(&:_object).should =~ countries.first(2) + [nil] * 4 }
-      specify { PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where('rating < 2') })
-        .map(&:_object).should =~ [nil] * 6 }
+      context 'mongoid', :mongoid do
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where(:rating.lt => 2) })
+          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where(:rating.lt => 2) }).order(:rating)
+          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where(:rating.lt => 2) })
+          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where(:rating.lt => 2) })
+          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where(:rating.lt => 2) })
+          .map(&:_object)).to match_array([nil] * 6) }
+      end
+
+      context 'active record', :active_record do
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(scope: ->{ where('rating < 2') })
+          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+        specify { expect(PlacesIndex.limit(6).preload(scope: ->{ where('rating < 2') }).order(:rating)
+          .map(&:_object)).to match_array(cities.first(2) + countries.first(2) + [nil] * 2) }
+
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: :city, scope: ->{ where('rating < 2') })
+          .map(&:_object)).to match_array(cities.first(2) + [nil] * 4) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(except: [:city], scope: ->{ where('rating < 2') })
+          .map(&:_object)).to match_array(countries.first(2) + [nil] * 4) }
+        specify { expect(PlacesIndex.order(:rating).limit(6).preload(only: [:city], except: :city, scope: ->{ where('rating < 2') })
+          .map(&:_object)).to match_array([nil] * 6) }
+      end
     end
   end
 end

data/spec/chewy/query/nodes/and_spec.rb

@@ -6,11 +6,11 @@ describe Chewy::Query::Nodes::And do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name? & (email == 'email') }.should == {
+    specify { expect(render { name? & (email == 'email') }).to eq({
       and: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}]
-    } }
-    specify { render { ~(name? & (email == 'email')) }.should == {
+    }) }
+    specify { expect(render { ~(name? & (email == 'email')) }).to eq({
       and: {filters: [{exists: {field: 'name'}}, {term: {'email' => 'email'}}], _cache: true}
-    } }
+    }) }
   end
 end

data/spec/chewy/query/nodes/bool_spec.rb

@@ -6,17 +6,17 @@ describe Chewy::Query::Nodes::Bool do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { must(name == 'name', email == 'email') }.should == {
+    specify { expect(render { must(name == 'name', email == 'email') }).to eq({
       bool: {must: [{term: {'name' => 'name'}}, {term: {'email' => 'email'}}]
-    } } }
-    specify { render { must(name == 'name').must_not(email == 'email') }.should == {
+    } }) }
+    specify { expect(render { must(name == 'name').must_not(email == 'email') }).to eq({
       bool: {must: [{term: {'name' => 'name'}}], must_not: [{term: {'email' => 'email'}}]
-    } } }
-    specify { render { must(name == 'name').should(email == 'email') }.should == {
+    } }) }
+    specify { expect(render { must(name == 'name').should(email == 'email') }).to eq({
       bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}]
-    } } }
-    specify { render { ~must(name == 'name').should(email == 'email') }.should == {
+    } }) }
+    specify { expect(render { ~must(name == 'name').should(email == 'email') }).to eq({
       bool: {must: [{term: {'name' => 'name'}}], should: [{ term: {'email' => 'email'}}], _cache: true
-    } } }
+    } }) }
   end
 end

data/spec/chewy/query/nodes/equal_spec.rb

@@ -6,27 +6,27 @@ describe Chewy::Query::Nodes::Equal do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name == 'name' }.should == {term: {'name' => 'name'}} }
-    specify { render { name != 'name' }.should == {not: {term: {'name' => 'name'}}} }
-    specify { render { name == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2']}} }
-    specify { render { name != ['name1', 'name2'] }.should == {not: {terms: {'name' => ['name1', 'name2']}}} }
+    specify { expect(render { name == 'name' }).to eq({term: {'name' => 'name'}}) }
+    specify { expect(render { name != 'name' }).to eq({not: {term: {'name' => 'name'}}}) }
+    specify { expect(render { name == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2']}}) }
+    specify { expect(render { name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['name1', 'name2']}}}) }
 
-    specify { render { name(:bool) == 'name' }.should == {term: {'name' => 'name'}} }
-    specify { render { name(:borogoves) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2']}} }
+    specify { expect(render { name(:bool) == 'name' }).to eq({term: {'name' => 'name'}}) }
+    specify { expect(render { name(:borogoves) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2']}}) }
 
-    specify { render { name(:|) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or}} }
-    specify { render { name(:or) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or}} }
-    specify { render { name(:&) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :and}} }
-    specify { render { name(:and) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :and}} }
-    specify { render { name(:b) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :bool}} }
-    specify { render { name(:bool) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :bool}} }
-    specify { render { name(:f) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :fielddata}} }
-    specify { render { name(:fielddata) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :fielddata}} }
+    specify { expect(render { name(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
+    specify { expect(render { name(:or) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or}}) }
+    specify { expect(render { name(:&) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
+    specify { expect(render { name(:and) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :and}}) }
+    specify { expect(render { name(:b) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
+    specify { expect(render { name(:bool) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :bool}}) }
+    specify { expect(render { name(:f) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :fielddata}}) }
+    specify { expect(render { name(:fielddata) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :fielddata}}) }
 
-    specify { render { ~name == 'name' }.should == {term: {'name' => 'name', _cache: true}} }
-    specify { render { ~(name == 'name') }.should == {term: {'name' => 'name', _cache: true}} }
-    specify { render { ~name != 'name' }.should == {not: {term: {'name' => 'name', _cache: true}}} }
-    specify { render { ~name(:|) == ['name1', 'name2'] }.should == {terms: {'name' => ['name1', 'name2'], execution: :or, _cache: true}} }
-    specify { render { ~name != ['name1', 'name2'] }.should == {not: {terms: {'name' => ['name1', 'name2'], _cache: true}}} }
+    specify { expect(render { ~name == 'name' }).to eq({term: {'name' => 'name', _cache: true}}) }
+    specify { expect(render { ~(name == 'name') }).to eq({term: {'name' => 'name', _cache: true}}) }
+    specify { expect(render { ~name != 'name' }).to eq({not: {term: {'name' => 'name', _cache: true}}}) }
+    specify { expect(render { ~name(:|) == ['name1', 'name2'] }).to eq({terms: {'name' => ['name1', 'name2'], execution: :or, _cache: true}}) }
+    specify { expect(render { ~name != ['name1', 'name2'] }).to eq({not: {terms: {'name' => ['name1', 'name2'], _cache: true}}}) }
   end
 end

data/spec/chewy/query/nodes/exists_spec.rb

@@ -6,13 +6,13 @@ describe Chewy::Query::Nodes::Exists do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { name? }.should == {exists: {field: 'name'}} }
+    specify { expect(render { name? }).to eq({exists: {field: 'name'}}) }
 
-    specify { render { !!name? }.should == {exists: {field: 'name'}} }
-    specify { render { !!name }.should == {exists: {field: 'name'}} }
-    specify { render { name != nil }.should == {exists: {field: 'name'}} }
-    specify { render { !(name == nil) }.should == {exists: {field: 'name'}} }
+    specify { expect(render { !!name? }).to eq({exists: {field: 'name'}}) }
+    specify { expect(render { !!name }).to eq({exists: {field: 'name'}}) }
+    specify { expect(render { name != nil }).to eq({exists: {field: 'name'}}) }
+    specify { expect(render { !(name == nil) }).to eq({exists: {field: 'name'}}) }
 
-    specify { render { ~name? }.should == {exists: {field: 'name'}} }
+    specify { expect(render { ~name? }).to eq({exists: {field: 'name'}}) }
   end
 end

data/spec/chewy/query/nodes/has_child_spec.rb

@@ -6,35 +6,35 @@ describe Chewy::Query::Nodes::HasChild do
       Chewy::Query::Filters.new(&block).__render__
     end
 
-    specify { render { has_child('child') }.should == {has_child: {type: 'child'}} }
-
-
-    specify { render { has_child('child').filter(term: {name: 'name'}) }
-      .should == {has_child: {type: 'child', filter: {term: {name: 'name'}}}} }
-    specify { render { has_child('child').filter{ name == 'name' } }
-      .should == {has_child: {type: 'child', filter: {term: {'name' => 'name'}}}} }
-    specify { render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 } }
-      .should == {has_child: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
-    specify { render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) }
-      .should == {has_child: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}} }
-
-    specify { render { has_child('child').query(match: {name: 'name'}) }
-      .should == {has_child: {type: 'child', query: {match: {name: 'name'}}}} }
-    specify { render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) }
-      .should == {has_child: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
-    specify { render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) }
-      .should == {has_child: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}} }
-
-    specify { render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}) }
-      .should == {has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}} }
-    specify { render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } }
-      .should == {has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}} }
+    specify { expect(render { has_child('child') }).to eq({has_child: {type: 'child'}}) }
+
+
+    specify { expect(render { has_child('child').filter(term: {name: 'name'}) })
+      .to eq({has_child: {type: 'child', filter: {term: {name: 'name'}}}}) }
+    specify { expect(render { has_child('child').filter{ name == 'name' } })
+      .to eq({has_child: {type: 'child', filter: {term: {'name' => 'name'}}}}) }
+    specify { expect(render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 } })
+      .to eq({has_child: {type: 'child', filter: {and: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}}) }
+    specify { expect(render { has_child('child').filter(term: {name: 'name'}).filter{ age < 42 }.filter_mode(:or) })
+      .to eq({has_child: {type: 'child', filter: {or: [{term: {name: 'name'}}, range: {'age' => {lt: 42}}]}}}) }
+
+    specify { expect(render { has_child('child').query(match: {name: 'name'}) })
+      .to eq({has_child: {type: 'child', query: {match: {name: 'name'}}}}) }
+    specify { expect(render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}) })
+      .to eq({has_child: {type: 'child', query: {bool: {must: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}}) }
+    specify { expect(render { has_child('child').query(match: {name: 'name'}).query(match: {surname: 'surname'}).query_mode(:should) })
+      .to eq({has_child: {type: 'child', query: {bool: {should: [{match: {name: 'name'}}, {match: {surname: 'surname'}}]}}}}) }
+
+    specify { expect(render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}) })
+      .to eq({has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {term: {'name' => 'name'}}}}}}) }
+    specify { expect(render { has_child('child').filter{ name == 'name' }.query(match: {name: 'name'}).filter{ age < 42 } })
+      .to eq({has_child: {type: 'child', query: {filtered: {query: {match: {name: 'name'}}, filter: {and: [{term: {'name' => 'name'}}, range: {'age' => {lt: 42}}]}}}}}) }
 
     context do
       let(:name) { 'Name' }
 
-      specify { render { has_child('child').filter{ name == o{name} } }
-       .should == {has_child: {type: 'child', filter: {term: {'name' => 'Name'}}}} }
+      specify { expect(render { has_child('child').filter{ name == o{name} } })
+       .to eq({has_child: {type: 'child', filter: {term: {'name' => 'Name'}}}}) }
     end
   end
 end