chewy 0.6.2 → 0.7.0

data/spec/chewy/query/criteria_spec.rb

@@ -8,6 +8,7 @@ describe Chewy::Query::Criteria do
   its(:facets) { should == {} }
   its(:scores) { should == [] }
   its(:aggregations) { should == {} }
+  its(:script_fields) { should == {} }
   its(:queries) { should == [] }
   its(:filters) { should == [] }
   its(:post_filters) { should == [] }
@@ -19,6 +20,7 @@ describe Chewy::Query::Criteria do
   its(:facets?) { should eq(false) }
   its(:scores?) { should eq(false) }
   its(:aggregations?) { should eq(false) }
+  its(:script_fields?) { should eq(false) }
   its(:queries?) { should eq(false) }
   its(:filters?) { should eq(false) }
   its(:post_filters?) { should eq(false) }
@@ -54,6 +56,11 @@ describe Chewy::Query::Criteria do
     specify { expect { subject.update_aggregations(field: 'hello') }.to change { subject.aggregations }.to(field: 'hello') }
   end
 
+  describe '#update_script_fields' do
+    specify { expect { subject.update_script_fields(distance: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }.to change { subject.script_fields? }.to(true) }
+    specify { expect { subject.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }.to change { subject.script_fields }.to(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }
+  end
+
   describe '#update_queries' do
     specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries? }.to(true) }
     specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries }.to([field: 'hello']) }
@@ -132,6 +139,8 @@ describe Chewy::Query::Criteria do
       .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
     specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
+      .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields).to eq({distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}}) }
     specify { expect(subject.tap { |c| c.update_scores(script: 'hello') }
       .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores).to eq([{script: 'hello'}, { script: 'foobar' } ]) }
     specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
@@ -162,6 +171,8 @@ describe Chewy::Query::Criteria do
       .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
     specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello', field1: 'hello'}) }
+    specify { expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
+      .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields).to eq({distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}}) }
     specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello', field1: 'hello'}) }
     specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
@@ -217,6 +228,9 @@ describe Chewy::Query::Criteria do
     specify { expect(request_body {
       update_queries(:query); update_post_filters(:post_filter);
     }).to eq({body: {query: :query, post_filter: :post_filter}}) }
+    specify { expect(request_body {
+      update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"})
+    }).to eq({:body=>{:script_fields=>{:distance_m=>{:script=>"doc['coordinates'].distanceInMiles(lat, lon)"}}}}) }
   end
 
   describe '#_filtered_query' do

data/spec/chewy/query_spec.rb

@@ -106,7 +106,7 @@ describe Chewy::Query do
     specify { expect(subject.script_score('23')).not_to eq(subject) }
     specify { expect(subject.script_score('23').criteria.scores).to eq([ { script_score: { script: '23' } } ]) }
     specify { expect { subject.script_score('23') }.not_to change { subject.criteria.scores } }
-    specify { expect(subject.script_score('23', filter: { foo: :bar}).criteria.scores).to eq([{ script_score: { script: '23' }, filter: { foo: :bar } }]) }
+    specify { expect(subject.script_score('23 * factor', params: { factor: 0.5}).criteria.scores).to eq([{ script_score: { script: '23 * factor', params: { factor: 0.5} } }]) }
   end
 
   describe '#boost_factor' do

data/spec/chewy/repository_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Chewy::Repository do
+  subject { described_class.send(:new) }
+
+  its(:analyzers) { should == {} }
+  its(:tokenizers) { should == {} }
+  its(:filters) { should == {} }
+  its(:char_filters) { should == {} }
+
+  describe '#analyzer' do
+    specify { expect(subject.analyzer(:name)).to be_nil }
+
+    context do
+      before { subject.analyzer(:name, option: :foo) }
+      specify { expect(subject.analyzer(:name)).to eq({option: :foo}) }
+      specify { expect(subject.analyzers).to eq({name: {option: :foo}}) }
+    end
+  end
+
+  describe '#tokenizer' do
+    specify { expect(subject.tokenizer(:name)).to be_nil }
+
+    context do
+      before { subject.tokenizer(:name, option: :foo) }
+      specify { expect(subject.tokenizer(:name)).to eq({option: :foo}) }
+      specify { expect(subject.tokenizers).to eq({name: {option: :foo}}) }
+    end
+  end
+
+  describe '#filter' do
+    specify { expect(subject.filter(:name)).to be_nil }
+
+    context do
+      before { subject.filter(:name, option: :foo) }
+      specify { expect(subject.filter(:name)).to eq({option: :foo}) }
+      specify { expect(subject.filters).to eq({name: {option: :foo}}) }
+    end
+  end
+
+  describe '#char_filter' do
+    specify { expect(subject.char_filter(:name)).to be_nil }
+
+    context do
+      before { subject.char_filter(:name, option: :foo) }
+      specify { expect(subject.char_filter(:name)).to eq({option: :foo}) }
+      specify { expect(subject.char_filters).to eq({name: {option: :foo}}) }
+    end
+  end
+end

data/spec/chewy/search_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Chewy::Search do
+  before { Chewy.massacre }
+
+  before do
+    stub_index(:products) do
+      define_type :product
+      define_type :product2
+    end
+  end
+
+  let(:product) { ProductsIndex::Product }
+
+  describe '.all' do
+    specify { expect(ProductsIndex.all).to be_a(Chewy::Query) }
+    specify { expect(product.all).to be_a(Chewy::Query) }
+  end
+
+  describe '.search_string' do
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(q: 'hello')).twice
+      ProductsIndex.search_string('hello')
+      product.search_string('hello')
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(explain: true)).twice
+      ProductsIndex.search_string('hello', explain: true)
+      product.search_string('hello', explain: true)
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: []))
+      ProductsIndex.search_string('hello')
+    end
+
+    specify do
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: ['product']))
+      product.search_string('hello')
+    end
+  end
+
+  context 'named scopes' do
+    before do
+      stub_model(:city)
+      stub_model(:country)
+
+      stub_index(:places) do
+        def self.by_rating(value)
+          filter { rating == value }
+        end
+
+        def self.by_name(index)
+          filter { name == "Name#{index}" }
+        end
+
+        define_type City do
+          def self.by_rating
+            filter { rating == yield }
+          end
+
+          field :name, index: 'not_analyzed'
+          field :rating, type: :integer
+        end
+
+        define_type Country do
+          field :name, index: 'not_analyzed'
+          field :rating, type: :integer
+        end
+      end
+    end
+
+    let!(:cities) { 3.times.map { |i| City.create! rating: i + 1, name: "Name#{i+1}" } }
+    let!(:countries) { 3.times.map { |i| Country.create! rating: i + 1, name: "Name#{i+4}" } }
+
+    before { PlacesIndex.import! city: cities, country: countries }
+
+    specify { expect(PlacesIndex.by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify { expect(PlacesIndex.by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
+    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:rating)).to eq([1]) }
+    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
+
+    specify { expect(PlacesIndex::City.by_rating {2}.map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
+
+    specify { expect(PlacesIndex::Country.by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(PlacesIndex::Country.by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
+    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:rating)).to eq([3]) }
+    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:class)).to eq([PlacesIndex::Country]) }
+    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
+  end
+end

data/spec/chewy/strategy_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Chewy::Strategy do
+  before { Chewy.massacre }
+  subject(:strategy) { Chewy::Strategy.new }
+
+  describe '#current' do
+    specify { expect(strategy.current).to be_a(Chewy::Strategy::Base) }
+
+    context do
+      before { allow(Chewy).to receive_messages(root_strategy: :bypass) }
+      specify { expect(strategy.current).to be_a(Chewy::Strategy::Bypass) }
+    end
+  end
+
+  describe '#push' do
+    specify { expect { strategy.push(:unexistant) }.to raise_error }
+
+    specify do
+      expect { strategy.push(:atomic) }
+        .to change { strategy.current }
+        .to(an_instance_of(Chewy::Strategy::Atomic))
+    end
+  end
+
+  describe '#pop' do
+    specify { expect { strategy.pop }.to raise_error }
+
+    specify do
+      strategy.push(:urgent)
+      expect { strategy.pop }
+        .to change { strategy.current }
+        .to(an_instance_of(Chewy::Strategy::Base))
+    end
+  end
+
+  context 'nesting', :orm do
+    before do
+      stub_model(:city) do
+        update_index('cities#city') { self }
+      end
+
+      stub_index(:cities) do
+        define_type City
+      end
+    end
+
+    let(:city) { City.create!(name: 'hello') }
+    let(:other_city) { City.create!(name: 'world') }
+
+    context do
+      around { |example| Chewy.strategy(:bypass) { example.run } }
+
+      specify do
+        expect(CitiesIndex::City).not_to receive(:import)
+        [city, other_city].map(&:save!)
+      end
+
+      specify do
+        expect(CitiesIndex::City).to receive(:import).with([city.id, other_city.id]).once
+        Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
+      end
+    end
+
+    context do
+      around { |example| Chewy.strategy(:urgent) { example.run } }
+
+      specify do
+        expect(CitiesIndex::City).to receive(:import).at_least(2).times
+        [city, other_city].map(&:save!)
+      end
+
+      specify do
+        expect(CitiesIndex::City).to receive(:import).with([city.id, other_city.id]).once
+        Chewy.strategy(:atomic) { [city, other_city].map(&:save!) }
+      end
+
+      context 'hash passed to urgent' do
+        before do
+          stub_index(:cities) do
+            define_type :city
+          end
+
+          stub_model(:city) do
+            update_index('cities#city') { { name: name } }
+          end
+        end
+
+        specify do
+          [city, other_city].map(&:save!)
+          expect(CitiesIndex::City.total_count).to eq(4)
+        end
+
+        context do
+          before do
+            stub_model(:city) do
+              update_index('cities#city') { { id: id.to_s, name: name } }
+            end
+          end
+
+          specify do
+            [city, other_city].map(&:save!)
+            expect(CitiesIndex::City.total_count).to eq(2)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,14 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
     end
   end
 
+  describe '#default_scope' do
+    specify { expect(described_class.new(City).default_scope).to eq(City.where(nil)) }
+    specify { expect(described_class.new(City.order(:id)).default_scope).to eq(City.where(nil)) }
+    specify { expect(described_class.new(City.limit(10)).default_scope).to eq(City.where(nil)) }
+    specify { expect(described_class.new(City.offset(10)).default_scope).to eq(City.where(nil)) }
+    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)).type_name).to eq('city') }
@@ -29,6 +37,29 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
     end
   end
 
+  describe '#identify' do
+    context do
+      subject { described_class.new(City) }
+      let!(:cities) { 3.times.map { City.create! } }
+
+      specify { expect(subject.identify(City.where(nil))).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
+
+    context 'custom primary_key' do
+      before { stub_model(:city) { self.primary_key = 'rating' } }
+      subject { described_class.new(City) }
+      let!(:cities) { 3.times.map { |i| City.create! { |c| c.rating = i } } }
+
+      specify { expect(subject.identify(City.where(nil))).to match_array([0, 1, 2]) }
+      specify { expect(subject.identify(cities)).to eq([0, 1, 2]) }
+      specify { expect(subject.identify(cities.first)).to eq([0]) }
+      specify { expect(subject.identify(cities.first(2).map(&:id))).to eq([0, 1]) }
+    end
+  end
+
   describe '#import' do
     def import(*args)
       result = []
@@ -37,11 +68,12 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
     end
 
     context do
-      let!(:cities) { 3.times.map { |i| City.create! } }
-      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) } }
+      let!(:cities) { 3.times.map { City.create! } }
+      let!(:deleted) { 4.times.map { City.create!.tap(&:destroy) } }
       subject { described_class.new(City) }
 
       specify { expect(import).to eq([{index: cities}]) }
+      specify { expect(import nil).to eq([]) }
 
       specify { expect(import(City.order(:id))).to eq([{index: cities}]) }
       specify { expect(import(City.order(:id), batch_size: 2))
@@ -50,11 +82,13 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record 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,48 +100,61 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record 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.where(nil))).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.where(nil))).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! } }
-      let!(:deleted) { 3.times.map { |i| City.create!(rating: 42) } }
-      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))).to eq([{index: cities, delete: deleted}]) }
     end
 
     context 'custom primary_key' do
@@ -125,11 +172,13 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record 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(1)}]) }
 
       specify { expect(import(cities.map(&:id))).to eq([{index: cities}]) }
       specify { expect(import(cities.map(&:id), batch_size: 2))
@@ -150,14 +199,29 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
 
       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))
+      specify { expect(import(City.where('rating < 2')))
+        .to eq([{index: cities.first(3)}]) }
+      specify { expect(import(City.where('rating < 2'), batch_size: 2))
         .to eq([{index: cities.first(2)}, {index: [cities[2]]}]) }
+      specify { expect(import(City.where('rating < 1')))
+        .to eq([{index: cities.first(3)}]) }
+      specify { expect(import(City.where('rating > 1'))).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)).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.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))
@@ -177,7 +241,7 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       subject { described_class.new(City) }
 
       let(:data_comparer) do
-        ->(id, data) { object = (data[:index] || data[:delete]).first; (object.respond_to?(:id) ? object.id : object) != id }
+        ->(id, data) { objects = data[:index] || data[:delete]; !objects.map { |o| o.respond_to?(:id) ? o.id : o }.include?(id) }
       end
 
       context 'implicit scope' do