chewy 0.8.4 → 5.1.0

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

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Source do
+  subject { described_class.new(%i[foo bar]) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to eq(includes: [], excludes: [], enabled: true) }
+    specify { expect(described_class.new(nil).value).to eq(includes: [], excludes: [], enabled: true) }
+    specify { expect(described_class.new([:foo, nil]).value).to eq(includes: %w[foo], excludes: [], enabled: true) }
+    specify { expect(described_class.new([:foo, 42]).value).to eq(includes: %w[foo 42], excludes: [], enabled: true) }
+    specify { expect(described_class.new(false).value).to eq(includes: [], excludes: [], enabled: false) }
+    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) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: [], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.replace!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo baz], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.replace!(excludes: 42) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: [], excludes: %w[42], enabled: true)
+    end
+
+    specify do
+      expect { subject.replace!(false) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: [], excludes: [], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.replace!(true) }
+          .to change { subject.value }
+          .from(includes: %w[foo bar], excludes: [], enabled: false)
+          .to(includes: [], excludes: [], enabled: true)
+      end
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.update!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar baz], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.update!(excludes: 42) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar], excludes: %w[42], enabled: true)
+    end
+
+    specify do
+      expect { subject.update!(false) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar], excludes: [], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.update!(true) }
+          .to change { subject.value }
+          .from(includes: %w[foo bar], excludes: [], enabled: false)
+          .to(includes: %w[foo bar], excludes: [], enabled: true)
+      end
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(%i[foo baz])) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar baz], excludes: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(excludes: 42)) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar], excludes: %w[42], enabled: true)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(:baz).tap { |i| i.update!(false) }) }
+        .to change { subject.value }
+        .from(includes: %w[foo bar], excludes: [], enabled: true)
+        .to(includes: %w[foo bar baz], excludes: [], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.merge!(described_class.new(excludes: :baz).tap { |i| i.update!(true) }) }
+          .to change { subject.value }
+          .from(includes: %w[foo bar], excludes: [], enabled: false)
+          .to(includes: %w[foo bar], excludes: %w[baz], enabled: true)
+      end
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(:foo).render).to eq(_source: %w[foo]) }
+    specify { expect(described_class.new(excludes: :foo).render).to eq(_source: {excludes: %w[foo]}) }
+    specify do
+      expect(described_class.new(includes: :foo, excludes: 42).render)
+        .to eq(_source: {includes: %w[foo], excludes: %w[42]})
+    end
+
+    specify { expect(described_class.new(false).render).to eq(_source: false) }
+
+    context do
+      before { subject.update!(false) }
+      specify { expect(subject.render).to eq(_source: false) }
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::Storage do
+  subject { described_class.new }
+
+  describe '.param_name' do
+    specify { expect(described_class.param_name).to eq(:storage) }
+
+    context do
+      before { stub_class('Namespace::CustomParamName', Class.new(described_class)) }
+      specify { expect(Namespace::CustomParamName.param_name).to eq(:custom_param_name) }
+    end
+  end
+
+  describe '.param_name=' do
+    before { stub_class('Namespace::Whatever', Class.new(described_class)) }
+    specify do
+      expect { Namespace::Whatever.param_name = :custom }
+        .to change { Namespace::Whatever.param_name }.from(:whatever).to(:custom)
+    end
+  end
+
+  describe '#initialize' do
+    specify { expect(subject.value).to be_nil }
+    specify { expect(described_class.new(a: 1).value).to eq(a: 1) }
+  end
+
+  describe '#==' do
+    specify { expect(subject).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)) }
+
+    context do
+      let(:other_value) { Class.new(described_class) }
+      specify { expect(other_value.new(:foo)).not_to eq(described_class.new(:foo)) }
+      specify { expect(other_value.new(:foo)).to eq(other_value.new(:foo)) }
+    end
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(42) }.to change { subject.value }.from(nil).to(42) }
+    specify { expect { subject.replace!('42') }.to change { subject.value }.from(nil).to('42') }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(true) }.to change { subject.value }.from(nil).to(true) }
+    specify { expect { subject.update!(:symbol) }.to change { subject.value }.from(nil).to(:symbol) }
+  end
+
+  describe '#merge!' do
+    let(:other) { described_class.new(['something']) }
+    specify { expect { subject.merge!(other) }.to change { subject.value }.from(nil).to(['something']) }
+  end
+
+  describe '#render' do
+    specify { expect(subject.render).to be_nil }
+    specify { expect(described_class.new(false).render).to be_nil }
+    specify { expect(described_class.new('42').render).to eq(storage: '42') }
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::StoredFields do
+  subject { described_class.new(%i[foo bar]) }
+
+  describe '#initialize' do
+    specify { expect(described_class.new.value).to eq(stored_fields: [], enabled: true) }
+    specify { expect(described_class.new(nil).value).to eq(stored_fields: [], enabled: true) }
+    specify { expect(described_class.new(:foo).value).to eq(stored_fields: %w[foo], enabled: true) }
+    specify { expect(described_class.new([:foo, nil]).value).to eq(stored_fields: %w[foo], enabled: true) }
+    specify { expect(described_class.new([:foo, 42]).value).to eq(stored_fields: %w[foo 42], enabled: true) }
+    specify { expect(described_class.new(false).value).to eq(stored_fields: [], enabled: false) }
+    specify { expect(described_class.new(true).value).to eq(stored_fields: [], enabled: true) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: [], enabled: true)
+    end
+
+    specify do
+      expect { subject.replace!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: %w[foo baz], enabled: true)
+    end
+
+    specify do
+      expect { subject.replace!(false) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: [], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.replace!(true) }
+          .to change { subject.value }
+          .from(stored_fields: %w[foo bar], enabled: false)
+          .to(stored_fields: [], enabled: true)
+      end
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+    end
+
+    specify do
+      expect { subject.update!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: %w[foo bar baz], enabled: true)
+    end
+
+    specify do
+      expect { subject.update!(false) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: %w[foo bar], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.update!(true) }
+          .to change { subject.value }
+          .from(stored_fields: %w[foo bar], enabled: false)
+          .to(stored_fields: %w[foo bar], enabled: true)
+      end
+    end
+  end
+
+  describe '#merge!' do
+    specify do
+      expect { subject.merge!(described_class.new) }
+        .not_to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(%i[foo baz])) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: %w[foo bar baz], enabled: true)
+    end
+
+    specify do
+      expect { subject.merge!(described_class.new(:baz).tap { |i| i.update!(false) }) }
+        .to change { subject.value }
+        .from(stored_fields: %w[foo bar], enabled: true)
+        .to(stored_fields: %w[foo bar baz], enabled: false)
+    end
+
+    context do
+      before { subject.update!(false) }
+
+      specify do
+        expect { subject.merge!(described_class.new(:baz).tap { |i| i.update!(true) }) }
+          .to change { subject.value }
+          .from(stored_fields: %w[foo bar], enabled: false)
+          .to(stored_fields: %w[foo bar baz], enabled: true)
+      end
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(:foo).render).to eq(stored_fields: %w[foo]) }
+    specify { expect(described_class.new(false).render).to eq(stored_fields: '_none_') }
+
+    context do
+      before { subject.update!(false) }
+      specify { expect(subject.render).to eq(stored_fields: '_none_') }
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+shared_examples :string_array_storage do |param_name|
+  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(:foo).value).to eq(%w[foo]) }
+    specify { expect(described_class.new([:foo, nil]).value).to eq(%w[foo]) }
+    specify { expect(subject.value).to eq(%w[foo bar]) }
+  end
+
+  describe '#replace!' do
+    specify do
+      expect { subject.replace!(nil) }
+        .to change { subject.value }
+        .from(%w[foo bar]).to([])
+    end
+
+    specify do
+      expect { subject.replace!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(%w[foo bar]).to(%w[foo baz])
+    end
+  end
+
+  describe '#update!' do
+    specify do
+      expect { subject.update!(nil) }
+        .not_to change { subject.value }
+    end
+
+    specify do
+      expect { subject.update!(%i[foo baz]) }
+        .to change { subject.value }
+        .from(%w[foo bar]).to(%w[foo bar 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(%i[foo baz])) }
+        .to change { subject.value }
+        .from(%w[foo bar]).to(%w[foo bar baz])
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+
+    if param_name
+      specify { expect(subject.render).to eq(param_name => %w[foo bar]) }
+    else
+      specify { expect(subject.render).to be_nil }
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/spec/chewy/search/parameters_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters do
+  subject { described_class.new }
+
+  describe '.storages' do
+    specify { expect(described_class.storages[:limit]).to eq(Chewy::Search::Parameters::Limit) }
+  end
+
+  describe '#initialize' do
+    let(:limit) { described_class.storages[:limit].new(3) }
+    subject { described_class.new(limit: limit, order: :foo) }
+
+    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 { described_class.new(offset: limit) }.to raise_error(TypeError) }
+  end
+
+  describe '#storages' do
+    specify { expect(subject.storages).to eq({}) }
+    specify { expect(subject.storages[:limit]).to be_a(Chewy::Search::Parameters::Limit) }
+  end
+
+  describe '#==' do
+    specify { expect(described_class.new(limit: 10)).to eq(described_class.new(limit: 10)) }
+    specify { expect(described_class.new(limit: 10)).to eq(described_class.new(limit: 10, offset: nil)) }
+    specify { expect(described_class.new(limit: 10, offset: 20)).to eq(described_class.new(limit: 10, offset: 20)) }
+    specify { expect(described_class.new(limit: 10)).not_to eq(described_class.new(limit: 20)) }
+    specify { expect(described_class.new(limit: 10)).not_to eq(described_class.new(limit: 10, offset: 20)) }
+  end
+
+  describe '#modify!' do
+    it 'updates the storage value' do
+      expect { subject.modify!(:limit) { replace!(42) } }
+        .to change { subject[:limit].value }
+        .from(nil).to(42)
+    end
+
+    it 'replaces the storage' do
+      expect { subject.modify!(:limit) { replace!(42) } }
+        .to change { subject[:limit].object_id }
+    end
+
+    it 'doesn\'t change the old object' do
+      subject.modify!(:limit) { replace!(42) }
+      old_limit = subject[:limit]
+      subject.modify!(:limit) { replace!(43) }
+      expect(old_limit.value).to eq(42)
+    end
+  end
+
+  describe '#only!' 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 { expect { subject.only!(%i[limit something]) }.to raise_error NameError }
+    specify { expect { subject.only!([]) }.to raise_error ArgumentError }
+  end
+
+  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 { expect { subject.except!(%i[limit something]) }.to raise_error NameError }
+    specify { expect { subject.except!([]) }.to raise_error ArgumentError }
+  end
+
+  describe '#merge!' do
+    let(:first) { described_class.new(offset: 10, order: 'foo') }
+    let(:second) { described_class.new(limit: 20, offset: 20, order: 'bar') }
+
+    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 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 } }
+
+    context 'spawns new storages for the merge' do
+      let(:names) { %i[limit offset order] }
+      def storage_object_ids(params)
+        params.storages.values_at(*names).map(&:object_id)
+      end
+
+      specify { expect(storage_object_ids(first) | storage_object_ids(subject)).to have(6).items }
+      specify { expect(storage_object_ids(second) | storage_object_ids(subject)).to have(6).items }
+    end
+  end
+
+  describe '#render' do
+    subject { described_class.new(offset: 10, order: 'foo') }
+
+    specify { expect(subject.render).to eq(body: {from: 10, sort: ['foo']}) }
+    specify { expect(described_class.new.render).to eq(body: {}) }
+
+    context do
+      subject { described_class.new(request_cache: true) }
+      specify { expect(subject.render).to eq(body: {}, request_cache: true) }
+    end
+
+    context do
+      subject { described_class.new(search_type: 'query_then_fetch') }
+      specify { expect(subject.render).to eq(body: {}, search_type: 'query_then_fetch') }
+    end
+
+    context do
+      subject { described_class.new(allow_partial_search_results: true) }
+      specify { expect(subject.render).to eq(body: {}, allow_partial_search_results: 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'}}}}) }
+    end
+
+    context do
+      subject { described_class.new(query: {should: {foo: 'bar'}}, filter: {moo: 'baz'}) }
+      specify { expect(subject.render).to eq(body: {query: {bool: {should: {foo: 'bar'}, filter: {moo: 'baz'}}}}) }
+    end
+
+    context do
+      subject { described_class.new(query: {must_not: {foo: 'bar'}}, filter: {moo: 'baz'}) }
+      specify { expect(subject.render).to eq(body: {query: {bool: {must_not: {foo: 'bar'}, filter: {moo: 'baz'}}}}) }
+    end
+
+    context do
+      subject { described_class.new(filter: {moo: 'baz'}) }
+      specify { expect(subject.render).to eq(body: {query: {bool: {filter: {moo: 'baz'}}}}) }
+    end
+
+    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: {}}}}}}}) }
+    end
+  end
+end