chewy 0.9.0 → 0.10.0

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Chewy::Search::Parameters::RequestCache do
+  subject { described_class.new(true) }
+
+  describe '#initialize' do
+    specify { expect(subject.value).to eq(true) }
+    specify { expect(described_class.new.value).to eq(nil) }
+    specify { expect(described_class.new(42).value).to eq(true) }
+    specify { expect(described_class.new(false).value).to eq(false) }
+  end
+
+  describe '#replace!' do
+    specify { expect { subject.replace!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.replace!(nil) }.to change { subject.value }.from(true).to(nil) }
+  end
+
+  describe '#update!' do
+    specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.update!(false) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.update!(true) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(false) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.update!(nil) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.update!(false) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.update!(true) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#merge!' do
+    specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(true) }
+    specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(true).to(false) }
+    specify { expect { subject.merge!(described_class.new(true)) }.not_to change { subject.value }.from(true) }
+
+    context do
+      subject { described_class.new(false) }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(false)) }.not_to change { subject.value }.from(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(false).to(true) }
+    end
+
+    context do
+      subject { described_class.new }
+
+      specify { expect { subject.merge!(described_class.new) }.not_to change { subject.value }.from(nil) }
+      specify { expect { subject.merge!(described_class.new(false)) }.to change { subject.value }.from(nil).to(false) }
+      specify { expect { subject.merge!(described_class.new(true)) }.to change { subject.value }.from(nil).to(true) }
+    end
+  end
+
+  describe '#render' do
+    specify { expect(described_class.new.render).to be_nil }
+    specify { expect(described_class.new(false).render).to eq(request_cache: false) }
+    specify { expect(subject.render).to eq(request_cache: true) }
+  end
+end

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

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

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

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

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

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

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

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

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