chewy 0.5.2 → 0.6.0

data/spec/chewy/rspec/update_index_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe :update_index do
-  before { Chewy.client.indices.delete index: '*' }
+  before { Chewy.massacre }
 
   before do
     stub_index(:dummies) do

data/spec/chewy/runtime/version_spec.rb

@@ -2,47 +2,47 @@ require 'spec_helper'
 
 describe Chewy::Runtime::Version do
   describe '#major' do
-    specify { described_class.new('1.2.3').major.should == 1 }
-    specify { described_class.new('1.2').major.should == 1 }
-    specify { described_class.new(1.2).major.should == 1 }
-    specify { described_class.new('1').major.should == 1 }
-    specify { described_class.new('').major.should == 0 }
+    specify { expect(described_class.new('1.2.3').major).to eq(1) }
+    specify { expect(described_class.new('1.2').major).to eq(1) }
+    specify { expect(described_class.new(1.2).major).to eq(1) }
+    specify { expect(described_class.new('1').major).to eq(1) }
+    specify { expect(described_class.new('').major).to eq(0) }
   end
 
   describe '#minor' do
-    specify { described_class.new('1.2.3').minor.should == 2 }
-    specify { described_class.new('1.2').minor.should == 2 }
-    specify { described_class.new(1.2).minor.should == 2 }
-    specify { described_class.new('1').minor.should == 0 }
+    specify { expect(described_class.new('1.2.3').minor).to eq(2) }
+    specify { expect(described_class.new('1.2').minor).to eq(2) }
+    specify { expect(described_class.new(1.2).minor).to eq(2) }
+    specify { expect(described_class.new('1').minor).to eq(0) }
   end
 
   describe '#patch' do
-    specify { described_class.new('1.2.3').patch.should == 3 }
-    specify { described_class.new('1.2.3.pre1').patch.should == 3 }
-    specify { described_class.new('1.2').patch.should == 0 }
-    specify { described_class.new(1.2).patch.should == 0 }
+    specify { expect(described_class.new('1.2.3').patch).to eq(3) }
+    specify { expect(described_class.new('1.2.3.pre1').patch).to eq(3) }
+    specify { expect(described_class.new('1.2').patch).to eq(0) }
+    specify { expect(described_class.new(1.2).patch).to eq(0) }
   end
 
   describe '#to_s' do
-    specify { described_class.new('1.2.3').to_s.should == '1.2.3' }
-    specify { described_class.new('1.2.3.pre1').to_s.should == '1.2.3' }
-    specify { described_class.new('1.2').to_s.should == '1.2.0' }
-    specify { described_class.new(1.2).to_s.should == '1.2.0' }
-    specify { described_class.new('1').to_s.should == '1.0.0' }
-    specify { described_class.new('').to_s.should == '0.0.0' }
+    specify { expect(described_class.new('1.2.3').to_s).to eq('1.2.3') }
+    specify { expect(described_class.new('1.2.3.pre1').to_s).to eq('1.2.3') }
+    specify { expect(described_class.new('1.2').to_s).to eq('1.2.0') }
+    specify { expect(described_class.new(1.2).to_s).to eq('1.2.0') }
+    specify { expect(described_class.new('1').to_s).to eq('1.0.0') }
+    specify { expect(described_class.new('').to_s).to eq('0.0.0') }
   end
 
   describe '#<=>' do
-    specify { described_class.new('1.2.3').should == '1.2.3' }
-    specify { described_class.new('1.2.3').should be < '1.2.4' }
-    specify { described_class.new('1.2.3').should be < '1.2.10' }
-    specify { described_class.new('1.10.2').should be == '1.10.2' }
-    specify { described_class.new('1.10.2').should be > '1.7.2' }
-    specify { described_class.new('2.10.2').should be > '1.7.2' }
-    specify { described_class.new('1.10.2').should be < '2.7.2' }
-    specify { described_class.new('1.10.2').should be < described_class.new('2.7.2') }
-    specify { described_class.new('1.10.2').should be < 2.7 }
-    specify { described_class.new('1.10.2').should be < 1.11 }
-    specify { described_class.new('1.2.0').should be == '1.2' }
+    specify { expect(described_class.new('1.2.3')).to eq('1.2.3') }
+    specify { expect(described_class.new('1.2.3')).to be < '1.2.4' }
+    specify { expect(described_class.new('1.2.3')).to be < '1.2.10' }
+    specify { expect(described_class.new('1.10.2')).to eq('1.10.2') }
+    specify { expect(described_class.new('1.10.2')).to be > '1.7.2' }
+    specify { expect(described_class.new('2.10.2')).to be > '1.7.2' }
+    specify { expect(described_class.new('1.10.2')).to be < '2.7.2' }
+    specify { expect(described_class.new('1.10.2')).to be < described_class.new('2.7.2') }
+    specify { expect(described_class.new('1.10.2')).to be < 2.7 }
+    specify { expect(described_class.new('1.10.2')).to be < 1.11 }
+    specify { expect(described_class.new('1.2.0')).to eq('1.2') }
   end
 end

data/spec/chewy/runtime_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Chewy::Runtime do
   describe '.version' do
-    specify { described_class.version.should be_a(described_class::Version) }
-    specify { described_class.version.should be >= '1.0' }
-    specify { described_class.version.should be < '1.4' }
+    specify { expect(described_class.version).to be_a(described_class::Version) }
+    specify { expect(described_class.version).to be >= '1.0' }
+    specify { expect(described_class.version).to be < '1.4' }
   end
 end

data/spec/chewy/type/actions_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Chewy::Type::Actions do
-  before { Chewy.client.indices.delete index: '*' }
+describe Chewy::Type::Actions, :orm do
+  before { Chewy.massacre }
 
   before do
     stub_model(:city)
@@ -25,4 +25,4 @@ describe Chewy::Type::Actions do
   describe '.reset' do
     specify { expect { city.reset }.to update_index(city) }
   end
-end
+end

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -1,31 +1,31 @@
 require 'spec_helper'
 
-describe Chewy::Type::Adapter::ActiveRecord do
+describe Chewy::Type::Adapter::ActiveRecord, :active_record do
   before { stub_model(:city) }
 
   describe '#name' do
-    specify { described_class.new(City).name.should == 'City' }
-    specify { described_class.new(City.order(:id)).name.should == 'City' }
-    specify { described_class.new(City, name: 'town').name.should == 'Town' }
+    specify { expect(described_class.new(City).name).to eq('City') }
+    specify { expect(described_class.new(City.order(:id)).name).to eq('City') }
+    specify { expect(described_class.new(City, name: 'town').name).to eq('Town') }
 
     context do
       before { stub_model('namespace/city') }
 
-      specify { described_class.new(Namespace::City).name.should == 'City' }
-      specify { described_class.new(Namespace::City.order(:id)).name.should == 'City' }
+      specify { expect(described_class.new(Namespace::City).name).to eq('City') }
+      specify { expect(described_class.new(Namespace::City.order(:id)).name).to eq('City') }
     end
   end
 
   describe '#type_name' do
-    specify { described_class.new(City).type_name.should == 'city' }
-    specify { described_class.new(City.order(:id)).type_name.should == 'city' }
-    specify { described_class.new(City, name: 'town').type_name.should == 'town' }
+    specify { expect(described_class.new(City).type_name).to eq('city') }
+    specify { expect(described_class.new(City.order(:id)).type_name).to eq('city') }
+    specify { expect(described_class.new(City, name: 'town').type_name).to eq('town') }
 
     context do
       before { stub_model('namespace/city') }
 
-      specify { described_class.new(Namespace::City).type_name.should == 'city' }
-      specify { described_class.new(Namespace::City.order(:id)).type_name.should == 'city' }
+      specify { expect(described_class.new(Namespace::City).type_name).to eq('city') }
+      specify { expect(described_class.new(Namespace::City.order(:id)).type_name).to eq('city') }
     end
   end
 
@@ -41,54 +41,54 @@ describe Chewy::Type::Adapter::ActiveRecord do
       let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) } }
       subject { described_class.new(City) }
 
-      specify { import.should == [{index: cities}] }
+      specify { expect(import).to eq([{index: cities}]) }
 
-      specify { import(City.order(:id)).should == [{index: cities}] }
-      specify { import(City.order(:id), batch_size: 2)
-        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { expect(import(City.order(:id))).to eq([{index: cities}]) }
+      specify { expect(import(City.order(:id), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
 
-      specify { import(cities).should == [{index: cities}] }
-      specify { import(cities, batch_size: 2)
-          .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
-      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
-      specify { import(cities, deleted, batch_size: 2).should == [
+      specify { expect(import(cities)).to eq([{index: cities}]) }
+      specify { expect(import(cities, batch_size: 2))
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+      specify { expect(import(cities, deleted)).to eq([{index: cities, delete: deleted}]) }
+      specify { expect(import(cities, deleted, batch_size: 2)).to eq([
           {index: cities.first(2)},
           {index: cities.last(1), delete: deleted.first(1)},
-          {delete: deleted.last(2)}] }
-
-      specify { import(cities.map(&:id)).should == [{index: cities}] }
-      specify { import(deleted.map(&:id)).should == [{delete: deleted.map(&:id)}] }
-      specify { import(cities.map(&:id), batch_size: 2)
-        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
-      specify { import(cities.map(&:id), deleted.map(&:id))
-        .should == [{index: cities}, {delete: deleted.map(&:id)}] }
-      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
+          {delete: deleted.last(2)}]) }
+
+      specify { expect(import(cities.map(&:id))).to eq([{index: cities}]) }
+      specify { expect(import(deleted.map(&:id))).to eq([{delete: deleted.map(&:id)}]) }
+      specify { expect(import(cities.map(&:id), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id)))
+        .to eq([{index: cities}, {delete: deleted.map(&:id)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 2)).to eq([
         {index: cities.first(2)},
         {index: cities.last(1)},
         {delete: deleted.first(2).map(&:id)},
-        {delete: deleted.last(1).map(&:id)}] }
+        {delete: deleted.last(1).map(&:id)}]) }
 
-      specify { import(cities.first, nil).should == [{index: [cities.first]}] }
-      specify { import(cities.first.id, nil).should == [{index: [cities.first]}] }
+      specify { expect(import(cities.first, nil)).to eq([{index: [cities.first]}]) }
+      specify { expect(import(cities.first.id, nil)).to eq([{index: [cities.first]}]) }
 
       context do
-        before { deleted.map { |object| object.stub(delete_from_index?: true, destroyed?: true) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        before { deleted.map { |object| allow(object).to receive_messages(delete_from_index?: true, destroyed?: true) } }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
       context do
-        before { deleted.map { |object| object.stub(delete_from_index?: true, destroyed?: false) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        before { deleted.map { |object| allow(object).to receive_messages(delete_from_index?: true, destroyed?: false) } }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
       context do
-        before { deleted.map { |object| object.stub(delete_from_index?: false, destroyed?: true) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        before { deleted.map { |object| allow(object).to receive_messages(delete_from_index?: false, destroyed?: true) } }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
       context do
-        before { deleted.map { |object| object.stub(delete_from_index?: false, destroyed?: false) } }
-        specify { import(deleted).should == [{index: deleted}] }
+        before { deleted.map { |object| allow(object).to receive_messages(delete_from_index?: false, destroyed?: false) } }
+        specify { expect(import(deleted)).to eq([{index: deleted}]) }
       end
     end
 
@@ -104,10 +104,10 @@ describe Chewy::Type::Adapter::ActiveRecord do
       let!(:deleted) { 3.times.map { |i| City.create!(rating: 42) } }
       subject { described_class.new(City) }
 
-      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
-      specify { import(cities.map(&:id), deleted.map(&:id))
-        .should == [{index: cities, delete: deleted}] }
-      specify { import(City.order(:id)).should == [{index: cities, delete: deleted}] }
+      specify { expect(import(cities, deleted)).to eq([{index: cities, delete: deleted}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id)))
+        .to eq([{index: cities, delete: deleted}]) }
+      specify { expect(import(City.order(:id))).to eq([{index: cities, delete: deleted}]) }
     end
 
     context 'custom primary_key' do
@@ -116,58 +116,58 @@ describe Chewy::Type::Adapter::ActiveRecord do
       let!(:deleted) { 3.times.map { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
       subject { described_class.new(City) }
 
-      specify { import.should == [{index: cities}] }
+      specify { expect(import).to eq([{index: cities}]) }
 
-      specify { import(City.order(:rating)).should == [{index: cities}] }
-      specify { import(City.order(:rating), batch_size: 2)
-        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
+      specify { expect(import(City.order(:rating))).to eq([{index: cities}]) }
+      specify { expect(import(City.order(:rating), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
 
-      specify { import(cities).should == [{index: cities}] }
-      specify { import(cities, batch_size: 2)
-          .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
-      specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
-      specify { import(cities, deleted, batch_size: 2).should == [
+      specify { expect(import(cities)).to eq([{index: cities}]) }
+      specify { expect(import(cities, batch_size: 2))
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+      specify { expect(import(cities, deleted)).to eq([{index: cities, delete: deleted}]) }
+      specify { expect(import(cities, deleted, batch_size: 2)).to eq([
           {index: cities.first(2)},
           {index: cities.last(1), delete: deleted.first(1)},
-          {delete: deleted.last(2)}] }
-
-      specify { import(cities.map(&:id)).should == [{index: cities}] }
-      specify { import(cities.map(&:id), batch_size: 2)
-        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
-      specify { import(cities.map(&:id), deleted.map(&:id))
-        .should == [{index: cities}, {delete: deleted.map(&:id)}] }
-      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
+          {delete: deleted.last(2)}]) }
+
+      specify { expect(import(cities.map(&:id))).to eq([{index: cities}]) }
+      specify { expect(import(cities.map(&:id), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id)))
+        .to eq([{index: cities}, {delete: deleted.map(&:id)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 2)).to eq([
         {index: cities.first(2)},
         {index: cities.last(1)},
         {delete: deleted.first(2).map(&:id)},
-        {delete: deleted.last(1).map(&:id)}] }
+        {delete: deleted.last(1).map(&:id)}]) }
     end
 
     context 'default scope' do
-      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
-      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
-      subject { described_class.new(City.where(country_id: 0)) }
-
-      specify { import.should == [{index: cities.first(2)}] }
-
-      specify { import(City.order(:id)).should == [{index: cities.first(2)}] }
-      specify { import(City.order(:id), batch_size: 1)
-        .should == [{index: [cities.first]}, {index: [cities.second]}] }
-
-      specify { import(cities).should == [{index: cities}] }
-      specify { import(cities, batch_size: 2)
-        .should == [{index: cities.first(2)}, {index: cities.last(1)}] }
-
-      specify { import(cities.map(&:id))
-        .should == [{index: cities.first(2)}, {delete: [cities.last.id]}] }
-      specify { import(cities.map(&:id), batch_size: 1)
-        .should == [{index: [cities.first]}, {index: [cities.second]}, {delete: [cities.last.id]}] }
-      specify { import(cities.map(&:id), deleted.map(&:id))
-        .should == [{index: cities.first(2)}, {delete: [cities.last.id] + deleted.map(&:id)}] }
-      specify { import(cities.map(&:id), deleted.map(&:id), batch_size: 2).should == [
-        {index: cities.first(2)},
-        {delete: [cities.last.id] + deleted.first(1).map(&:id)},
-        {delete: deleted.last(1).map(&:id)}] }
+      let!(:cities) { 4.times.map { |i| City.create!(rating: i/3) } }
+      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) } }
+      subject { described_class.new(City.where(rating: 0)) }
+
+      specify { expect(import).to eq([{index: cities.first(3)}]) }
+
+      specify { expect(import(City.order(:id))).to eq([{index: cities.first(3)}]) }
+      specify { expect(import(City.order(:id), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: [cities[2]]}]) }
+
+      specify { expect(import(cities)).to eq([{index: cities}]) }
+      specify { expect(import(cities, batch_size: 3))
+        .to eq([{index: cities.first(3)}, {index: cities.last(1)}]) }
+
+      specify { expect(import(cities.map(&:id)))
+        .to eq([{index: cities.first(3)}, {delete: [cities.last.id]}]) }
+      specify { expect(import(cities.map(&:id), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: [cities[2]]}, {delete: [cities.last.id]}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id)))
+        .to eq([{index: cities.first(3)}, {delete: [cities.last.id] + deleted.map(&:id)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 3)).to eq([
+        {index: cities.first(3)},
+        {delete: [cities.last.id] + deleted.first(2).map(&:id)},
+        {delete: deleted.last(1).map(&:id)}]) }
     end
 
     context 'error handling' do
@@ -181,72 +181,72 @@ describe Chewy::Type::Adapter::ActiveRecord do
       end
 
       context 'implicit scope' do
-        specify { subject.import { |data| true }.should eq(true) }
-        specify { subject.import { |data| false }.should eq(false) }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(true) }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(true) }
+        specify { expect(subject.import { |data| true }).to eq(true) }
+        specify { expect(subject.import { |data| false }).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(true) }
       end
 
       context 'explicit scope' do
         let(:scope) { City.where(id: ids) }
 
-        specify { subject.import(scope) { |data| true }.should eq(true) }
-        specify { subject.import(scope) { |data| false }.should eq(false) }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(true) }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(true) }
+        specify { expect(subject.import(scope) { |data| true }).to eq(true) }
+        specify { expect(subject.import(scope) { |data| false }).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(true) }
       end
 
       context 'objects' do
-        specify { subject.import(cities + deleted) { |data| true }.should eq(true) }
-        specify { subject.import(cities + deleted) { |data| false }.should eq(false) }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(false) }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(false) }
+        specify { expect(subject.import(cities + deleted) { |data| true }).to eq(true) }
+        specify { expect(subject.import(cities + deleted) { |data| false }).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
       end
 
       context 'ids' do
-        specify { subject.import(ids) { |data| true }.should eq(true) }
-        specify { subject.import(ids) { |data| false }.should eq(false) }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(false) }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(false) }
+        specify { expect(subject.import(ids) { |data| true }).to eq(true) }
+        specify { expect(subject.import(ids) { |data| false }).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
       end
     end
   end
 
   describe '#load' do
     context do
-      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) } }
+      let!(:cities) { 3.times.map { |i| City.create!(rating: i/2) } }
       let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
 
       let(:type) { double(type_name: 'user') }
 
       subject { described_class.new(City) }
 
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type).should == cities }
-      specify { subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type).should == cities.reverse }
-      specify { subject.load(deleted.map { |c| double(id: c.id) }, _type: type).should == [nil, nil] }
-      specify { subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type).should == [*cities, nil, nil] }
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) })
-        .should == cities.first(2) + [nil] }
-      specify { subject.load(cities.map { |c| double(id: c.id) },
-        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}})
-        .should == [nil, nil] + cities.last(1) }
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1))
-        .should == [nil, nil] + cities.last(1) }
-      specify { subject.load(cities.map { |c| double(id: c.id) },
-        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}})
-        .should == cities.first(2) + [nil] }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type)).to eq(cities) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted.map { |c| double(id: c.id) }, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(rating: 0) }))
+        .to eq(cities.first(2) + [nil]) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: ->{ where(rating: 0) }, user: {scope: ->{ where(rating: 1)}}))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(rating: 1)))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: City.where(rating: 1), user: {scope: ->{ where(rating: 0)}}))
+        .to eq(cities.first(2) + [nil]) }
     end
 
     context 'custom primary_key' do
@@ -258,20 +258,20 @@ describe Chewy::Type::Adapter::ActiveRecord do
 
       subject { described_class.new(City) }
 
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type).should == cities }
-      specify { subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type).should == cities.reverse }
-      specify { subject.load(deleted.map { |c| double(id: c.id) }, _type: type).should == [nil, nil] }
-      specify { subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type).should == [*cities, nil, nil] }
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) })
-        .should == cities.first(2) + [nil] }
-      specify { subject.load(cities.map { |c| double(id: c.id) },
-        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}})
-        .should == [nil, nil] + cities.last(1) }
-      specify { subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1))
-        .should == [nil, nil] + cities.last(1) }
-      specify { subject.load(cities.map { |c| double(id: c.id) },
-        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}})
-        .should == cities.first(2) + [nil] }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type)).to eq(cities) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted.map { |c| double(id: c.id) }, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: ->{ where(country_id: 0) }))
+        .to eq(cities.first(2) + [nil]) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}}))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(country_id: 1)))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}}))
+        .to eq(cities.first(2) + [nil]) }
     end
   end
 end