chewy 0.8.1 → 0.8.2

data/spec/chewy/config_spec.rb

@@ -21,15 +21,19 @@ describe Chewy::Config do
       .to change { Chewy.client.transport.logger }.to(logger) }
     specify { expect { subject.transport_logger = logger }
       .to change { subject.transport_logger }.to(logger) }
+    specify { expect { subject.transport_logger = logger }
+      .to change { subject.configuration[:logger] }.from(nil).to(logger) }
   end
 
   describe '#transport_tracer=' do
-    let(:logger) { Logger.new('/dev/null') }
+    let(:tracer) { Logger.new('/dev/null') }
     after { subject.transport_tracer = nil }
 
-    specify { expect { subject.transport_tracer = logger }
-      .to change { Chewy.client.transport.tracer }.to(logger) }
-    specify { expect { subject.transport_tracer = logger }
-      .to change { subject.transport_tracer }.to(logger) }
+    specify { expect { subject.transport_tracer = tracer }
+      .to change { Chewy.client.transport.tracer }.to(tracer) }
+    specify { expect { subject.transport_tracer = tracer }
+      .to change { subject.transport_tracer }.to(tracer) }
+    specify { expect { subject.transport_tracer = tracer }
+      .to change { subject.configuration[:tracer] }.from(nil).to(tracer) }
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -314,16 +314,20 @@ describe Chewy::Fields::Base do
         stub_model(:city)
         stub_model(:country)
 
-        City.belongs_to :country
-
-        if active_record?
+        case adapter
+        when :active_record
+          City.belongs_to :country
           if ActiveRecord::VERSION::MAJOR >= 4
             Country.has_many :cities, -> { order :id }
           else
             Country.has_many :cities, order: :id
           end
-        else # mongoid
+        when :mongoid
+          City.belongs_to :country
           Country.has_many :cities, order: :id.asc
+        when :sequel
+          City.many_to_one :country
+          Country.one_to_many :cities, order: :id
         end
 
         stub_index(:countries) do
@@ -337,10 +341,20 @@ describe Chewy::Fields::Base do
         end
       end
 
+      let(:country_with_cities) do
+        cities = [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')]
+
+        if adapter == :sequel
+          Country.create(id: 1).tap do |country|
+            cities.each { |city| country.add_city(city) }
+          end
+        else
+          Country.create!(id: 1, cities: cities)
+        end
+      end
+
       specify do
-        expect(CountriesIndex::Country.root_object.compose(
-          Country.create!(id: 1, cities: [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')])
-        )).to eq({
+        expect(CountriesIndex::Country.root_object.compose(country_with_cities)).to eq({
           country: { 'id' => 1, 'cities' => [
             { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
           ] }

data/spec/chewy/index/actions_spec.rb

@@ -54,8 +54,8 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create }
-      specify { expect { DummiesIndex.create! }.to raise_error }
-      specify { expect { DummiesIndex.create!('2013') }.to raise_error }
+      specify { expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies\] already exists\]/) }
+      specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/Invalid alias name \[dummies\]/) }
     end
 
     context do
@@ -64,7 +64,7 @@ describe Chewy::Index::Actions do
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
-      specify { expect { DummiesIndex.create!('2013') }.to raise_error }
+      specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies_2013\] already exists\]/) }
       specify { expect(DummiesIndex.create!('2014')["acknowledged"]).to eq(true) }
 
       context do
@@ -128,8 +128,8 @@ describe Chewy::Index::Actions do
   end
 
   describe '.delete!' do
-    specify { expect { DummiesIndex.delete! }.to raise_error }
-    specify { expect { DummiesIndex.delete!('2013') }.to raise_error }
+    specify { expect { DummiesIndex.delete! }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound) }
+    specify { expect { DummiesIndex.delete!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound) }
 
     context do
       before { DummiesIndex.create }

data/spec/chewy/query_spec.rb

@@ -213,6 +213,75 @@ describe Chewy::Query do
     specify { expect(subject.aggregations(aggregation1: {field: 'hello'}).criteria.aggregations).to include(aggregation1: {field: 'hello'}) }
     specify { expect { subject.aggregations(aggregation1: {field: 'hello'}) }.not_to change { subject.criteria.aggregations } }
 
+    context 'when requesting a named aggregation' do
+
+      before do
+        stub_index(:products) do
+          define_type :product do
+            root do
+              field :name, 'surname'
+              field :title, type: 'string' do
+                field :subfield1
+              end
+              field 'price', type: 'float' do
+                field :subfield2
+              end
+              agg :uniquely_named_agg do
+                { min: { field: 'title.subfield1' } }
+              end
+            end
+          end
+        end
+      end
+      specify { expect(subject.aggregations(:uniquely_named_agg).criteria.aggregations).to include(uniquely_named_agg: { min: { field: 'title.subfield1' } }) }
+
+      context 'when more than one aggregation of the same name exists' do
+        before do
+          stub_index(:products) do
+            define_type :product do
+              root do
+                field :name, 'surname'
+                field :title, type: 'string' do
+                  field :subfield1
+                end
+                field 'price', type: 'float' do
+                  field :subfield2
+                end
+                agg :uniquely_named_agg do
+                  { min: { field: 'title.subfield1' } }
+                end
+                agg :named_agg do
+                  { avg: { field: 'title.subfield1' } }
+                end
+              end
+            end
+            define_type :review do
+              field :title, :body
+              field :comments do
+                field :message
+                field :rating, type: 'long'
+              end
+              agg :named_agg do
+                { avg: { field: 'comments.rating' } }
+              end
+            end
+          end
+        end
+
+        it "is the aggregation definition that was last defined" do
+          expect(subject.aggregations(:named_agg).criteria.aggregations).to include(named_agg: { avg: { field: 'comments.rating' } })
+        end
+
+        context "when the fully qualified aggregation name is provided" do
+          specify { expect(subject
+                               .aggregations("products#product.named_agg")
+                               .criteria
+                               .aggregations)
+                        .to include({ "products#product.named_agg" => { avg: { field: 'title.subfield1' } } }) }
+        end
+      end
+    end
+
     context 'results', :orm do
       before { stub_model(:city) }
       let(:cities) { 10.times.map { |i| City.create! id: i + 1, name: "name#{i}", rating: i % 3 } }

data/spec/chewy/runtime_spec.rb

@@ -4,6 +4,6 @@ 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 < '1.6' }
+    specify { expect(described_class.version).to be < '1.8' }
   end
 end

data/spec/chewy/strategy/active_job_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+if defined?(::ActiveJob)
+  describe Chewy::Strategy::ActiveJob do
+    around { |example| Chewy.strategy(:bypass) { example.run } }
+    before(:all) do
+      ::ActiveJob::Base.logger = Chewy.logger
+    end
+    before do
+      ::ActiveJob::Base.queue_adapter = :test
+      ::ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+      ::ActiveJob::Base.queue_adapter.performed_jobs.clear
+    end
+
+    before do
+      stub_model(:city) do
+        update_index('cities#city') { self }
+      end
+
+      stub_index(:cities) do
+        define_type City
+      end
+    end
+
+    let(:city) { City.create!(name: 'hello') }
+    let(:other_city) { City.create!(name: 'world') }
+
+    specify do
+      expect { [city, other_city].map(&:save!) }
+        .not_to update_index(CitiesIndex::City, strategy: :active_job)
+    end
+
+    specify do
+      Chewy.strategy(:active_job) do
+        [city, other_city].map(&:save!)
+      end
+      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      expect(enqueued_job[:job]).to eq(Chewy::Strategy::ActiveJob::Worker)
+      expect(enqueued_job[:queue]).to eq('chewy')
+    end
+
+    specify do
+      ::ActiveJob::Base.queue_adapter = :inline
+      expect { [city, other_city].map(&:save!) }
+        .to update_index(CitiesIndex::City, strategy: :active_job)
+        .and_reindex(city, other_city)
+    end
+  end
+end

data/spec/chewy/strategy_spec.rb

@@ -14,7 +14,7 @@ describe Chewy::Strategy do
   end
 
   describe '#push' do
-    specify { expect { strategy.push(:unexistant) }.to raise_error }
+    specify { expect { strategy.push(:unexistant) }.to raise_error(NameError).with_message(/uninitialized constant.*Unexistant/) }
 
     specify do
       expect { strategy.push(:atomic) }
@@ -24,7 +24,7 @@ describe Chewy::Strategy do
   end
 
   describe '#pop' do
-    specify { expect { strategy.pop }.to raise_error }
+    specify { expect { strategy.pop }.to raise_error(RuntimeError).with_message(/Can't pop root strategy/) }
 
     specify do
       strategy.push(:urgent)

data/spec/chewy/type/adapter/sequel_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Chewy::Type::Adapter::Sequel, :sequel do
+
+  let(:adapter) { described_class }
+
+  before do
+    stub_model(:city)
+    stub_model(:country)
+  end
+
+  describe '#name' do
+
+    it { expect( adapter.new(City).name ).to eq 'City' }
+    it { expect( adapter.new(City.order(:id)).name ).to eq 'City' }
+    it { expect( adapter.new(City, name: 'town').name ).to eq 'Town' }
+
+    context do
+      before { stub_model('namespace/city') }
+
+      it { expect( adapter.new(Namespace::City).name ).to eq 'City' }
+      it { expect( adapter.new(Namespace::City.order(:id)).name ).to eq 'City' }
+    end
+  end
+
+  describe '#default_dataset' do
+
+    it { expect( adapter.new(City).default_dataset.sql ).to eql City.where(nil).sql }
+    it { expect( adapter.new(City.order(:id)).default_dataset.sql ).to eql City.where(nil).sql }
+    it { expect( adapter.new(City.limit(10)).default_dataset.sql ).to eql City.where(nil).sql  }
+    it { expect( adapter.new(City.offset(10)).default_dataset.sql ).to eql City.where(nil).sql }
+    it { expect( adapter.new(City.where(rating: 10)).default_dataset.sql ).to eql City.where(rating: 10).sql }
+  end
+
+  describe '#identify' do
+    context do
+      subject(:s) { adapter.new(City) }
+      let!(:cities) { 3.times.map { City.new.save } }
+
+      it { expect( s.identify(City.where(nil)) ).to match_array cities.map(&:id) }
+      it { expect( s.identify(cities) ).to eq cities.map(&:id) }
+      it { expect( s.identify(cities.first) ).to eq([cities.first.id]) }
+      it { expect( s.identify(cities.first(2).map(&:pk)) ).to eq cities.first(2).map(&:id) }
+    end
+  end
+end

data/spec/chewy/type/import_spec.rb

@@ -164,7 +164,8 @@ describe Chewy::Type::Import do
             type: CitiesIndex::City,
             errors: {
               index: {
-                'MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]' => ['1', '2', '3']
+                "WriteFailureException; nested: MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]; " => ["1"],
+                "MapperParsingException[object mapping for [city] tried to parse field [name] as object, but got EOF, has a concrete value been provided to it?]" => ["2", "3"]
               }
             },
             import: {index: 3}
@@ -209,7 +210,8 @@ describe Chewy::Type::Import do
 
       before do
         stub_model(:country)
-        stub_model(:city) { belongs_to :country }
+        stub_model(:city)
+        adapter == :sequel ? City.many_to_one(:country) : City.belongs_to(:country)
       end
 
       before do

data/spec/chewy/type/mapping_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Chewy::Type::Mapping do
   let(:product) { ProductsIndex::Product }
+  let(:review)  { ProductsIndex::Review }
 
   before do
     stub_index(:products) do
@@ -14,11 +15,29 @@ describe Chewy::Type::Mapping do
           field 'price', type: 'float' do
             field :subfield2
           end
+          agg :named_agg do
+            { avg: { field: 'title.subfield1' } }
+          end
+        end
+      end
+      define_type :review do
+        field :title, :body
+        field :comments do
+          field :message
+          field :rating, type: 'long'
+        end
+        agg :named_agg do
+          { avg: { field: 'comments.rating' } }
         end
       end
     end
   end
 
+  describe '.agg' do
+    specify { expect(product._agg_defs[:named_agg].call).to eq({ avg: { field: 'title.subfield1' } }) }
+    specify { expect(review._agg_defs[:named_agg].call).to eq({ avg: { field: 'comments.rating' } }) }
+  end
+
   describe '.field' do
     specify { expect(product.root_object.children.map(&:name)).to eq([:name, :surname, :title, :price]) }
     specify { expect(product.root_object.children.map(&:parent)).to eq([product.root_object] * 4) }

data/spec/chewy/type/observe_spec.rb

@@ -10,30 +10,43 @@ describe Chewy::Type::Import do
 
     let(:backreferenced) { 3.times.map { |i| double(id: i) } }
 
-    specify { expect { DummiesIndex.dummy.update_index(backreferenced) }
+    specify { expect { DummiesIndex::Dummy.update_index(backreferenced) }
       .to raise_error Chewy::UndefinedUpdateStrategy }
-    specify { expect { DummiesIndex.dummy.update_index([]) }
+    specify { expect { DummiesIndex::Dummy.update_index([]) }
       .not_to update_index('dummies#dummy') }
-    specify { expect { DummiesIndex.dummy.update_index(nil) }
+    specify { expect { DummiesIndex::Dummy.update_index(nil) }
       .not_to update_index('dummies#dummy') }
   end
 
   context 'integration', :orm do
+    let(:update_condition) { true }
+
     before do
-      stub_model(:city) do
-        update_index('cities#city') { self }
-        update_index 'countries#country' do
-          changes['country_id'] || previous_changes['country_id'] || country
+      city_countries_update_proc = if adapter == :sequel
+          ->(*) { previous_changes.try(:[], :country_id) || country }
+        else
+          ->(*) { changes['country_id'] || previous_changes['country_id'] || country }
         end
+
+      stub_model(:city) do
+        update_index(->(city) { "cities##{city.class.name.underscore}" }) { self }
+        update_index 'countries#country', &city_countries_update_proc
       end
 
       stub_model(:country) do
-        update_index('cities#city') { cities }
-        update_index 'countries#country', :self
+        update_index('cities#city', if: -> { update_condition }) { cities }
+        update_index(->{ "countries##{self.class.name.underscore}" }, :self)
+        attr_accessor :update_condition
       end
 
-      City.belongs_to :country
-      Country.has_many :cities
+      if adapter == :sequel
+        City.many_to_one :country
+        Country.one_to_many :cities
+        City.plugin :dirty
+      else
+        City.belongs_to :country
+        Country.has_many :cities
+      end
 
       stub_index(:cities) do
         define_type City
@@ -45,8 +58,8 @@ describe Chewy::Type::Import do
     end
 
     context do
-      let!(:country1) { Chewy.strategy(:atomic) { Country.create!(id: 1) } }
-      let!(:country2) { Chewy.strategy(:atomic) { Country.create!(id: 2) } }
+      let!(:country1) { Chewy.strategy(:atomic) { Country.create!(id: 1, update_condition: update_condition) } }
+      let!(:country2) { Chewy.strategy(:atomic) { Country.create!(id: 2, update_condition: update_condition) } }
       let!(:city) { Chewy.strategy(:atomic) { City.create!(id: 1, country: country1) } }
 
       specify { expect { city.save! }.to update_index('cities#city').and_reindex(city) }
@@ -60,10 +73,26 @@ describe Chewy::Type::Import do
     end
 
     context do
-      let!(:country) { Chewy.strategy(:atomic) { Country.create!(id: 1, cities: 2.times.map { |i| City.create!(id: i) }) } }
+      let!(:country) do
+        Chewy.strategy(:atomic) do
+          cities = 2.times.map { |i| City.create!(id: i) }
+          if adapter == :sequel
+            Country.create(id: 1, update_condition: update_condition).tap do |country|
+              cities.each { |city| country.add_city(city) }
+            end
+          else
+            Country.create!(id: 1, cities: cities, update_condition: update_condition)
+          end
+        end
+      end
 
       specify { expect { country.save! }.to update_index('cities#city').and_reindex(country.cities) }
       specify { expect { country.save! }.to update_index('countries#country').and_reindex(country) }
+
+      context 'conditional update' do
+        let(:update_condition) { false }
+        specify { expect { country.save! }.not_to update_index('cities#city') }
+      end
     end
   end