chewy 5.1.0 → 7.2.7

data/spec/chewy/search/parameters/ignore_unavailable_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::IgnoreUnavailable do
+  subject { described_class.new(true) }
+
+  describe '#initialize' do
+    specify { expect(subject.value).to eq(true) }
+    specify { expect(described_class.new.value).to eq(nil) }
+    specify { expect(described_class.new(42).value).to eq(true) }
+    specify { expect(described_class.new(false).value).to eq(false) }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from(true).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.update!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.update!(true) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(false) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.update!(false) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#merge!' do
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.merge!(described_class.new(true)) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(false)) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(false).render).to eq(ignore_unavailable: false) }
+    specify { expect(subject.render).to eq(ignore_unavailable: true) }
+  end
+end

data/spec/chewy/search/parameters/indices_spec.rb

@@ -2,38 +2,33 @@ require 'spec_helper'
 
 describe Chewy::Search::Parameters::Indices do
   before do
-    stub_index(:first) do
-      define_type :one
-      define_type :two
-    end
-
-    stub_index(:second) do
-      define_type :three
-    end
+    stub_index(:first)
+    stub_index(:second)
+    stub_index(:third)
   end
 
-  subject { described_class.new(indices: FirstIndex, types: SecondIndex::Three) }
+  subject { described_class.new(indices: [FirstIndex, SecondIndex]) }
 
   describe '#initialize' do
-    specify { expect(described_class.new.value).to eq(indices: [], types: []) }
-    specify { expect(described_class.new(nil).value).to eq(indices: [], types: []) }
-    specify { expect(described_class.new(foo: :whatever).value).to eq(indices: [], types: []) }
-    specify { expect(subject.value).to eq(indices: [FirstIndex], types: [SecondIndex::Three]) }
+    specify { expect(described_class.new.value).to eq(indices: []) }
+    specify { expect(described_class.new(nil).value).to eq(indices: []) }
+    specify { expect(described_class.new(foo: :whatever).value).to eq(indices: []) }
+    specify { expect(subject.value).to eq(indices: [FirstIndex, SecondIndex]) }
   end
 
   describe '#replace!' do
     specify do
       expect { subject.replace!(nil) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [], types: [])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [])
     end
 
     specify do
-      expect { subject.replace!(indices: SecondIndex, types: FirstIndex::One) }
+      expect { subject.replace!(indices: SecondIndex) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [SecondIndex], types: [FirstIndex::One])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [SecondIndex])
     end
   end
 
@@ -44,10 +39,10 @@ describe Chewy::Search::Parameters::Indices do
     end
 
     specify do
-      expect { subject.update!(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three]) }
+      expect { subject.update!(indices: ThirdIndex) }
         .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+        .from(indices: [FirstIndex, SecondIndex])
+        .to(indices: [FirstIndex, SecondIndex, ThirdIndex])
     end
   end
 
@@ -58,10 +53,8 @@ describe Chewy::Search::Parameters::Indices do
     end
 
     specify do
-      expect { subject.merge!(described_class.new(indices: SecondIndex, types: [FirstIndex::One, SecondIndex::Three])) }
-        .to change { subject.value }
-        .from(indices: [FirstIndex], types: [SecondIndex::Three])
-        .to(indices: [FirstIndex, SecondIndex], types: [SecondIndex::Three, FirstIndex::One])
+      expect { subject.merge!(described_class.new(indices: SecondIndex)) }
+        .not_to change { subject.value }
     end
   end
 
@@ -70,7 +63,7 @@ describe Chewy::Search::Parameters::Indices do
     specify do
       expect(described_class.new(
         indices: FirstIndex
-      ).render).to eq(index: %w[first], type: %w[one two])
+      ).render).to eq(index: %w[first])
     end
     specify do
       expect(described_class.new(
@@ -79,113 +72,28 @@ describe Chewy::Search::Parameters::Indices do
     end
     specify do
       expect(described_class.new(
-        types: FirstIndex::One
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        types: :whatever
-      ).render).to eq({})
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: SecondIndex::Three
-      ).render).to eq(index: %w[first second], type: %w[one three two])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: :one
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: :whatever
-      ).render).to eq(index: %w[first], type: %w[one two])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: %i[one whatever]
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: :whatever, types: SecondIndex::Three
-      ).render).to eq(index: %w[second whatever], type: %w[three])
-    end
-    specify do
-      expect(described_class.new(
-        indices: :whatever, types: [SecondIndex::Three, :whatever]
-      ).render).to eq(index: %w[second whatever], type: %w[three whatever])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: FirstIndex::One
-      ).render).to eq(index: %w[first whatever], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: [FirstIndex::One, :whatever]
-      ).render).to eq(index: %w[first], type: %w[one])
-    end
-    specify do
-      expect(described_class.new(
-        indices: FirstIndex, types: [SecondIndex::Three, :whatever]
-      ).render).to eq(index: %w[first second], type: %w[one three two])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: [FirstIndex::One, :whatever]
-      ).render).to eq(index: %w[first whatever], type: %w[one whatever])
-    end
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever], types: [SecondIndex::Three, FirstIndex::One]
-      ).render).to eq(index: %w[first second whatever], type: %w[one three])
+        indices: [FirstIndex, :whatever]
+      ).render).to eq(index: %w[first whatever])
     end
   end
 
   describe '#==' do
     specify { expect(described_class.new).to eq(described_class.new) }
     specify do
-      expect(described_class.new(indices: SecondIndex, types: [SecondIndex::Three, :whatever]))
-        .to eq(described_class.new(indices: SecondIndex, types: :whatever))
-    end
-    specify do
-      expect(described_class.new(indices: :first, types: %w[one two]))
+      expect(described_class.new(indices: :first))
         .to eq(described_class.new(indices: FirstIndex))
     end
     specify do
-      expect(described_class.new(indices: FirstIndex, types: SecondIndex::Three))
-        .not_to eq(described_class.new(indices: FirstIndex))
+      expect(described_class.new(indices: FirstIndex))
+        .to eq(described_class.new(indices: FirstIndex))
     end
   end
 
   describe '#indices' do
     specify do
       expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [SecondIndex::Three, :whatever]
-      ).indices).to contain_exactly(FirstIndex, SecondIndex)
-    end
-  end
-
-  describe '#types' do
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [SecondIndex::Three, :whatever]
-      ).types).to contain_exactly(
-        FirstIndex::One, FirstIndex::Two, SecondIndex::Three
-      )
-    end
-
-    specify do
-      expect(described_class.new(
-        indices: [FirstIndex, :whatever],
-        types: [FirstIndex::One, SecondIndex::Three, :whatever]
-      ).types).to contain_exactly(
-        FirstIndex::One, SecondIndex::Three
-      )
+        indices: [FirstIndex, :whatever]
+      ).indices).to contain_exactly(FirstIndex)
     end
   end
 end

data/spec/chewy/search/parameters/none_spec.rb

@@ -1,5 +1,5 @@
 require 'chewy/search/parameters/bool_storage_examples'
 
 describe Chewy::Search::Parameters::None do
-  it_behaves_like :bool_storage, query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}
+  it_behaves_like :bool_storage, query: {match_none: {}}
 end

data/spec/chewy/search/parameters/order_spec.rb

@@ -4,26 +4,29 @@ describe Chewy::Search::Parameters::Order do
   subject { described_class.new(%i[foo bar]) }
 
   describe '#initialize' do
-    specify { expect(described_class.new.value).to eq({}) }
-    specify { expect(described_class.new(nil).value).to eq({}) }
-    specify { expect(described_class.new('').value).to eq({}) }
-    specify { expect(described_class.new(42).value).to eq('42' => nil) }
-    specify { expect(described_class.new([42, 43]).value).to eq('42' => nil, '43' => nil) }
-    specify { expect(described_class.new(a: 1).value).to eq('a' => 1) }
-    specify { expect(described_class.new(['', 43, a: 1]).value).to eq('a' => 1, '43' => nil) }
+    specify { expect(described_class.new.value).to eq([]) }
+    specify { expect(described_class.new(nil).value).to eq([]) }
+    specify { expect(described_class.new('').value).to eq([]) }
+    specify { expect(described_class.new(42).value).to eq(['42']) }
+    specify { expect(described_class.new([42, 43]).value).to eq(%w[42 43]) }
+    specify { expect(described_class.new([42, 42]).value).to eq(%w[42 42]) }
+    specify { expect(described_class.new([42, [43, 44]]).value).to eq(%w[42 43 44]) }
+    specify { expect(described_class.new(a: 1).value).to eq([{'a' => 1}]) }
+    specify { expect(described_class.new(['a', {a: 1}, {a: 2}]).value).to eq(['a', {'a' => 1}, {'a' => 2}]) }
+    specify { expect(described_class.new(['', 43, {a: 1}]).value).to eq(['43', {'a' => 1}]) }
   end
 
   describe '#replace!' do
     specify do
       expect { subject.replace!(foo: {}) }
         .to change { subject.value }
-        .from('foo' => nil, 'bar' => nil).to('foo' => {})
+        .from(%w[foo bar]).to([{'foo' => {}}])
     end
 
     specify do
       expect { subject.replace!(nil) }
         .to change { subject.value }
-        .from('foo' => nil, 'bar' => nil).to({})
+        .from(%w[foo bar]).to([])
     end
   end
 
@@ -31,7 +34,7 @@ describe Chewy::Search::Parameters::Order do
     specify do
       expect { subject.update!(foo: {}) }
         .to change { subject.value }
-        .from('foo' => nil, 'bar' => nil).to('foo' => {}, 'bar' => nil)
+        .from(%w[foo bar]).to(['foo', 'bar', {'foo' => {}}])
     end
 
     specify { expect { subject.update!(nil) }.not_to change { subject.value } }
@@ -41,7 +44,7 @@ describe Chewy::Search::Parameters::Order do
     specify do
       expect { subject.merge!(described_class.new(foo: {})) }
         .to change { subject.value }
-        .from('foo' => nil, 'bar' => nil).to('foo' => {}, 'bar' => nil)
+        .from(%w[foo bar]).to(['foo', 'bar', {'foo' => {}}])
     end
 
     specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value } }
@@ -51,6 +54,7 @@ describe Chewy::Search::Parameters::Order do
     specify { expect(described_class.new.render).to be_nil }
     specify { expect(described_class.new(:foo).render).to eq(sort: ['foo']) }
     specify { expect(described_class.new([:foo, {bar: 42}, :baz]).render).to eq(sort: ['foo', {'bar' => 42}, 'baz']) }
+    specify { expect(described_class.new([:foo, {bar: 42}, {bar: 43}, :baz]).render).to eq(sort: ['foo', {'bar' => 42}, {'bar' => 43}, 'baz']) }
   end
 
   describe '#==' do
@@ -59,7 +63,10 @@ describe Chewy::Search::Parameters::Order do
     specify { expect(described_class.new(:foo)).not_to eq(described_class.new(:bar)) }
     specify { expect(described_class.new(%i[foo bar])).to eq(described_class.new(%i[foo bar])) }
     specify { expect(described_class.new(%i[foo bar])).not_to eq(described_class.new(%i[bar foo])) }
+    specify { expect(described_class.new(%i[foo foo])).not_to eq(described_class.new(%i[foo])) }
     specify { expect(described_class.new(foo: {a: 42})).to eq(described_class.new(foo: {a: 42})) }
     specify { expect(described_class.new(foo: {a: 42})).not_to eq(described_class.new(foo: {b: 42})) }
+    specify { expect(described_class.new(['foo', {'foo' => 42}])).not_to eq(described_class.new([{'foo' => 42}, 'foo'])) }
+    specify { expect(described_class.new([{'foo' => 42}, {'foo' => 43}])).not_to eq(described_class.new([{'foo' => 43}, {'foo' => 42}])) }
   end
 end

data/spec/chewy/search/parameters/query_storage_examples.rb

@@ -4,19 +4,46 @@ shared_examples :query_storage do |param_name|
   subject { described_class.new(must: {foo: 'bar'}, should: {moo: 'baz'}) }
 
   describe '#initialize' do
-    specify { expect(described_class.new.value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(nil).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(foobar: {}).value.to_h).to eq(must: [{foobar: {}}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(must: {}, should: {}, must_not: {}).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: nil) }
+    specify do
+      expect(described_class.new.value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(nil).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(foobar: {}).value.to_h)
+        .to eq(must: [{foobar: {}}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(must: {}, should: {}, must_not: {}).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
     specify do
       expect(described_class.new(must: {foo: 'bar'}, should: {foo: 'bar'}, foobar: {}).value.to_h)
         .to eq(must: [{foo: 'bar'}], should: [{foo: 'bar'}], must_not: [], minimum_should_match: nil)
     end
-    specify { expect(subject.value.to_h).to eq(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(proc { match foo: 'bar' }).value.to_h).to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(must: proc { match foo: 'bar' }).value.to_h).to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil) }
-    specify { expect(described_class.new(minimum_should_match: 3).value.to_h).to eq(must: [], should: [], must_not: [], minimum_should_match: 3) }
-    specify { expect(described_class.new(must: {foo: 'bar'}, minimum_should_match: 3).value.to_h).to eq(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: 3) }
+    specify do
+      expect(subject.value.to_h)
+        .to eq(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(proc { match foo: 'bar' }).value.to_h)
+        .to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(must: proc { match foo: 'bar' }).value.to_h)
+        .to eq(must: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+    end
+    specify do
+      expect(described_class.new(minimum_should_match: 3).value.to_h)
+        .to eq(must: [], should: [], must_not: [], minimum_should_match: 3)
+    end
+    specify do
+      expect(described_class.new(must: {foo: 'bar'}, minimum_should_match: 3).value.to_h)
+        .to eq(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: 3)
+    end
     specify do
       expect(described_class.new(must: [proc { match foo: 'bar' }, {moo: 'baz'}]).value.to_h)
         .to eq(must: [{match: {foo: 'bar'}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
@@ -73,14 +100,16 @@ shared_examples :query_storage do |param_name|
       expect { subject.and(moo: 'baz') }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
       expect { subject.and([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -93,7 +122,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.and(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     context do
@@ -113,14 +143,16 @@ shared_examples :query_storage do |param_name|
       expect { subject.or(moo: 'baz') }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               {moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
       expect { subject.or([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -133,7 +165,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.or(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                               {bool: {should: {foo: 'bar'}}}], must_not: [], minimum_should_match: nil)
     end
 
     context do
@@ -160,7 +193,12 @@ shared_examples :query_storage do |param_name|
       expect { subject.not([{moo: 'baz'}, {doo: 'scooby'}]) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [{bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}}], minimum_should_match: nil)
+        .to(
+          must: [{foo: 'bar'}],
+          should: [{moo: 'baz'}],
+          must_not: [{bool: {must: [{moo: 'baz'}, {doo: 'scooby'}]}}],
+          minimum_should_match: nil
+        )
     end
 
     specify do
@@ -173,7 +211,11 @@ shared_examples :query_storage do |param_name|
       expect { subject.not(should: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [{bool: {should: {foo: 'bar'}}}], minimum_should_match: nil)
+        .to(
+          must: [{foo: 'bar'}], should: [{moo: 'baz'}],
+          must_not: [{bool: {should: {foo: 'bar'}}}],
+          minimum_should_match: nil
+        )
     end
 
     context do
@@ -223,7 +265,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.update!(must: proc { match foo: 'bar' }) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}, {match: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foo: 'bar'},
+                   {match: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -237,7 +280,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.update!(foobar: {foo: 'bar'}) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{foo: 'bar'}, {foobar: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foo: 'bar'},
+                   {foobar: {foo: 'bar'}}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -279,7 +323,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.merge!(described_class.new(moo: 'baz')) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     specify do
@@ -292,7 +337,8 @@ shared_examples :query_storage do |param_name|
       expect { subject.merge!(described_class.new(should: {foo: 'bar'})) }
         .to change { subject.value.to_h }
         .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
-        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}}, {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
+        .to(must: [{bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}},
+                   {bool: {should: {foo: 'bar'}}}], should: [], must_not: [], minimum_should_match: nil)
     end
 
     context do

data/spec/chewy/search/parameters/search_after_spec.rb

@@ -20,7 +20,10 @@ describe Chewy::Search::Parameters::SearchAfter do
   end
 
   describe '#merge!' do
-    specify { expect { subject.merge!(described_class.new(:baz)) }.to change { subject.value }.from([:foo, 42]).to([:baz]) }
+    specify do
+      expect { subject.merge!(described_class.new(:baz)) }
+        .to change { subject.value }.from([:foo, 42]).to([:baz])
+    end
     specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from([:foo, 42]) }
   end
 

data/spec/chewy/search/parameters/source_spec.rb

@@ -12,8 +12,14 @@ describe Chewy::Search::Parameters::Source do
     specify { expect(described_class.new(true).value).to eq(includes: [], excludes: [], enabled: true) }
     specify { expect(described_class.new(a: 1).value).to eq(includes: [], excludes: [], enabled: true) }
     specify { expect(described_class.new(includes: :foo).value).to eq(includes: %w[foo], excludes: [], enabled: true) }
-    specify { expect(described_class.new(includes: :foo, excludes: 42).value).to eq(includes: %w[foo], excludes: %w[42], enabled: true) }
-    specify { expect(described_class.new(includes: :foo, excludes: 42, enabled: false).value).to eq(includes: %w[foo], excludes: %w[42], enabled: true) }
+    specify do
+      expect(described_class.new(includes: :foo, excludes: 42).value)
+        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
+    end
+    specify do
+      expect(described_class.new(includes: :foo, excludes: 42, enabled: false).value)
+        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
+    end
   end
 
   describe '#replace!' do

data/spec/chewy/search/parameters/track_total_hits_spec.rb

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/bool_storage_examples'
+
+describe Chewy::Search::Parameters::TrackTotalHits do
+  it_behaves_like :bool_storage, :track_total_hits
+end

data/spec/chewy/search/parameters_spec.rb

@@ -13,7 +13,7 @@ describe Chewy::Search::Parameters do
 
     specify { expect(subject.storages[:limit]).to equal(limit) }
     specify { expect(subject.storages[:limit].value).to eq(3) }
-    specify { expect(subject.storages[:order].value).to eq('foo' => nil) }
+    specify { expect(subject.storages[:order].value).to eq(['foo']) }
 
     specify { expect { described_class.new(offset: limit) }.to raise_error(TypeError) }
   end
@@ -55,7 +55,10 @@ describe Chewy::Search::Parameters do
     subject { described_class.new(limit: 10, offset: 20, order: :foo) }
 
     specify { expect { subject.only!([:limit]) }.to change { subject.clone }.to(described_class.new(limit: 10)) }
-    specify { expect { subject.only!(%i[offset order]) }.to change { subject.clone }.to(described_class.new(offset: 20, order: :foo)) }
+    specify do
+      expect { subject.only!(%i[offset order]) }
+        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
+    end
     specify { expect { subject.only!(%i[limit something]) }.to raise_error NameError }
     specify { expect { subject.only!([]) }.to raise_error ArgumentError }
   end
@@ -63,8 +66,14 @@ describe Chewy::Search::Parameters do
   describe '#except!' do
     subject { described_class.new(limit: 10, offset: 20, order: :foo) }
 
-    specify { expect { subject.except!([:limit]) }.to change { subject.clone }.to(described_class.new(offset: 20, order: :foo)) }
-    specify { expect { subject.except!(%i[offset order]) }.to change { subject.clone }.to(described_class.new(limit: 10)) }
+    specify do
+      expect { subject.except!([:limit]) }
+        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
+    end
+    specify do
+      expect { subject.except!(%i[offset order]) }
+        .to change { subject.clone }.to(described_class.new(limit: 10))
+    end
     specify { expect { subject.except!(%i[limit something]) }.to raise_error NameError }
     specify { expect { subject.except!([]) }.to raise_error ArgumentError }
   end
@@ -72,18 +81,20 @@ describe Chewy::Search::Parameters do
   describe '#merge!' do
     let(:first) { described_class.new(offset: 10, order: 'foo') }
     let(:second) { described_class.new(limit: 20, offset: 20, order: 'bar') }
+    let(:first_clone) { first.clone }
+    let(:second_clone) { second.clone }
 
     specify do
       expect { first.merge!(second) }.to change { first.clone }
         .to(described_class.new(limit: 20, offset: 20, order: %w[foo bar]))
     end
-    specify { expect { first.merge!(second) }.not_to change { second.clone } }
+    specify { expect { first.merge!(second) }.not_to change { second_clone } }
 
     specify do
       expect { second.merge!(first) }.to change { second.clone }
         .to(described_class.new(limit: 20, offset: 10, order: %w[bar foo]))
     end
-    specify { expect { second.merge!(first) }.not_to change { first.clone } }
+    specify { expect { second.merge!(first) }.not_to change { first_clone } }
 
     context 'spawns new storages for the merge' do
       let(:names) { %i[limit offset order] }
@@ -117,6 +128,11 @@ describe Chewy::Search::Parameters do
       specify { expect(subject.render).to eq(body: {}, allow_partial_search_results: true) }
     end
 
+    context do
+      subject { described_class.new(ignore_unavailable: true) }
+      specify { expect(subject.render).to eq(body: {}, ignore_unavailable: true) }
+    end
+
     context do
       subject { described_class.new(query: {foo: 'bar'}, filter: {moo: 'baz'}) }
       specify { expect(subject.render).to eq(body: {query: {bool: {must: {foo: 'bar'}, filter: {moo: 'baz'}}}}) }
@@ -139,7 +155,7 @@ describe Chewy::Search::Parameters do
 
     context do
       subject { described_class.new(filter: {moo: 'baz'}, none: true) }
-      specify { expect(subject.render).to eq(body: {query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}}) }
+      specify { expect(subject.render).to eq(body: {query: {match_none: {}}}) }
     end
   end
 end