chewy 0.5.0 → 0.5.1

data/spec/chewy/query/criteria_spec.rb

@@ -6,6 +6,7 @@ describe Chewy::Query::Criteria do
   its(:options) { should be_a Hash }
   its(:request_options) { should be_a Hash }
   its(:facets) { should == {} }
+  its(:scores) { should == [] }
   its(:aggregations) { should == {} }
   its(:queries) { should == [] }
   its(:filters) { should == [] }
@@ -14,17 +15,18 @@ describe Chewy::Query::Criteria do
   its(:fields) { should == [] }
   its(:types) { should == [] }
 
-  its(:request_options?) { should be_false }
-  its(:facets?) { should be_false }
-  its(:aggregations?) { should be_false }
-  its(:queries?) { should be_false }
-  its(:filters?) { should be_false }
-  its(:post_filters?) { should be_false }
-  its(:sort?) { should be_false }
-  its(:fields?) { should be_false }
-  its(:types?) { should be_false }
+  its(:request_options?) { should eq(false) }
+  its(:facets?) { should eq(false) }
+  its(:scores?) { should eq(false) }
+  its(:aggregations?) { should eq(false) }
+  its(:queries?) { should eq(false) }
+  its(:filters?) { should eq(false) }
+  its(:post_filters?) { should eq(false) }
+  its(:sort?) { should eq(false) }
+  its(:fields?) { should eq(false) }
+  its(:types?) { should eq(false) }
 
-  its(:none?){ should be_false }
+  its(:none?){ should eq(false) }
 
   describe '#update_options' do
     specify { expect { subject.update_options(field: 'hello') }.to change { subject.options }.to(hash_including(field: 'hello')) }
@@ -39,6 +41,14 @@ describe Chewy::Query::Criteria do
     specify { expect { subject.update_facets(field: 'hello') }.to change { subject.facets }.to(field: 'hello') }
   end
 
+  describe '#update_scores' do
+    specify { expect { subject.update_scores(:score) }.to change { subject.scores? }.to(true) }
+    specify { expect { subject.update_scores(:score) }.to change { subject.scores }.to([:score]) }
+    specify { expect { subject.update_scores([:score, :score2]) }.to change { subject.scores }.to([:score, :score2]) }
+    specify { expect { subject.tap { |s| s.update_scores(:score1) }.update_scores([:score2, :score3]) }
+      .to change { subject.scores }.to([:score1, :score2, :score3]) }
+  end
+
   describe '#update_aggregations' do
     specify { expect { subject.update_aggregations(field: 'hello') }.to change { subject.aggregations? }.to(true) }
     specify { expect { subject.update_aggregations(field: 'hello') }.to change { subject.aggregations }.to(field: 'hello') }
@@ -122,6 +132,8 @@ describe Chewy::Query::Criteria do
       .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options.should include(opt1: 'hello', opt2: 'hello') }
     specify { subject.tap { |c| c.update_facets(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets.should == {field1: 'hello', field1: 'hello'} }
+    specify { subject.tap { |c| c.update_scores(script: 'hello') }
+      .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores.should == [{script: 'hello'}, { script: 'foobar' } ] }
     specify { subject.tap { |c| c.update_aggregations(field1: 'hello') }
       .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations.should == {field1: 'hello', field1: 'hello'} }
     specify { subject.tap { |c| c.update_queries(field1: 'hello') }
@@ -177,6 +189,24 @@ describe Chewy::Query::Criteria do
     specify { request_body { update_request_options(from: 10) }.should == {body: {from: 10}} }
     specify { request_body { update_request_options(explain: true) }.should == {body: {explain: true}} }
     specify { request_body { update_queries(:query) }.should == {body: {query: :query}} }
+    specify { request_body {
+      update_scores(script_score: { script: '_score'})
+    }.should == {body: {query: { function_score: { functions: [{ script_score: {script: '_score' }}] }}}} }
+    specify { request_body {
+      update_scores(script_score: { script: "boost_me" })
+      update_queries(:query)
+      update_options(boost_mode: :add)
+      update_options(score_mode: :avg)
+    }.should == {body: {query: {
+      function_score: {
+        functions: [{
+          script_score: {script: 'boost_me' }
+        }],
+        query: :query,
+        boost_mode: :add,
+        score_mode: :avg
+      }}}}
+    }
     specify { request_body {
       update_request_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
     }.should == {body: {query: :query, from: 10, sort: [:field], _source: ['field']}} }
@@ -233,6 +263,24 @@ describe Chewy::Query::Criteria do
     }
   end
 
+  describe "#_boost_query" do
+    specify { subject.send(:_boost_query, query: :query).should eq(query: :query) }
+    specify {
+      subject.update_scores({ boost_factor: 5 })
+      subject.send(:_boost_query, query: :query).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
+    }
+    specify {
+      subject.update_scores({ boost_factor: 5 })
+      subject.update_options(boost_mode: :multiply)
+      subject.update_options(score_mode: :add)
+      subject.send(:_boost_query, query: :query).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
+    }
+    specify {
+      subject.update_scores({ boost_factor: 5 })
+      subject.send(:_boost_query, query: :query, filter: :filter).should eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
+    }
+  end
+
   describe '#_request_filter' do
     def _request_filter &block
       subject.instance_exec(&block) if block

data/spec/chewy/query_spec.rb

@@ -75,6 +75,20 @@ describe Chewy::Query do
     specify { expect { subject.post_filter_mode(:or) }.not_to change { subject.criteria.options } }
   end
 
+  describe '#boost_mode' do
+    specify { subject.boost_mode(:replace).should be_a described_class }
+    specify { subject.boost_mode(:replace).should_not == subject }
+    specify { subject.boost_mode(:replace).criteria.options.should include(boost_mode: :replace) }
+    specify { expect { subject.boost_mode(:replace) }.not_to change { subject.criteria.options } }
+  end
+
+  describe '#score_mode' do
+    specify { subject.score_mode(:first).should be_a described_class }
+    specify { subject.score_mode(:first).should_not == subject }
+    specify { subject.score_mode(:first).criteria.options.should include(score_mode: :first) }
+    specify { expect { subject.score_mode(:first) }.not_to change { subject.criteria.options } }
+  end
+
   describe '#limit' do
     specify { subject.limit(10).should be_a described_class }
     specify { subject.limit(10).should_not == subject }
@@ -89,6 +103,74 @@ describe Chewy::Query do
     specify { expect { subject.offset(10) }.not_to change { subject.criteria.request_options } }
   end
 
+  describe '#script_score' do
+    specify { subject.script_score('23').should be_a described_class }
+    specify { subject.script_score('23').should_not == subject }
+    specify { subject.script_score('23').criteria.scores.should == [ { script_score: { script: '23' } } ] }
+    specify { expect { subject.script_score('23') }.not_to change { subject.criteria.scores } }
+    specify { subject.script_score('23', filter: { foo: :bar}).criteria.scores.should == [{ script_score: { script: '23' }, filter: { foo: :bar } }] }
+  end
+
+  describe '#boost_factor' do
+    specify { subject.boost_factor('23').should be_a described_class }
+    specify { subject.boost_factor('23').should_not == subject }
+    specify { subject.boost_factor('23').criteria.scores.should == [ { boost_factor: 23  } ] }
+    specify { expect { subject.boost_factor('23') }.not_to change { subject.criteria.scores } }
+    specify { subject.boost_factor('23', filter: { foo: :bar}).criteria.scores.should == [{ boost_factor: 23, filter: { foo: :bar } }] }
+  end
+
+  describe '#random_score' do
+    specify { subject.random_score('23').should be_a described_class }
+    specify { subject.random_score('23').should_not == subject }
+    specify { subject.random_score('23').criteria.scores.should == [ { random_score: { seed: 23 } } ] }
+    specify { expect { subject.random_score('23') }.not_to change { subject.criteria.scores } }
+    specify { subject.random_score('23', filter: { foo: :bar}).criteria.scores.should == [{ random_score: { seed: 23 }, filter: { foo: :bar } }] }
+  end
+
+  describe '#field_value_score' do
+    specify { subject.field_value_factor(field: :boost).should be_a described_class }
+    specify { subject.field_value_factor(field: :boost).should_not == subject }
+    specify { subject.field_value_factor(field: :boost).criteria.scores.should == [ { field_value_factor: { field: :boost } } ] }
+    specify { expect { subject.field_value_factor(field: :boost) }.not_to change { subject.criteria.scores } }
+    specify { subject.field_value_factor({ field: :boost }, filter: { foo: :bar}).criteria.scores.should == [{ field_value_factor: { field: :boost }, filter: { foo: :bar } }] }
+  end
+
+  describe '#decay' do
+    specify { subject.decay(:gauss, :field).should be_a described_class }
+    specify { subject.decay(:gauss, :field).should_not == subject }
+    specify { subject.decay(:gauss, :field).criteria.scores.should == [ {
+      gauss: {
+        field: {
+          origin: 0,
+          scale: 1,
+          offset: 0,
+          decay: 0.1
+        }
+      }
+    }] }
+    specify { expect { subject.decay(:gauss, :field) }.not_to change { subject.criteria.scores } }
+    specify {
+      subject.decay(:gauss, :field,
+                    origin: '11, 12',
+                    scale: '2km',
+                    offset: '5km',
+                    decay: 0.4,
+                    filter: { foo: :bar }).criteria.scores.should == [
+        {
+          gauss: {
+            field: {
+              origin: '11, 12',
+              scale: '2km',
+              offset: '5km',
+              decay: 0.4
+            }
+          },
+          filter: { foo: :bar }
+        }
+      ]
+    }
+  end
+
   describe '#facets' do
     specify { subject.facets(term: {field: 'hello'}).should be_a described_class }
     specify { subject.facets(term: {field: 'hello'}).should_not == subject }
@@ -161,7 +243,7 @@ describe Chewy::Query do
   describe '#suggest' do
     specify { subject.suggest(name1: {text: 'hello', term: {field: 'name'}}) }
     specify { subject.suggest(name1: {text: 'hello'}).should_not == subject }
-    specify { subject.suggest(name1: {text: 'hello'}).criteria.suggest.should include(name1: {text: 'hello'}) }
+    specify { expect(subject.suggest(name1: {text: 'hello'}).criteria.suggest).to include(name1: {text: 'hello'}) }
     specify { expect { subject.suggest(name1: {text: 'hello'}) }.not_to change { subject.criteria.suggest } }
 
     context 'results' do
@@ -196,13 +278,31 @@ describe Chewy::Query do
     end
   end
 
+  describe '#delete_all' do
+    let(:products) { 3.times.map { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+    let(:cities) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+    let(:countries) { 3.times.map { |i| {id: i.next.to_s}.stringify_keys! } }
+
+    before do
+      ProductsIndex::Product.import!(products.map { |h| double(h) })
+      ProductsIndex::City.import!(cities.map { |h| double(h) })
+      ProductsIndex::Country.import!(countries.map { |h| double(h) })
+    end
+
+    specify { expect { subject.query(match: {name: 'name3'}).delete_all }.to change { ProductsIndex.total_count }.from(9).to(8) }
+    specify { expect { subject.filter { age == [10, 20] }.delete_all }.to change { ProductsIndex.total_count }.from(9).to(7) }
+    specify { expect { subject.types(:product).delete_all }.to change { ProductsIndex::Product.total_count }.from(3).to(0) }
+    specify { expect { ProductsIndex.delete_all }.to change { ProductsIndex.total_count }.from(9).to(0) }
+    specify { expect { ProductsIndex::City.delete_all }.to change { ProductsIndex.total_count }.from(9).to(6) }
+  end
+
   describe '#none' do
     specify { subject.none.should be_a described_class }
     specify { subject.none.should_not == subject }
     specify { subject.none.criteria.should be_none }
 
     context do
-      before { described_class.any_instance.should_not_receive(:_response) }
+      before { expect_any_instance_of(described_class).not_to receive(:_response) }
 
       specify { subject.none.to_a.should == [] }
       specify { subject.query(match: 'hello').none.to_a.should == [] }

data/spec/chewy/runtime_spec.rb

@@ -4,6 +4,6 @@ describe Chewy::Runtime do
   describe '.version' do
     specify { described_class.version.should be_a(described_class::Version) }
     specify { described_class.version.should be >= '1.0' }
-    specify { described_class.version.should be < '1.3' }
+    specify { described_class.version.should be < '1.4' }
   end
 end

data/spec/chewy/type/actions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Chewy::Type::Actions do
+  before { Chewy.client.indices.delete index: '*' }
+
+  before do
+    stub_model(:city)
+  end
+
+  before do
+    stub_index(:cities) do
+      define_type City do
+        field :name
+      end
+    end
+  end
+
+  let!(:dummy_cities) { 3.times.map { |i| City.create(name: "name#{i}") } }
+  let(:city) { CitiesIndex::City }
+
+  before do
+    city.import
+  end
+
+  describe '.reset' do
+    specify { expect { city.reset }.to update_index(city) }
+  end
+end

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

@@ -104,6 +104,7 @@ describe Chewy::Type::Adapter::ActiveRecord do
       specify { import(cities, deleted).should == [{index: cities, delete: deleted}] }
       specify { import(cities.map(&:id), deleted.map(&:id))
         .should == [{index: cities, delete: deleted}] }
+      specify { import(City.order(:id)).should == [{index: cities, delete: deleted}] }
     end
 
     context 'custom primary_key' do
@@ -177,45 +178,45 @@ describe Chewy::Type::Adapter::ActiveRecord do
       end
 
       context 'implicit scope' do
-        specify { subject.import { |data| true }.should be_true }
-        specify { subject.import { |data| false }.should be_false }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[0].id]).should be_false }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[1].id]).should be_false }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[2].id]).should be_false }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[0].id]).should be_true }
-        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[1].id]).should be_true }
+        specify { subject.import { |data| true }.should eq(true) }
+        specify { subject.import { |data| false }.should eq(false) }
+        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
+        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
+        specify { subject.import(batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
+        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(true) }
+        specify { subject.import(batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(true) }
       end
 
       context 'explicit scope' do
         let(:scope) { City.where(id: ids) }
 
-        specify { subject.import(scope) { |data| true }.should be_true }
-        specify { subject.import(scope) { |data| false }.should be_false }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[0].id]).should be_false }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[1].id]).should be_false }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[2].id]).should be_false }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[0].id]).should be_true }
-        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[1].id]).should be_true }
+        specify { subject.import(scope) { |data| true }.should eq(true) }
+        specify { subject.import(scope) { |data| false }.should eq(false) }
+        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
+        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
+        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
+        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(true) }
+        specify { subject.import(scope, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(true) }
       end
 
       context 'objects' do
-        specify { subject.import(cities + deleted) { |data| true }.should be_true }
-        specify { subject.import(cities + deleted) { |data| false }.should be_false }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id]).should be_false }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id]).should be_false }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id]).should be_false }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id]).should be_false }
-        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id]).should be_false }
+        specify { subject.import(cities + deleted) { |data| true }.should eq(true) }
+        specify { subject.import(cities + deleted) { |data| false }.should eq(false) }
+        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
+        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
+        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
+        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(false) }
+        specify { subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(false) }
       end
 
       context 'ids' do
-        specify { subject.import(ids) { |data| true }.should be_true }
-        specify { subject.import(ids) { |data| false }.should be_false }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[0].id]).should be_false }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[1].id]).should be_false }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[2].id]).should be_false }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[0].id]).should be_false }
-        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[1].id]).should be_false }
+        specify { subject.import(ids) { |data| true }.should eq(true) }
+        specify { subject.import(ids) { |data| false }.should eq(false) }
+        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[0].id]).should eq(false) }
+        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[1].id]).should eq(false) }
+        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[cities[2].id]).should eq(false) }
+        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[0].id]).should eq(false) }
+        specify { subject.import(ids, batch_size: 1, &data_comparer.curry[deleted[1].id]).should eq(false) }
       end
     end
   end

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

@@ -36,8 +36,8 @@ describe Chewy::Type::Adapter::Object do
       result
     end
 
-    specify { subject.import(3.times.map { |i| double }) { |data| true }.should be_true }
-    specify { subject.import(3.times.map { |i| double }) { |data| false }.should be_false }
+    specify { subject.import(3.times.map { |i| double }) { |data| true }.should eq(true) }
+    specify { subject.import(3.times.map { |i| double }) { |data| false }.should eq(false) }
 
     context do
       let(:objects) { 3.times.map { |i| double } }
@@ -96,13 +96,13 @@ describe Chewy::Type::Adapter::Object do
         ->(n, data) { (data[:index] || data[:delete]).first.rating != n }
       end
 
-      specify { subject.import(products, deleted) { |data| true }.should be_true }
-      specify { subject.import(products, deleted) { |data| false }.should be_false }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[1]).should be_false }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[2]).should be_false }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[3]).should be_false }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[4]).should be_false }
-      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[5]).should be_false }
+      specify { subject.import(products, deleted) { |data| true }.should eq(true) }
+      specify { subject.import(products, deleted) { |data| false }.should eq(false) }
+      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[1]).should eq(false) }
+      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[2]).should eq(false) }
+      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[3]).should eq(false) }
+      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[4]).should eq(false) }
+      specify { subject.import(products, deleted, batch_size: 1, &data_comparer.curry[5]).should eq(false) }
     end
   end
 

data/spec/chewy/type/import_spec.rb

@@ -19,10 +19,10 @@ describe Chewy::Type::Import do
   let(:city) { CitiesIndex::City }
 
   describe '.import' do
-    specify { city.import.should be_true }
-    specify { city.import([]).should be_true }
-    specify { city.import(dummy_cities).should be_true }
-    specify { city.import(dummy_cities.map(&:id)).should be_true }
+    specify { city.import.should eq(true) }
+    specify { city.import([]).should eq(true) }
+    specify { city.import(dummy_cities).should eq(true) }
+    specify { city.import(dummy_cities.map(&:id)).should eq(true) }
 
     specify { expect { city.import([]) }.not_to update_index(city) }
     specify { expect { city.import }.to update_index(city).and_reindex(dummy_cities) }
@@ -153,9 +153,9 @@ describe Chewy::Type::Import do
           end
         end
 
-        specify { city.import(dummy_cities).should be_false }
-        specify { city.import(dummy_cities.map(&:id)).should be_false }
-        specify { city.import(dummy_cities, batch_size: 1).should be_false }
+        specify { city.import(dummy_cities).should eq(false) }
+        specify { city.import(dummy_cities.map(&:id)).should eq(false) }
+        specify { city.import(dummy_cities, batch_size: 1).should eq(false) }
       end
 
       context do
@@ -167,9 +167,86 @@ describe Chewy::Type::Import do
           end
         end
 
-        specify { city.import(dummy_cities).should be_false }
-        specify { city.import(dummy_cities.map(&:id)).should be_false }
-        specify { city.import(dummy_cities, batch_size: 1).should be_false }
+        specify { city.import(dummy_cities).should eq(false) }
+        specify { city.import(dummy_cities.map(&:id)).should eq(false) }
+        specify { city.import(dummy_cities, batch_size: 1).should eq(false) }
+      end
+    end
+
+    context 'parent-child relationship' do
+      let(:country) { Country.create(name: 'country') }
+      let(:another_country) { Country.create(name: 'another country') }
+
+      before do
+        stub_model(:country)
+        stub_model(:city)
+      end
+
+      before do
+        stub_index(:countries) do
+          define_type Country do
+            field :name
+          end
+
+          define_type City do
+            root parent: { type: 'country' }, parent_id: -> { country_id } do
+              field :name
+            end
+          end
+        end
+      end
+
+      before { CountriesIndex::Country.import(country) }
+
+      let(:child_city) { City.create(country_id: country.id, name: 'city') }
+      let(:city) { CountriesIndex::City }
+
+      specify { city.import(child_city).should eq(true)  }
+      specify { expect { city.import child_city }.to update_index(city).and_reindex(child_city) }
+
+      specify do
+        expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
+          body: [{ index: { _id: child_city.id, parent: country.id, data: { 'name' => 'city' } } }]
+        ))
+
+        city.import child_city
+      end
+
+      context 'updating or deleting' do
+        before { city.import child_city }
+
+        specify do
+          child_city.update_attributes(country_id: another_country.id)
+
+          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
+            body: [
+              { delete: { _id: child_city.id, parent: country.id.to_s } },
+              { index: { _id: child_city.id, parent: another_country.id, data: { 'name' => 'city' } } }
+            ]
+          ))
+
+          city.import child_city
+        end
+
+        specify do
+          child_city.destroy
+
+          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
+            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
+          ))
+
+          city.import child_city
+        end
+
+        specify do
+          child_city.destroy
+
+          expect(CountriesIndex.client).to receive(:bulk).with(hash_including(
+            body: [{ delete: { _id: child_city.id, parent: country.id.to_s } }]
+          ))
+
+          city.import child_city.id
+        end
       end
     end
   end