chewy 0.8.3 → 0.8.4

data/spec/chewy/index_spec.rb

@@ -68,6 +68,11 @@ describe Chewy::Index do
     end
   end
 
+  describe '.default_prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+    specify { expect(Class.new(Chewy::Index).default_prefix).to eq('testing') }
+  end
+
   describe '.define_type' do
     specify { expect(DummiesIndex.type_hash['dummy']).to eq(DummiesIndex::Dummy) }
 
@@ -108,6 +113,20 @@ describe Chewy::Index do
         }.to raise_error(NameError)
       end
     end
+
+    context 'type methods should be deprecated and can\'t redefine existion ones' do
+      before do
+        stub_index(:places) do
+          def self.city
+          end
+          define_type :city
+          define_type :country
+        end
+      end
+
+      specify { expect(PlacesIndex.city).to be_nil }
+      specify { expect(PlacesIndex.country).to be < Chewy::Type }
+    end
   end
 
   describe '.type_hash' do

data/spec/chewy/query/pagination_spec.rb

@@ -24,7 +24,7 @@ describe Chewy::Query::Pagination do
     describe '#total_count' do
       specify { expect(search.total_count).to eq(10) }
       specify { expect(search.limit(5).total_count).to eq(10) }
-      specify { expect(search.filter(numeric_range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+      specify { expect(search.filter(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
     end
 
     describe '#load' do

data/spec/chewy/query_spec.rb

@@ -33,7 +33,8 @@ describe Chewy::Query do
     specify { expect(subject.first._data).to be_a Hash }
     specify { expect(subject.limit(6).count).to eq(6) }
     specify { expect(subject.offset(6).count).to eq(3) }
-    specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name).to eq('<em>Name3</em>') }
+    specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name).to eq('Name3') }
+    specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first.name_highlight).to eq('<em>Name3</em>') }
     specify { expect(subject.query(match: {name: 'name3'}).highlight(fields: {name: {}}).first._data['_source']['name']).to eq('Name3') }
     specify { expect(subject.types(:product).count).to eq(3) }
     specify { expect(subject.types(:product, :country).count).to eq(6) }
@@ -174,10 +175,27 @@ describe Chewy::Query do
   end
 
   describe '#facets' do
-    specify { expect(subject.facets(term: {field: 'hello'})).to be_a described_class }
-    specify { expect(subject.facets(term: {field: 'hello'})).not_to eq(subject) }
-    specify { expect(subject.facets(term: {field: 'hello'}).criteria.facets).to include(term: {field: 'hello'}) }
-    specify { expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets } }
+    specify do
+      skip_on_version_lt('2.0')
+      expect { subject.facets }.to raise_error(Chewy::RemovedFeature).with_message('removed in elasticsearch 2.0')
+    end
+
+    specify do
+      skip_on_version_gte('2.0')
+      expect(subject.facets(term: {field: 'hello'})).to be_a described_class
+    end
+    specify do
+      skip_on_version_gte('2.0')
+      expect(subject.facets(term: {field: 'hello'})).not_to eq(subject)
+    end
+    specify do
+      skip_on_version_gte('2.0')
+      expect(subject.facets(term: {field: 'hello'}).criteria.facets).to include(term: {field: 'hello'})
+    end
+    specify do
+      skip_on_version_gte('2.0')
+      expect { subject.facets(term: {field: 'hello'}) }.not_to change { subject.criteria.facets }
+    end
 
     context 'results', :orm do
       before { stub_model(:city) }
@@ -193,17 +211,23 @@ describe Chewy::Query do
 
       before { CitiesIndex::City.import! cities }
 
-      specify { expect(CitiesIndex.facets).to eq({}) }
-      specify { expect(CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets).to eq({
-        'ratings' => {
-          '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
-          'terms' => [
-            {'term' => 0, 'count' => 4},
-            {'term' => 2, 'count' => 3},
-            {'term' => 1, 'count' => 3}
-          ]
-        }
-      }) }
+      specify do
+        skip_on_version_gte('2.0')
+        expect(CitiesIndex.facets).to eq({})
+      end
+      specify do
+        skip_on_version_gte('2.0')
+        expect(CitiesIndex.facets(ratings: {terms: {field: 'rating'}}).facets).to eq({
+          'ratings' => {
+            '_type' => 'terms', 'missing' => 0, 'total' => 10, 'other' => 0,
+            'terms' => [
+              {'term' => 0, 'count' => 4},
+              {'term' => 2, 'count' => 3},
+              {'term' => 1, 'count' => 3}
+            ]
+          }
+        })
+      end
     end
   end
 
@@ -357,11 +381,42 @@ describe Chewy::Query do
       ProductsIndex::Country.import!(countries.map { |h| double(h) })
     end
 
-    specify { expect { subject.query(match: {name: 'name3'}).delete_all }.to change { ProductsIndex.total }.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_entries }.from(3).to(0) }
-    specify { expect { ProductsIndex.delete_all }.to change { ProductsIndex.total }.from(9).to(0) }
-    specify { expect { ProductsIndex::City.delete_all }.to change { ProductsIndex.total }.from(9).to(6) }
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect {
+        subject.query(match: {name: 'name3'}).delete_all
+        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(8)
+    end
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect {
+        subject.filter { age == [10, 20] }.delete_all
+        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total_count }.from(9).to(7)
+    end
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect {
+        subject.types(:product).delete_all
+        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex::Product.total_entries }.from(3).to(0)
+    end
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect {
+        ProductsIndex.delete_all
+        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(0)
+    end
+    specify do
+      skip_on_plugin_missing_from_version('delete-by-query', '2.0')
+      expect {
+        ProductsIndex::City.delete_all
+        Chewy.client.indices.refresh(index: 'products') }.to change { ProductsIndex.total }.from(9).to(6)
+    end
+
+    specify do
+      skip_on_version_lt('2.0')
+      expect(Chewy.client.nodes).to receive(:info).and_return({"nodes" => {"a" => {"plugins" => {"name" => "hello"}}}})
+      expect { ProductsIndex.delete_all }.to raise_error(Chewy::PluginMissing).with_message("install delete-by-query plugin")
+    end
   end
 
   describe '#find' do
@@ -447,6 +502,7 @@ describe Chewy::Query do
     specify { expect(subject.order(:field).criteria.sort).to eq([:field]) }
     specify { expect(subject.order([:field1, :field2]).criteria.sort).to eq([:field1, :field2]) }
     specify { expect(subject.order(field: :asc).criteria.sort).to eq([{field: :asc}]) }
+    specify { expect(subject.order({field1: :asc, field2: :desc}).criteria.sort).to eq([{field1: :asc}, {field2: :desc}]) }
     specify { expect(subject.order({field1: {order: :asc}, field2: :desc}).order([:field3], :field4).criteria.sort).to eq([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
   end
 

data/spec/chewy/rspec/update_index_spec.rb

@@ -11,17 +11,17 @@ describe :update_index do
     end
   end
 
-  specify { expect {  }.not_to update_index(DummiesIndex.dummy) }
-  specify { expect { DummiesIndex.dummy.bulk body: [] }.not_to update_index(DummiesIndex.dummy) }
+  specify { expect {  }.not_to update_index(DummiesIndex::Dummy) }
+  specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex::Dummy) }
 
-  specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex.dummy) }
+  specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.not_to update_index(DummiesIndex::Dummy) }
     .to fail_with(/Expected index .* not to be updated, but it was with/) }
 
   context do
     let(:expectation) do
       expect { expect {
-        DummiesIndex.dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
-      }.not_to update_index(DummiesIndex.dummy) }
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}, {index: {_id: 41}}, {index: {_id: 42}}]
+      }.not_to update_index(DummiesIndex::Dummy) }
     end
 
     specify { expectation.to fail_matching 'document id `42` (2 times)' }
@@ -29,49 +29,62 @@ describe :update_index do
   end
 
   context '#only' do
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(41, 42).only }
-    specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(41).only }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(41).only }
         .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
-    specify { expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(41, times: 2).only }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(41, times: 2).only }
         .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also' }
 
-    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex.dummy).and_delete(41, 42).only }
-    specify { expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex.dummy).and_delete(41).only }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
-    specify { expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
-      .to update_index(DummiesIndex.dummy).and_delete(41, times: 2).only }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(41, times: 2).only }
         .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also' }
+
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(42).only }
+        .to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also' }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}, index: {_id: 43, data: {}}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(42).only }
+        .to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also' }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also' }
+    specify { expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 41}, delete: {_id: 43}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(41).only }
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also' }
   end
 
   context '#and_reindex' do
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex.dummy) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(42) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(double(id: 42)) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(double(id: 42), double(id: 43)) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex([double(id: 42), 43]) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42}}] }.to update_index(DummiesIndex::Dummy) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(42) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42)) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42), double(id: 43)) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex([double(id: 42), 43]) }
 
     specify do
       expect {
         expect {
-          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        }.to update_index(DummiesIndex.dummy).and_reindex([44, 43])
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        }.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
       }.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
     end
 
     context do
       let(:expectation) do
         expect { expect {
-          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        }.to update_index(DummiesIndex.dummy).and_reindex(44, double(id: 47)) }
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        }.to update_index(DummiesIndex::Dummy).and_reindex(44, double(id: 47)) }
       end
 
       specify { expectation.to fail_matching('Expected document with id `44` to be reindexed, but it was not') }
@@ -80,22 +93,22 @@ describe :update_index do
 
     context ':times' do
       specify { expect {
-        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-        DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-      }.to update_index(DummiesIndex.dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) }
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+      }.to update_index(DummiesIndex::Dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) }
 
       specify { expect {
         expect {
-          DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-        }.to update_index(DummiesIndex.dummy).and_reindex(42, times: 3)
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+        }.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
       }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
 
       context do
         let(:expectation) do
           expect { expect {
-            DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
-            DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
-          }.to update_index(DummiesIndex.dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) }
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 43, data: {}}}]
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {}}}, {index: {_id: 44, data: {}}}]
+          }.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) }
         end
 
         specify { expectation.to fail_matching 'Expected document with id `44` to be reindexed' }
@@ -107,17 +120,17 @@ describe :update_index do
 
     context ':with' do
       specify { expect {
-        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-      }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: 2}) }
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+      }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 2}) }
 
       specify { expect {
-        DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
-      }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: '1', b: 2}) }
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {a: '1'}}}, {index: {_id: 42, data: {'b' => 2}}}]
+      }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: '1', b: 2}) }
 
       specify { expect {
         expect {
-          DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
-        }.to update_index(DummiesIndex.dummy).and_reindex(42, with: {a: 1})
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}]
+        }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: {a: 1})
       }.to fail_matching('Expected document with id `42` to be reindexed, but it was not') }
 
       [
@@ -128,8 +141,8 @@ describe :update_index do
         [{a: 1, b: 1}, {a: 1}]
       ].each do |(data, with)|
         specify { expect {
-          DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: data}}]
-        }.to update_index(DummiesIndex.dummy).and_reindex(42, with: with) }
+          DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
+        }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) }
       end
 
       [
@@ -141,16 +154,16 @@ describe :update_index do
       ].each do |(data, with)|
         specify { expect {
           expect {
-            DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: data}}]
-          }.to update_index(DummiesIndex.dummy).and_reindex(42, with: with)
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
+          }.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with)
         }.to fail_matching('Expected document with id `42` to be reindexed') }
       end
 
       context do
         let(:expectation) do
           expect { expect {
-            DummiesIndex.dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
-          }.to update_index(DummiesIndex.dummy).and_reindex(43, times: 2, with: {a: 2}) }
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 43, data: {a: '1'}}}, {index: {_id: 42, data: {'a' => 2}}}]
+          }.to update_index(DummiesIndex::Dummy).and_reindex(43, times: 2, with: {a: 2}) }
         end
 
         specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
@@ -161,19 +174,19 @@ describe :update_index do
   end
 
   context '#and_delete' do
-    specify { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex.dummy).and_reindex(42).and_delete(double(id: 43)) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex.dummy).and_delete(42).and_delete(double(id: 43)) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex.dummy).and_delete(42, double(id: 43)) }
-    specify { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
-      .to update_index(DummiesIndex.dummy).and_delete([43, double(id: 42)]) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex::Dummy).and_reindex(42).and_delete(double(id: 43)) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(id: 43)) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete(42, double(id: 43)) }
+    specify { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42}}, {delete: {_id: 43}}] }
+      .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)]) }
 
     context do
       let(:expectation) do
-        expect { expect { DummiesIndex.dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
-          .to update_index(DummiesIndex.dummy).and_reindex(43).and_delete(double(id: 42)) }
+        expect { expect { DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {delete: {_id: 43}}] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(43).and_delete(double(id: 42)) }
       end
 
       specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed, but it was not' }
@@ -182,8 +195,8 @@ describe :update_index do
 
     context do
       let(:expectation) do
-        expect { expect { DummiesIndex.dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
-          .to update_index(DummiesIndex.dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3) }
+        expect { expect { DummiesIndex::Dummy.bulk body: [{delete: {_id: 42, data: {}}}, {delete: {_id: 42}}] }
+          .to update_index(DummiesIndex::Dummy).and_delete(44, times: 2).and_delete(double(id: 42), times: 3) }
       end
 
       specify { expectation.to fail_matching 'Expected document with id `44` to be deleted, but it was not' }

data/spec/chewy/runtime_spec.rb

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

data/spec/chewy/strategy/active_job_spec.rb

@@ -43,7 +43,12 @@ if defined?(::ActiveJob)
       ::ActiveJob::Base.queue_adapter = :inline
       expect { [city, other_city].map(&:save!) }
         .to update_index(CitiesIndex::City, strategy: :active_job)
-        .and_reindex(city, other_city)
+        .and_reindex(city, other_city).only
+    end
+
+    specify do
+      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], {suffix: '201601'})
+      Chewy::Strategy::ActiveJob::Worker.new.perform("CitiesIndex::City", [city.id, other_city.id], suffix: '201601')
     end
   end
 end

data/spec/chewy/strategy/atomic_spec.rb

@@ -19,13 +19,13 @@ describe Chewy::Strategy::Atomic, :orm do
   specify do
     expect { [country, other_country].map(&:save!) }
       .to update_index(CountriesIndex::Country, strategy: :atomic)
-      .and_reindex(country, other_country)
+      .and_reindex(country, other_country).only
   end
 
   specify do
     expect { [country, other_country].map(&:destroy) }
       .to update_index(CountriesIndex::Country, strategy: :atomic)
-      .and_delete(country, other_country)
+      .and_delete(country, other_country).only
   end
 
   context do
@@ -41,19 +41,19 @@ describe Chewy::Strategy::Atomic, :orm do
     specify do
       expect { [country, other_country].map(&:save!) }
         .to update_index(CountriesIndex::Country, strategy: :atomic)
-        .and_reindex('HL', 'WD')
+        .and_reindex('HL', 'WD').only
     end
 
     specify do
       expect { [country, other_country].map(&:destroy) }
         .to update_index(CountriesIndex::Country, strategy: :atomic)
-        .and_delete('HL', 'WD')
+        .and_delete('HL', 'WD').only
     end
 
     specify do
       expect { country.save!; other_country.destroy }
         .to update_index(CountriesIndex::Country, strategy: :atomic)
-        .and_reindex('HL').and_delete('WD')
+        .and_reindex('HL').and_delete('WD').only
     end
   end
 end