chewy 0.8.2 → 0.8.3

data/lib/chewy/type/mapping.rb

@@ -111,7 +111,7 @@ module Chewy
         #
         def field *args, &block
           options = args.extract_options!
-          build_root unless root_object
+          build_root
 
           if args.size > 1
             args.map { |name| field(name, options) }
@@ -138,7 +138,7 @@ module Chewy
         #   end
         def agg *args, &block
           options = args.extract_options!
-          build_root unless root_object
+          build_root
           self._agg_defs = _agg_defs.merge(args.first => block)
         end
         alias_method :aggregation, :agg
@@ -164,9 +164,7 @@ module Chewy
         #   template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is
         #
         def template *args
-          build_root unless root_object
-
-          root_object.dynamic_template *args
+          build_root.dynamic_template *args
         end
         alias_method :dynamic_template, :template
 
@@ -192,6 +190,7 @@ module Chewy
         end
 
         def build_root options = {}, &block
+          return root_object if root_object
           self.root_object = Chewy::Fields::Root.new(type_name, options)
           expand_nested(root_object, &block)
           @_current_field = root_object

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.8.2'
+  VERSION = '0.8.3'
 end

data/lib/sequel/plugins/chewy_observe.rb

@@ -25,7 +25,7 @@ module Sequel
       def self.apply(model)
         model.instance_eval do
           include ActiveSupport::Callbacks
-          define_callbacks :commit, :save, :destroy
+          define_callbacks :commit, :destroy_commit, :save, :destroy
         end
       end
 
@@ -38,6 +38,7 @@ module Sequel
 
           if Chewy.use_after_commit_callbacks
             set_callback(:commit, callback_options, &update_proc)
+            set_callback(:destroy_commit, callback_options, &update_proc)
           else
             set_callback(:save, callback_options, &update_proc)
             set_callback(:destroy, callback_options, &update_proc)
@@ -54,6 +55,12 @@ module Sequel
           end
         end
 
+        def after_destroy_commit
+          run_callbacks(:destroy_commit) do
+            super
+          end
+        end
+
         def after_save
           run_callbacks(:save) do
             super

data/spec/chewy/query/criteria_spec.rb

@@ -138,13 +138,13 @@ describe Chewy::Query::Criteria do
     specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
       .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'}) }
+      .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({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') }
-      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello', field1: 'hello'}) }
+      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello'}) }
     specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
     specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }
@@ -170,11 +170,11 @@ describe Chewy::Query::Criteria do
     specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
       .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'}) }
+      .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({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'}) }
+      .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello'}) }
     specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
       .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
     specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }

data/spec/chewy/strategy/atomic_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Chewy::Strategy::Atomic, :orm do
+  around { |example| Chewy.strategy(:bypass) { example.run } }
+
+  before do
+    stub_model(:country) do
+      update_index('countries#country') { self }
+    end
+
+    stub_index(:countries) do
+      define_type Country
+    end
+  end
+
+  let(:country) { Country.create!(name: 'hello', country_code: 'HL') }
+  let(:other_country) { Country.create!(name: 'world', country_code: 'WD') }
+
+  specify do
+    expect { [country, other_country].map(&:save!) }
+      .to update_index(CountriesIndex::Country, strategy: :atomic)
+      .and_reindex(country, other_country)
+  end
+
+  specify do
+    expect { [country, other_country].map(&:destroy) }
+      .to update_index(CountriesIndex::Country, strategy: :atomic)
+      .and_delete(country, other_country)
+  end
+
+  context do
+    before do
+      stub_index(:countries) do
+        define_type Country do
+          root id: -> { country_code } do
+          end
+        end
+      end
+    end
+
+    specify do
+      expect { [country, other_country].map(&:save!) }
+        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .and_reindex('HL', 'WD')
+    end
+
+    specify do
+      expect { [country, other_country].map(&:destroy) }
+        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .and_delete('HL', 'WD')
+    end
+
+    specify do
+      expect { country.save!; other_country.destroy }
+        .to update_index(CountriesIndex::Country, strategy: :atomic)
+        .and_reindex('HL').and_delete('WD')
+    end
+  end
+end

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

@@ -38,8 +38,9 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
   end
 
   describe '#identify' do
+    subject { described_class.new(City) }
+
     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)) }
@@ -50,7 +51,6 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
 
     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]) }
@@ -111,50 +111,26 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       before { cities.last(2).map(&:destroy) }
       subject { described_class.new(City) }
 
-      context do
-        before do
-          City.class_eval do
-            def delete_from_index?
-              rating.in?([1, 3])
-            end
-          end
-        end
-
-        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 do
-          City.class_eval do
-            def delete_already?
-              rating.in?([1, 3])
-            end
+      before do
+        City.class_eval do
+          def delete_already?
+            rating.in?([1, 3])
           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
+      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
 
     context 'custom primary_key' do

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

@@ -107,50 +107,26 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       before { cities.last(2).map(&:destroy) }
       subject { described_class.new(City) }
 
-      context do
-        before do
-          City.class_eval do
-            def delete_from_index?
-              rating.in?([1, 3])
-            end
+      before do
+        City.class_eval do
+          def delete_already?
+            rating.in?([1, 3])
           end
         end
-
-        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 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
+      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
 
     context 'default scope' do

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

@@ -76,19 +76,6 @@ describe Chewy::Type::Adapter::Object do
           .to eq([{index: objects.first(2)}, {index: objects.last(1)}]) }
       end
 
-      context do
-        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
         subject { described_class.new('product', delete_if: :delete?) }
         let(:deleted) { [

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

@@ -1,46 +1,320 @@
 require 'spec_helper'
 
 describe Chewy::Type::Adapter::Sequel, :sequel do
-
-  let(:adapter) { described_class }
-
   before do
     stub_model(:city)
     stub_model(:country)
   end
 
   describe '#name' do
-
-    it { expect( adapter.new(City).name ).to eq 'City' }
-    it { expect( adapter.new(City.order(:id)).name ).to eq 'City' }
-    it { expect( adapter.new(City, name: 'town').name ).to eq 'Town' }
+    it { expect( described_class.new(City).name ).to eq 'City' }
+    it { expect( described_class.new(City.order(:id)).name ).to eq 'City' }
+    it { expect( described_class.new(City, name: 'town').name ).to eq 'Town' }
 
     context do
       before { stub_model('namespace/city') }
 
-      it { expect( adapter.new(Namespace::City).name ).to eq 'City' }
-      it { expect( adapter.new(Namespace::City.order(:id)).name ).to eq 'City' }
+      it { expect( described_class.new(Namespace::City).name ).to eq 'City' }
+      it { expect( described_class.new(Namespace::City.order(:id)).name ).to eq 'City' }
     end
   end
 
-  describe '#default_dataset' do
+  describe '#default_scope' do
+    it { expect( described_class.new(City).default_scope.sql ).to eql City.where(nil).sql }
+    it { expect( described_class.new(City.order(:id)).default_scope.sql ).to eql City.where(nil).sql }
+    it { expect( described_class.new(City.limit(10)).default_scope.sql ).to eql City.where(nil).sql  }
+    it { expect( described_class.new(City.offset(10)).default_scope.sql ).to eql City.where(nil).sql }
+    it { expect( described_class.new(City.where(rating: 10)).default_scope.sql ).to eql City.where(rating: 10).sql }
+  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') }
+    specify { expect(described_class.new(City, name: 'town').type_name).to eq('town') }
+
+    context do
+      before { stub_model('namespace/city') }
 
-    it { expect( adapter.new(City).default_dataset.sql ).to eql City.where(nil).sql }
-    it { expect( adapter.new(City.order(:id)).default_dataset.sql ).to eql City.where(nil).sql }
-    it { expect( adapter.new(City.limit(10)).default_dataset.sql ).to eql City.where(nil).sql  }
-    it { expect( adapter.new(City.offset(10)).default_dataset.sql ).to eql City.where(nil).sql }
-    it { expect( adapter.new(City.where(rating: 10)).default_dataset.sql ).to eql City.where(rating: 10).sql }
+      specify { expect(described_class.new(Namespace::City).type_name).to eq('city') }
+      specify { expect(described_class.new(Namespace::City.order(:id)).type_name).to eq('city') }
+    end
   end
 
   describe '#identify' do
+    subject { described_class.new(City) }
+
+    context do
+      let!(:cities) { 3.times.map { City.new.save! } }
+
+      it { expect(subject.identify(City.where(nil)) ).to match_array cities.map(&:id) }
+      it { expect(subject.identify(cities) ).to eq cities.map(&:id) }
+      it { expect(subject.identify(cities.first) ).to eq([cities.first.id]) }
+      it { 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).set_dataset :rating_cities }
+      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(&:rating))).to eq([0, 1]) }
+    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 { 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))
+        .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]}]) }
+    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) }
+
+      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
+
+    context 'custom primary_key' do
+      before { stub_model(:city).set_dataset :rating_cities }
+      let!(:cities) { 3.times.map { |i| City.create! { |c| c.rating = i + 7 } } }
+      let!(:deleted) { 3.times.map { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+      subject { described_class.new(City) }
+
+      specify { expect(import).to eq([{index: cities}]) }
+
+      specify { expect(import(City.order(:rating))).to eq([{index: cities}]) }
+      specify { expect(import(City.order(:rating), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+
+      specify { 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(1)}]) }
+
+      specify { expect(import(cities.map(&:rating))).to eq([{index: cities}]) }
+      specify { expect(import(cities.map(&:rating), batch_size: 2))
+        .to eq([{index: cities.first(2)}, {index: cities.last(1)}]) }
+      specify { expect(import(cities.map(&:rating), deleted.map(&:rating)))
+        .to eq([{index: cities}, {delete: deleted.map(&:rating)}]) }
+      specify { expect(import(cities.map(&:rating), deleted.map(&:rating), batch_size: 2)).to eq([
+        {index: cities.first(2)},
+        {index: cities.last(1)},
+        {delete: deleted.first(2).map(&:rating)},
+        {delete: deleted.last(1).map(&:rating)}]) }
+    end
+
+    context 'default scope' do
+      let!(:cities) { 4.times.map { |i| City.create!(rating: i/3) } }
+      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) } }
+      subject { described_class.new(City.where(rating: 0)) }
+
+      specify { expect(import).to eq([{index: cities.first(3)}]) }
+
+      specify { expect(import(City.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.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)}]) }
+    end
+
+    context 'error handling' do
+      let!(:cities) { 3.times.map { |i| City.create! } }
+      let!(:deleted) { 2.times.map { |i| 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) }
+      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: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(true) }
+      end
+
+      context 'explicit scope' do
+        let(:scope) { City.where(id: ids) }
+
+        specify { expect(subject.import(scope) { |data| true }).to eq(true) }
+        specify { expect(subject.import(scope) { |data| false }).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(true) }
+        specify { expect(subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(true) }
+      end
+
+      context 'objects' do
+        specify { expect(subject.import(cities + deleted) { |data| true }).to eq(true) }
+        specify { expect(subject.import(cities + deleted) { |data| false }).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
+      end
+
+      context 'ids' do
+        specify { expect(subject.import(ids) { |data| true }).to eq(true) }
+        specify { expect(subject.import(ids) { |data| false }).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
+        specify { expect(subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
+      end
+    end
+  end
+
+  describe '#load' do
     context do
-      subject(:s) { adapter.new(City) }
-      let!(:cities) { 3.times.map { City.new.save } }
+      let!(:cities) { 3.times.map { |i| City.create!(rating: i/2) } }
+      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) } }
+
+      let(:type) { double(type_name: 'user') }
+
+      subject { described_class.new(City) }
+
+      specify { 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)) }
+      xspecify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(rating: 1)))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(id: c.id) },
+        _type: type, scope: City.where(rating: 1), user: {scope: ->{ where(rating: 0)}}))
+        .to eq(cities.first(2) + [nil]) }
+    end
+
+    context 'custom primary_key' do
+      before { stub_model(:city).set_dataset :rating_cities }
+      let!(:cities) { 3.times.map { |i| City.create!(country_id: i/2) { |c| c.rating = i + 7 } } }
+      let!(:deleted) { 2.times.map { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+
+      let(:type) { double(type_name: 'user') }
+
+      subject { described_class.new(City) }
 
-      it { expect( s.identify(City.where(nil)) ).to match_array cities.map(&:id) }
-      it { expect( s.identify(cities) ).to eq cities.map(&:id) }
-      it { expect( s.identify(cities.first) ).to eq([cities.first.id]) }
-      it { expect( s.identify(cities.first(2).map(&:pk)) ).to eq cities.first(2).map(&:id) }
+      specify { expect(subject.load(cities.map { |c| double(rating: c.rating) }, _type: type)).to eq(cities) }
+      specify { expect(subject.load(cities.map { |c| double(rating: c.rating) }.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted.map { |c| double(rating: c.rating) }, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load((cities + deleted).map { |c| double(rating: c.rating) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(cities.map { |c| double(rating: c.rating) }, _type: type, scope: ->{ where(country_id: 0) }))
+        .to eq(cities.first(2) + [nil]) }
+      specify { expect(subject.load(cities.map { |c| double(rating: c.rating) },
+        _type: type, scope: ->{ where(country_id: 0) }, user: {scope: ->{ where(country_id: 1)}}))
+        .to eq([nil, nil] + cities.last(1)) }
+      xspecify { expect(subject.load(cities.map { |c| double(rating: c.rating) }, _type: type, scope: City.where(country_id: 1)))
+        .to eq([nil, nil] + cities.last(1)) }
+      specify { expect(subject.load(cities.map { |c| double(rating: c.rating) },
+        _type: type, scope: City.where(country_id: 1), user: {scope: ->{ where(country_id: 0)}}))
+        .to eq(cities.first(2) + [nil]) }
     end
   end
 end