chewy 0.5.2 → 0.6.0

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

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe Chewy::Type::Adapter::Mongoid, :mongoid do
+  before { stub_model(:city) }
+
+  describe '#name' do
+    specify { expect(described_class.new(City).name).to eq('City') }
+    specify { expect(described_class.new(City.order(:id.asc)).name).to eq('City') }
+    specify { expect(described_class.new(City, name: 'town').name).to eq('Town') }
+
+    context do
+      before { stub_model('namespace/city') }
+
+      specify { expect(described_class.new(Namespace::City).name).to eq('City') }
+      specify { expect(described_class.new(Namespace::City.order(:id.asc)).name).to eq('City') }
+    end
+  end
+
+  describe '#type_name' do
+    specify { expect(described_class.new(City).type_name).to eq('city') }
+    specify { expect(described_class.new(City.order(:id.asc)).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 { expect(described_class.new(Namespace::City).type_name).to eq('city') }
+      specify { expect(described_class.new(Namespace::City.order(:id.asc)).type_name).to eq('city') }
+    end
+  end
+
+  describe '#import' do
+    def import(*args)
+      result = []
+      subject.import(*args) { |data| result.push data }
+      result
+    end
+
+    context do
+      let!(:cities) { 3.times.map { |i| City.create! }.sort_by(&:id) }
+      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      subject { described_class.new(City) }
+
+      specify { expect(import).to eq([{index: cities}]) }
+
+      specify { expect(import(City.order(:id.asc))).to eq([{index: cities}]) }
+      specify { expect(import(City.order(:id.asc), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+
+      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 { 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)}]) }
+
+      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| 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| 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| 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| allow(object).to receive_messages(delete_from_index?: false, destroyed?: false) } }
+        specify { expect(import(deleted)).to eq([{index: deleted}]) }
+      end
+    end
+
+    describe '#delete_from_index?' do
+      before do
+        stub_model(:city) do
+          def delete_from_index?
+            rating == 42
+          end
+        end
+      end
+      let!(:cities) { 3.times.map { |i| City.create! }.sort_by(&:id) }
+      let!(:deleted) { 3.times.map { |i| City.create!(rating: 42) }.sort_by(&:id) }
+      subject { described_class.new(City) }
+
+      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.asc))).to eq([{index: cities, delete: deleted}]) }
+    end
+
+    context 'default scope' do
+      let!(:cities) { 3.times.map { |i| City.create!(rating: i/2) }.sort_by(&:id) }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      subject { described_class.new(City.where(rating: 0)) }
+
+      specify { expect(import).to eq([{index: cities.first(2)}]) }
+
+      specify { expect(import(City.order(:id.asc))).to eq([{index: cities.first(2)}]) }
+      xspecify { expect(import(City.order(:id.asc), batch_size: 1))
+        .to eq([{index: [cities.first]}, {index: [cities.second]}]) }
+
+      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.map(&:id)))
+        .to eq([{index: cities.first(2)}, {delete: [cities.last.id]}]) }
+      xspecify { expect(import(cities.map(&:id), batch_size: 1))
+        .to eq([{index: [cities.first]}, {index: [cities.second]}, {delete: [cities.last.id]}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id)))
+        .to eq([{index: cities.first(2)}, {delete: [cities.last.id] + deleted.map(&:id)}]) }
+      specify { expect(import(cities.map(&:id), deleted.map(&:id), batch_size: 2)).to eq([
+        {index: cities.first(2)},
+        {delete: [cities.last.id] + deleted.first(1).map(&:id)},
+        {delete: deleted.last(1).map(&:id)}]) }
+    end
+
+    context 'error handling' do
+      let!(:cities) { 6.times.map { |i| City.create! }.sort_by(&:id) }
+      let!(:deleted) { 4.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      let(:ids) { (cities + deleted).map(&:id) }
+      subject { described_class.new(City) }
+
+      let(:data_comparer) do
+        ->(ids, data) { objects = (data[:index] || data[:delete]).first(2); objects.map { |o| o.respond_to?(:id) ? o.id : o }.sort != ids.map(&:id).sort }
+      end
+
+      context 'implicit scope' do
+        specify { expect(subject.import { |data| true }).to eq(true) }
+        specify { expect(subject.import { |data| false }).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[0..1]])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[2..3]])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[4..5]])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[0..1]])).to eq(true) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[2..3]])).to eq(true) }
+      end
+
+      context 'explicit scope' do
+        let(:scope) { mongoid? ? City.where(:id.in => ids) : City.where(id: ids) }
+
+        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: 2, &data_comparer.curry[cities[0..1]])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[2..3]])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[4..5]])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[0..1]])).to eq(true) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[2..3]])).to eq(true) }
+      end
+
+      context 'objects' do
+        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: 2, &data_comparer.curry[cities[0..1]])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[2..3]])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[4..5]])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[0..1]])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[2..3]])).to eq(false) }
+      end
+
+      context 'ids' do
+        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: 2, &data_comparer.curry[cities[0..1]])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[2..3]])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[4..5]])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[0..1]])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[2..3]])).to eq(false) }
+      end
+    end
+  end
+
+  describe '#load' do
+    context do
+      let!(:cities) { 3.times.map { |i| City.create!(rating: i/2) }.sort_by(&:id) }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+
+      let(:type) { double(type_name: 'user') }
+
+      subject { described_class.new(City) }
+
+      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
+  end
+end

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

@@ -4,28 +4,28 @@ describe Chewy::Type::Adapter::Object do
   before { stub_class(:product) }
 
   describe '#name' do
-    specify { described_class.new('product').name.should == 'Product' }
-    specify { described_class.new(:products).name.should == 'Products' }
-    specify { described_class.new(Product).name.should == 'Product' }
-    specify { described_class.new(Product, name: 'house').name.should == 'House' }
+    specify { expect(described_class.new('product').name).to eq('Product') }
+    specify { expect(described_class.new(:products).name).to eq('Products') }
+    specify { expect(described_class.new(Product).name).to eq('Product') }
+    specify { expect(described_class.new(Product, name: 'house').name).to eq('House') }
 
     context do
       before { stub_class('namespace/product') }
 
-      specify { described_class.new(Namespace::Product).name.should == 'Product' }
+      specify { expect(described_class.new(Namespace::Product).name).to eq('Product') }
     end
   end
 
   describe '#type_name' do
-    specify { described_class.new('product').type_name.should == 'product' }
-    specify { described_class.new(:products).type_name.should == 'products' }
-    specify { described_class.new(Product).type_name.should == 'product' }
-    specify { described_class.new(Product, name: 'house').type_name.should == 'house' }
+    specify { expect(described_class.new('product').type_name).to eq('product') }
+    specify { expect(described_class.new(:products).type_name).to eq('products') }
+    specify { expect(described_class.new(Product).type_name).to eq('product') }
+    specify { expect(described_class.new(Product, name: 'house').type_name).to eq('house') }
 
     context do
       before { stub_class('namespace/product') }
 
-      specify { described_class.new(Namespace::Product).type_name.should == 'product' }
+      specify { expect(described_class.new(Namespace::Product).type_name).to eq('product') }
     end
   end
 
@@ -36,61 +36,61 @@ describe Chewy::Type::Adapter::Object do
       result
     end
 
-    specify { subject.import(3.times.map { |i| double }) { |data| true }.should eq(true) }
-    specify { subject.import(3.times.map { |i| double }) { |data| false }.should eq(false) }
+    specify { expect(subject.import(3.times.map { |i| double }) { |data| true }).to eq(true) }
+    specify { expect(subject.import(3.times.map { |i| double }) { |data| false }).to eq(false) }
 
     context do
       let(:objects) { 3.times.map { |i| double } }
       let(:deleted) { 2.times.map { |i| double(destroyed?: true) } }
       subject { described_class.new('product') }
 
-      specify { import.should == [] }
-      specify { import(objects).should == [{index: objects}] }
-      specify { import(objects, batch_size: 2)
-          .should == [{index: objects.first(2)}, {index: objects.last(1)}] }
-      specify { import(objects, deleted).should == [{index: objects, delete: deleted}] }
-      specify { import(objects, deleted, batch_size: 2).should == [
+      specify { expect(import).to eq([]) }
+      specify { expect(import(objects)).to eq([{index: objects}]) }
+      specify { expect(import(objects, batch_size: 2))
+          .to eq([{index: objects.first(2)}, {index: objects.last(1)}]) }
+      specify { expect(import(objects, deleted)).to eq([{index: objects, delete: deleted}]) }
+      specify { expect(import(objects, deleted, batch_size: 2)).to eq([
           {index: objects.first(2)},
           {index: objects.last(1), delete: deleted.first(1)},
-          {delete: deleted.last(1)}] }
+          {delete: deleted.last(1)}]) }
 
-      specify { import(objects.first, nil).should == [{index: [objects.first]}] }
+      specify { expect(import(objects.first, nil)).to eq([{index: [objects.first]}]) }
 
       context do
         let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: true) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
       context do
         let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: false) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
 
       context do
         let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: true) } }
-        specify { import(deleted).should == [{delete: deleted}] }
+        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
       end
 
       context do
         let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: false) } }
-        specify { import(deleted).should == [{index: deleted}] }
+        specify { expect(import(deleted)).to eq([{index: deleted}]) }
       end
     end
 
     context do
       let(:products) { 3.times.map { |i| double.tap { |product|
-        product.stub(:is_a?).with(Product).and_return(true)
+        allow(product).to receive(:is_a?).with(Product).and_return(true)
       } } }
       let(:non_product) { double }
       subject { described_class.new(Product) }
 
-      specify { import(products).should == [{index: products}] }
+      specify { expect(import(products)).to eq([{index: products}]) }
       specify { expect { import(products, non_product) {} }.to raise_error }
     end
 
     context 'error handling' do
-      let(:products) { 3.times.map { |i| double.tap { |product| product.stub(rating: i.next) } } }
+      let(:products) { 3.times.map { |i| double.tap { |product| allow(product).to receive_messages(rating: i.next) } } }
       let(:deleted) { 2.times.map { |i| double(destroyed?: true, rating: i + 4) } }
       subject { described_class.new('product') }
 
@@ -98,13 +98,13 @@ describe Chewy::Type::Adapter::Object do
         ->(n, data) { (data[:index] || data[:delete]).first.rating != n }
       end
 
-      specify { subject.import(products, deleted) { |data| true }.should eq(true) }
-      specify { subject.import(products, deleted) { |data| false }.should eq(false) }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[1]).should eq(false) }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[2]).should eq(false) }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[3]).should eq(false) }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[4]).should eq(false) }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[5]).should eq(false) }
+      specify { expect(subject.import(products, deleted) { |data| true }).to eq(true) }
+      specify { expect(subject.import(products, deleted) { |data| false }).to eq(false) }
+      specify { expect(subject.import(products, deleted, batch_size: 1, &data_comparer.curry[1])).to eq(false) }
+      specify { expect(subject.import(products, deleted, batch_size: 1, &data_comparer.curry[2])).to eq(false) }
+      specify { expect(subject.import(products, deleted, batch_size: 1, &data_comparer.curry[3])).to eq(false) }
+      specify { expect(subject.import(products, deleted, batch_size: 1, &data_comparer.curry[4])).to eq(false) }
+      specify { expect(subject.import(products, deleted, batch_size: 1, &data_comparer.curry[5])).to eq(false) }
     end
   end
 
@@ -113,23 +113,23 @@ describe Chewy::Type::Adapter::Object do
       subject { described_class.new('product') }
       let(:objects) { 3.times.map { |i| double } }
 
-      specify { subject.load(objects).should == objects }
+      specify { expect(subject.load(objects)).to eq(objects) }
     end
 
     context do
-      before { Product.stub(:wrap) { |object| object.stub(wrapped?: true); object } }
+      before { allow(Product).to receive(:wrap) { |object| allow(object).to receive_messages(wrapped?: true); object } }
       subject { described_class.new(Product) }
       let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
 
-      specify { subject.load(objects).should satisfy { |objects| objects.all?(&:wrapped?) } }
+      specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:wrapped?) } }
     end
 
     context do
-      before { Product.stub(:wrap) { |object| nil } }
+      before { allow(Product).to receive(:wrap) { |object| nil } }
       subject { described_class.new(Product) }
       let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
 
-      specify { subject.load(objects).should satisfy { |objects| objects.all?(&:nil?) } }
+      specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:nil?) } }
     end
   end
 end

data/spec/chewy/type/import_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Chewy::Type::Import do
-  before { Chewy.client.indices.delete index: '*' }
+  before { Chewy.massacre }
 
   before do
     stub_model(:city)
@@ -15,23 +15,33 @@ describe Chewy::Type::Import do
     end
   end
 
-  let!(:dummy_cities) { 3.times.map { |i| City.create(name: "name#{i}") } }
+  let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
   let(:city) { CitiesIndex::City }
 
-  describe '.import' do
-    specify { city.import.should eq(true) }
-    specify { city.import([]).should eq(true) }
-    specify { city.import(dummy_cities).should eq(true) }
-    specify { city.import(dummy_cities.map(&:id)).should eq(true) }
+  describe '.import', :orm do
+    specify { expect(city.import).to eq(true) }
+    specify { expect(city.import([])).to eq(true) }
+    specify { expect(city.import(dummy_cities)).to eq(true) }
+    specify { expect(city.import(dummy_cities.map(&:id))).to eq(true) }
 
     specify { expect { city.import([]) }.not_to update_index(city) }
     specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities) }
     specify { expect { city.import dummy_cities }.to update_index(city).and_reindex(dummy_cities) }
     specify { expect { city.import dummy_cities.map(&:id) }.to update_index(city).and_reindex(dummy_cities) }
-    specify { expect { city.import(City.where(name: ['name0', 'name1'])) }
-      .to update_index(city).and_reindex(dummy_cities.first(2)) }
-    specify { expect { city.import(City.where(name: ['name0', 'name1']).map(&:id)) }
-        .to update_index(city).and_reindex(dummy_cities.first(2)) }
+
+    describe 'criteria-driven importing' do
+      let(:names) { %w(name0 name1) }
+
+      context 'mongoid', :mongoid do
+        specify { expect { city.import(City.where(:name.in => names)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
+        specify { expect { city.import(City.where(:name.in => names).map(&:id)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
+      end
+
+      context 'active record', :active_record do
+        specify { expect { city.import(City.where(name: names)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
+        specify { expect { city.import(City.where(name: names).map(&:id)) }.to update_index(city).and_reindex(dummy_cities.first(2)) }
+      end
+    end
 
     specify do
       dummy_cities.first.destroy
@@ -47,15 +57,16 @@ describe Chewy::Type::Import do
 
     specify do
       dummy_cities.first.destroy
+
       expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
         body: [{delete: {_id: dummy_cities.first.id}}]
       ))
-      dummy_cities.from(1).each.with_index do |c, i|
-        expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
-          body: [{index: {_id: c.id, data: {'name' => "name#{i+1}"}}}]
-        ))
-      end
-      city.import dummy_cities.map(&:id), batch_size: 1
+
+      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
+        body: [{index: {_id: 2, data: {'name' => "name1"}}}, {index: {_id: 3, data: {'name' => "name2"}}}]
+      ))
+
+      city.import dummy_cities.map(&:id), batch_size: 2
     end
 
     specify do
@@ -70,15 +81,34 @@ describe Chewy::Type::Import do
 
     context 'scoped' do
       before do
+        names = %w(name0 name1)
+
+        criteria = if defined?(::Mongoid)
+          { :name.in => names }
+        else
+          { name: names }
+        end
+
         stub_index(:cities) do
-          define_type City.where(name: ['name0', 'name1']) do
+          define_type City.where(criteria) do
             field :name
           end
         end
       end
 
       specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities.first(2)) }
-      specify { expect { city.import City.where(id: dummy_cities.first.id) }.to update_index(city).and_reindex(dummy_cities.first).only }
+
+      context 'mongoid', :mongoid do
+        specify do
+          expect { city.import City.where(_id: dummy_cities.first.id) }.to update_index(city).and_reindex(dummy_cities.first).only
+        end
+      end
+
+      context 'active record', :active_record do
+        specify do
+          expect { city.import City.where(id: dummy_cities.first.id) }.to update_index(city).and_reindex(dummy_cities.first).only
+        end
+      end
     end
 
     context 'instrumentation payload' do
@@ -90,7 +120,7 @@ describe Chewy::Type::Import do
 
         dummy_cities.first.destroy
         city.import dummy_cities
-        outer_payload.should == {type: CitiesIndex::City, import: {delete: 1, index: 2}}
+        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
       end
 
       specify do
@@ -101,7 +131,7 @@ describe Chewy::Type::Import do
 
         dummy_cities.first.destroy
         city.import dummy_cities, batch_size: 1
-        outer_payload.should == {type: CitiesIndex::City, import: {delete: 1, index: 2}}
+        expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
       end
 
       specify do
@@ -111,7 +141,7 @@ describe Chewy::Type::Import do
         end
 
         city.import dummy_cities, batch_size: 1
-        outer_payload.should == {type: CitiesIndex::City, import: {index: 3}}
+        expect(outer_payload).to eq({type: CitiesIndex::City, import: {index: 3}})
       end
 
       context do
@@ -130,7 +160,7 @@ describe Chewy::Type::Import do
           end
 
           city.import dummy_cities, batch_size: 1
-          outer_payload.should == {
+          expect(outer_payload).to eq({
             type: CitiesIndex::City,
             errors: {
               index: {
@@ -138,7 +168,7 @@ describe Chewy::Type::Import do
               }
             },
             import: {index: 3}
-          }
+          })
         end
       end
     end
@@ -153,9 +183,9 @@ describe Chewy::Type::Import do
           end
         end
 
-        specify { city.import(dummy_cities).should eq(false) }
-        specify { city.import(dummy_cities.map(&:id)).should eq(false) }
-        specify { city.import(dummy_cities, batch_size: 1).should eq(false) }
+        specify { expect(city.import(dummy_cities)).to eq(false) }
+        specify { expect(city.import(dummy_cities.map(&:id))).to eq(false) }
+        specify { expect(city.import(dummy_cities, batch_size: 1)).to eq(false) }
       end
 
       context do
@@ -167,15 +197,15 @@ describe Chewy::Type::Import do
           end
         end
 
-        specify { city.import(dummy_cities).should eq(false) }
-        specify { city.import(dummy_cities.map(&:id)).should eq(false) }
-        specify { city.import(dummy_cities, batch_size: 1).should eq(false) }
+        specify { expect(city.import(dummy_cities)).to eq(false) }
+        specify { expect(city.import(dummy_cities.map(&:id))).to eq(false) }
+        specify { expect(city.import(dummy_cities, batch_size: 1)).to eq(false) }
       end
     end
 
-    context 'parent-child relationship' do
-      let(:country) { Country.create(name: 'country') }
-      let(:another_country) { Country.create(name: 'another country') }
+    context 'parent-child relationship', :orm do
+      let(:country) { Country.create(id: 1, name: 'country') }
+      let(:another_country) { Country.create(id: 2, name: 'another country') }
 
       before do
         stub_model(:country)
@@ -198,10 +228,10 @@ describe Chewy::Type::Import do
 
       before { CountriesIndex::Country.import(country) }
 
-      let(:child_city) { City.create(country_id: country.id, name: 'city') }
+      let(:child_city) { City.create(id: 4, country_id: country.id, name: 'city') }
       let(:city) { CountriesIndex::City }
 
-      specify { city.import(child_city).should eq(true)  }
+      specify { expect(city.import(child_city)).to eq(true)  }
       specify { expect { city.import child_city }.to update_index(city).and_reindex(child_city) }
 
       specify do
@@ -251,8 +281,8 @@ describe Chewy::Type::Import do
     end
   end
 
-  describe '.import!' do
-    specify { expect { city.import!.should }.not_to raise_error }
+  describe '.import!', :orm do
+    specify { expect { city.import! }.not_to raise_error }
 
     context do
       before do