chewy 0.9.0 → 5.2.0

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

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

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

@@ -0,0 +1,191 @@
+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
+  end
+
+  subject { described_class.new(indices: FirstIndex, types: SecondIndex::Three) }
+
+  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]) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [], types: [])
+    end
+
+    specify do
+      expect { subject.replace!(indices: SecondIndex, types: FirstIndex::One) }
+        .to change { subject.value }
+        .from(indices: [FirstIndex], types: [SecondIndex::Three])
+        .to(indices: [SecondIndex], types: [FirstIndex::One])
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(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])
+    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(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])
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to eq({}) }
+    specify do
+      expect(described_class.new(
+        indices: FirstIndex
+      ).render).to eq(index: %w[first], type: %w[one two])
+    end
+    specify do
+      expect(described_class.new(
+        indices: :whatever
+      ).render).to eq(index: %w[whatever])
+    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])
+    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]))
+        .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))
+    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
+      )
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+shared_examples :integer_storage do |param_name|
+  subject { described_class.new(10) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to be_nil }
+    specify { expect(described_class.new('42').value).to eq(42) }
+    specify { expect(described_class.new(33.3).value).to eq(33) }
+    specify { expect(described_class.new(nil).value).to be_nil }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(42) }.to change { subject.value }.from(10).to(42) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from(10).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!('42') }.to change { subject.value }.from(10).to(42) }
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(10) }
+  end
+
+  describe '#merge!' do
+    specify { expect { subject.merge!(described_class.new('33')) }.to change { subject.value }.from(10).to(33) }
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(10) }
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new('42').render).to eq(param_name => 42) }
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/integer_storage_examples'
+
+describe Chewy::Search::Parameters::Limit do
+  it_behaves_like :integer_storage, :size
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Load do
+  subject { described_class.new(only: :foo) }
+
+  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(scope: {'type' => :foo}).value).to eq(scope: {type: :foo}) }
+    specify { expect(subject.value).to eq(only: :foo) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(only: :foo).to({})
+    end
+
+    specify do
+      expect { subject.replace!('except' => :bar) }
+        .to change { subject.value }
+        .from(only: :foo)
+        .to(except: :bar)
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!('except' => :bar) }
+        .to change { subject.value }
+        .from(only: :foo)
+        .to(only: :foo, except: :bar)
+    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('except' => :bar)) }
+        .to change { subject.value }
+        .from(only: :foo)
+        .to(only: :foo, except: :bar)
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(only: :foo).render).to be_nil }
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::MinScore do
+  subject { described_class.new(0.5) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to be_nil }
+    specify { expect(described_class.new('1.4').value).to eq(1.4) }
+    specify { expect(described_class.new(2).value).to eq(2.0) }
+    specify { expect(described_class.new(nil).value).to be_nil }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(1.4) }.to change { subject.value }.from(0.5).to(1.4) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from(0.5).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!('1.4') }.to change { subject.value }.from(0.5).to(1.4) }
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(0.5) }
+  end
+
+  describe '#merge!' do
+    specify { expect { subject.merge!(described_class.new('2')) }.to change { subject.value }.from(0.5).to(2.0) }
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(0.5) }
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new('1.4').render).to eq(min_score: 1.4) }
+  end
+end

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

@@ -0,0 +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: {}}}}}}
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/integer_storage_examples'
+
+describe Chewy::Search::Parameters::Offset do
+  it_behaves_like :integer_storage, :from
+end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+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) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(foo: {}) }
+        .to change { subject.value }
+        .from('foo' => nil, 'bar' => nil).to('foo' => {})
+    end
+
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from('foo' => nil, 'bar' => nil).to({})
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(foo: {}) }
+        .to change { subject.value }
+        .from('foo' => nil, 'bar' => nil).to('foo' => {}, 'bar' => nil)
+    end
+
+    specify { expect { subject.update!(nil) }.not_to change { subject.value } }
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new(foo: {})) }
+        .to change { subject.value }
+        .from('foo' => nil, 'bar' => nil).to('foo' => {}, 'bar' => nil)
+    end
+
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value } }
+  end
+
+  describe '#render' 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']) }
+  end
+
+  describe '#==' do
+    specify { expect(described_class.new).to eq(described_class.new) }
+    specify { expect(described_class.new(:foo)).to eq(described_class.new(:foo)) }
+    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(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})) }
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/query_storage_examples'
+
+describe Chewy::Search::Parameters::PostFilter do
+  it_behaves_like :query_storage, :post_filter
+end

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

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

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

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

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/query_storage_examples'
+
+describe Chewy::Search::Parameters::Query do
+  it_behaves_like :query_storage, :query
+end

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

@@ -0,0 +1,388 @@
+require 'spec_helper'
+
+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(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(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