chewy 0.8.4 → 7.3.4

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

@@ -0,0 +1,434 @@
+require 'spec_helper'
+
+shared_examples :query_storage do |param_name|
+  subject { described_class.new(must: {foo: 'bar'}, should: {moo: 'baz'}) }
+
+  describe '#initialize' do
+    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 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)
+    end
+  end
+
+  describe '#must' do
+    specify do
+      expect { subject.must(moo: 'baz') }
+        .to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foo: 'bar'}, {moo: 'baz'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.must(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+  end
+
+  describe '#should' do
+    specify do
+      expect { subject.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'}, {foo: 'bar'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.should(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+  end
+
+  describe '#must_not' do
+    specify do
+      expect { subject.must_not(moo: 'baz') }
+        .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: [{moo: 'baz'}], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.must_not(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+  end
+
+  describe '#and' do
+    specify do
+      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)
+    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)
+    end
+
+    specify do
+      expect { subject.and(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      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)
+    end
+
+    context do
+      subject { described_class.new(must: {foo: 'bar'}) }
+
+      specify do
+        expect { subject.and(moo: 'baz') }
+          .to change { subject.value.to_h }
+          .from(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+          .to(must: [{foo: 'bar'}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+      end
+    end
+  end
+
+  describe '#or' do
+    specify do
+      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)
+    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)
+    end
+
+    specify do
+      expect { subject.or(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      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)
+    end
+
+    context do
+      subject { described_class.new(must: {foo: 'bar'}) }
+
+      specify do
+        expect { subject.or(moo: 'baz') }
+          .to change { subject.value.to_h }
+          .from(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+          .to(must: [], should: [{foo: 'bar'}, {moo: 'baz'}], must_not: [], minimum_should_match: nil)
+      end
+    end
+  end
+
+  describe '#not' do
+    specify do
+      expect { subject.not(moo: 'baz') }
+        .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: [{moo: 'baz'}], minimum_should_match: nil)
+    end
+
+    specify do
+      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
+        )
+    end
+
+    specify do
+      expect { subject.not(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      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
+        )
+    end
+
+    context do
+      subject { described_class.new(must: {foo: 'bar'}) }
+
+      specify do
+        expect { subject.not(moo: 'baz') }
+          .to change { subject.value.to_h }
+          .from(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+          .to(must: [{foo: 'bar'}], should: [], must_not: [{moo: 'baz'}], minimum_should_match: nil)
+      end
+    end
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(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: [match: {foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.replace!(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: [{foo: 'bar'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.replace!(foobar: {foo: 'bar'}) }
+        .to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [{foobar: {foo: 'bar'}}], should: [], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        .to(must: [], should: [], must_not: [], minimum_should_match: nil)
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      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)
+    end
+
+    specify do
+      expect { subject.update!(must_not: {moo: 'baz'}) }
+        .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: [{moo: 'baz'}], minimum_should_match: nil)
+    end
+
+    specify do
+      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)
+    end
+
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    context 'minimum_should_match' do
+      specify do
+        expect { subject.update!(minimum_should_match: 2) }
+          .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: [], minimum_should_match: 2)
+      end
+
+      context do
+        before { subject.update!(minimum_should_match: 2) }
+
+        specify do
+          expect { subject.update!(minimum_should_match: 3) }
+            .to change { subject.value.to_h }
+            .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 2)
+            .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 3)
+        end
+
+        specify do
+          expect { subject.update!(minimum_should_match: nil) }
+            .to change { subject.value.to_h }
+            .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 2)
+            .to(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+        end
+      end
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      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)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value.to_h }
+        .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+    end
+
+    specify do
+      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)
+    end
+
+    context do
+      subject { described_class.new(must: {foo: 'bar'}) }
+
+      specify do
+        expect { subject.merge!(described_class.new(moo: 'baz')) }
+          .to change { subject.value.to_h }
+          .from(must: [{foo: 'bar'}], should: [], must_not: [], minimum_should_match: nil)
+          .to(must: [{foo: 'bar'}, {moo: 'baz'}], should: [], must_not: [], minimum_should_match: nil)
+      end
+    end
+
+    context 'minimum_should_match' do
+      specify do
+        expect { subject.merge!(described_class.new(minimum_should_match: 2)) }
+          .not_to change { subject.value.to_h }
+          .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: nil)
+      end
+
+      context do
+        before { subject.update!(minimum_should_match: 2) }
+
+        specify do
+          expect { subject.merge!(described_class.new(must: {doo: 'scooby'}, minimum_should_match: 3)) }
+            .to change { subject.value.to_h }
+            .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 2)
+            .to(must: [
+              {bool: {must: {foo: 'bar'}, should: {moo: 'baz'}, minimum_should_match: 2}},
+              {doo: 'scooby'}
+            ], should: [], must_not: [], minimum_should_match: nil)
+        end
+
+        specify do
+          expect { subject.merge!(described_class.new(should: {doo: 'scooby'}, minimum_should_match: 3)) }
+            .to change { subject.value.to_h }
+            .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 2)
+            .to(must: [
+              {bool: {must: {foo: 'bar'}, should: {moo: 'baz'}, minimum_should_match: 2}},
+              {bool: {should: {doo: 'scooby'}, minimum_should_match: 3}}
+            ], should: [], must_not: [], minimum_should_match: nil)
+        end
+
+        specify do
+          expect { subject.merge!(described_class.new(minimum_should_match: nil)) }
+            .not_to change { subject.value.to_h }
+            .from(must: [{foo: 'bar'}], should: [{moo: 'baz'}], must_not: [], minimum_should_match: 2)
+        end
+      end
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+
+    specify do
+      expect(described_class.new(must: [{foo: 'bar'}]).render)
+        .to eq(param_name => {foo: 'bar'})
+    end
+
+    specify do
+      expect(described_class.new(must: {foo: 'bar'}, minimum_should_match: 2).render)
+        .to eq(param_name => {foo: 'bar'})
+    end
+
+    specify do
+      expect(described_class.new(should: {foo: 'bar'}, minimum_should_match: 2).render)
+        .to eq(param_name => {bool: {should: {foo: 'bar'}, minimum_should_match: 2}})
+    end
+
+    specify do
+      expect(described_class.new(must_not: {foo: 'bar'}, minimum_should_match: 2).render)
+        .to eq(param_name => {bool: {must_not: {foo: 'bar'}}})
+    end
+
+    if param_name == :filter
+      specify do
+        expect(described_class.new(must: [{foo: 'bar'}, {moo: 'baz'}]).render)
+          .to eq(param_name => [{foo: 'bar'}, {moo: 'baz'}])
+      end
+    else
+      specify do
+        expect(described_class.new(must: [{foo: 'bar'}, {moo: 'baz'}]).render)
+          .to eq(param_name => {bool: {must: [{foo: 'bar'}, {moo: 'baz'}]}})
+      end
+    end
+
+    specify do
+      expect(subject.render)
+        .to eq(param_name => {bool: {must: {foo: 'bar'}, should: {moo: 'baz'}}})
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::RequestCache 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(request_cache: false) }
+    specify { expect(subject.render).to eq(request_cache: true) }
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Rescore do
+  subject { described_class.new([{foo: 42}, {bar: 43}]) }
+
+  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(foo: 42).value).to eq([{foo: 42}]) }
+    specify { expect(described_class.new([{foo: 42}, nil]).value).to eq([{foo: 42}]) }
+    specify { expect(subject.value).to eq([{foo: 42}, {bar: 43}]) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from([{foo: 42}, {bar: 43}]).to([])
+    end
+
+    specify do
+      expect { subject.replace!(baz: 44) }
+        .to change { subject.value }
+        .from([{foo: 42}, {bar: 43}])
+        .to([{baz: 44}])
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(baz: 44) }
+        .to change { subject.value }
+        .from([{foo: 42}, {bar: 43}])
+        .to([{foo: 42}, {bar: 43}, {baz: 44}])
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(baz: 44)) }
+        .to change { subject.value }
+        .from([{foo: 42}, {bar: 43}])
+        .to([{foo: 42}, {bar: 43}, {baz: 44}])
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(foo: 42).render).to eq(rescore: [{foo: 42}]) }
+    specify { expect(subject.render).to eq(rescore: [{foo: 42}, {bar: 43}]) }
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/hash_storage_examples'
+
+describe Chewy::Search::Parameters::ScriptFields do
+  it_behaves_like :hash_storage, :script_fields
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::SearchAfter do
+  subject { described_class.new([:foo, 42]) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to be_nil }
+    specify { expect(described_class.new(:foo).value).to eq([:foo]) }
+    specify { expect(described_class.new(nil).value).to be_nil }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(:baz) }.to change { subject.value }.from([:foo, 42]).to([:baz]) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from([:foo, 42]).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(:baz) }.to change { subject.value }.from([:foo, 42]).to([:baz]) }
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from([:foo, 42]) }
+  end
+
+  describe '#merge!' do
+    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
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(:baz).render).to eq(search_after: [:baz]) }
+    specify { expect(subject.render).to eq(search_after: [:foo, 42]) }
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/string_storage_examples'
+
+describe Chewy::Search::Parameters::SearchType do
+  it_behaves_like :string_storage, :search_type
+end