chewy 0.8.4 → 0.9.0

data/spec/chewy/minitest/helpers_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'chewy/minitest'
+
+describe :minitest_helper do
+  class << self
+    alias_method :teardown, :after
+  end
+
+  def assert_includes(haystack, needle, _comment)
+    expect(haystack).to include(needle)
+  end
+
+  include ::Chewy::Minitest::Helpers
+
+  before do
+    Chewy.massacre
+  end
+
+  before do
+    stub_index(:dummies) do
+      define_type :dummy do
+        root value: ->(_o) { {} }
+      end
+    end
+  end
+
+  context 'assert_indexes' do
+    specify 'doesn\'t fail when index updates correctly' do
+      expect do
+        assert_indexes DummiesIndex::Dummy do
+          DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+        end
+      end.to_not raise_error
+    end
+
+    specify 'fails when index doesn\'t update' do
+      expect do
+        assert_indexes DummiesIndex::Dummy do
+        end
+      end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    specify 'SearchIndexReceiver catches the indexes' do
+      receiver = assert_indexes DummiesIndex::Dummy do
+        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+      end
+
+      expect(receiver).to be_a(SearchIndexReceiver)
+
+      expect(
+        receiver.indexes_for(DummiesIndex::Dummy)
+                .map { |index| index[:_id] }
+      ).to match_array([41, 42])
+    end
+
+    specify 'Real index is bypassed when asserting' do
+      expect(DummiesIndex::Dummy).not_to receive(:bulk)
+
+      assert_indexes DummiesIndex::Dummy do
+        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+      end
+    end
+
+    specify 'Real index is allowed when asserting' do
+      expect(DummiesIndex::Dummy).to receive(:bulk)
+
+      assert_indexes DummiesIndex::Dummy, bypass_actual_index: false do
+        DummiesIndex::Dummy.bulk body: [{ index: { _id: 42, data: {} } }, { index: { _id: 41, data: {} } }]
+      end
+    end
+  end
+
+  context 'run_indexing' do
+    specify 'pushes onto the chewy strategy stack' do
+      Chewy.strategy :bypass do
+        run_indexing do
+          expect(Chewy.strategy.current.name).to be(:atomic)
+        end
+      end
+    end
+
+    specify 'allows tester to specify the strategy' do
+      Chewy.strategy :atomic do
+        run_indexing strategy: :bypass do
+          expect(Chewy.strategy.current.name).to be(:bypass)
+        end
+      end
+    end
+  end
+end

data/spec/chewy/minitest/search_index_receiver_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'chewy/minitest'
+
+describe :search_index_receiver do
+  def search_request(item_count = 2, verb: :index)
+    items = Array.new(item_count) do |i|
+      {
+        verb => { _id: i + 1, data: {} }
+      }
+    end
+
+    [
+      {
+        body: items
+      }
+    ]
+  end
+
+  def parse_request(request)
+    request.map { |r| r[:_id] }
+  end
+
+  let(:receiver) do
+    SearchIndexReceiver.new
+  end
+
+  before do
+    stub_index(:dummies) do
+      define_type :fizz do
+        root value: ->(_o) { {} }
+      end
+
+      define_type :buzz do
+        root value: ->(_o) { {} }
+      end
+    end
+  end
+
+  context 'catch' do
+    specify 'archives more than one type' do
+      receiver.catch search_request(2), DummiesIndex::Fizz
+      receiver.catch search_request(3), DummiesIndex::Buzz
+      expect(receiver.indexes.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+    end
+  end
+
+  context 'indexes_for' do
+    before do
+      receiver.catch search_request(2), DummiesIndex::Fizz
+      receiver.catch search_request(3), DummiesIndex::Buzz
+    end
+
+    specify 'returns indexes for a specific type' do
+      expect(parse_request(receiver.indexes_for(DummiesIndex::Fizz))).to match_array([1, 2])
+    end
+
+    specify 'returns only indexes for all types' do
+      index_responses = receiver.indexes
+      expect(index_responses.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+      expect(parse_request(index_responses.values.flatten)).to match_array([1, 2, 1, 2, 3])
+    end
+  end
+
+  context 'deletes_for' do
+    before do
+      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
+      receiver.catch search_request(3, verb: :delete), DummiesIndex::Buzz
+    end
+
+    specify 'returns deletes for a specific type' do
+      expect(receiver.deletes_for(DummiesIndex::Buzz)).to match_array([1, 2, 3])
+    end
+
+    specify 'returns only deletes for all types' do
+      deletes = receiver.deletes
+      expect(deletes.keys).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+      expect(deletes.values.flatten).to match_array([1, 2, 1, 2, 3])
+    end
+  end
+
+  context 'indexed?' do
+    before do
+      receiver.catch search_request(1), DummiesIndex::Fizz
+    end
+
+    specify 'validates that an object was indexed' do
+      dummy = OpenStruct.new(id: 1)
+      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(true)
+    end
+
+    specify 'doesn\'t validate than unindexed objects were indexed' do
+      dummy = OpenStruct.new(id: 2)
+      expect(receiver.indexed?(dummy, DummiesIndex::Fizz)).to be(false)
+    end
+  end
+
+  context 'deleted?' do
+    before do
+      receiver.catch search_request(1, verb: :delete), DummiesIndex::Fizz
+    end
+
+    specify 'validates than an object was deleted' do
+      dummy = OpenStruct.new(id: 1)
+      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(true)
+    end
+
+    specify 'doesn\'t validate than undeleted objects were deleted' do
+      dummy = OpenStruct.new(id: 2)
+      expect(receiver.deleted?(dummy, DummiesIndex::Fizz)).to be(false)
+    end
+  end
+
+  context 'updated_indexes' do
+    specify 'provides a list of indices updated' do
+      receiver.catch search_request(2, verb: :delete), DummiesIndex::Fizz
+      receiver.catch search_request(3, verb: :delete), DummiesIndex::Buzz
+      expect(receiver.updated_indexes).to match_array([DummiesIndex::Fizz, DummiesIndex::Buzz])
+    end
+  end
+end

data/spec/chewy/query/criteria_spec.rb

@@ -28,7 +28,7 @@ describe Chewy::Query::Criteria do
   its(:fields?) { should eq(false) }
   its(:types?) { should eq(false) }
 
-  its(:none?){ should eq(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')) }
@@ -47,8 +47,10 @@ describe Chewy::Query::Criteria 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]) }
+    specify do
+      expect { subject.tap { |s| s.update_scores(:score1) }.update_scores([:score2, :score3]) }
+        .to change { subject.scores }.to([:score1, :score2, :score3])
+    end
   end
 
   describe '#update_aggregations' do
@@ -57,74 +59,154 @@ describe Chewy::Query::Criteria do
   end
 
   describe '#update_script_fields' do
-    specify { expect { subject.update_script_fields(distance: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }.to change { subject.script_fields? }.to(true) }
-    specify { expect { subject.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }.to change { subject.script_fields }.to(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }
+    specify do
+      expect { subject.update_script_fields(distance: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
+        .to change { subject.script_fields? }.to(true)
+    end
+    specify do
+      expect { subject.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }
+        .to change { subject.script_fields }.to(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+    end
   end
 
   describe '#update_queries' do
-    specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries? }.to(true) }
-    specify { expect { subject.update_queries(field: 'hello') }.to change { subject.queries }.to([field: 'hello']) }
-    specify { expect { subject.update_queries(field: 'hello'); subject.update_queries(field: 'world') }
-      .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}]) }
-    specify { expect { subject.update_queries([{field: 'hello'}, {field: 'world'}, nil]) }
-      .to change { subject.queries }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify do
+      expect { subject.update_queries(field: 'hello') }
+        .to change { subject.queries? }.to(true)
+    end
+    specify do
+      expect { subject.update_queries(field: 'hello') }
+        .to change { subject.queries }.to([field: 'hello'])
+    end
+    specify do
+      expect do
+        subject.update_queries(field: 'hello')
+        subject.update_queries(field: 'world')
+      end
+        .to change { subject.queries }.to([{ field: 'hello' }, { field: 'world' }])
+    end
+    specify do
+      expect { subject.update_queries([{ field: 'hello' }, { field: 'world' }, nil]) }
+        .to change { subject.queries }.to([{ field: 'hello' }, { field: 'world' }])
+    end
   end
 
   describe '#update_filters' do
     specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters? }.to(true) }
-    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{field: 'hello'}]) }
-    specify { expect { subject.update_filters(field: 'hello'); subject.update_filters(field: 'world') }
-      .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}]) }
-    specify { expect { subject.update_filters([{field: 'hello'}, {field: 'world'}, nil]) }
-      .to change { subject.filters }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify { expect { subject.update_filters(field: 'hello') }.to change { subject.filters }.to([{ field: 'hello' }]) }
+    specify do
+      expect do
+        subject.update_filters(field: 'hello')
+        subject.update_filters(field: 'world')
+      end
+        .to change { subject.filters }.to([{ field: 'hello' }, { field: 'world' }])
+    end
+    specify do
+      expect { subject.update_filters([{ field: 'hello' }, { field: 'world' }, nil]) }
+        .to change { subject.filters }.to([{ field: 'hello' }, { field: 'world' }])
+    end
   end
 
   describe '#update_post_filters' do
     specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters? }.to(true) }
-    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters }.to([{field: 'hello'}]) }
-    specify { expect { subject.update_post_filters(field: 'hello'); subject.update_post_filters(field: 'world') }
-      .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}]) }
-    specify { expect { subject.update_post_filters([{field: 'hello'}, {field: 'world'}, nil]) }
-      .to change { subject.post_filters }.to([{field: 'hello'}, {field: 'world'}]) }
+    specify { expect { subject.update_post_filters(field: 'hello') }.to change { subject.post_filters }.to([{ field: 'hello' }]) }
+    specify do
+      expect do
+        subject.update_post_filters(field: 'hello')
+        subject.update_post_filters(field: 'world')
+      end
+        .to change { subject.post_filters }.to([{ field: 'hello' }, { field: 'world' }])
+    end
+    specify do
+      expect { subject.update_post_filters([{ field: 'hello' }, { field: 'world' }, nil]) }
+        .to change { subject.post_filters }.to([{ field: 'hello' }, { field: 'world' }])
+    end
   end
 
   describe '#update_sort' do
-    specify { expect { subject.update_sort(:field) }.to change { subject.sort? }.to(true) }
-
-    specify { expect { subject.update_sort([:field]) }.to change { subject.sort }.to([:field]) }
-    specify { expect { subject.update_sort([:field1, :field2]) }.to change { subject.sort }.to([:field1, :field2]) }
-    specify { expect { subject.update_sort([{field: :asc}]) }.to change { subject.sort }.to([{field: :asc}]) }
-    specify { expect { subject.update_sort([:field1, field2: {order: :asc}]) }.to change { subject.sort }.to([:field1, {field2: {order: :asc}}]) }
-    specify { expect { subject.update_sort([{field1: {order: :asc}}, :field2]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2]) }
-    specify { expect { subject.update_sort([field1: :asc, field2: {order: :asc}]) }.to change { subject.sort }.to([{field1: :asc}, {field2: {order: :asc}}]) }
-    specify { expect { subject.update_sort([{field1: {order: :asc}}, :field2, :field3]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
-    specify { expect { subject.update_sort([{field1: {order: :asc}}, [:field2, :field3]]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
-    specify { expect { subject.update_sort([{field1: {order: :asc}}, [:field2], :field3]) }.to change { subject.sort }.to([{field1: {order: :asc}}, :field2, :field3]) }
-    specify { expect { subject.update_sort([{field1: {order: :asc}, field2: :desc}, [:field3], :field4]) }.to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
-    specify { expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4]) }.to change { subject.sort }.to([{field1: {order: :asc}}, {field2: :desc}, :field3, :field4]) }
-    specify { expect { subject.tap { |s| s.update_sort([field1: {order: :asc}, field2: :desc]) }.update_sort([[:field3], :field4], purge: true) }.to change { subject.sort }.to([:field3, :field4]) }
+    specify do
+      expect { subject.update_sort(:field) }
+        .to change { subject.sort? }.to(true)
+    end
+
+    specify do
+      expect { subject.update_sort([:field]) }
+        .to change { subject.sort }.to([:field])
+    end
+    specify do
+      expect { subject.update_sort([:field1, :field2]) }
+        .to change { subject.sort }.to([:field1, :field2])
+    end
+    specify do
+      expect { subject.update_sort([{ field: :asc }]) }
+        .to change { subject.sort }.to([{ field: :asc }])
+    end
+    specify do
+      expect { subject.update_sort([:field1, field2: { order: :asc }]) }
+        .to change { subject.sort }.to([:field1, { field2: { order: :asc } }])
+    end
+    specify do
+      expect { subject.update_sort([{ field1: { order: :asc } }, :field2]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2])
+    end
+    specify do
+      expect { subject.update_sort([field1: :asc, field2: { order: :asc }]) }
+        .to change { subject.sort }.to([{ field1: :asc }, { field2: { order: :asc } }])
+    end
+    specify do
+      expect { subject.update_sort([{ field1: { order: :asc } }, :field2, :field3]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+    end
+    specify do
+      expect { subject.update_sort([{ field1: { order: :asc } }, [:field2, :field3]]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+    end
+    specify do
+      expect { subject.update_sort([{ field1: { order: :asc } }, [:field2], :field3]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, :field2, :field3])
+    end
+    specify do
+      expect { subject.update_sort([{ field1: { order: :asc }, field2: :desc }, [:field3], :field4]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, { field2: :desc }, :field3, :field4])
+    end
+    specify do
+      expect { subject.tap { |s| s.update_sort([field1: { order: :asc }, field2: :desc]) }.update_sort([[:field3], :field4]) }
+        .to change { subject.sort }.to([{ field1: { order: :asc } }, { field2: :desc }, :field3, :field4])
+    end
+    specify do
+      expect { subject.tap { |s| s.update_sort([field1: { order: :asc }, field2: :desc]) }.update_sort([[:field3], :field4], purge: true) }
+        .to change { subject.sort }.to([:field3, :field4])
+    end
   end
 
   describe '#update_fields' do
     specify { expect { subject.update_fields(:field) }.to change { subject.fields? }.to(true) }
     specify { expect { subject.update_fields(:field) }.to change { subject.fields }.to(['field']) }
     specify { expect { subject.update_fields([:field, :field]) }.to change { subject.fields }.to(['field']) }
-    specify { expect { subject.update_fields([:field1, :field2]) }.to change { subject.fields }.to(['field1', 'field2']) }
-    specify { expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3]) }
-      .to change { subject.fields }.to(['field1', 'field2', 'field3']) }
-    specify { expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3], purge: true) }
-      .to change { subject.fields }.to(['field2', 'field3']) }
+    specify { expect { subject.update_fields([:field1, :field2]) }.to change { subject.fields }.to(%w(field1 field2)) }
+    specify do
+      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3]) }
+        .to change { subject.fields }.to(%w(field1 field2 field3))
+    end
+    specify do
+      expect { subject.tap { |s| s.update_fields(:field1) }.update_fields([:field2, :field3], purge: true) }
+        .to change { subject.fields }.to(%w(field2 field3))
+    end
   end
 
   describe '#update_types' do
     specify { expect { subject.update_types(:type) }.to change { subject.types? }.to(true) }
     specify { expect { subject.update_types(:type) }.to change { subject.types }.to(['type']) }
     specify { expect { subject.update_types([:type, :type]) }.to change { subject.types }.to(['type']) }
-    specify { expect { subject.update_types([:type1, :type2]) }.to change { subject.types }.to(['type1', 'type2']) }
-    specify { expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3]) }
-      .to change { subject.types }.to(['type1', 'type2', 'type3']) }
-    specify { expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3], purge: true) }
-      .to change { subject.types }.to(['type2', 'type3']) }
+    specify { expect { subject.update_types([:type1, :type2]) }.to change { subject.types }.to(%w(type1 type2)) }
+    specify do
+      expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3]) }
+        .to change { subject.types }.to(%w(type1 type2 type3))
+    end
+    specify do
+      expect { subject.tap { |s| s.update_types(:type1) }.update_types([:type2, :type3], purge: true) }
+        .to change { subject.types }.to(%w(type2 type3))
+    end
   end
 
   describe '#merge' do
@@ -133,30 +215,63 @@ describe Chewy::Query::Criteria do
     specify { expect(subject.merge(criteria)).not_to be_equal subject }
     specify { expect(subject.merge(criteria)).not_to be_equal criteria }
 
-    specify { expect(subject.tap { |c| c.update_options(opt1: 'hello') }
-      .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options).to include(opt1: 'hello', opt2: 'hello') }
-    specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
-      .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
-    specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello'}) }
-    specify { expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
-      .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields).to eq({distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}}) }
-    specify { expect(subject.tap { |c| c.update_scores(script: 'hello') }
-      .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores).to eq([{script: 'hello'}, { script: 'foobar' } ]) }
-    specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello'}) }
-    specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
-      .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_sort(:field1) }
-      .merge(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2]) }
-    specify { expect(subject.tap { |c| c.update_fields(:field1) }
-      .merge(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(['field1', 'field2']) }
-    specify { expect(subject.tap { |c| c.update_types(:type1) }
-      .merge(criteria.tap { |c| c.update_types(:type2) }).types).to eq(['type1', 'type2']) }
+    specify do
+      expect(subject.tap { |c| c.update_options(opt1: 'hello') }
+        .merge(criteria.tap { |c| c.update_options(opt2: 'hello') }).options)
+        .to include(opt1: 'hello', opt2: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
+        .merge(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options)
+        .to include(opt1: 'hello', opt2: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_facets(field1: 'hello') }
+        .merge(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets)
+        .to eq(field1: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
+        .merge(criteria.tap { |c| c.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }).script_fields)
+        .to eq(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }, distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+    end
+    specify do
+      expect(subject.tap { |c| c.update_scores(script: 'hello') }
+        .merge(criteria.tap { |c| c.update_scores(script: 'foobar') }).scores)
+        .to eq([{ script: 'hello' }, { script: 'foobar' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
+        .merge(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations)
+        .to eq(field1: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_queries(field1: 'hello') }
+        .merge(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_filters(field1: 'hello') }
+        .merge(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
+        .merge(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_sort(:field1) }
+        .merge(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_fields(:field1) }
+        .merge(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(%w(field1 field2))
+    end
+    specify do
+      expect(subject.tap { |c| c.update_types(:type1) }
+        .merge(criteria.tap { |c| c.update_types(:type2) }).types).to eq(%w(type1 type2))
+    end
   end
 
   describe '#merge!' do
@@ -165,269 +280,421 @@ describe Chewy::Query::Criteria do
     specify { expect(subject.merge!(criteria)).to be_equal subject }
     specify { expect(subject.merge!(criteria)).not_to be_equal criteria }
 
-    specify { expect(subject.tap { |c| c.update_options(opt1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options).to include(opt1: 'hello', opt2: 'hello') }
-    specify { expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options).to include(opt1: 'hello', opt2: 'hello') }
-    specify { expect(subject.tap { |c| c.update_facets(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets).to eq({field1: 'hello'}) }
-    specify { expect(subject.tap { |c| c.update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}) }
-      .merge(criteria.tap { |c| c.update_script_fields(distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}) }).script_fields).to eq({distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"}, distance_km: {script: "doc['coordinates'].distanceInKm(lat, lon)"}}) }
-    specify { expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations).to eq({field1: 'hello'}) }
-    specify { expect(subject.tap { |c| c.update_queries(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_filters(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
-      .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters).to eq([{field1: 'hello'}, {field2: 'hello'}]) }
-    specify { expect(subject.tap { |c| c.update_sort(:field1) }
-      .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort).to eq([:field1, :field2]) }
-    specify { expect(subject.tap { |c| c.update_fields(:field1) }
-      .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields).to eq(['field1', 'field2']) }
-    specify { expect(subject.tap { |c| c.update_types(:type1) }
-      .merge!(criteria.tap { |c| c.update_types(:type2) }).types).to eq(['type1', 'type2']) }
+    specify do
+      expect(subject.tap { |c| c.update_options(opt1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_options(opt2: 'hello') }).options)
+        .to include(opt1: 'hello', opt2: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_request_options(opt1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_request_options(opt2: 'hello') }).request_options)
+        .to include(opt1: 'hello', opt2: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_facets(field1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_facets(field1: 'hello') }).facets)
+        .to eq(field1: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }) }
+        .merge(criteria.tap { |c| c.update_script_fields(distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" }) }).script_fields)
+        .to eq(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" }, distance_km: { script: "doc['coordinates'].distanceInKm(lat, lon)" })
+    end
+    specify do
+      expect(subject.tap { |c| c.update_aggregations(field1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_aggregations(field1: 'hello') }).aggregations)
+        .to eq(field1: 'hello')
+    end
+    specify do
+      expect(subject.tap { |c| c.update_queries(field1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_queries(field2: 'hello') }).queries)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_filters(field1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_filters(field2: 'hello') }).filters)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_post_filters(field1: 'hello') }
+        .merge!(criteria.tap { |c| c.update_post_filters(field2: 'hello') }).post_filters)
+        .to eq([{ field1: 'hello' }, { field2: 'hello' }])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_sort(:field1) }
+        .merge!(criteria.tap { |c| c.update_sort(:field2) }).sort)
+        .to eq([:field1, :field2])
+    end
+    specify do
+      expect(subject.tap { |c| c.update_fields(:field1) }
+        .merge!(criteria.tap { |c| c.update_fields(:field2) }).fields)
+        .to eq(%w(field1 field2))
+    end
+    specify do
+      expect(subject.tap { |c| c.update_types(:type1) }
+        .merge!(criteria.tap { |c| c.update_types(:type2) }).types)
+        .to eq(%w(type1 type2))
+    end
   end
 
   describe '#request_body' do
-    def request_body &block
+    def request_body(&block)
       subject.instance_exec(&block) if block
       subject.request_body
     end
 
-    specify { expect(request_body).to eq({body: {}}) }
-    specify { expect(request_body { update_request_options(size: 10) }).to eq({body: {size: 10}}) }
-    specify { expect(request_body { update_request_options(from: 10) }).to eq({body: {from: 10}}) }
-    specify { expect(request_body { update_request_options(explain: true) }).to eq({body: {explain: true}}) }
-    specify { expect(request_body { update_queries(:query) }).to eq({body: {query: :query}}) }
-    specify { expect(request_body {
-      update_scores(script_score: { script: '_score'})
-    }).to eq({body: {query: { function_score: { functions: [{ script_score: {script: '_score' }}] }}}}) }
-    specify { expect(request_body {
-      update_scores(script_score: { script: "boost_me" })
-      update_queries(:query)
-      update_options(boost_mode: :add)
-      update_options(score_mode: :avg)
-    }).to eq({body: {query: {
-      function_score: {
-        functions: [{
-          script_score: {script: 'boost_me' }
-        }],
-        query: :query,
-        boost_mode: :add,
-        score_mode: :avg
-      }}}})
-    }
-    specify { expect(request_body {
-      update_request_options(from: 10); update_sort(:field); update_fields(:field); update_queries(:query)
-    }).to eq({body: {query: :query, from: 10, sort: [:field], _source: ['field']}}) }
-
-    specify { expect(request_body {
-      update_queries(:query); update_filters(:filters);
-    }).to eq({body: {query: {filtered: {query: :query, filter: :filters}}}}) }
-    specify { expect(request_body {
-      update_queries(:query); update_post_filters(:post_filter);
-    }).to eq({body: {query: :query, post_filter: :post_filter}}) }
-    specify { expect(request_body {
-      update_script_fields(distance_m: {script: "doc['coordinates'].distanceInMiles(lat, lon)"})
-    }).to eq({:body=>{:script_fields=>{:distance_m=>{:script=>"doc['coordinates'].distanceInMiles(lat, lon)"}}}}) }
+    specify { expect(request_body).to eq(body: {}) }
+    specify { expect(request_body { update_request_options(size: 10) }).to eq(body: { size: 10 }) }
+    specify { expect(request_body { update_request_options(from: 10) }).to eq(body: { from: 10 }) }
+    specify { expect(request_body { update_request_options(explain: true) }).to eq(body: { explain: true }) }
+    specify { expect(request_body { update_queries(:query) }).to eq(body: { query: :query }) }
+    specify do
+      expect(request_body do
+               update_scores(script_score: { script: '_score' })
+             end).to eq(body: { query: { function_score: { functions: [{ script_score: { script: '_score' } }] } } }) end
+    specify do
+      expect(request_body do
+               update_scores(script_score: { script: 'boost_me' })
+               update_queries(:query)
+               update_options(boost_mode: :add)
+               update_options(score_mode: :avg)
+             end).to eq(body: { query: {
+                          function_score: {
+                            functions: [{
+                              script_score: { script: 'boost_me' }
+                            }],
+                            query: :query,
+                            boost_mode: :add,
+                            score_mode: :avg
+                          }
+                        } })
+    end
+    specify do
+      expect(request_body do
+               update_request_options(from: 10)
+               update_sort(:field)
+               update_fields(:field)
+               update_queries(:query)
+             end).to eq(body: { query: :query, from: 10, sort: [:field], _source: ['field'] }) end
+
+    specify do
+      expect(request_body do
+               update_queries(:query)
+               update_filters(:filters)
+             end).to eq(body: { query: { filtered: { query: :query, filter: :filters } } }) end
+    specify do
+      expect(request_body do
+               update_queries(:query)
+               update_post_filters(:post_filter)
+             end).to eq(body: { query: :query, post_filter: :post_filter }) end
+    specify do
+      expect(request_body do
+               update_script_fields(distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" })
+             end).to eq(body: { script_fields: { distance_m: { script: "doc['coordinates'].distanceInMiles(lat, lon)" } } }) end
   end
 
   describe '#_filtered_query' do
-    def _filtered_query options = {}, &block
+    def _filtered_query(options = {}, &block)
       subject.instance_exec(&block) if block
       subject.send(:_filtered_query, subject.send(:_request_query), subject.send(:_request_filter), options)
     end
 
     specify { expect(_filtered_query).to eq({}) }
-    specify { expect(_filtered_query { update_queries(:query) }).to eq({query: :query}) }
-    specify { expect(_filtered_query(strategy: 'query_first') { update_queries(:query) }).to eq({query: :query}) }
-    specify { expect(_filtered_query { update_queries([:query1, :query2]) })
-      .to eq({query: {bool: {must: [:query1, :query2]}}}) }
-    specify { expect(_filtered_query { update_options(query_mode: :should); update_queries([:query1, :query2]) })
-      .to eq({query: {bool: {should: [:query1, :query2]}}}) }
-    specify { expect(_filtered_query { update_options(query_mode: :dis_max); update_queries([:query1, :query2]) })
-      .to eq({query: {dis_max: {queries: [:query1, :query2]}}}) }
-
-    specify { expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) })
-      .to eq({query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}, strategy: 'query_first'}}}) }
-    specify { expect(_filtered_query { update_filters([:filter1, :filter2]) })
-      .to eq({query: {filtered: {query: {match_all: {}}, filter: {and: [:filter1, :filter2]}}}}) }
-
-    specify { expect(_filtered_query { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) })
-      .to eq({query: {filtered: {
-        query: {bool: {must: [:query1, :query2]}},
-        filter: {and: [:filter1, :filter2]}
-      }}})
-    }
-    specify { expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]); update_queries([:query1, :query2]) })
-      .to eq({query: {filtered: {
-        query: {bool: {must: [:query1, :query2]}},
-        filter: {and: [:filter1, :filter2]},
-        strategy: 'query_first'
-      }}})
-    }
-    specify { expect(_filtered_query {
-        update_options(query_mode: :should); update_options(filter_mode: :or);
-        update_filters([:filter1, :filter2]); update_queries([:query1, :query2])
-      }).to eq({query: {filtered: {
-        query: {bool: {should: [:query1, :query2]}},
-        filter: {or: [:filter1, :filter2]}
-      }}})
-    }
+    specify { expect(_filtered_query { update_queries(:query) }).to eq(query: :query) }
+    specify { expect(_filtered_query(strategy: 'query_first') { update_queries(:query) }).to eq(query: :query) }
+    specify do
+      expect(_filtered_query { update_queries([:query1, :query2]) })
+        .to eq(query: { bool: { must: [:query1, :query2] } })
+    end
+    specify do
+      expect(_filtered_query do
+        update_options(query_mode: :should)
+        update_queries([:query1, :query2])
+      end)
+        .to eq(query: { bool: { should: [:query1, :query2] } })
+    end
+    specify do
+      expect(_filtered_query do
+        update_options(query_mode: :dis_max)
+        update_queries([:query1, :query2])
+      end)
+        .to eq(query: { dis_max: { queries: [:query1, :query2] } })
+    end
+
+    specify do
+      expect(_filtered_query(strategy: 'query_first') { update_filters([:filter1, :filter2]) })
+        .to eq(query: { filtered: { query: { match_all: {} }, filter: { and: [:filter1, :filter2] }, strategy: 'query_first' } })
+    end
+    specify do
+      expect(_filtered_query { update_filters([:filter1, :filter2]) })
+        .to eq(query: { filtered: { query: { match_all: {} }, filter: { and: [:filter1, :filter2] } } })
+    end
+
+    specify do
+      expect(_filtered_query do
+        update_filters([:filter1, :filter2])
+        update_queries([:query1, :query2])
+      end)
+        .to eq(query: { filtered: {
+                 query: { bool: { must: [:query1, :query2] } },
+                 filter: { and: [:filter1, :filter2] }
+               } })
+    end
+    specify do
+      expect(_filtered_query(strategy: 'query_first') do
+        update_filters([:filter1, :filter2])
+        update_queries([:query1, :query2])
+      end)
+        .to eq(query: { filtered: {
+                 query: { bool: { must: [:query1, :query2] } },
+                 filter: { and: [:filter1, :filter2] },
+                 strategy: 'query_first'
+               } })
+    end
+    specify do
+      expect(_filtered_query do
+               update_options(query_mode: :should)
+               update_options(filter_mode: :or)
+               update_filters([:filter1, :filter2])
+               update_queries([:query1, :query2])
+             end).to eq(query: { filtered: {
+                          query: { bool: { should: [:query1, :query2] } },
+                          filter: { or: [:filter1, :filter2] }
+                        } })
+    end
   end
 
-  describe "#_boost_query" do
-    specify { expect(subject.send(:_boost_query, query: :query)).to eq(query: :query) }
-    specify {
-      subject.update_scores({ boost_factor: 5 })
-      expect(subject.send(:_boost_query, query: :query)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
-    }
-    specify {
-      subject.update_scores({ boost_factor: 5 })
+  describe '#_boost_query' do
+    specify do
+      expect(subject.send(:_boost_query, query: :query))
+        .to eq(query: :query)
+    end
+    specify do
+      subject.update_scores(boost_factor: 5)
+      expect(subject.send(:_boost_query, query: :query))
+        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query } })
+    end
+    specify do
+      subject.update_scores(boost_factor: 5)
       subject.update_options(boost_mode: :multiply)
       subject.update_options(score_mode: :add)
-      expect(subject.send(:_boost_query, query: :query)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
-    }
-    specify {
-      subject.update_scores({ boost_factor: 5 })
-      expect(subject.send(:_boost_query, query: :query, filter: :filter)).to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
-    }
+      expect(subject.send(:_boost_query, query: :query))
+        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: :query, boost_mode: :multiply, score_mode: :add } })
+    end
+    specify do
+      subject.update_scores(boost_factor: 5)
+      expect(subject.send(:_boost_query, query: :query, filter: :filter))
+        .to eq(query: { function_score: { functions: [{ boost_factor: 5 }], query: { filtered: { query: :query, filter: :filter } } } })
+    end
   end
 
   describe '#_request_filter' do
-    def _request_filter &block
+    def _request_filter(&block)
       subject.instance_exec(&block) if block
       subject.send(:_request_filter)
     end
 
     specify { expect(_request_filter).to be_nil }
 
-    specify { expect(_request_filter { update_types(:type) }).to eq({type: {value: 'type'}}) }
-    specify { expect(_request_filter { update_types([:type1, :type2]) })
-      .to eq({or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}) }
-
-    specify { expect(_request_filter { update_filters([:filter1, :filter2]) })
-      .to eq({and: [:filter1, :filter2]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :or); update_filters([:filter1, :filter2]) })
-      .to eq({or: [:filter1, :filter2]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :must); update_filters([:filter1, :filter2]) })
-      .to eq({bool: {must: [:filter1, :filter2]}}) }
-    specify { expect(_request_filter { update_options(filter_mode: :should); update_filters([:filter1, :filter2]) })
-      .to eq({bool: {should: [:filter1, :filter2]}}) }
-    specify { expect(_request_filter { update_options(filter_mode: :must_not); update_filters([:filter1, :filter2]) })
-      .to eq({bool: {must_not: [:filter1, :filter2]}}) }
-
-    specify { expect(_request_filter { update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
-      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, :filter1, :filter2]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :or); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
-      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {or: [:filter1, :filter2]}]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :must); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
-      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must: [:filter1, :filter2]}}]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :should); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
-      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {should: [:filter1, :filter2]}}]}) }
-    specify { expect(_request_filter { update_options(filter_mode: :must_not); update_types([:type1, :type2]); update_filters([:filter1, :filter2]) })
-      .to eq({and: [{or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}, {bool: {must_not: [:filter1, :filter2]}}]}) }
+    specify { expect(_request_filter { update_types(:type) }).to eq(type: { value: 'type' }) }
+    specify do
+      expect(_request_filter { update_types([:type1, :type2]) })
+        .to eq(or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }])
+    end
+
+    specify do
+      expect(_request_filter { update_filters([:filter1, :filter2]) })
+        .to eq(and: [:filter1, :filter2])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :or)
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(or: [:filter1, :filter2])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :must)
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(bool: { must: [:filter1, :filter2] })
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :should)
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(bool: { should: [:filter1, :filter2] })
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :must_not)
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(bool: { must_not: [:filter1, :filter2] })
+    end
+
+    specify do
+      expect(_request_filter do
+        update_types([:type1, :type2])
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, :filter1, :filter2])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :or)
+        update_types([:type1, :type2])
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { or: [:filter1, :filter2] }])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :must)
+        update_types([:type1, :type2])
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { must: [:filter1, :filter2] } }])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :should)
+        update_types([:type1, :type2])
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { should: [:filter1, :filter2] } }])
+    end
+    specify do
+      expect(_request_filter do
+        update_options(filter_mode: :must_not)
+        update_types([:type1, :type2])
+        update_filters([:filter1, :filter2])
+      end)
+        .to eq(and: [{ or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }] }, { bool: { must_not: [:filter1, :filter2] } }])
+    end
   end
 
   describe '#_request_post_filter' do
-    def _request_post_filter &block
+    def _request_post_filter(&block)
       subject.instance_exec(&block) if block
       subject.send(:_request_post_filter)
     end
 
     specify { expect(_request_post_filter).to be_nil }
 
-    specify { expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
-      .to eq({and: [:post_filter1, :post_filter2]}) }
-    specify { expect(_request_post_filter { update_options(post_filter_mode: :or); update_post_filters([:post_filter1, :post_filter2]) })
-      .to eq({or: [:post_filter1, :post_filter2]}) }
-    specify { expect(_request_post_filter { update_options(post_filter_mode: :must); update_post_filters([:post_filter1, :post_filter2]) })
-      .to eq({bool: {must: [:post_filter1, :post_filter2]}}) }
-    specify { expect(_request_post_filter { update_options(post_filter_mode: :should); update_post_filters([:post_filter1, :post_filter2]) })
-      .to eq({bool: {should: [:post_filter1, :post_filter2]}}) }
+    specify do
+      expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
+        .to eq(and: [:post_filter1, :post_filter2])
+    end
+    specify do
+      expect(_request_post_filter do
+        update_options(post_filter_mode: :or)
+        update_post_filters([:post_filter1, :post_filter2])
+      end)
+        .to eq(or: [:post_filter1, :post_filter2])
+    end
+    specify do
+      expect(_request_post_filter do
+        update_options(post_filter_mode: :must)
+        update_post_filters([:post_filter1, :post_filter2])
+      end)
+        .to eq(bool: { must: [:post_filter1, :post_filter2] })
+    end
+    specify do
+      expect(_request_post_filter do
+        update_options(post_filter_mode: :should)
+        update_post_filters([:post_filter1, :post_filter2])
+      end)
+        .to eq(bool: { should: [:post_filter1, :post_filter2] })
+    end
 
     context do
       before { allow(Chewy).to receive_messages(filter_mode: :or) }
 
-      specify { expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
-        .to eq({or: [:post_filter1, :post_filter2]}) }
+      specify do
+        expect(_request_post_filter { update_post_filters([:post_filter1, :post_filter2]) })
+          .to eq(or: [:post_filter1, :post_filter2])
+      end
     end
   end
 
   describe '#_request_types' do
-    def _request_types &block
+    def _request_types(&block)
       subject.instance_exec(&block) if block
       subject.send(:_request_types)
     end
 
     specify { expect(_request_types).to be_nil }
-    specify { expect(_request_types { update_types(:type1) }).to eq({type: {value: 'type1'}}) }
-    specify { expect(_request_types { update_types([:type1, :type2]) })
-      .to eq({or: [{type: {value: 'type1'}}, {type: {value: 'type2'}}]}) }
+    specify { expect(_request_types { update_types(:type1) }).to eq(type: { value: 'type1' }) }
+    specify do
+      expect(_request_types { update_types([:type1, :type2]) })
+        .to eq(or: [{ type: { value: 'type1' } }, { type: { value: 'type2' } }])
+    end
   end
 
   describe '#_queries_join' do
-    def _queries_join *args
+    def _queries_join(*args)
       subject.send(:_queries_join, *args)
     end
 
-    let(:query) { {term: {field: 'value'}} }
+    let(:query) { { term: { field: 'value' } } }
 
     specify { expect(_queries_join([], :dis_max)).to be_nil }
     specify { expect(_queries_join([query], :dis_max)).to eq(query) }
-    specify { expect(_queries_join([query, query], :dis_max)).to eq({dis_max: {queries: [query, query]}}) }
+    specify { expect(_queries_join([query, query], :dis_max)).to eq(dis_max: { queries: [query, query] }) }
 
     specify { expect(_queries_join([], 0.7)).to be_nil }
     specify { expect(_queries_join([query], 0.7)).to eq(query) }
-    specify { expect(_queries_join([query, query], 0.7)).to eq({dis_max: {queries: [query, query], tie_breaker: 0.7}}) }
+    specify { expect(_queries_join([query, query], 0.7)).to eq(dis_max: { queries: [query, query], tie_breaker: 0.7 }) }
 
     specify { expect(_queries_join([], :must)).to be_nil }
     specify { expect(_queries_join([query], :must)).to eq(query) }
-    specify { expect(_queries_join([query, query], :must)).to eq({bool: {must: [query, query]}}) }
+    specify { expect(_queries_join([query, query], :must)).to eq(bool: { must: [query, query] }) }
 
     specify { expect(_queries_join([], :should)).to be_nil }
     specify { expect(_queries_join([query], :should)).to eq(query) }
-    specify { expect(_queries_join([query, query], :should)).to eq({bool: {should: [query, query]}}) }
+    specify { expect(_queries_join([query, query], :should)).to eq(bool: { should: [query, query] }) }
 
     specify { expect(_queries_join([], :must_not)).to be_nil }
-    specify { expect(_queries_join([query], :must_not)).to eq({bool: {must_not: [query]}}) }
-    specify { expect(_queries_join([query, query], :must_not)).to eq({bool: {must_not: [query, query]}}) }
+    specify { expect(_queries_join([query], :must_not)).to eq(bool: { must_not: [query] }) }
+    specify { expect(_queries_join([query, query], :must_not)).to eq(bool: { must_not: [query, query] }) }
 
     specify { expect(_queries_join([], '25%')).to be_nil }
     specify { expect(_queries_join([query], '25%')).to eq(query) }
-    specify { expect(_queries_join([query, query], '25%')).to eq({bool: {should: [query, query], minimum_should_match: '25%'}}) }
+    specify { expect(_queries_join([query, query], '25%')).to eq(bool: { should: [query, query], minimum_should_match: '25%' }) }
   end
 
   describe '#_filters_join' do
-    def _filters_join *args
+    def _filters_join(*args)
       subject.send(:_filters_join, *args)
     end
 
-    let(:filter) { {term: {field: 'value'}} }
+    let(:filter) { { term: { field: 'value' } } }
 
     specify { expect(_filters_join([], :and)).to be_nil }
     specify { expect(_filters_join([filter], :and)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :and)).to eq({and: [filter, filter]}) }
+    specify { expect(_filters_join([filter, filter], :and)).to eq(and: [filter, filter]) }
 
     specify { expect(_filters_join([], :or)).to be_nil }
     specify { expect(_filters_join([filter], :or)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :or)).to eq({or: [filter, filter]}) }
+    specify { expect(_filters_join([filter, filter], :or)).to eq(or: [filter, filter]) }
 
     specify { expect(_filters_join([], :must)).to be_nil }
     specify { expect(_filters_join([filter], :must)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :must)).to eq({bool: {must: [filter, filter]}}) }
+    specify { expect(_filters_join([filter, filter], :must)).to eq(bool: { must: [filter, filter] }) }
 
     specify { expect(_filters_join([], :should)).to be_nil }
     specify { expect(_filters_join([filter], :should)).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], :should)).to eq({bool: {should: [filter, filter]}}) }
+    specify { expect(_filters_join([filter, filter], :should)).to eq(bool: { should: [filter, filter] }) }
 
     specify { expect(_filters_join([], :must_not)).to be_nil }
-    specify { expect(_filters_join([filter], :must_not)).to eq({bool: {must_not: [filter]}}) }
-    specify { expect(_filters_join([filter, filter], :must_not)).to eq({bool: {must_not: [filter, filter]}}) }
+    specify { expect(_filters_join([filter], :must_not)).to eq(bool: { must_not: [filter] }) }
+    specify { expect(_filters_join([filter, filter], :must_not)).to eq(bool: { must_not: [filter, filter] }) }
 
     specify { expect(_filters_join([], '25%')).to be_nil }
     specify { expect(_filters_join([filter], '25%')).to eq(filter) }
-    specify { expect(_filters_join([filter, filter], '25%')).to eq({bool: {should: [filter, filter], minimum_should_match: '25%'}}) }
+    specify { expect(_filters_join([filter, filter], '25%')).to eq(bool: { should: [filter, filter], minimum_should_match: '25%' }) }
   end
 end