chewy 0.5.2 → 0.6.0

data/spec/chewy/index/aliases_spec.rb

@@ -1,49 +1,49 @@
 require 'spec_helper'
 
 describe Chewy::Index::Aliases do
-  before { Chewy.client.indices.delete index: '*' }
+  before { Chewy.massacre }
 
   before { stub_index :dummies }
 
   describe '.indexes' do
-    specify { DummiesIndex.indexes.should == [] }
+    specify { expect(DummiesIndex.indexes).to eq([]) }
 
     context do
       before { DummiesIndex.create! }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
     end
 
     context do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
-      specify { DummiesIndex.indexes.should == [] }
+      specify { expect(DummiesIndex.indexes).to eq([]) }
     end
 
     context do
       before { DummiesIndex.create! '2013' }
       before { DummiesIndex.create! '2014' }
-      specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+      specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
     end
   end
 
   describe '.aliases' do
-    specify { DummiesIndex.aliases.should == [] }
+    specify { expect(DummiesIndex.aliases).to eq([]) }
 
     context do
       before { DummiesIndex.create! }
-      specify { DummiesIndex.aliases.should == [] }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
     end
 
     context do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2014' }
-      specify { DummiesIndex.aliases.should =~ ['dummies_2013', 'dummies_2014'] }
+      specify { expect(DummiesIndex.aliases).to match_array(['dummies_2013', 'dummies_2014']) }
     end
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { DummiesIndex.aliases.should == [] }
+      specify { expect(DummiesIndex.aliases).to eq([]) }
     end
   end
 end

data/spec/chewy/index/search_spec.rb

@@ -35,12 +35,12 @@ describe Chewy::Index::Search do
   end
 
   describe '.search_index' do
-    specify { ProductsIndex.search_index.should == ProductsIndex }
-    specify { product.search_index.should == ProductsIndex }
+    specify { expect(ProductsIndex.search_index).to eq(ProductsIndex) }
+    specify { expect(product.search_index).to eq(ProductsIndex) }
   end
 
   describe '.search_type' do
-    specify { ProductsIndex.search_type.should == ['product', 'product2'] }
-    specify { product.search_type.should == 'product' }
+    specify { expect(ProductsIndex.search_type).to eq(['product', 'product2']) }
+    specify { expect(product.search_type).to eq('product') }
   end
 end

data/spec/chewy/index/settings_spec.rb

@@ -2,35 +2,35 @@ require 'spec_helper'
 
 describe Chewy::Index::Settings do
   describe '#to_hash' do
-    before { Chewy.stub(config: Chewy::Config.send(:new)) }
+    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { described_class.new.to_hash.should == {} }
-    specify { described_class.new(number_of_nodes: 3).to_hash.should == {settings: {number_of_nodes: 3}} }
-    specify { described_class.new(number_of_nodes: 3, analysis: {}).to_hash
-      .should == {settings: {number_of_nodes: 3, analysis: {}}} }
-    specify { described_class.new(number_of_nodes: 3, analysis: {filter: {filter1: {}}}).to_hash
-      .should == {settings: {number_of_nodes: 3, analysis: {filter: {filter1: {}}}}} }
-    specify { described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}).to_hash
-      .should == {settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}}} }
-    specify { described_class.new(number_of_nodes: 3, analysis: {
+    specify { expect(described_class.new.to_hash).to eq({}) }
+    specify { expect(described_class.new(number_of_nodes: 3).to_hash).to eq({settings: {number_of_nodes: 3}}) }
+    specify { expect(described_class.new(number_of_nodes: 3, analysis: {}).to_hash)
+      .to eq({settings: {number_of_nodes: 3, analysis: {}}}) }
+    specify { expect(described_class.new(number_of_nodes: 3, analysis: {filter: {filter1: {}}}).to_hash)
+      .to eq({settings: {number_of_nodes: 3, analysis: {filter: {filter1: {}}}}}) }
+    specify { expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}).to_hash)
+      .to eq({settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}}}) }
+    specify { expect(described_class.new(number_of_nodes: 3, analysis: {
       analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-    }).to_hash
-      .should == {settings: {number_of_nodes: 3, analysis: {
+    }).to_hash)
+      .to eq({settings: {number_of_nodes: 3, analysis: {
         analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-      }}} }
-    specify { described_class.new(number_of_nodes: 3, analysis: {analyser: ['analyzer1']}).to_hash
-      .should == {settings: {number_of_nodes: 3, analysis: {}}} }
+      }}}) }
+    specify { expect(described_class.new(number_of_nodes: 3, analysis: {analyser: ['analyzer1']}).to_hash)
+      .to eq({settings: {number_of_nodes: 3, analysis: {}}}) }
 
     context do
       before { Chewy.tokenizer :tokenizer1, {options: 42} }
 
-      specify { described_class.new(number_of_nodes: 3, analysis: {
+      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
         analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-      }).to_hash
-        .should == {settings: {number_of_nodes: 3, analysis: {
+      }).to_hash)
+        .to eq({settings: {number_of_nodes: 3, analysis: {
           analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
           tokenizer: {tokenizer1: {options: 42}}
-        }}} }
+        }}}) }
     end
 
     context do
@@ -40,14 +40,14 @@ describe Chewy::Index::Settings do
         Chewy.filter :filter5, {options: 44}
       end
 
-      specify { described_class.new(number_of_nodes: 3, analysis: {
+      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
         analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
         filter: ['filter3', {filter4: {options: 45}}]
-      }).to_hash
-        .should == {settings: {number_of_nodes: 3, analysis: {
+      }).to_hash)
+        .to eq({settings: {number_of_nodes: 3, analysis: {
           analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
           filter: {filter2: {options: 42}, filter3: {options: 43}, filter4: {options: 45}}
-        }}} }
+        }}}) }
     end
 
     context do
@@ -56,26 +56,26 @@ describe Chewy::Index::Settings do
         Chewy.tokenizer :tokenizer1, {options: 43}
       end
 
-      specify { described_class.new(number_of_nodes: 3, analysis: {
+      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
         analyzer: ['analyzer1', {analyzer2: {options: 44}}]
-      }).to_hash
-        .should == {settings: {number_of_nodes: 3, analysis: {
+      }).to_hash)
+        .to eq({settings: {number_of_nodes: 3, analysis: {
           analyzer: {analyzer1: {options: 42, tokenizer: 'tokenizer1'}, analyzer2: {options: 44}},
           tokenizer: {tokenizer1: {options: 43}}
-        }}} }
+        }}}) }
     end
 
     context ':index' do
-      specify { described_class.new(index: {number_of_shards: 3}).to_hash
-        .should == {settings: {index: {number_of_shards: 3}}} }
+      specify { expect(described_class.new(index: {number_of_shards: 3}).to_hash)
+        .to eq({settings: {index: {number_of_shards: 3}}}) }
 
       context do
         before { Chewy.configuration = {index: {number_of_shards: 7, number_of_replicas: 2}} }
 
-        specify { described_class.new.to_hash
-          .should == {settings: {index: {number_of_shards: 7, number_of_replicas: 2}}} }
-        specify { described_class.new(index: {number_of_shards: 3}).to_hash
-          .should == {settings: {index: {number_of_shards: 3, number_of_replicas: 2}}} }
+        specify { expect(described_class.new.to_hash)
+          .to eq({settings: {index: {number_of_shards: 7, number_of_replicas: 2}}}) }
+        specify { expect(described_class.new(index: {number_of_shards: 3}).to_hash)
+          .to eq({settings: {index: {number_of_shards: 3, number_of_replicas: 2}}}) }
       end
     end
   end

data/spec/chewy/index_spec.rb

@@ -8,7 +8,7 @@ describe Chewy::Index do
   end
 
   describe '.client' do
-    specify { stub_index(:dummies1).client.should == stub_index(:dummies2).client }
+    specify { expect(stub_index(:dummies1).client).to eq(stub_index(:dummies2).client) }
 
     context do
       before do
@@ -16,13 +16,13 @@ describe Chewy::Index do
         stub_index(:dummies2, Dummies1Index)
       end
 
-      specify { Dummies1Index.client.should == Dummies2Index.client }
+      specify { expect(Dummies1Index.client).to eq(Dummies2Index.client) }
     end
   end
 
   describe '.settings' do
     before do
-      Chewy.stub(config: Chewy::Config.send(:new))
+      allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
       Chewy.analyzer :name, filter: ['lowercase', 'icu_folding', 'names_nysiis']
       Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
@@ -34,34 +34,34 @@ describe Chewy::Index do
     let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
 
     specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect)  }
-    specify { documents.settings_hash.should == {settings: {analysis: {
+    specify { expect(documents.settings_hash).to eq({settings: {analysis: {
       analyzer: {name: {filter: ['lowercase', 'icu_folding', 'names_nysiis']},
                  phone: {tokenizer: 'ngram', char_filter: ['phone']},
                  sorted: {option: :baz}},
       tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
       char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
       filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
-    }}} }
+    }}}) }
   end
 
   describe '.define_type' do
-    specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
+    specify { expect(DummiesIndex.type_hash['dummy']).to eq(DummiesIndex::Dummy) }
 
     context do
       before { stub_index(:dummies) { define_type :dummy, name: :borogoves } }
-      specify { DummiesIndex.type_hash['borogoves'].should == DummiesIndex::Borogoves }
+      specify { expect(DummiesIndex.type_hash['borogoves']).to eq(DummiesIndex::Borogoves) }
     end
 
     context do
-      before { stub_model(:city) }
+      before { stub_class(:city) }
       before { stub_index(:dummies) { define_type City, name: :country } }
-      specify { DummiesIndex.type_hash['country'].should == DummiesIndex::Country }
+      specify { expect(DummiesIndex.type_hash['country']).to eq(DummiesIndex::Country) }
     end
 
 
     context do
-      before { stub_model('City') }
-      before { stub_model('City::District', City) }
+      before { stub_class('City') }
+      before { stub_class('City::District', City) }
 
       specify do
         expect {
@@ -88,85 +88,85 @@ describe Chewy::Index do
   end
 
   describe '.type_hash' do
-    specify { DummiesIndex.type_hash['dummy'].should == DummiesIndex::Dummy }
-    specify { DummiesIndex.type_hash.should have_key 'dummy' }
-    specify { DummiesIndex.type_hash['dummy'].should be < Chewy::Type }
-    specify { DummiesIndex.type_hash['dummy'].type_name.should == 'dummy' }
+    specify { expect(DummiesIndex.type_hash['dummy']).to eq(DummiesIndex::Dummy) }
+    specify { expect(DummiesIndex.type_hash).to have_key 'dummy' }
+    specify { expect(DummiesIndex.type_hash['dummy']).to be < Chewy::Type }
+    specify { expect(DummiesIndex.type_hash['dummy'].type_name).to eq('dummy') }
   end
 
-  specify { DummiesIndex.type_names.should == DummiesIndex.type_hash.keys }
+  specify { expect(DummiesIndex.type_names).to eq(DummiesIndex.type_hash.keys) }
 
   describe '.types' do
-    specify { DummiesIndex.types.should == DummiesIndex.type_hash.values }
-    specify { DummiesIndex.types(:dummy).should be_a Chewy::Query }
-    specify { DummiesIndex.types(:user).should be_a Chewy::Query }
+    specify { expect(DummiesIndex.types).to eq(DummiesIndex.type_hash.values) }
+    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Query }
+    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Query }
   end
 
   describe '.index_name' do
     specify { expect { Class.new(Chewy::Index).index_name }.to raise_error Chewy::UndefinedIndex }
-    specify { Class.new(Chewy::Index) { index_name :myindex }.index_name.should == 'myindex' }
-    specify { stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name.should == 'developer' }
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name.should == 'developers' }
+    specify { expect(Class.new(Chewy::Index) { index_name :myindex }.index_name).to eq('myindex') }
+    specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
     context do
-      before { Chewy.stub(configuration: {prefix: 'testing'}) }
-      specify { DummiesIndex.index_name.should == 'testing_dummies' }
-      specify { stub_index(:dummies) { index_name :users }.index_name.should == 'testing_users' }
+      before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+      specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
+      specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
     end
   end
 
   describe '.build_index_name' do
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '').should == 'developers' }
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013').should == 'developers_2013' }
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '').should == 'developers' }
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test').should == 'test_developers' }
-    specify { stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013').should == 'test_users_2013' }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013')).to eq('developers_2013') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test')).to eq('test_developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013')).to eq('test_users_2013') }
   end
 
   describe '.index_params' do
-    before { Chewy.stub(config: Chewy::Config.send(:new)) }
+    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { stub_index(:documents).index_params.should == {} }
-    specify { stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys.should == [:settings] }
-    specify { stub_index(:documents) do
+    specify { expect(stub_index(:documents).index_params).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
+    specify { expect(stub_index(:documents) do
       define_type :document do
         field :name, type: 'string'
       end
-    end.index_params.keys.should == [:mappings] }
-    specify { stub_index(:documents) do
+    end.index_params.keys).to eq([:mappings]) }
+    specify { expect(stub_index(:documents) do
       settings number_of_shards: 1
       define_type :document do
         field :name, type: 'string'
       end
-    end.index_params.keys.should =~ [:mappings, :settings] }
+    end.index_params.keys).to match_array([:mappings, :settings]) }
   end
 
   describe '.settings_hash' do
-    before { Chewy.stub(config: Chewy::Config.send(:new)) }
+    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { stub_index(:documents).settings_hash.should == {} }
-    specify { stub_index(:documents) { settings number_of_shards: 1 }.settings_hash.should == {settings: {number_of_shards: 1}} }
+    specify { expect(stub_index(:documents).settings_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq({settings: {number_of_shards: 1}}) }
   end
 
   describe '.mappings_hash' do
-    specify { stub_index(:documents).mappings_hash.should == {} }
-    specify { stub_index(:documents) { define_type :document }.mappings_hash.should == {} }
-    specify { stub_index(:documents) do
+    specify { expect(stub_index(:documents).mappings_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { define_type :document }.mappings_hash).to eq({}) }
+    specify { expect(stub_index(:documents) do
       define_type :document do
         field :name, type: 'string'
       end
-    end.mappings_hash.should == {mappings: {document: {properties: {name: {type: 'string'}}}}} }
-    specify { stub_index(:documents) do
+    end.mappings_hash).to eq({mappings: {document: {properties: {name: {type: 'string'}}}}}) }
+    specify { expect(stub_index(:documents) do
       define_type :document do
         field :name, type: 'string'
       end
       define_type :document2 do
         field :name, type: 'string'
       end
-    end.mappings_hash[:mappings].keys.should =~ [:document, :document2] }
+    end.mappings_hash[:mappings].keys).to match_array([:document, :document2]) }
   end
 
-  describe '.import' do
+  describe '.import', :orm do
     before do
       stub_model(:city)
       stub_model(:country)
@@ -177,8 +177,8 @@ describe Chewy::Index do
       end
     end
 
-    let!(:cities) { 2.times.map { City.create! } }
-    let!(:countries) { 2.times.map { Country.create! } }
+    let!(:cities) { 2.times.map { |i| City.create! id: i + 1 } }
+    let!(:countries) { 2.times.map { |i| Country.create! id: i + 1 } }
 
     specify do
       expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)

data/spec/chewy/query/criteria_spec.rb

@@ -123,59 +123,59 @@ describe Chewy::Query::Criteria do
   describe '#merge' do
     let(:criteria) { described_class.new }
 
-    specify { subject.merge(criteria).should_not be_equal subject }
-    specify { subject.merge(criteria).should_not be_equal criteria }
-
-    specify { subject.tap { |c| c.update_options(opt1: 'hello') }
-      .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
-    specify { subject.tap { |c| c.update_request_options(opt1: 'hello') }
-      .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options.should include(opt1: 'hello', opt2: 'hello') }
-    specify { subject.tap { |c| c.update_facets(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
-    specify { subject.tap { |c| c.update_scores(script: 'hello') }
-      .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores.should == [{script: 'hello'}, { script: 'foobar' } ] }
-    specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations.should == {field1: 'hello', field1: 'hello'} }
-    specify { subject.tap { |c| c.update_queries(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_filters(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_post_filters(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_sort(:field1) }
-      .merge(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
-    specify { subject.tap { |c| c.update_fields(:field1) }
-      .merge(criteria.tap { |c| c.update_fields(:field2) }).fields.should == ['field1', 'field2'] }
-    specify { subject.tap { |c| c.update_types(:type1) }
-      .merge(criteria.tap { |c| c.update_types(:type2) }).types.should == ['type1', 'type2'] }
+    specify { expect(subject.merge(criteria)).not_to be_equal subject }
+    specify { expect(subject.merge(criteria)).not_to be_equal criteria }
+
+    specify { expect(subject.tap { |c| c.update_options(opt1: 'hello') }
+      .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options).to include(opt1: 'hello', opt2: 'hello') }
+    specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
+      .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
+    specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_scores(script: 'hello') }
+      .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores).to eq([{script: 'hello'}, { script: 'foobar' } ]) }
+    specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
+      .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_sort(:field1) }
+      .merge(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2]) }
+    specify { expect(subject.tap { |c| c.update_fields(:field1) }
+      .merge(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(['field1', 'field2']) }
+    specify { expect(subject.tap { |c| c.update_types(:type1) }
+      .merge(criteria.tap { |c| c.update_types(:type2) }).types).to eq(['type1', 'type2']) }
   end
 
   describe '#merge!' do
     let(:criteria) { described_class.new }
 
-    specify { subject.merge!(criteria).should be_equal subject }
-    specify { subject.merge!(criteria).should_not be_equal criteria }
-
-    specify { subject.tap { |c| c.update_options(opt1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options.should include(opt1: 'hello', opt2: 'hello') }
-    specify { subject.tap { |c| c.update_request_options(opt1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options.should include(opt1: 'hello', opt2: 'hello') }
-    specify { subject.tap { |c| c.update_facets(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
-    specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations.should == {field1: 'hello', field1: 'hello'} }
-    specify { subject.tap { |c| c.update_queries(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_filters(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_post_filters(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters.should == [{field1: 'hello'}, {field2: 'hello'}] }
-    specify { subject.tap { |c| c.update_sort(:field1) }
-      .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort.should == [:field1, :field2] }
-    specify { subject.tap { |c| c.update_fields(:field1) }
-      .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields.should == ['field1', 'field2'] }
-    specify { subject.tap { |c| c.update_types(:type1) }
-      .merge!(criteria.tap { |c| c.update_types(:type2) }).types.should == ['type1', 'type2'] }
+    specify { expect(subject.merge!(criteria)).to be_equal subject }
+    specify { expect(subject.merge!(criteria)).not_to be_equal criteria }
+
+    specify { expect(subject.tap { |c| c.update_options(opt1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options).to include(opt1: 'hello', opt2: 'hello') }
+    specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
+    specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
+      .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
+    specify { expect(subject.tap { |c| c.update_sort(:field1) }
+      .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2]) }
+    specify { expect(subject.tap { |c| c.update_fields(:field1) }
+      .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(['field1', 'field2']) }
+    specify { expect(subject.tap { |c| c.update_types(:type1) }
+      .merge!(criteria.tap { |c| c.update_types(:type2) }).types).to eq(['type1', 'type2']) }
   end
 
   describe '#request_body' do
@@ -184,20 +184,20 @@ describe Chewy::Query::Criteria do
       subject.request_body
     end
 
-    specify { request_body.should == {body: {}} }
-    specify { request_body { update_request_options(size: 10) }.should == {body: {size: 10}} }
-    specify { request_body { update_request_options(from: 10) }.should == {body: {from: 10}} }
-    specify { request_body { update_request_options(explain: true) }.should == {body: {explain: true}} }
-    specify { request_body { update_queries(:query) }.should == {body: {query: :query}} }
-    specify { request_body {
+    specify { expect(request_body).to eq({body: {}}) }
+    specify { expect(request_body { update_request_options(size: 10) }).to eq({body: {size: 10}}) }
+    specify { expect(request_body { update_request_options(from: 10) }).to eq({body: {from: 10}}) }
+    specify { expect(request_body { update_request_options(explain: true) }).to eq({body: {explain: true}}) }
+    specify { expect(request_body { update_queries(:query) }).to eq({body: {query: :query}}) }
+    specify { expect(request_body {
       update_scores(script_score: { script: '_score'})
-    }.should == {body: {query: { function_score: { functions: [{ script_score: {script: '_score' }}] }}}} }
-    specify { request_body {
+    }).to eq({body: {query: { function_score: { functions: [{ script_score: {script: '_score' }}] }}}}) }
+    specify { expect(request_body {
       update_scores(script_score: { script: "boost_me" })
       update_queries(:query)
       update_options(boost_mode: :add)
       update_options(score_mode: :avg)
-    }.should == {body: {query: {
+    }).to eq({body: {query: {
       function_score: {
         functions: [{
           script_score: {script: 'boost_me' }
@@ -205,18 +205,18 @@ describe Chewy::Query::Criteria do
         query: :query,
         boost_mode: :add,
         score_mode: :avg
-      }}}}
+      }}}})
     }
-    specify { request_body {
+    specify { expect(request_body {
       update_request_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
-    }.should == {body: {query: :query, from: 10, sort: [:field], _source: ['field']}} }
+    }).to eq({body: {query: :query, from: 10, sort: [:field], _source: ['field']}}) }
 
-    specify { request_body {
+    specify { expect(request_body {
       update_queries(:query); update_filters(:filters);
-    }.should == {body: {query: {filtered: {query: :query, filter: :filters}}}} }
-    specify { request_body {
+    }).to eq({body: {query: {filtered: {query: :query, filter: :filters}}}}) }
+    specify { expect(request_body {
       update_queries(:query); update_post_filters(:post_filter);
-    }.should == {body: {query: :query, post_filter: :post_filter}} }
+    }).to eq({body: {query: :query, post_filter: :post_filter}}) }
   end
 
   describe '#_filtered_query' do
@@ -225,59 +225,59 @@ describe Chewy::Query::Criteria do
       subject.send(:_filtered_query, subject.send(:_request_query), subject.send(:_request_filter), options)
     end
 
-    specify { _filtered_query.should == {} }
-    specify { _filtered_query { update_queries(:query) }.should == {query: :query} }
-    specify { _filtered_query(strategy: 'query_first') { update_queries(:query) }.should == {query: :query} }
-    specify { _filtered_query { update_queries([:query1, :query2]) }
-      .should == {query: {bool: {must: [:query1, :query2]}}} }
-    specify { _filtered_query { update_options(query_mode: :should); update_queries([:query1, :query2]) }
-      .should == {query: {bool: {should: [:query1, :query2]}}} }
-    specify { _filtered_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) }
-      .should == {query: {dis_max: {queries: [:query1, :query2]}}} }
-
-    specify { _filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) }
-      .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}, strategy: 'query_first'}}} }
-    specify { _filtered_query { update_filters([:filter1, :filter2]) }
-      .should == {query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}} }
-
-    specify { _filtered_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
-      .should == {query: {filtered: {
+    specify { expect(_filtered_query).to eq({}) }
+    specify { expect(_filtered_query { update_queries(:query) }).to eq({query: :query}) }
+    specify { expect(_filtered_query(strategy: 'query_first') { update_queries(:query) }).to eq({query: :query}) }
+    specify { expect(_filtered_query { update_queries([:query1, :query2]) })
+      .to eq({query: {bool: {must: [:query1, :query2]}}}) }
+    specify { expect(_filtered_query { update_options(query_mode: :should); update_queries([:query1, :query2]) })
+      .to eq({query: {bool: {should: [:query1, :query2]}}}) }
+    specify { expect(_filtered_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) })
+      .to eq({query: {dis_max: {queries: [:query1, :query2]}}}) }
+
+    specify { expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) })
+      .to eq({query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}, strategy: 'query_first'}}}) }
+    specify { expect(_filtered_query { update_filters([:filter1, :filter2]) })
+      .to eq({query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}}) }
+
+    specify { expect(_filtered_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) })
+      .to eq({query: {filtered: {
         query: {bool: {must: [:query1, :query2]}},
         filter: {and: [:filter1, :filter2]}
-      }}}
+      }}})
     }
-    specify { _filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) }
-      .should == {query: {filtered: {
+    specify { expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) })
+      .to eq({query: {filtered: {
         query: {bool: {must: [:query1, :query2]}},
         filter: {and: [:filter1, :filter2]},
         strategy: 'query_first'
-      }}}
+      }}})
     }
-    specify { _filtered_query {
+    specify { expect(_filtered_query {
         update_options(query_mode: :should); update_options(filter_mode: :or);
         update_filters([:filter1, :filter2]); update_queries([:query1, :query2])
-      }.should == {query: {filtered: {
+      }).to eq({query: {filtered: {
         query: {bool: {should: [:query1, :query2]}},
         filter: {or: [:filter1, :filter2]}
-      }}}
+      }}})
     }
   end
 
   describe "#_boost_query" do
-    specify { subject.send(:_boost_query, query: :query).should eq(query: :query) }
+    specify { expect(subject.send(:_boost_query, query: :query)).to eq(query: :query) }
     specify {
       subject.update_scores({ boost_factor: 5 })
-      subject.send(:_boost_query, query: :query).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
+      expect(subject.send(:_boost_query, query: :query)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
     }
     specify {
       subject.update_scores({ boost_factor: 5 })
       subject.update_options(boost_mode: :multiply)
       subject.update_options(score_mode: :add)
-      subject.send(:_boost_query, query: :query).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
+      expect(subject.send(:_boost_query, query: :query)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
     }
     specify {
       subject.update_scores({ boost_factor: 5 })
-      subject.send(:_boost_query, query: :query, filter: :filter).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
+      expect(subject.send(:_boost_query, query: :query, filter: :filter)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
     }
   end
 
@@ -287,29 +287,33 @@ describe Chewy::Query::Criteria do
       subject.send(:_request_filter)
     end
 
-    specify { _request_filter.should be_nil }
-
-    specify { _request_filter { update_types(:type) }.should == {type: {value: 'type'}} }
-    specify { _request_filter { update_types([:type1, :type2]) }
-      .should == {or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]} }
-
-    specify { _request_filter { update_filters([:filter1, :filter2]) }
-      .should == {and: [:filter1, :filter2]} }
-    specify { _request_filter { update_options(filter_mode: :or); update_filters([:filter1, :filter2]) }
-      .should == {or: [:filter1, :filter2]} }
-    specify { _request_filter { update_options(filter_mode: :must); update_filters([:filter1, :filter2]) }
-      .should == {bool: {must: [:filter1, :filter2]}} }
-    specify { _request_filter { update_options(filter_mode: :should); update_filters([:filter1, :filter2]) }
-      .should == {bool: {should: [:filter1, :filter2]}} }
-
-    specify { _request_filter { update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
-      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, :filter1, :filter2]} }
-    specify { _request_filter { update_options(filter_mode: :or); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
-      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {or: [:filter1, :filter2]}]} }
-    specify { _request_filter { update_options(filter_mode: :must); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
-      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must: [:filter1, :filter2]}}]} }
-    specify { _request_filter { update_options(filter_mode: :should); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) }
-      .should == {and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: [:filter1, :filter2]}}]} }
+    specify { expect(_request_filter).to be_nil }
+
+    specify { expect(_request_filter { update_types(:type) }).to eq({type: {value: 'type'}}) }
+    specify { expect(_request_filter { update_types([:type1, :type2]) })
+      .to eq({or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}) }
+
+    specify { expect(_request_filter { update_filters([:filter1, :filter2]) })
+      .to eq({and: [:filter1, :filter2]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :or); update_filters([:filter1, :filter2]) })
+      .to eq({or: [:filter1, :filter2]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :must); update_filters([:filter1, :filter2]) })
+      .to eq({bool: {must: [:filter1, :filter2]}}) }
+    specify { expect(_request_filter { update_options(filter_mode: :should); update_filters([:filter1, :filter2]) })
+      .to eq({bool: {should: [:filter1, :filter2]}}) }
+    specify { expect(_request_filter { update_options(filter_mode: :must_not); update_filters([:filter1, :filter2]) })
+      .to eq({bool: {must_not: [:filter1, :filter2]}}) }
+
+    specify { expect(_request_filter { update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
+      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, :filter1, :filter2]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :or); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
+      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {or: [:filter1, :filter2]}]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :must); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
+      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must: [:filter1, :filter2]}}]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :should); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
+      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: [:filter1, :filter2]}}]}) }
+    specify { expect(_request_filter { update_options(filter_mode: :must_not); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
+      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must_not: [:filter1, :filter2]}}]}) }
   end
 
   describe '#_request_post_filter' do
@@ -318,22 +322,22 @@ describe Chewy::Query::Criteria do
       subject.send(:_request_post_filter)
     end
 
-    specify { _request_post_filter.should be_nil }
+    specify { expect(_request_post_filter).to be_nil }
 
-    specify { _request_post_filter { update_post_filters([:post_filter1, :post_filter2]) }
-      .should == {and: [:post_filter1, :post_filter2]} }
-    specify { _request_post_filter { update_options(post_filter_mode: :or); update_post_filters([:post_filter1, :post_filter2]) }
-      .should == {or: [:post_filter1, :post_filter2]} }
-    specify { _request_post_filter { update_options(post_filter_mode: :must); update_post_filters([:post_filter1, :post_filter2]) }
-      .should == {bool: {must: [:post_filter1, :post_filter2]}} }
-    specify { _request_post_filter { update_options(post_filter_mode: :should); update_post_filters([:post_filter1, :post_filter2]) }
-      .should == {bool: {should: [:post_filter1, :post_filter2]}} }
+    specify { expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
+      .to eq({and: [:post_filter1, :post_filter2]}) }
+    specify { expect(_request_post_filter { update_options(post_filter_mode: :or); update_post_filters([:post_filter1, :post_filter2]) })
+      .to eq({or: [:post_filter1, :post_filter2]}) }
+    specify { expect(_request_post_filter { update_options(post_filter_mode: :must); update_post_filters([:post_filter1, :post_filter2]) })
+      .to eq({bool: {must: [:post_filter1, :post_filter2]}}) }
+    specify { expect(_request_post_filter { update_options(post_filter_mode: :should); update_post_filters([:post_filter1, :post_filter2]) })
+      .to eq({bool: {should: [:post_filter1, :post_filter2]}}) }
 
     context do
-      before { Chewy.stub(filter_mode: :or) }
+      before { allow(Chewy).to receive_messages(filter_mode: :or) }
 
-      specify { _request_post_filter { update_post_filters([:post_filter1, :post_filter2]) }
-        .should == {or: [:post_filter1, :post_filter2]} }
+      specify { expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
+        .to eq({or: [:post_filter1, :post_filter2]}) }
     end
   end
 
@@ -343,10 +347,10 @@ describe Chewy::Query::Criteria do
       subject.send(:_request_types)
     end
 
-    specify { _request_types.should be_nil }
-    specify { _request_types { update_types(:type1) }.should == {type: {value: 'type1'}} }
-    specify { _request_types { update_types([:type1, :type2]) }
-      .should == {or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]} }
+    specify { expect(_request_types).to be_nil }
+    specify { expect(_request_types { update_types(:type1) }).to eq({type: {value: 'type1'}}) }
+    specify { expect(_request_types { update_types([:type1, :type2]) })
+      .to eq({or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}) }
   end
 
   describe '#_queries_join' do
@@ -356,25 +360,29 @@ describe Chewy::Query::Criteria do
 
     let(:query) { {term: {field: 'value'}} }
 
-    specify { _queries_join([], :dis_max).should be_nil }
-    specify { _queries_join([query], :dis_max).should == query }
-    specify { _queries_join([query, query], :dis_max).should == {dis_max: {queries: [query, query]}} }
+    specify { expect(_queries_join([], :dis_max)).to be_nil }
+    specify { expect(_queries_join([query], :dis_max)).to eq(query) }
+    specify { expect(_queries_join([query, query], :dis_max)).to eq({dis_max: {queries: [query, query]}}) }
 
-    specify { _queries_join([], 0.7).should be_nil }
-    specify { _queries_join([query], 0.7).should == query }
-    specify { _queries_join([query, query], 0.7).should == {dis_max: {queries: [query, query], tie_breaker: 0.7}} }
+    specify { expect(_queries_join([], 0.7)).to be_nil }
+    specify { expect(_queries_join([query], 0.7)).to eq(query) }
+    specify { expect(_queries_join([query, query], 0.7)).to eq({dis_max: {queries: [query, query], tie_breaker: 0.7}}) }
 
-    specify { _queries_join([], :must).should be_nil }
-    specify { _queries_join([query], :must).should == query }
-    specify { _queries_join([query, query], :must).should == {bool: {must: [query, query]}} }
+    specify { expect(_queries_join([], :must)).to be_nil }
+    specify { expect(_queries_join([query], :must)).to eq(query) }
+    specify { expect(_queries_join([query, query], :must)).to eq({bool: {must: [query, query]}}) }
 
-    specify { _queries_join([], :should).should be_nil }
-    specify { _queries_join([query], :should).should == query }
-    specify { _queries_join([query, query], :should).should == {bool: {should: [query, query]}} }
+    specify { expect(_queries_join([], :should)).to be_nil }
+    specify { expect(_queries_join([query], :should)).to eq(query) }
+    specify { expect(_queries_join([query, query], :should)).to eq({bool: {should: [query, query]}}) }
 
-    specify { _queries_join([], '25%').should be_nil }
-    specify { _queries_join([query], '25%').should == query }
-    specify { _queries_join([query, query], '25%').should == {bool: {should: [query, query], minimum_should_match: '25%'}} }
+    specify { expect(_queries_join([], :must_not)).to be_nil }
+    specify { expect(_queries_join([query], :must_not)).to eq({bool: {must_not: [query]}}) }
+    specify { expect(_queries_join([query, query], :must_not)).to eq({bool: {must_not: [query, query]}}) }
+
+    specify { expect(_queries_join([], '25%')).to be_nil }
+    specify { expect(_queries_join([query], '25%')).to eq(query) }
+    specify { expect(_queries_join([query, query], '25%')).to eq({bool: {should: [query, query], minimum_should_match: '25%'}}) }
   end
 
   describe '#_filters_join' do
@@ -384,24 +392,28 @@ describe Chewy::Query::Criteria do
 
     let(:filter) { {term: {field: 'value'}} }
 
-    specify { _filters_join([], :and).should be_nil }
-    specify { _filters_join([filter], :and).should == filter }
-    specify { _filters_join([filter, filter], :and).should == {and: [filter, filter]} }
+    specify { expect(_filters_join([], :and)).to be_nil }
+    specify { expect(_filters_join([filter], :and)).to eq(filter) }
+    specify { expect(_filters_join([filter, filter], :and)).to eq({and: [filter, filter]}) }
+
+    specify { expect(_filters_join([], :or)).to be_nil }
+    specify { expect(_filters_join([filter], :or)).to eq(filter) }
+    specify { expect(_filters_join([filter, filter], :or)).to eq({or: [filter, filter]}) }
 
-    specify { _filters_join([], :or).should be_nil }
-    specify { _filters_join([filter], :or).should == filter }
-    specify { _filters_join([filter, filter], :or).should == {or: [filter, filter]} }
+    specify { expect(_filters_join([], :must)).to be_nil }
+    specify { expect(_filters_join([filter], :must)).to eq(filter) }
+    specify { expect(_filters_join([filter, filter], :must)).to eq({bool: {must: [filter, filter]}}) }
 
-    specify { _filters_join([], :must).should be_nil }
-    specify { _filters_join([filter], :must).should == filter }
-    specify { _filters_join([filter, filter], :must).should == {bool: {must: [filter, filter]}} }
+    specify { expect(_filters_join([], :should)).to be_nil }
+    specify { expect(_filters_join([filter], :should)).to eq(filter) }
+    specify { expect(_filters_join([filter, filter], :should)).to eq({bool: {should: [filter, filter]}}) }
 
-    specify { _filters_join([], :should).should be_nil }
-    specify { _filters_join([filter], :should).should == filter }
-    specify { _filters_join([filter, filter], :should).should == {bool: {should: [filter, filter]}} }
+    specify { expect(_filters_join([], :must_not)).to be_nil }
+    specify { expect(_filters_join([filter], :must_not)).to eq({bool: {must_not: [filter]}}) }
+    specify { expect(_filters_join([filter, filter], :must_not)).to eq({bool: {must_not: [filter, filter]}}) }
 
-    specify { _filters_join([], '25%').should be_nil }
-    specify { _filters_join([filter], '25%').should == filter }
-    specify { _filters_join([filter, filter], '25%').should == {bool: {should: [filter, filter], minimum_should_match: '25%'}} }
+    specify { expect(_filters_join([], '25%')).to be_nil }
+    specify { expect(_filters_join([filter], '25%')).to eq(filter) }
+    specify { expect(_filters_join([filter, filter], '25%')).to eq({bool: {should: [filter, filter], minimum_should_match: '25%'}}) }
   end
 end