chewy 0.8.4 → 0.9.0

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

@@ -39,7 +39,7 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
 
   describe '#identify' do
     subject { described_class.new(City) }
-    let!(:cities) { 3.times.map { City.create! } }
+    let!(:cities) { Array.new(3) { City.create! } }
 
     specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id).map(&:to_s)) }
     specify { expect(subject.identify(cities)).to eq(cities.map(&:id).map(&:to_s)) }
@@ -47,7 +47,7 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id).map(&:to_s)) }
 
     context 'non-bson ids' do
-      let!(:cities) { 3.times.map { |i| City.create! id: i+1 } }
+      let!(:cities) { Array.new(3) { |i| City.create! id: i + 1 } }
 
       specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id)) }
       specify { expect(subject.identify(cities)).to eq(cities.map(&:id)) }
@@ -64,46 +64,62 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     end
 
     context do
-      let!(:cities) { 3.times.map { |i| City.create! }.sort_by(&:id) }
-      let!(:deleted) { 4.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      let!(:cities) { Array.new(3) { City.create! }.sort_by(&:id) }
+      let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) }.sort_by(&:id) }
       subject { described_class.new(City) }
 
-      specify { expect(import).to match([{index: match_array(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))
-        .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(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)}]) }
-      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(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]}]) }
+      specify { expect(import).to match([{ index: match_array(cities) }]) }
+      specify { expect(import(nil)).to eq([]) }
+
+      specify { expect(import(City.order(:id.asc))).to eq([{ index: cities }]) }
+      specify do
+        expect(import(City.order(:id.asc), batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+      end
+
+      specify { expect(import(cities)).to eq([{ index: cities }]) }
+      specify do
+        expect(import(cities, batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+      end
+      specify do
+        expect(import(cities, deleted))
+          .to eq([{ index: cities }, { delete: deleted }])
+      end
+      specify do
+        expect(import(cities, deleted, batch_size: 2)).to eq([
+          { index: cities.first(2) },
+          { index: cities.last(1) },
+          { delete: deleted.first(2) },
+          { delete: deleted.last(2) }
+        ])
+      end
+
+      specify { expect(import(cities.map(&:id))).to eq([{ index: cities }]) }
+      specify { expect(import(deleted.map(&:id))).to eq([{ delete: deleted.map(&:id) }]) }
+      specify do
+        expect(import(cities.map(&:id), batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+      end
+      specify do
+        expect(import(cities.map(&:id), deleted.map(&:id)))
+          .to eq([{ index: cities }, { delete: deleted.map(&:id) }])
+      end
+      specify do
+        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(2).map(&:id) }
+        ])
+      end
+
+      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 'additional delete conitions' do
-      let!(:cities) { 4.times.map { |i| City.create! rating: i } }
+    context 'additional delete conditions' do
+      let!(:cities) { Array.new(4) { |i| City.create! rating: i } }
       before { cities.last(2).map(&:destroy) }
       subject { described_class.new(City) }
 
@@ -114,76 +130,113 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
           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) }
-      ]) }
+      subject { described_class.new(City, delete_if: -> { delete_already? }) }
+
+      specify do
+        expect(import(City.all)).to eq([
+          { index: [cities[0]], delete: [cities[1]] }
+        ])
+      end
+      specify do
+        expect(import(cities)).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2) }
+        ])
+      end
+      specify do
+        expect(import(cities.map(&:id))).to eq([
+          { index: [cities[0]], delete: [cities[1]] },
+          { delete: cities.last(2).map(&:id) }
+        ])
+      end
     end
 
     context 'default scope' do
-      let!(:cities) { 4.times.map { |i| City.create!(id: i, rating: i/3) }.sort_by(&:id) }
-      let!(:deleted) { 3.times.map { |i| City.create!(id: 4 + i).tap(&:destroy) }.sort_by(&:id) }
+      let!(:cities) { Array.new(4) { |i| City.create!(id: i, rating: i / 3) }.sort_by(&:id) }
+      let!(:deleted) { Array.new(3) { |i| City.create!(id: 4 + i).tap(&:destroy) }.sort_by(&:id) }
       subject { described_class.new(City.where(rating: 0)) }
 
-      specify { expect(import).to eq([{index: cities.first(3)}]) }
+      specify { expect(import).to eq([{ index: cities.first(3) }]) }
 
-      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 do
+        expect(import(City.where(:rating.lt => 2).order(:id.asc)))
+          .to eq([{ index: cities.first(3) }])
+      end
+      specify do
+        expect(import(City.where(:rating.lt => 2).order(:id.asc), batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }])
+      end
+      specify do
+        expect(import(City.where(:rating.lt => 1).order(:id.asc)))
+          .to eq([{ index: cities.first(3) }])
+      end
       specify { expect(import(City.where(:rating.gt => 1).order(:id.asc))).to eq([]) }
 
-      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[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(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)}]) }
+      specify do
+        expect(import(cities.first(2)))
+          .to eq([{ index: cities.first(2) }])
+      end
+      specify do
+        expect(import(cities))
+          .to eq([{ index: cities.first(3) }, { delete: cities.last(1) }])
+      end
+      specify do
+        expect(import(cities, batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }, { delete: cities.last(1) }])
+      end
+      specify do
+        expect(import(cities, deleted))
+          .to eq([{ index: cities.first(3) }, { delete: cities.last(1) + deleted }])
+      end
+      specify do
+        expect(import(cities, deleted, batch_size: 3)).to eq([
+          { index: cities.first(3) },
+          { delete: cities.last(1) + deleted.first(2) },
+          { delete: deleted.last(1) }
+        ])
+      end
+
+      specify do
+        expect(import(cities.first(2).map(&:id)))
+          .to eq([{ index: cities.first(2) }])
+      end
+      specify do
+        expect(import(cities.map(&:id)))
+          .to eq([{ index: cities.first(3) }, { delete: [cities.last.id] }])
+      end
+      specify do
+        expect(import(cities.map(&:id), batch_size: 2))
+          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }, { delete: [cities.last.id] }])
+      end
+      specify do
+        expect(import(cities.map(&:id), deleted.map(&:id)))
+          .to eq([{ index: cities.first(3) }, { delete: [cities.last.id] + deleted.map(&:id) }])
+      end
+      specify do
+        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
     end
 
     context 'error handling' do
-      let!(:cities) { 6.times.map { |i| City.create! } }
-      let!(:deleted) { 4.times.map { |i| City.create!.tap(&:destroy) } }
+      let!(:cities) { Array.new(6) { City.create! } }
+      let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) } }
       let(:ids) { (cities + deleted).map(&:id) }
       subject { described_class.new(City) }
 
       let(:data_comparer) do
-        ->(id, data) { objects = data[:index] || data[:delete]; !objects.map { |o| o.respond_to?(:id) ? o.id : o }.include?(id) }
+        lambda do |id, data|
+          objects = data[:index] || data[:delete]
+          !objects.map { |o| o.respond_to?(:id) ? o.id : o }.include?(id)
+        end
       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 { |_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].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) }
@@ -194,8 +247,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       context 'explicit scope' do
         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) { |_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].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) }
@@ -204,8 +257,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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) { |_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].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) }
@@ -214,8 +267,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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) { |_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].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) }
@@ -227,8 +280,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
 
   describe '#load' do
     context do
-      let!(:cities) { 3.times.map { |i| City.create!(id: i, rating: i/2) }.sort_by(&:id) }
-      let!(:deleted) { 2.times.map { |i| City.create!(id: 3 + i).tap(&:destroy) }.sort_by(&:id) }
+      let!(:cities) { Array.new(3) { |i| City.create!(id: i, rating: i / 2) }.sort_by(&:id) }
+      let!(:deleted) { Array.new(2) { |i| City.create!(id: 3 + i).tap(&:destroy) }.sort_by(&:id) }
 
       let(:type) { double(type_name: 'user') }
 
@@ -238,16 +291,24 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       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]) }
+      specify do
+        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: -> { where(rating: 0) }))
+          .to eq(cities.first(2) + [nil])
+      end
+      specify do
+        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))
+      end
+      specify do
+        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(rating: 1)))
+          .to eq([nil, nil] + cities.last(1))
+      end
+      specify do
+        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
 end

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

@@ -30,7 +30,7 @@ describe Chewy::Type::Adapter::Object do
   end
 
   describe '#identify' do
-    let!(:objects) { 3.times.map { double } }
+    let!(:objects) { Array.new(3) { double } }
 
     specify { expect(subject.identify(objects)).to eq(objects) }
     specify { expect(subject.identify(objects.first)).to eq([objects.first]) }
@@ -43,65 +43,76 @@ describe Chewy::Type::Adapter::Object do
       result
     end
 
-    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) }
+    specify { expect(subject.import(Array.new(3) { double }) { |_data| true }).to eq(true) }
+    specify { expect(subject.import(Array.new(3) { double }) { |_data| false }).to eq(false) }
 
     context do
-      let(:objects) { 3.times.map { |i| double } }
-      let(:deleted) { 2.times.map { |i| double(destroyed?: true) } }
+      let(:objects) { Array.new(3) { double } }
+      let(:deleted) { Array.new(2) { double(destroyed?: true) } }
       subject { described_class.new('product') }
 
       specify { expect(import).to eq([]) }
-      specify { expect(import nil).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)}]) }
-      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)}]) }
+      specify { expect(import(objects)).to eq([{ index: objects }]) }
+      specify do
+        expect(import(objects, batch_size: 2))
+          .to eq([{ index: objects.first(2) }, { index: objects.last(1) }])
+      end
+      specify { expect(import(objects, deleted)).to eq([{ index: objects, delete: deleted }]) }
+      specify do
+        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) }
+        ])
+      end
 
-      specify { expect(import(objects.first, nil)).to eq([{index: [objects.first]}]) }
+      specify { expect(import(objects.first, nil)).to eq([{ index: [objects.first] }]) }
 
       context 'initial data' do
-        subject { described_class.new ->{ objects } }
+        subject { described_class.new -> { objects } }
 
-        specify { expect(import).to eq([{index: objects}]) }
-        specify { expect(import nil).to eq([]) }
+        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)}]) }
+        specify { expect(import(objects[0..1])).to eq([{ index: objects[0..1] }]) }
+        specify do
+          expect(import(batch_size: 2))
+            .to eq([{ index: objects.first(2) }, { index: objects.last(1) }])
+        end
       end
 
       context do
         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) }
-        ]) }
+        let(:deleted) do
+          [
+            double(delete?: true, destroyed?: true),
+            double(delete?: true, destroyed?: false),
+            double(delete?: false, destroyed?: true),
+            double(delete?: false, destroyed?: false)
+          ]
+        end
+
+        specify do
+          expect(import(deleted)).to eq([
+            { delete: deleted[0..2], index: deleted.last(1) }
+          ])
+        end
       end
     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) } }
+      let(:products) { Array.new(3) { |i| double.tap { |product| allow(product).to receive_messages(rating: i.next) } } }
+      let(:deleted) { Array.new(2) { |i| double(destroyed?: true, rating: i + 4) } }
       subject { described_class.new('product') }
 
       let(:data_comparer) do
         ->(n, data) { (data[:index] || data[:delete]).first.rating != n }
       end
 
-      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) { |_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) }
@@ -113,24 +124,29 @@ describe Chewy::Type::Adapter::Object do
   describe '#load' do
     context do
       subject { described_class.new('product') }
-      let(:objects) { 3.times.map { |i| double } }
+      let(:objects) { Array.new(3) { double } }
 
       specify { expect(subject.load(objects)).to eq(objects) }
     end
 
     [: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 } }
+        before do
+          allow(Product).to receive(load_method) { |object|
+                              allow(object).to receive_messages(wrapped?: true)
+                              object
+                            }
+        end
         subject { described_class.new(Product) }
-        let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
+        let(:objects) { Array.new(3) { double(wrapped?: false) } }
 
         specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:wrapped?) } }
       end
 
       context do
-        before { allow(Product).to receive(load_method) { |object| nil } }
+        before { allow(Product).to receive(load_method) { |_object| nil } }
         subject { described_class.new(Product) }
-        let(:objects) { 3.times.map { |i| double(wrapped?: false) } }
+        let(:objects) { Array.new(3) { double(wrapped?: false) } }
 
         specify { expect(subject.load(objects)).to satisfy { |objects| objects.all?(&:nil?) } }
       end