chewy 0.6.2 → 0.7.0

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

@@ -16,6 +16,14 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     end
   end
 
+  describe '#default_scope' do
+    specify { expect(described_class.new(City).default_scope).to eq(City.all) }
+    specify { expect(described_class.new(City.order(:id.asc)).default_scope).to eq(City.all) }
+    specify { expect(described_class.new(City.limit(10)).default_scope).to eq(City.all) }
+    specify { expect(described_class.new(City.offset(10)).default_scope).to eq(City.all) }
+    specify { expect(described_class.new(City.where(rating: 10)).default_scope).to eq(City.where(rating: 10)) }
+  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') }
@@ -29,6 +37,16 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     end
   end
 
+  describe '#identify' do
+    subject { described_class.new(City) }
+    let!(:cities) { 3.times.map { City.create! } }
+
+    specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id)) }
+    specify { expect(subject.identify(cities)).to eq(cities.map(&:id)) }
+    specify { expect(subject.identify(cities.first)).to eq([cities.first.id]) }
+    specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id)) }
+  end
+
   describe '#import' do
     def import(*args)
       result = []
@@ -38,10 +56,11 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
 
     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) }
+      let!(:deleted) { 4.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 nil).to eq([]) }
 
       specify { expect(import(City.order(:id.asc))).to eq([{index: cities}]) }
       specify { expect(import(City.order(:id.asc), batch_size: 2))
@@ -50,11 +69,13 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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))
+        .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)}]) }
+        {index: cities.first(2)},
+        {index: cities.last(1)},
+        {delete: deleted.first(2)},
+        {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)}]) }
@@ -66,127 +87,155 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
         {index: cities.first(2)},
         {index: cities.last(1)},
         {delete: deleted.first(2).map(&:id)},
-        {delete: deleted.last(1).map(&:id)}]) }
+        {delete: deleted.last(2).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]}]) }
+    end
 
-      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 'additional delete conitions' do
+      let!(:cities) { 4.times.map { |i| City.create! rating: i } }
+      before { cities.last(2).map(&:destroy) }
+      subject { described_class.new(City) }
 
       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
+        before do
+          City.class_eval do
+            def delete_from_index?
+              rating.in?([1, 3])
+            end
+          end
+        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}]) }
+        specify { expect(import(City.all)).to eq([
+          { index: [cities[0]], delete: [cities[1]] }
+        ]) }
+        specify { expect(import(cities)).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2) }
+        ]) }
+        specify { expect(import(cities.map(&:id))).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2).map(&:id) }
+        ]) }
       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
+        before do
+          City.class_eval do
+            def delete_already?
+              rating.in?([1, 3])
+            end
           end
         end
+        subject { described_class.new(City, delete_if: ->{ delete_already? }) }
+
+        specify { expect(import(City.all)).to eq([
+          { index: [cities[0]], delete: [cities[1]] }
+        ]) }
+        specify { expect(import(cities)).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2) }
+        ]) }
+        specify { expect(import(cities.map(&:id))).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2).map(&:id) }
+        ]) }
       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) }
+      let!(:cities) { 4.times.map { |i| City.create!(rating: i/3) }.sort_by(&:id) }
+      let!(:deleted) { 3.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).to eq([{index: cities.first(3)}]) }
 
-      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(City.where(:rating.lt => 2).order(:id.asc)))
+        .to eq([{index: cities.first(3)}]) }
+      specify { expect(import(City.where(:rating.lt => 2).order(:id.asc), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: [cities[2]]}]) }
+      specify { expect(import(City.where(:rating.lt => 1).order(:id.asc)))
+        .to eq([{index: cities.first(3)}]) }
+      specify { expect(import(City.where(:rating.gt => 1).order(:id.asc))).to eq([]) }
 
-      specify { expect(import(cities)).to eq([{index: cities}]) }
+      specify { expect(import(cities.first(2)))
+        .to eq([{index: cities.first(2)}]) }
+      specify { expect(import(cities))
+        .to eq([{index: cities.first(3)}, {delete: cities.last(1)}]) }
       specify { expect(import(cities, batch_size: 2))
-        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
-
+        .to eq([{index: cities.first(2)}, {index: [cities[2]]}, {delete: cities.last(1)}]) }
+      specify { expect(import(cities, deleted))
+        .to eq([{index: cities.first(3)}, {delete: cities.last(1) + deleted}]) }
+      specify { expect(import(cities, deleted, batch_size: 3)).to eq([
+        {index: cities.first(3)},
+        {delete: cities.last(1) + deleted.first(2)},
+        {delete: deleted.last(1)}]) }
+
+      specify { expect(import(cities.first(2).map(&:id)))
+        .to eq([{index: cities.first(2)}]) }
       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]}]) }
+        .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(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)},
+        .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
-      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!(:cities) { 6.times.map { |i| City.create! } }
+      let!(:deleted) { 4.times.map { |i| City.create!.tap(&:destroy) } }
       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 }
+        ->(id, data) { objects = data[:index] || data[:delete]; !objects.map { |o| o.respond_to?(:id) ? o.id : o }.include?(id) }
       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) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(true) }
       end
 
       context 'explicit scope' do
-        let(:scope) { mongoid? ? City.where(:id.in => ids) : City.where(id: ids) }
+        let(:scope) { City.where(:id.in => 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) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(scope, batch_size: 2, &data_comparer.curry[deleted[2].id])).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) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 2, &data_comparer.curry[deleted[2].id])).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) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[cities[4].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 2, &data_comparer.curry[deleted[2].id])).to eq(false) }
       end
     end
   end

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

@@ -29,6 +29,13 @@ describe Chewy::Type::Adapter::Object do
     end
   end
 
+  describe '#identify' do
+    let!(:objects) { 3.times.map { double } }
+
+    specify { expect(subject.identify(objects)).to eq(objects) }
+    specify { expect(subject.identify(objects.first)).to eq([objects.first]) }
+  end
+
   describe '#import' do
     def import(*args)
       result = []
@@ -45,6 +52,8 @@ describe Chewy::Type::Adapter::Object do
       subject { described_class.new('product') }
 
       specify { expect(import).to eq([]) }
+      specify { expect(import nil).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)}]) }
@@ -56,39 +65,45 @@ describe Chewy::Type::Adapter::Object do
 
       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 { expect(import(deleted)).to eq([{delete: deleted}]) }
-      end
+      context 'initial data' do
+        subject { described_class.new ->{ objects } }
 
-      context do
-        let(:deleted) { 2.times.map { |i| double(delete_from_index?: true, destroyed?: false) } }
-        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
-      end
+        specify { expect(import).to eq([{index: objects}]) }
+        specify { expect(import nil).to eq([]) }
 
+        specify { expect(import(objects[0..1])).to eq([{index: objects[0..1]}]) }
+        specify { expect(import(batch_size: 2))
+          .to eq([{index: objects.first(2)}, {index: objects.last(1)}]) }
+      end
 
       context do
-        let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: true) } }
-        specify { expect(import(deleted)).to eq([{delete: deleted}]) }
+        let(:deleted) { [
+          double(delete_from_index?: true, destroyed?: true),
+          double(delete_from_index?: true, destroyed?: false),
+          double(delete_from_index?: false, destroyed?: true),
+          double(delete_from_index?: false, destroyed?: false)
+        ] }
+
+        specify { expect(import(deleted)).to eq([
+          { delete: deleted[0..2], index: deleted.last(1) }
+        ]) }
       end
 
       context do
-        let(:deleted) { 2.times.map { |i| double(delete_from_index?: false, destroyed?: false) } }
-        specify { expect(import(deleted)).to eq([{index: deleted}]) }
+        subject { described_class.new('product', delete_if: :delete?) }
+        let(:deleted) { [
+          double(delete?: true, destroyed?: true),
+          double(delete?: true, destroyed?: false),
+          double(delete?: false, destroyed?: true),
+          double(delete?: false, destroyed?: false)
+        ] }
+
+        specify { expect(import(deleted)).to eq([
+          { delete: deleted[0..2], index: deleted.last(1) }
+        ]) }
       end
     end
 
-    context do
-      let(:products) { 3.times.map { |i| double.tap { |product|
-        allow(product).to receive(:is_a?).with(Product).and_return(true)
-      } } }
-      let(:non_product) { double }
-      subject { described_class.new(Product) }
-
-      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| allow(product).to receive_messages(rating: i.next) } } }
       let(:deleted) { 2.times.map { |i| double(destroyed?: true, rating: i + 4) } }
@@ -116,20 +131,22 @@ describe Chewy::Type::Adapter::Object do
       specify { expect(subject.load(objects)).to eq(objects) }
     end
 
-    context do
-      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) } }
+    [:wrap, :load_one].each do |load_method|
+      context do
+        before { allow(Product).to receive(load_method) { |object| allow(object).to receive_messages(wrapped?: true); object } }
+        subject { described_class.new(Product) }
+        let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
 
-      specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:wrapped?) } }
-    end
+        specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:wrapped?) } }
+      end
 
-    context do
-      before { allow(Product).to receive(:wrap) { |object| nil } }
-      subject { described_class.new(Product) }
-      let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
+      context do
+        before { allow(Product).to receive(load_method) { |object| nil } }
+        subject { described_class.new(Product) }
+        let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
 
-      specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:nil?) } }
+        specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:nil?) } }
+      end
     end
   end
 end

data/spec/chewy/type/import_spec.rb

@@ -58,15 +58,15 @@ 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}}]
-      ))
-
-      expect(CitiesIndex.client).to receive(:bulk).with(hash_including(
-        body: [{index: {_id: 2, data: {'name' => "name1"}}}, {index: {_id: 3, data: {'name' => "name2"}}}]
-      ))
+      imported = []
+      allow(CitiesIndex.client).to receive(:bulk) { |params| imported << params[:body]; nil }
 
       city.import dummy_cities.map(&:id), batch_size: 2
+      expect(imported.flatten).to match_array([
+        {index: {_id: 2, data: {'name' => 'name1'}}},
+        {index: {_id: 3, data: {'name' => 'name2'}}},
+        {delete: {_id: dummy_cities.first.id}}
+      ])
     end
 
     specify do
@@ -130,7 +130,7 @@ describe Chewy::Type::Import do
         end
 
         dummy_cities.first.destroy
-        city.import dummy_cities, batch_size: 1
+        city.import dummy_cities, batch_size: 2
         expect(outer_payload).to eq({type: CitiesIndex::City, import: {delete: 1, index: 2}})
       end
 
@@ -140,7 +140,7 @@ describe Chewy::Type::Import do
           outer_payload = payload
         end
 
-        city.import dummy_cities, batch_size: 1
+        city.import dummy_cities, batch_size: 2
         expect(outer_payload).to eq({type: CitiesIndex::City, import: {index: 3}})
       end
 
@@ -159,12 +159,12 @@ describe Chewy::Type::Import do
             outer_payload = payload
           end
 
-          city.import dummy_cities, batch_size: 1
+          city.import dummy_cities, batch_size: 2
           expect(outer_payload).to eq({
             type: CitiesIndex::City,
             errors: {
               index: {
-                'MapperParsingException[object mapping for [city] tried to parse as object, but got EOF, has a concrete value been provided to it?]' => ['1', '2', '3']
+                'MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]' => ['1', '2', '3']
               }
             },
             import: {index: 3}
@@ -199,7 +199,7 @@ describe Chewy::Type::Import do
 
         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) }
+        specify { expect(city.import(dummy_cities, batch_size: 2)).to eq(false) }
       end
     end
 
@@ -209,7 +209,7 @@ describe Chewy::Type::Import do
 
       before do
         stub_model(:country)
-        stub_model(:city)
+        stub_model(:city) { belongs_to :country }
       end
 
       before do
@@ -279,15 +279,15 @@ describe Chewy::Type::Import do
         end
       end
     end
-    
+
     context 'root id', :orm do
       let(:canada) { Country.create(id: 1, name: 'Canada', country_code: 'CA', rating: 4) }
       let(:country)  { CountriesIndex::Country }
-      
+
       before do
         stub_model(:country)
       end
-      
+
       before do
         stub_index(:countries) do
           define_type Country do
@@ -298,8 +298,8 @@ describe Chewy::Type::Import do
           end
         end
       end
-      
-      specify { expect( country.import(canada) ).to eq(true)  }
+
+      specify { expect(country.import(canada)).to eq(true)  }
       specify { expect { country.import(canada) }.to update_index(country).and_reindex(canada.country_code) }
 
       specify do
@@ -309,7 +309,7 @@ describe Chewy::Type::Import do
 
         country.import canada
       end
-      
+
       specify do
         canada.update_attributes(rating: 9)
 
@@ -319,7 +319,7 @@ describe Chewy::Type::Import do
 
         country.import canada
       end
-      
+
       specify do
         canada.destroy
 
@@ -329,7 +329,7 @@ describe Chewy::Type::Import do
 
         country.import canada
       end
-      
+
     end  # END root id
   end