chewy 0.9.0 → 0.10.0

data/spec/chewy/rake_helper_spec.rb

@@ -0,0 +1,368 @@
+require 'spec_helper'
+
+describe Chewy::RakeHelper, :orm do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:places) do
+      define_type City do
+        field :name
+        field :updated_at, type: 'date'
+      end
+      define_type Country
+    end
+    stub_index(:users)
+
+    allow(described_class).to receive(:all_indexes) { [PlacesIndex, UsersIndex] }
+  end
+
+  let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
+  let!(:countries) { Array.new(2) { |i| Country.create!(name: "Name#{i + 1}") } }
+  let(:journal) do
+    Chewy::Stash::Journal.import([
+      {index_name: 'places', type_name: 'city', action: 'index', references: cities.first(2).map(&:id).map(&:to_s).map(&:to_json), created_at: 2.minutes.since},
+      {index_name: 'places', type_name: 'country', action: 'index', references: [countries.first.id.to_s.to_json], created_at: 4.minutes.since}
+    ])
+  end
+
+  describe '.reset' do
+    before { journal }
+
+    specify do
+      output = StringIO.new
+      expect { described_class.reset(output: output) }
+        .to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AResetting PlacesIndex
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+  Imported PlacesIndex::Country for \\d+s, stats: index 1
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Resetting UsersIndex
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    specify do
+      output = StringIO.new
+      expect { described_class.reset(only: 'places', output: output) }
+        .to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AResetting PlacesIndex
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+  Imported PlacesIndex::Country for \\d+s, stats: index 1
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    specify do
+      output = StringIO.new
+      expect { described_class.reset(except: PlacesIndex, output: output) }
+        .not_to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AResetting UsersIndex
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+      OUTPUT
+    end
+  end
+
+  describe '.upgrade' do
+    specify do
+      output = StringIO.new
+      expect { described_class.upgrade(output: output) }
+        .to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AResetting PlacesIndex
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Resetting UsersIndex
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context do
+      before { PlacesIndex.reset! }
+
+      specify do
+        output = StringIO.new
+        expect { described_class.upgrade(output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASkipping PlacesIndex, the specification didn't change
+Resetting UsersIndex
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.upgrade(except: PlacesIndex, output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AResetting UsersIndex
+  Imported Chewy::Stash::Specification for \\d+s, stats: index 1
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      context do
+        before { UsersIndex.reset! }
+
+        specify do
+          output = StringIO.new
+          expect { described_class.upgrade(except: ['places'], output: output) }
+            .not_to update_index(PlacesIndex::City)
+          expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ANo index specification was changed
+Total: \\d+s\\Z
+          OUTPUT
+        end
+      end
+    end
+  end
+
+  describe '.update' do
+    specify do
+      output = StringIO.new
+      expect { described_class.update(output: output) }
+        .not_to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASkipping PlacesIndex, it does not exists \\(use rake chewy:reset\\[places\\] to create and update it\\)
+      OUTPUT
+    end
+
+    context do
+      before { PlacesIndex.reset! }
+
+      specify do
+        output = StringIO.new
+        expect { described_class.update(output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AUpdating PlacesIndex
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.update(only: 'places#country', output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AUpdating PlacesIndex
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.update(except: PlacesIndex::Country, output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AUpdating PlacesIndex
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+  end
+
+  describe '.sync' do
+    specify do
+      output = StringIO.new
+      expect { described_class.sync(output: output) }
+        .to update_index(PlacesIndex::City)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASynchronizing PlacesIndex::City
+  Imported PlacesIndex::City for \\d+s, stats: index 3
+  Missing documents: \\[[^\\]]+\\]
+  Took \\d+s
+Synchronizing PlacesIndex::Country
+  PlacesIndex::Country doesn't support outdated synchronization
+  Imported PlacesIndex::Country for \\d+s, stats: index 2
+  Missing documents: \\[[^\\]]+\\]
+  Took \\d+s
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context do
+      before do
+        PlacesIndex::City.import(cities.first(2))
+        PlacesIndex::Country.import
+
+        sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
+        cities.first.update(name: 'Name5')
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.sync(output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASynchronizing PlacesIndex::City
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+  Missing documents: \\["#{cities.last.id}"\\]
+  Outdated documents: \\["#{cities.first.id}"\\]
+  Took \\d+s
+Synchronizing PlacesIndex::Country
+  PlacesIndex::Country doesn't support outdated synchronization
+  Skipping PlacesIndex::Country, up to date
+  Took \\d+s
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.sync(only: PlacesIndex::City, output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASynchronizing PlacesIndex::City
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+  Missing documents: \\["#{cities.last.id}"\\]
+  Outdated documents: \\["#{cities.first.id}"\\]
+  Took \\d+s
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.sync(except: ['places#city'], output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ASynchronizing PlacesIndex::Country
+  PlacesIndex::Country doesn't support outdated synchronization
+  Skipping PlacesIndex::Country, up to date
+  Took \\d+s
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+  end
+
+  describe '.journal_apply' do
+    specify { expect { described_class.journal_apply }.to raise_error ArgumentError }
+    specify do
+      output = StringIO.new
+      described_class.journal_apply(time: Time.now, output: output)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AApplying journal entries created after [+-:\\d\\s]+
+No journal entries were created after the specified time
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    context do
+      before { journal }
+
+      specify do
+        output = StringIO.new
+        expect { described_class.journal_apply(time: Time.now, output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AApplying journal entries created after [+-:\\d\\s]+
+  Applying journal to \\[PlacesIndex::City, PlacesIndex::Country\\], 3 entries, stage 1
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+  Imported PlacesIndex::Country for \\d+s, stats: index 1
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.journal_apply(time: 3.minutes.since, output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AApplying journal entries created after [+-:\\d\\s]+
+  Applying journal to \\[PlacesIndex::Country\\], 1 entries, stage 1
+  Imported PlacesIndex::Country for \\d+s, stats: index 1
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.journal_apply(time: Time.now, only: PlacesIndex::City, output: output) }
+          .to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AApplying journal entries created after [+-:\\d\\s]+
+  Applying journal to \\[PlacesIndex::City\\], 2 entries, stage 1
+  Imported PlacesIndex::City for \\d+s, stats: index 2
+Total: \\d+s\\Z
+        OUTPUT
+      end
+
+      specify do
+        output = StringIO.new
+        expect { described_class.journal_apply(time: Time.now, except: PlacesIndex::City, output: output) }
+          .not_to update_index(PlacesIndex::City)
+        expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\AApplying journal entries created after [+-:\\d\\s]+
+  Applying journal to \\[PlacesIndex::Country\\], 1 entries, stage 1
+  Imported PlacesIndex::Country for \\d+s, stats: index 1
+Total: \\d+s\\Z
+        OUTPUT
+      end
+    end
+  end
+
+  describe '.journal_clean' do
+    before { journal }
+
+    specify do
+      output = StringIO.new
+      described_class.journal_clean(output: output)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ACleaned up 2 journal entries
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    specify do
+      output = StringIO.new
+      described_class.journal_clean(time: 3.minutes.since, output: output)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ACleaning journal entries created before [+-:\\d\\s]+
+Cleaned up 1 journal entries
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    specify do
+      output = StringIO.new
+      described_class.journal_clean(only: PlacesIndex::City, output: output)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ACleaned up 1 journal entries
+Total: \\d+s\\Z
+      OUTPUT
+    end
+
+    specify do
+      output = StringIO.new
+      described_class.journal_clean(except: PlacesIndex::City, output: output)
+      expect(output.string).to match(Regexp.new(<<-OUTPUT, Regexp::MULTILINE))
+\\ACleaned up 1 journal entries
+Total: \\d+s\\Z
+      OUTPUT
+    end
+  end
+end

data/spec/chewy/repository_spec.rb

@@ -14,7 +14,7 @@ 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.analyzers).to eq(name: {option: :foo}) }
     end
   end
 
@@ -24,7 +24,7 @@ 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.tokenizers).to eq(name: {option: :foo}) }
     end
   end
 
@@ -34,7 +34,7 @@ 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.filters).to eq(name: {option: :foo}) }
     end
   end
 
@@ -44,7 +44,7 @@ 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_filters).to eq(name: {option: :foo}) }
     end
   end
 end

data/spec/chewy/rspec/update_index_spec.rb

@@ -1,70 +1,103 @@
 require 'spec_helper'
 
 describe :update_index do
-  before { Chewy.massacre }
-
   before do
     stub_index(:dummies) do
-      define_type :dummy do
-        root value: ->(_o) { {} }
-      end
+      define_type :dummy
+      define_type :dummy2
     end
   end
 
+  before do
+    Chewy.massacre
+    DummiesIndex.create!
+  end
+
   specify { expect {}.not_to update_index(DummiesIndex::Dummy) }
   specify { expect { DummiesIndex::Dummy.bulk body: [] }.not_to update_index(DummiesIndex::Dummy) }
 
   specify do
-    expect { expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42 } }] }.not_to update_index(DummiesIndex::Dummy) }
+    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
 
+  specify do
+    expect do
+      DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+      DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+    end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+  end
+
   context do
     let(:expectation) do
       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
+          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)' }
     specify { expectation.to fail_matching 'document id `41` (1 times)' }
   end
 
+  context 'compound matchers' do
+    specify do
+      expect do
+        DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: {}}}, {index: {_id: 41, data: {}}}]
+        DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+      end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+        .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+    end
+
+    context do
+      let(:expectation) do
+        expect do
+          expect do
+            DummiesIndex::Dummy2.bulk body: [{index: {_id: 43, data: {}}}]
+          end.to update_index(DummiesIndex::Dummy).and_reindex(41, 42).only
+            .and update_index(DummiesIndex::Dummy2).and_reindex(43).only
+        end
+      end
+
+      specify { expectation.to fail_matching 'Expected index `DummiesIndex::Dummy` to be updated' }
+    end
+  end
+
   context '#only' do
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }] }
+      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: {} } }] }
+        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: {} } }] }
+        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 } }] }
+      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 } }] }
+        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 } }] }
+        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'
@@ -72,28 +105,28 @@ describe :update_index do
 
     specify do
       expect do
-        expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 41 } }] }
+        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 } }] }
+        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 } }] }
+        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 } }] }
+        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'
@@ -101,28 +134,28 @@ describe :update_index do
   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}}] }.to update_index(DummiesIndex::Dummy) }
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }] }
+      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: {} } }] }
+      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: {} } }] }
+      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: {} } }] }
+      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 do
         expect do
-          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+          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
@@ -131,7 +164,7 @@ describe :update_index do
       let(:expectation) do
         expect do
           expect do
-            DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 43, data: {} } }]
+            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
 
@@ -142,14 +175,14 @@ describe :update_index do
     context ':times' do
       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: {} } }]
+          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 do
         expect do
           expect do
-            DummiesIndex::Dummy.bulk body: [{ index: { _id: 43, data: { a: '1' } } }]
+            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
 
@@ -157,8 +190,8 @@ describe :update_index do
         let(:expectation) do
           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: {} } }]
+              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
 
@@ -172,45 +205,45 @@ describe :update_index do
     context ':with' do
       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
+          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 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
+          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 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 })
+            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: %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 }]
+        [{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 do
           expect do
-            DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: data } }]
+            DummiesIndex::Dummy.bulk body: [{index: {_id: 42, data: data}}]
           end.to update_index(DummiesIndex::Dummy).and_reindex(42, with: with) end
       end
 
       [
-        [{ 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 }]
+        [{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 do
           expect do
             expect do
-              DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: data } }]
+              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
@@ -219,8 +252,8 @@ describe :update_index do
         let(:expectation) do
           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
+              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' }
@@ -232,26 +265,26 @@ describe :update_index do
 
   context '#and_delete' do
     specify do
-      expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 43 } }] }
+      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 } }] }
+      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 } }] }
+      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 } }] }
+      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 do
-          expect { DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { delete: { _id: 43 } }] }
+          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
@@ -263,7 +296,7 @@ describe :update_index do
     context do
       let(:expectation) do
         expect do
-          expect { DummiesIndex::Dummy.bulk body: [{ delete: { _id: 42, data: {} } }, { delete: { _id: 42 } }] }
+          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