chewy 0.9.0 → 0.10.0

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

@@ -4,6 +4,8 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
   before do
     stub_model(:city)
     stub_model(:country)
+    City.many_to_one :country
+    Country.one_to_many :cities
   end
 
   describe '#name' do
@@ -75,54 +77,54 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
       let!(:deleted) { Array.new(4) { City.create!.tap(&:destroy) } }
       subject { described_class.new(City) }
 
-      specify { expect(import).to eq([{ index: cities }]) }
+      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))).to eq([{index: cities}]) }
       specify do
         expect(import(City.order(:id), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
 
-      specify { expect(import(cities)).to eq([{ index: cities }]) }
+      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) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities, deleted))
-          .to eq([{ index: cities }, { delete: 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) }
+          {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 { 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) }])
+          .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) }])
+          .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) }
+          {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] }]) }
+      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 conditions' do
@@ -141,19 +143,19 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
 
       specify do
         expect(import(City.where(nil))).to eq([
-          { index: [cities[0]], delete: [cities[1]] }
+          {index: [cities[0]], delete: [cities[1]]}
         ])
       end
       specify do
         expect(import(cities)).to eq([
-          { index: [cities[0]], delete: [cities[1]] },
-          { delete: cities.last(2) }
+          {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) }
+          {index: [cities[0]], delete: [cities[1]]},
+          {delete: cities.last(2).map(&:id)}
         ])
       end
     end
@@ -164,47 +166,47 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
       let!(:deleted) { Array.new(3) { |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).to eq([{index: cities}]) }
 
-      specify { expect(import(City.order(:rating))).to eq([{ index: cities }]) }
+      specify { expect(import(City.order(:rating))).to eq([{index: cities}]) }
       specify do
         expect(import(City.order(:rating), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
 
-      specify { expect(import(cities)).to eq([{ index: cities }]) }
+      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) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities, deleted))
-          .to eq([{ index: cities }, { delete: 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(1) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2)},
+          {delete: deleted.last(1)}
         ])
       end
 
-      specify { expect(import(cities.map(&:rating))).to eq([{ index: cities }]) }
+      specify { expect(import(cities.map(&:rating))).to eq([{index: cities}]) }
       specify do
         expect(import(cities.map(&:rating), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: cities.last(1) }])
+          .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
       specify do
         expect(import(cities.map(&:rating), deleted.map(&:rating)))
-          .to eq([{ index: cities }, { delete: deleted.map(&:rating) }])
+          .to eq([{index: cities}, {delete: deleted.map(&:rating)}])
       end
       specify do
         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) }
+          {index: cities.first(2)},
+          {index: cities.last(1)},
+          {delete: deleted.first(2).map(&:rating)},
+          {delete: deleted.last(1).map(&:rating)}
         ])
       end
     end
@@ -214,67 +216,67 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
       let!(:deleted) { Array.new(3) { City.create!.tap(&:destroy) } }
       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 do
         expect(import(City.where('rating < 2')))
-          .to eq([{ index: cities.first(3) }])
+          .to eq([{index: cities.first(3)}])
       end
       specify do
         expect(import(City.where('rating < 2'), batch_size: 2))
-          .to eq([{ index: cities.first(2) }, { index: [cities[2]] }])
+          .to eq([{index: cities.first(2)}, {index: [cities[2]]}])
       end
       specify do
         expect(import(City.where('rating < 1')))
-          .to eq([{ index: cities.first(3) }])
+          .to eq([{index: cities.first(3)}])
       end
       specify { expect(import(City.where('rating > 1'))).to eq([]) }
 
       specify do
         expect(import(cities.first(2)))
-          .to eq([{ index: 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) }])
+          .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) }])
+          .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 }])
+          .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) }
+          {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) }])
+          .to eq([{index: cities.first(2)}])
       end
       specify do
         expect(import(cities.map(&:id)))
-          .to eq([{ index: cities.first(3) }, { delete: [cities.last.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] }])
+          .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) }])
+          .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) }
+          {index: cities.first(3)},
+          {delete: [cities.last.id] + deleted.first(2).map(&:id)},
+          {delete: deleted.last(1).map(&:id)}
         ])
       end
     end
@@ -336,35 +338,98 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
     end
   end
 
+  describe '#import_fields' do
+    subject { described_class.new(Country) }
+    let!(:countries) { Array.new(3) { |i| Country.create!(rating: i) { |c| c.id = i + 1 } } }
+    let!(:cities) { Array.new(6) { |i| City.create!(rating: i + 3, country_id: (i + 4) / 2) { |c| c.id = i + 3 } } }
+
+    specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3)]) }
+    specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2])]) }
+
+    context 'scopes' do
+      context do
+        subject { described_class.new(Country.eager_graph(:cities)) }
+
+        specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3)]) }
+        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2])]) }
+      end
+
+      context do
+        subject { described_class.new(Country.eager(:cities)) }
+
+        specify { expect(subject.import_fields).to match([contain_exactly(1, 2, 3)]) }
+        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([1, 0], [2, 1], [3, 2])]) }
+      end
+
+      context do
+        subject { described_class.new(Country.join(:cities, country_id: :id)) }
+
+        specify { expect(subject.import_fields).to match([contain_exactly(2, 3)]) }
+        specify { expect(subject.import_fields(fields: [:rating])).to match([contain_exactly([2, 1], [3, 2])]) }
+      end
+
+      context 'ignores default scope if another scope is passed' do
+        subject { described_class.new(Country.join(:cities, country_id: :id)) }
+
+        specify { expect(subject.import_fields(Country.where('rating < 2'))).to match([contain_exactly(1, 2)]) }
+        specify { expect(subject.import_fields(Country.where('rating < 2'), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+      end
+    end
+
+    context 'objects/ids' do
+      specify { expect(subject.import_fields(1, 2)).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(1, 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+
+      specify { expect(subject.import_fields(countries.first(2))).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(countries.first(2), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+    end
+
+    context 'batch_size' do
+      specify { expect(subject.import_fields(batch_size: 2)).to match([contain_exactly(1, 2), [3]]) }
+      specify { expect(subject.import_fields(batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]]) }
+
+      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2)).to match([contain_exactly(1, 2)]) }
+      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+
+      specify { expect(subject.import_fields(1, 2, batch_size: 1)).to match([[1], [2]]) }
+      specify { expect(subject.import_fields(1, 2, batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
+
+      specify { expect(subject.import_fields(countries.first(2), batch_size: 1)).to match([[1], [2]]) }
+      specify { expect(subject.import_fields(countries.first(2), batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
+    end
+  end
+
   describe '#load' do
     context do
       let!(:cities) { Array.new(3) { |i| City.create!(rating: i / 2) } }
       let!(:deleted) { Array.new(2) { City.create!.tap(&:destroy) } }
+      let(:city_ids) { cities.map(&:id) }
+      let(:deleted_ids) { deleted.map(&:id) }
 
       let(:type) { double(type_name: 'user') }
 
       subject { described_class.new(City) }
 
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type)).to eq(cities) }
-      specify { expect(subject.load(cities.map { |c| double(id: c.id) }.reverse, _type: type)).to eq(cities.reverse) }
-      specify { expect(subject.load(deleted.map { |c| double(id: c.id) }, _type: type)).to eq([nil, nil]) }
-      specify { expect(subject.load((cities + deleted).map { |c| double(id: c.id) }, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(city_ids, _type: type)).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: -> { where(rating: 0) }))
+        expect(subject.load(city_ids, _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) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: -> { where(rating: 0) }, user: {scope: -> { where(rating: 1) }}))
           .to eq([nil, nil] + cities.last(1))
       end
-      xspecify do
-        expect(subject.load(cities.map { |c| double(id: c.id) }, _type: type, scope: City.where(rating: 1)))
+      xspecify 'sequel does not support scopes merge' do
+        expect(subject.load(city_ids, _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) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: City.where(rating: 1), user: {scope: -> { where(rating: 0) }}))
           .to eq(cities.first(2) + [nil])
       end
     end
@@ -373,31 +438,33 @@ describe Chewy::Type::Adapter::Sequel, :sequel do
       before { stub_model(:city).set_dataset :rating_cities }
       let!(:cities) { Array.new(3) { |i| City.create!(country_id: i / 2) { |c| c.rating = i + 7 } } }
       let!(:deleted) { Array.new(2) { |i| City.create! { |c| c.rating = i + 10 }.tap(&:destroy) } }
+      let(:city_ids) { cities.map(&:rating) }
+      let(:deleted_ids) { deleted.map(&:rating) }
 
       let(:type) { double(type_name: 'user') }
 
       subject { described_class.new(City) }
 
-      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(city_ids, _type: type)).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(cities.map { |c| double(rating: c.rating) }, _type: type, scope: -> { where(country_id: 0) }))
+        expect(subject.load(city_ids, _type: type, scope: -> { where(country_id: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        expect(subject.load(cities.map { |c| double(rating: c.rating) },
-          _type: type, scope: -> { where(country_id: 0) }, user: { scope: -> { where(country_id: 1) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: -> { where(country_id: 0) }, user: {scope: -> { where(country_id: 1) }}))
           .to eq([nil, nil] + cities.last(1))
       end
-      xspecify do
-        expect(subject.load(cities.map { |c| double(rating: c.rating) }, _type: type, scope: City.where(country_id: 1)))
+      xspecify 'sequel does not support scopes merge' do
+        expect(subject.load(city_ids, _type: type, scope: City.where(country_id: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(cities.map { |c| double(rating: c.rating) },
-          _type: type, scope: City.where(country_id: 1), user: { scope: -> { where(country_id: 0) } }))
+        expect(subject.load(city_ids,
+          _type: type, scope: City.where(country_id: 1), user: {scope: -> { where(country_id: 0) }}))
           .to eq(cities.first(2) + [nil])
       end
     end

data/spec/chewy/type/import/bulk_builder_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe Chewy::Type::Import::BulkBuilder do
+  before { Chewy.massacre }
+
+  subject { described_class.new(type, index: index, delete: delete, fields: fields) }
+  let(:type) { PlacesIndex::City }
+  let(:index) { [] }
+  let(:delete) { [] }
+  let(:fields) { [] }
+
+  describe '#bulk_body' do
+    context 'simple bulk', :orm do
+      before do
+        stub_model(:city)
+        stub_index(:places) do
+          define_type City do
+            field :name, :rating
+          end
+        end
+      end
+      let(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "City#{i + 17}", rating: 42) } }
+
+      specify { expect(subject.bulk_body).to eq([]) }
+
+      context do
+        let(:index) { cities }
+        specify do
+          expect(subject.bulk_body).to eq([
+            {index: {_id: 1, data: {'name' => 'City17', 'rating' => 42}}},
+            {index: {_id: 2, data: {'name' => 'City18', 'rating' => 42}}},
+            {index: {_id: 3, data: {'name' => 'City19', 'rating' => 42}}}
+          ])
+        end
+      end
+
+      context do
+        let(:delete) { cities }
+        specify do
+          expect(subject.bulk_body).to eq([
+            {delete: {_id: 1}}, {delete: {_id: 2}}, {delete: {_id: 3}}
+          ])
+        end
+      end
+
+      context do
+        let(:index) { cities.first(2) }
+        let(:delete) { [cities.last] }
+        specify do
+          expect(subject.bulk_body).to eq([
+            {index: {_id: 1, data: {'name' => 'City17', 'rating' => 42}}},
+            {index: {_id: 2, data: {'name' => 'City18', 'rating' => 42}}},
+            {delete: {_id: 3}}
+          ])
+        end
+
+        context ':fields' do
+          let(:fields) { %w[name] }
+          specify do
+            expect(subject.bulk_body).to eq([
+              {update: {_id: 1, data: {doc: {'name' => 'City17'}}}},
+              {update: {_id: 2, data: {doc: {'name' => 'City18'}}}},
+              {delete: {_id: 3}}
+            ])
+          end
+        end
+      end
+    end
+
+    context 'parent-child relationship', :orm do
+      before do
+        stub_model(:country)
+        stub_model(:city)
+        adapter == :sequel ? City.many_to_one(:country) : City.belongs_to(:country)
+      end
+
+      before do
+        stub_index(:places) do
+          define_type Country do
+            field :name
+          end
+
+          define_type City do
+            root parent: 'country', parent_id: -> { country_id } do
+              field :name
+              field :rating
+            end
+          end
+        end
+      end
+
+      before { PlacesIndex::Country.import(country) }
+      let(:country) { Country.create!(id: 1, name: 'country') }
+      let(:another_country) { Country.create!(id: 2, name: 'another country') }
+      let(:city) { City.create!(id: 4, country_id: country.id, name: 'city', rating: 42) }
+
+      context 'indexing' do
+        let(:index) { [city] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {index: {_id: city.id, parent: country.id, data: {'name' => 'city', 'rating' => 42}}}
+          ])
+        end
+
+        context do
+          let(:fields) { %w[name] }
+
+          specify do
+            expect(subject.bulk_body).to eq([
+              {update: {_id: city.id, parent: country.id, data: {doc: {'name' => 'city'}}}}
+            ])
+          end
+        end
+      end
+
+      context 'updating parent' do
+        before do
+          PlacesIndex::City.import(city)
+          city.update_attributes(country_id: another_country.id)
+        end
+        let(:index) { [city] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {delete: {_id: city.id, parent: country.id.to_s}},
+            {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
+          ])
+        end
+
+        context do
+          let(:fields) { %w[name] }
+
+          specify do
+            expect(subject.bulk_body).to eq([
+              {delete: {_id: city.id, parent: country.id.to_s}},
+              {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
+            ])
+          end
+        end
+      end
+
+      context 'destroying' do
+        before { PlacesIndex::City.import(city) }
+        let(:delete) { [city] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {delete: {_id: city.id, parent: country.id.to_s}}
+          ])
+        end
+      end
+    end
+
+    context 'custom id', :orm do
+      before do
+        stub_model(:city)
+      end
+
+      before do
+        stub_index(:places) do
+          define_type City do
+            root id: -> { name } do
+              field :rating
+            end
+          end
+        end
+      end
+
+      let(:london) { City.create(id: 1, name: 'London', rating: 4) }
+
+      specify do
+        expect { PlacesIndex::City.import(london) }
+          .to update_index(PlacesIndex::City).and_reindex(london.name)
+      end
+
+      context 'indexing' do
+        let(:index) { [london] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {index: {_id: london.name, data: {'rating' => 4}}}
+          ])
+        end
+      end
+
+      context 'destroying' do
+        let(:delete) { [london] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {delete: {_id: london.name}}
+          ])
+        end
+      end
+    end
+
+    context 'crutches' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            crutch :names do |collection|
+              collection.map { |item| [item.id, "Name#{item.id}"] }.to_h
+            end
+
+            field :name, value: ->(o, c) { c.names[o.id] }
+          end
+        end
+      end
+
+      let(:index) { [double(id: 42)] }
+
+      specify do
+        expect(subject.bulk_body).to eq([
+          {index: {_id: 42, data: {'name' => 'Name42'}}}
+        ])
+      end
+
+      context 'witchcraft' do
+        before { PlacesIndex::City.witchcraft! }
+        specify do
+          expect(subject.bulk_body).to eq([
+            {index: {_id: 42, data: {'name' => 'Name42'}}}
+          ])
+        end
+      end
+    end
+
+    context 'empty ids' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            field :name
+          end
+        end
+      end
+
+      let(:index) { [{id: 1, name: 'Name0'}, double(id: '', name: 'Name1'), double(name: 'Name2')] }
+      let(:delete) { [double(id: '', name: 'Name3'), {name: 'Name4'}, '', 2] }
+
+      specify do
+        expect(subject.bulk_body).to eq([
+          {index: {_id: 1, data: {'name' => 'Name0'}}},
+          {index: {data: {'name' => 'Name1'}}},
+          {index: {data: {'name' => 'Name2'}}},
+          {delete: {_id: {'name' => 'Name4'}}},
+          {delete: {_id: 2}}
+        ])
+      end
+
+      context do
+        let(:fields) { %w[name] }
+
+        specify do
+          expect(subject.bulk_body).to eq([
+            {update: {_id: 1, data: {doc: {'name' => 'Name0'}}}},
+            {delete: {_id: {'name' => 'Name4'}}},
+            {delete: {_id: 2}}
+          ])
+        end
+      end
+    end
+  end
+
+  describe '#index_objects_by_id' do
+    before do
+      stub_index(:places) do
+        define_type :city do
+          field :name
+        end
+      end
+    end
+
+    let(:index) { [double(id: 1), double(id: 2), double(id: ''), double] }
+    let(:delete) { [double(id: 3)] }
+
+    specify { expect(subject.index_objects_by_id).to eq('1' => index.first, '2' => index.second) }
+  end
+end