chewy 0.8.4 → 0.9.0

data/spec/chewy/repository_spec.rb

@@ -13,8 +13,8 @@ describe Chewy::Repository do
 
     context do
       before { subject.analyzer(:name, option: :foo) }
-      specify { expect(subject.analyzer(:name)).to eq({option: :foo}) }
-      specify { expect(subject.analyzers).to eq({name: {option: :foo}}) }
+      specify { expect(subject.analyzer(:name)).to eq(option: :foo) }
+      specify { expect(subject.analyzers).to eq(name: { option: :foo }) }
     end
   end
 
@@ -23,8 +23,8 @@ describe Chewy::Repository do
 
     context do
       before { subject.tokenizer(:name, option: :foo) }
-      specify { expect(subject.tokenizer(:name)).to eq({option: :foo}) }
-      specify { expect(subject.tokenizers).to eq({name: {option: :foo}}) }
+      specify { expect(subject.tokenizer(:name)).to eq(option: :foo) }
+      specify { expect(subject.tokenizers).to eq(name: { option: :foo }) }
     end
   end
 
@@ -33,8 +33,8 @@ describe Chewy::Repository do
 
     context do
       before { subject.filter(:name, option: :foo) }
-      specify { expect(subject.filter(:name)).to eq({option: :foo}) }
-      specify { expect(subject.filters).to eq({name: {option: :foo}}) }
+      specify { expect(subject.filter(:name)).to eq(option: :foo) }
+      specify { expect(subject.filters).to eq(name: { option: :foo }) }
     end
   end
 
@@ -43,8 +43,8 @@ describe Chewy::Repository do
 
     context do
       before { subject.char_filter(:name, option: :foo) }
-      specify { expect(subject.char_filter(:name)).to eq({option: :foo}) }
-      specify { expect(subject.char_filters).to eq({name: {option: :foo}}) }
+      specify { expect(subject.char_filter(:name)).to eq(option: :foo) }
+      specify { expect(subject.char_filters).to eq(name: { option: :foo }) }
     end
   end
 end

data/spec/chewy/rspec/update_index_spec.rb

@@ -6,22 +6,25 @@ describe :update_index do
   before do
     stub_index(:dummies) do
       define_type :dummy do
-        root value: ->(o){{}}
+        root value: ->(_o) { {} }
       end
     end
   end
 
-  specify { expect {  }.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) }
-    .to fail_with(/Expected index .* not to be updated, but it was with/) }
+  specify do
+    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/)
+  end
 
   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) }
+      expect do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42 } }, { index: { _id: 41 } }, { index: { _id: 42 } }]
+        end.not_to update_index(DummiesIndex::Dummy) end
     end
 
     specify { expectation.to fail_matching 'document id `42` (2 times)' }
@@ -29,62 +32,107 @@ 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 }
-        .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 }
-        .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 }
-        .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 }
-        .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' }
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(41).only
+      end
+        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(41, times: 2).only
+      end
+        .to fail_matching 'to update documents ["41"] only, but ["42"] was updated also'
+    end
+
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 41 } }] }
+        .to update_index(DummiesIndex::Dummy).and_delete(41, 42).only
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 41 } }] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+      end
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 41 } }] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41, times: 2).only
+      end
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was deleted also'
+    end
+
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 41 } }] }
+          .to update_index(DummiesIndex::Dummy).and_reindex(42).only
+      end
+        .to fail_matching 'to update documents ["42"] only, but ["41"] was deleted also'
+    end
+    specify do
+      expect do
+        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
+      end
+        .to fail_matching 'to update documents ["42"] only, but ["43"] was updated and ["41"] was deleted also'
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 41 } }] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+      end
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated also'
+    end
+    specify do
+      expect do
+        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 41 } }, { delete: { _id: 43 } }] }
+          .to update_index(DummiesIndex::Dummy).and_delete(41).only
+      end
+        .to fail_matching 'to delete documents ["41"] only, but ["42"] was updated and ["43"] was deleted also'
+    end
   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 do
+      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(42)
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }] }
+        .to update_index(DummiesIndex::Dummy).and_reindex(double(id: 42))
+    end
+    specify do
+      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))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }] }
+        .to update_index(DummiesIndex::Dummy).and_reindex([double(id: 42), 43])
+    end
 
     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])
-      }.to fail_matching 'Expected document with id `44` to be reindexed, but it was not'
+      expect do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+        end.to update_index(DummiesIndex::Dummy).and_reindex([44, 43])
+      end.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)) }
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(44, double(id: 47)) end
       end
 
       specify { expectation.to fail_matching('Expected document with id `44` to be reindexed, but it was not') }
@@ -92,23 +140,26 @@ describe :update_index do
     end
 
     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) }
+      specify do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: {} } }, { index: { _id: 44, data: {} } }]
+        end.to update_index(DummiesIndex::Dummy).and_reindex(42, 44, times: 1).and_reindex(43, times: 2) end
 
-      specify { expect {
-        expect {
-          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') }
+      specify do
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: { a: '1' } } }]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3)
+        end.to fail_matching('Expected document with id `42` 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: {}}}]
-            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) }
+          expect do
+            expect do
+              DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+              DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: {} } }, { index: { _id: 44, data: {} } }]
+            end.to update_index(DummiesIndex::Dummy).and_reindex(42, times: 3).and_reindex(44, 43, times: 4) end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `44` to be reindexed' }
@@ -119,51 +170,57 @@ describe :update_index do
     end
 
     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}) }
+      specify do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: { a: '1' } } }, { index: { _id: 42, data: { 'a' => 2 } } }]
+        end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: { a: 2 }) end
 
-      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}) }
+      specify do
+        expect do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: { a: '1' } } }, { index: { _id: 42, data: { 'b' => 2 } } }]
+        end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: { a: '1', b: 2 }) end
 
-      specify { expect {
-        expect {
-          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') }
+      specify do
+        expect do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: { a: '1' } } }]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: { a: 1 })
+        end.to fail_matching('Expected document with id `42` to be reindexed, but it was not') end
 
       [
-        [{a: ['one', 'two']}, {a: ['one', 'two']}],
-        [{a: ['one', 'two']}, {a: ['two', 'one']}],
-        [{a: ['one', 'one', 'two']}, {a: ['one', 'two', 'one']}],
-        [{a: {b: ['one', 'one', 'two']}}, {a: {b: ['one', 'two', 'one']}}],
-        [{a: 1, b: 1}, {a: 1}]
+        [{ a: %w(one two) }, { a: %w(one two) }],
+        [{ a: %w(one two) }, { a: %w(two one) }],
+        [{ a: %w(one one two) }, { a: %w(one two one) }],
+        [{ a: { b: %w(one one two) } }, { a: { b: %w(one two one) } }],
+        [{ 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) }
+        specify do
+          expect do
+            DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: data } }]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) end
       end
 
       [
-        [{a: ['one', 'two']}, {a: ['one', 'one', 'two']}],
-        [{a: ['one', 'one', 'two']}, {a: ['one', 'two']}],
-        [{a: ['one', 'two']}, {a: 1}],
-        [{a: 1}, {a: ['one', 'two']}],
-        [{a: 1}, {a: 1, b: 1}]
+        [{ a: %w(one two) }, { a: %w(one one two) }],
+        [{ a: %w(one one two) }, { a: %w(one two) }],
+        [{ a: %w(one two) }, { a: 1 }],
+        [{ a: 1 }, { a: %w(one two) }],
+        [{ a: 1 }, { a: 1, b: 1 }]
       ].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)
-        }.to fail_matching('Expected document with id `42` to be reindexed') }
+        specify do
+          expect do
+            expect do
+              DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: data } }]
+            end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with)
+          end.to fail_matching('Expected document with id `42` to be reindexed') end
       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}) }
+          expect do
+            expect do
+              DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: { a: '1' } } }, { index: { _id: 42, data: { 'a' => 2 } } }]
+            end.to update_index(DummiesIndex::Dummy).and_reindex(43, times: 2, with: { a: 2 }) end
         end
 
         specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed' }
@@ -174,19 +231,29 @@ 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 do
+      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))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 43 } }] }
+        .to update_index(DummiesIndex::Dummy).and_delete(42).and_delete(double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 43 } }] }
+        .to update_index(DummiesIndex::Dummy).and_delete(42, double(id: 43))
+    end
+    specify do
+      expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42 } }, { delete: { _id: 43 } }] }
+        .to update_index(DummiesIndex::Dummy).and_delete([43, double(id: 42)])
+    end
 
     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 do
+          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
       end
 
       specify { expectation.to fail_matching 'Expected document with id `43` to be reindexed, but it was not' }
@@ -195,8 +262,10 @@ 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 do
+          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
       end
 
       specify { expectation.to fail_matching 'Expected document with id `44` to be deleted, but it was not' }

data/spec/chewy/search_spec.rb

@@ -71,8 +71,8 @@ describe Chewy::Search do
       end
     end
 
-    let!(:cities) { 3.times.map { |i| City.create! rating: i + 1, name: "Name#{i+1}" } }
-    let!(:countries) { 3.times.map { |i| Country.create! rating: i + 1, name: "Name#{i+4}" } }
+    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 1}" } }
+    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 4}" } }
 
     before { PlacesIndex.import! city: cities, country: countries }
 
@@ -83,12 +83,12 @@ describe Chewy::Search do
     specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
     specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
 
-    specify { expect(PlacesIndex::City.by_rating {2}.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating {2}.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating {2}.map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
+    specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:rating)).to eq([2]) }
+    specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
 
     specify { expect(PlacesIndex::Country.by_rating(3).map(&:rating)).to eq([3]) }
     specify { expect(PlacesIndex::Country.by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }

data/spec/chewy/strategy/active_job_spec.rb

@@ -47,8 +47,8 @@ if defined?(::ActiveJob)
     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')
+      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