chewy 0.9.0 → 5.2.0

data/spec/chewy/runtime_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Chewy::Runtime do
   describe '.version' do
     specify { expect(described_class.version).to be_a(described_class::Version) }
-    specify { expect(described_class.version).to be >= '1.0' }
-    specify { expect(described_class.version).to be < '2.2' }
+    specify { expect(described_class.version).to be >= '2.4' }
+    specify { expect(described_class.version).to be < '6.0' }
   end
 end

data/spec/chewy/search/loader_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Chewy::Search::Loader do
+  before { Chewy.massacre }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+
+    stub_index(:cities) do
+      define_type City do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+
+    stub_index(:countries) do
+      define_type Country do
+        field :name
+        field :rating, type: 'integer'
+      end
+    end
+  end
+
+  before do
+    CitiesIndex.import!(cities: cities)
+    CountriesIndex.import!(countries: countries)
+  end
+
+  let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
+  let(:countries) { Array.new(2) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
+
+  let(:options) { {} }
+  subject { described_class.new(indexes: [CitiesIndex, CountriesIndex], **options) }
+
+  describe '#derive_type' do
+    specify { expect(subject.derive_type('cities', 'city')).to eq(CitiesIndex::City) }
+    specify { expect(subject.derive_type('cities_suffix', 'city')).to eq(CitiesIndex::City) }
+
+    specify { expect { subject.derive_type('cities', 'place') }.to raise_error(Chewy::UnderivableType) }
+    specify { expect { subject.derive_type('whatever', 'city') }.to raise_error(Chewy::UnderivableType) }
+    specify { expect { subject.derive_type('citiessuffix', 'city') }.to raise_error(Chewy::UnderivableType) }
+
+    context do
+      before { CitiesIndex.index_name :boro_goves }
+
+      specify { expect(subject.derive_type('boro_goves', 'city')).to eq(CitiesIndex::City) }
+      specify { expect(subject.derive_type('boro_goves_suffix', 'city')).to eq(CitiesIndex::City) }
+    end
+  end
+
+  describe '#load' do
+    let(:hits) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating).hits }
+
+    specify { expect(subject.load(hits)).to eq([*cities, *countries]) }
+
+    context do
+      let(:options) { {only: 'city'} }
+      specify { expect(subject.load(hits)).to eq([*cities, nil, nil]) }
+    end
+
+    context do
+      let(:options) { {except: 'city'} }
+      specify { expect(subject.load(hits)).to eq([nil, nil, *countries]) }
+    end
+
+    context do
+      let(:options) { {except: %w[city country]} }
+      specify { expect(subject.load(hits)).to eq([nil, nil, nil, nil]) }
+    end
+
+    context 'scopes', :active_record do
+      context do
+        let(:options) { {scope: -> { where('rating > 2') }} }
+        specify { expect(subject.load(hits)).to eq([nil, nil, nil, countries.last]) }
+      end
+
+      context do
+        let(:options) { {country: {scope: -> { where('rating > 2') }}} }
+        specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
+      end
+    end
+
+    context 'scopes', :mongoid do
+      context do
+        let(:options) { {scope: -> { where(:rating.gt => 2) }} }
+        specify { expect(subject.load(hits)).to eq([nil, nil, nil, countries.last]) }
+      end
+
+      context do
+        let(:options) { {country: {scope: -> { where(:rating.gt => 2) }}} }
+        specify { expect(subject.load(hits)).to eq([*cities, nil, countries.last]) }
+      end
+    end
+
+    context 'objects' do
+      before do
+        stub_index(:cities) do
+          define_type :city do
+            field :name
+            field :rating, type: 'integer'
+          end
+        end
+
+        stub_index(:countries) do
+          define_type :country do
+            field :name
+            field :rating, type: 'integer'
+          end
+        end
+      end
+
+      specify { expect(subject.load(hits).map(&:class).uniq).to eq([CitiesIndex::City, CountriesIndex::Country]) }
+      specify { expect(subject.load(hits).map(&:rating)).to eq([*cities, *countries].map(&:rating)) }
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+shared_examples :kaminari 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::Kaminari
+    end
+  end
+  let(:search) { request_class.new(ProductsIndex).order(:age) }
+
+  specify { expect(search.total_pages).to eq(0) }
+
+  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(::Kaminari.config).to receive_messages(default_per_page: 3) }
+
+    describe '#per, #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]) }
+      specify { expect(search.page(2).per(4).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..7]) }
+      specify { expect(search.per(2).page(3).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..5]) }
+      specify { expect(search.per(5).page.map { |e| e.attributes.except(*except_fields) }).to eq(data[0..4]) }
+      specify { expect(search.page.per(4).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..3]) }
+    end
+
+    describe '#total_pages' do
+      specify { expect(search.total_pages).to eq(4) }
+      specify { expect(search.per(5).page(2).total_pages).to eq(2) }
+      specify { expect(search.per(2).page(3).total_pages).to eq(5) }
+    end
+
+    describe '#total_count' do
+      specify { expect(search.per(4).page(1).total_count).to eq(10) }
+      specify { expect(search.query(range: {age: {gt: 20}}).limit(3).total_count).to eq(8) }
+    end
+
+    describe '#load' do
+      specify { expect(search.per(2).page(1).load.first.age).to eq(10) }
+      specify { expect(search.per(2).page(3).load.first.age).to eq(50) }
+      specify { expect(search.per(2).page(3).load.page(2).load.first.age).to eq(30) }
+
+      specify { expect(search.per(4).page(1).load.total_count).to eq(10) }
+      specify { expect(search.per(2).page(3).load.total_pages).to eq(5) }
+    end
+
+    describe '#limit_value' do
+      specify { expect(search.limit_value).to eq(3) }
+      specify { expect(search.per(15).limit_value).to eq(15) }
+    end
+
+    describe '#offset_value' do
+      specify { expect(search.offset_value).to eq(0) }
+      specify { expect(search.page(3).offset_value).to eq(6) }
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'chewy/search/pagination/kaminari_examples'
+
+describe Chewy::Search::Pagination::Kaminari do
+  it_behaves_like :kaminari, 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(::Kaminari.config).to receive_messages(default_per_page: 17) }
+
+      specify { expect(search.objects.class).to eq(Kaminari::PaginatableArray) }
+      specify { expect(search.objects.total_count).to eq(12) }
+      specify { expect(search.objects.limit_value).to eq(17) }
+      specify { expect(search.objects.offset_value).to eq(0) }
+      specify { expect(search.per(2).page(3).objects.class).to eq(Kaminari::PaginatableArray) }
+      specify { expect(search.per(2).page(3).objects.total_count).to eq(12) }
+      specify { expect(search.per(2).page(3).objects.limit_value).to eq(2) }
+      specify { expect(search.per(2).page(3).objects.offset_value).to eq(4) }
+    end
+  end
+end

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