chewy 8.0.0 → 8.1.0

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

@@ -1,162 +0,0 @@
-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 do
-      expect(described_class.new(includes: :foo, excludes: 42).value)
-        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
-    end
-    specify do
-      expect(described_class.new(includes: :foo, excludes: 42, enabled: false).value)
-        .to eq(includes: %w[foo], excludes: %w[42], enabled: true)
-    end
-  end
-
-  describe '#replace!' do
-    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

@@ -1,60 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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/track_total_hits_spec.rb

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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']) }
-
-    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 do
-      expect { subject.only!(%i[offset order]) }
-        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
-    end
-    specify { expect { subject.only!(%i[limit something]) }.to raise_error NameError }
-    specify { expect { subject.only!([]) }.to raise_error ArgumentError }
-  end
-
-  describe '#except!' do
-    subject { described_class.new(limit: 10, offset: 20, order: :foo) }
-
-    specify do
-      expect { subject.except!([:limit]) }
-        .to change { subject.clone }.to(described_class.new(offset: 20, order: :foo))
-    end
-    specify do
-      expect { subject.except!(%i[offset order]) }
-        .to change { subject.clone }.to(described_class.new(limit: 10))
-    end
-    specify { expect { subject.except!(%i[limit something]) }.to raise_error NameError }
-    specify { expect { subject.except!([]) }.to raise_error ArgumentError }
-  end
-
-  describe '#merge!' do
-    let(:first) { described_class.new(offset: 10, order: 'foo') }
-    let(:second) { described_class.new(limit: 20, offset: 20, order: 'bar') }
-    let(:first_clone) { first.clone }
-    let(:second_clone) { second.clone }
-
-    specify do
-      expect { first.merge!(second) }.to change { first.clone }
-        .to(described_class.new(limit: 20, offset: 20, order: %w[foo bar]))
-    end
-    specify { expect { first.merge!(second) }.not_to change { second_clone } }
-
-    specify 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(ignore_unavailable: true) }
-      specify { expect(subject.render).to eq(body: {}, ignore_unavailable: true) }
-    end
-
-    context do
-      subject { described_class.new(query: {foo: 'bar'}, filter: {moo: 'baz'}) }
-      specify { expect(subject.render).to eq(body: {query: {bool: {must: {foo: 'bar'}, filter: {moo: 'baz'}}}}) }
-    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: {match_none: {}}}) }
-    end
-  end
-end