chewy 0.8.4 → 5.1.0

data/spec/chewy/search/pagination/will_paginate_examples.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+shared_examples :will_paginate do |request_base_class|
+  before { Chewy.massacre }
+
+  before do
+    stub_index(:products) do
+      define_type(:product) do
+        field :name
+        field :age, type: 'integer'
+      end
+    end
+  end
+
+  let(:except_fields) { %w[_score _explanation] }
+  let(:request_class) do
+    Class.new(request_base_class).tap do |k|
+      k.include Chewy::Search::Pagination::WillPaginate
+    end
+  end
+  let(:search) { request_class.new(ProductsIndex).order(:age) }
+
+  specify { expect(search.total_pages).to eq(1) } # defaults to 1 on will_paginate
+
+  context do
+    let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+
+    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
+    before { allow(::WillPaginate).to receive_messages(per_page: 3) }
+
+    describe '#page' do
+      specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }
+      specify { expect(search.page(1).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..2]) }
+      specify { expect(search.page(2).map { |e| e.attributes.except(*except_fields) }).to eq(data[3..5]) }
+    end
+
+    describe '#paginate' do
+      specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..7]) }
+      specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..5]) }
+      specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..4]) }
+      specify { expect(search.paginate(per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..3]) }
+    end
+
+    describe '#total_pages' do
+      specify { expect(search.paginate(page: 2, per_page: 5).total_pages).to eq(2) }
+      specify { expect(search.paginate(page: 3, per_page: 2).total_pages).to eq(5) }
+    end
+
+    describe '#total_entries' do
+      specify { expect(search.paginate(page: 1, per_page: 4).total_entries).to eq(10) }
+      specify { expect(search.query(range: {age: {gt: 20}}).limit(3).total_entries).to eq(8) }
+    end
+
+    describe '#load' do
+      specify { expect(search.paginate(per_page: 2, page: 1).load.first.age).to eq(10) }
+      specify { expect(search.paginate(per_page: 2, page: 3).load.first.age).to eq(50) }
+      specify { expect(search.paginate(per_page: 2, page: 3).load.page(2).load.first.age).to eq(30) }
+
+      specify { expect(search.paginate(per_page: 4, page: 1).load.total_count).to eq(10) }
+      specify { expect(search.paginate(per_page: 2, page: 3).load.total_pages).to eq(5) }
+    end
+  end
+end

data/spec/chewy/search/pagination/will_paginate_spec.rb

@@ -0,0 +1,23 @@
+require 'chewy/search/pagination/will_paginate_examples'
+
+describe Chewy::Search::Pagination::WillPaginate do
+  it_behaves_like :will_paginate, Chewy::Search::Request do
+    describe '#objects' do
+      let(:data) { Array.new(12) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+
+      before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
+      before { allow(::WillPaginate).to receive_messages(per_page: 17) }
+
+      # specify { expect(search.current_page).to eq(1) }
+      # specify { expect(search.per_page).to eq(0) }
+      specify { expect(search.objects.class).to eq(WillPaginate::Collection) }
+      specify { expect(search.objects.total_entries).to eq(12) }
+      specify { expect(search.objects.per_page).to eq(17) }
+      specify { expect(search.objects.current_page).to eq(1) }
+      specify { expect(search.paginate(per_page: 2, page: 3).objects.class).to eq(WillPaginate::Collection) }
+      specify { expect(search.paginate(per_page: 2, page: 3).objects.total_entries).to eq(12) }
+      specify { expect(search.paginate(per_page: 2, page: 3).objects.per_page).to eq(2) }
+      specify { expect(search.paginate(per_page: 2, page: 3).objects.current_page).to eq(3) }
+    end
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+shared_examples :bool_storage do |param_name|
+  subject { described_class.new(true) }
+
+  describe '#initialize' do
+    specify { expect(subject.value).to eq(true) }
+    specify { expect(described_class.new.value).to eq(false) }
+    specify { expect(described_class.new(42).value).to eq(true) }
+    specify { expect(described_class.new(nil).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(false) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.update!(false) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.update!(true) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new }
+
+      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
+  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(true)) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(false).to(true) }
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+
+    if param_name.is_a?(Symbol)
+      specify { expect(subject.render).to eq(param_name => true) }
+    else
+      specify { expect(subject.render).to eq(param_name) }
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'chewy/search/parameters/string_array_storage_examples'
+
+describe Chewy::Search::Parameters::DocvalueFields do
+  it_behaves_like :string_array_storage, :docvalue_fields
+end

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

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

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

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

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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+shared_examples :hash_storage do |param_name|
+  subject { described_class.new(field: {foo: 'bar'}) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to eq({}) }
+    specify { expect(described_class.new(nil).value).to eq({}) }
+    specify { expect(subject.value).to eq('field' => {foo: 'bar'}) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from('field' => {foo: 'bar'}).to({})
+    end
+
+    specify do
+      expect { subject.replace!(other: {moo: 'baz'}) }
+        .to change { subject.value }
+        .from('field' => {foo: 'bar'})
+        .to('other' => {moo: 'baz'})
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(other: {moo: 'baz'}) }
+        .to change { subject.value }
+        .from('field' => {foo: 'bar'})
+        .to('field' => {foo: 'bar'}, 'other' => {moo: 'baz'})
+    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(other: {moo: 'baz'})) }
+        .to change { subject.value }
+        .from('field' => {foo: 'bar'})
+        .to('field' => {foo: 'bar'}, 'other' => {moo: 'baz'})
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(field: {foo: 'bar'}).render).to eq(param_name => {'field' => {foo: 'bar'}}) }
+  end
+end

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