chewy 0.8.4 → 5.1.0

data/spec/chewy/type/mapping_spec.rb

@@ -9,14 +9,14 @@ describe Chewy::Type::Mapping do
       define_type :product do
         root do
           field :name, 'surname'
-          field :title, type: 'string' do
+          field :title, type: 'text' do
             field :subfield1
           end
           field 'price', type: 'float' do
             field :subfield2
           end
           agg :named_agg do
-            { avg: { field: 'title.subfield1' } }
+            {avg: {field: 'title.subfield1'}}
           end
         end
       end
@@ -27,34 +27,93 @@ describe Chewy::Type::Mapping do
           field :rating, type: 'long'
         end
         agg :named_agg do
-          { avg: { field: 'comments.rating' } }
+          {avg: {field: 'comments.rating'}}
         end
       end
     end
   end
 
+  context 'no root element call' do
+    before do
+      stub_index(:products) do
+        define_type :product do
+          field :title, type: 'text' do
+            field :subfield1
+          end
+        end
+      end
+    end
+
+    specify { expect(product.root.children.map(&:name)).to eq([:title]) }
+    specify { expect(product.root.children.map(&:parent)).to eq([product.root]) }
+    specify { expect(product.root.children[0].children.map(&:name)).to eq([:subfield1]) }
+    specify { expect(product.root.children[0].children.map(&:parent)).to eq([product.root.children[0]]) }
+
+    context 'default root options are set' do
+      around do |example|
+        previous_options = Chewy.default_root_options
+        Chewy.default_root_options = {_all: {enabled: false}}
+        example.run
+        Chewy.default_root_options = previous_options
+      end
+
+      specify { expect(product.mappings_hash[:product]).to include(_all: {enabled: false}) }
+    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' } }) }
+    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) }
+    specify { expect(product.root.children.map(&:name)).to eq(%i[name surname title price]) }
+    specify { expect(product.root.children.map(&:parent)).to eq([product.root] * 4) }
 
-    specify { expect(product.root_object.children[0].children.map(&:name)).to eq([]) }
-    specify { expect(product.root_object.children[1].children.map(&:name)).to eq([]) }
+    specify { expect(product.root.children[0].children.map(&:name)).to eq([]) }
+    specify { expect(product.root.children[1].children.map(&:name)).to eq([]) }
 
-    specify { expect(product.root_object.children[2].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root_object.children[2].children.map(&:parent)).to eq([product.root_object.children[2]]) }
+    specify { expect(product.root.children[2].children.map(&:name)).to eq([:subfield1]) }
+    specify { expect(product.root.children[2].children.map(&:parent)).to eq([product.root.children[2]]) }
 
-    specify { expect(product.root_object.children[3].children.map(&:name)).to eq([:subfield2]) }
-    specify { expect(product.root_object.children[3].children.map(&:parent)).to eq([product.root_object.children[3]]) }
+    specify { expect(product.root.children[3].children.map(&:name)).to eq([:subfield2]) }
+    specify { expect(product.root.children[3].children.map(&:parent)).to eq([product.root.children[3]]) }
   end
 
   describe '.mappings_hash' do
-    specify { expect(Class.new(Chewy::Type).mappings_hash).to eq({}) }
-    specify { expect(product.mappings_hash).to eq(product.root_object.mappings_hash) }
+    specify { expect(product.mappings_hash).to eq(product.root.mappings_hash) }
+
+    context 'root merging' do
+      context do
+        before do
+          stub_index(:products) do
+            define_type :product do
+              root _parent: 'project', other_option: 'nothing' do
+                field :name do
+                  field :last_name # will be redefined in the following root flock
+                end
+              end
+              root _parent: 'something_else'
+              root other_option: 'option_value' do
+                field :identifier
+                field :name, type: 'integer'
+              end
+            end
+          end
+        end
+
+        specify do
+          expect(product.mappings_hash).to eq(product: {
+            properties: {
+              name: {type: 'integer'},
+              identifier: {type: Chewy.default_field_type}
+            },
+            other_option: 'option_value',
+            _parent: {type: 'something_else'}
+          })
+        end
+      end
+    end
 
     context 'parent-child relationship' do
       context do
@@ -68,7 +127,7 @@ describe Chewy::Type::Mapping do
           end
         end
 
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ type: 'project' }) }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq(type: 'project') }
       end
 
       context do
@@ -82,25 +141,33 @@ describe Chewy::Type::Mapping do
           end
         end
 
-        specify { expect(product.mappings_hash[:product][:_parent]).to eq({ type: 'project' }) }
+        specify { expect(product.mappings_hash[:product][:_parent]).to eq('type' => 'project') }
       end
     end
   end
 
-  context "no root element call" do
-    before do
-      stub_index(:products) do
-        define_type :product do
-          field :title, type: 'string' do
-            field :subfield1
-          end
-        end
+  describe '.supports_outdated_sync?' do
+    def type(&block)
+      stub_index(:cities) do
+        define_type :city, &block
       end
+      CitiesIndex::City
     end
 
-    specify { expect(product.root_object.children.map(&:name)).to eq([:title]) }
-    specify { expect(product.root_object.children.map(&:parent)).to eq([product.root_object]) }
-    specify { expect(product.root_object.children[0].children.map(&:name)).to eq([:subfield1]) }
-    specify { expect(product.root_object.children[0].children.map(&:parent)).to eq([product.root_object.children[0]]) }
+    specify { expect(type.supports_outdated_sync?).to eq(false) }
+    specify { expect(type { field :updated_at }.supports_outdated_sync?).to eq(true) }
+    specify { expect(type { field :updated_at, value: -> {} }.supports_outdated_sync?).to eq(false) }
+    specify do
+      expect(type do
+        self.outdated_sync_field = :version
+        field :updated_at
+      end.supports_outdated_sync?).to eq(false)
+    end
+    specify do
+      expect(type do
+        self.outdated_sync_field = :version
+        field :version
+      end.supports_outdated_sync?).to eq(true)
+    end
   end
 end

data/spec/chewy/type/observe_spec.rb

@@ -8,14 +8,20 @@ describe Chewy::Type::Observe do
       end
     end
 
-    let(:backreferenced) { 3.times.map { |i| double(id: i) } }
-
-    specify { expect { DummiesIndex::Dummy.update_index(backreferenced) }
-      .to raise_error Chewy::UndefinedUpdateStrategy }
-    specify { expect { DummiesIndex::Dummy.update_index([]) }
-      .not_to update_index('dummies#dummy') }
-    specify { expect { DummiesIndex::Dummy.update_index(nil) }
-      .not_to update_index('dummies#dummy') }
+    let(:backreferenced) { Array.new(3) { |i| double(id: i) } }
+
+    specify do
+      expect { DummiesIndex::Dummy.update_index(backreferenced) }
+        .to raise_error Chewy::UndefinedUpdateStrategy
+    end
+    specify do
+      expect { DummiesIndex::Dummy.update_index([]) }
+        .not_to update_index('dummies#dummy')
+    end
+    specify do
+      expect { DummiesIndex::Dummy.update_index(nil) }
+        .not_to update_index('dummies#dummy')
+    end
   end
 
   context 'integration', :orm do
@@ -23,10 +29,10 @@ describe Chewy::Type::Observe do
 
     before do
       city_countries_update_proc = if adapter == :sequel
-          ->(*) { previous_changes.try(:[], :country_id) || country }
-        else
-          ->(*) { changes['country_id'] || previous_changes['country_id'] || country }
-        end
+        ->(*) { 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 }
@@ -35,7 +41,7 @@ describe Chewy::Type::Observe do
 
       stub_model(:country) do
         update_index('cities#city', if: -> { update_condition }) { cities }
-        update_index(->{ "countries##{self.class.name.underscore}" }, :self)
+        update_index(-> { "countries##{self.class.name.underscore}" }, :self)
         attr_accessor :update_condition
       end
 
@@ -44,7 +50,11 @@ describe Chewy::Type::Observe do
         Country.one_to_many :cities
         City.plugin :dirty
       else
-        City.belongs_to :country
+        if adapter == :mongoid && Mongoid::VERSION.start_with?('6')
+          City.belongs_to :country, optional: true
+        else
+          City.belongs_to :country
+        end
         Country.has_many :cities
       end
 
@@ -75,7 +85,7 @@ describe Chewy::Type::Observe do
     context do
       let!(:country) do
         Chewy.strategy(:atomic) do
-          cities = 2.times.map { |i| City.create!(id: i) }
+          cities = Array.new(2) { |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) }

data/spec/chewy/type/syncer_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Chewy::Type::Syncer, :orm do
+  before { Chewy.massacre }
+  before do
+    stub_model(:city)
+    stub_index(:cities) do
+      define_type City do
+        field :name
+        field :updated_at, type: 'date'
+      end
+    end
+  end
+
+  shared_examples 'sync' do |options = {}|
+    let!(:cities) { Array.new(3) { |i| City.create!(name: "Name#{i + 1}") } }
+    subject { described_class.new(CitiesIndex::City, **options) }
+
+    describe '#perform' do
+      before { CitiesIndex::City.import!(cities) }
+      specify { expect(subject.perform).to eq(0) }
+
+      context do
+        before do
+          cities.first.destroy
+          sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
+          cities.last.update(name: 'Name5')
+        end
+        let!(:additional_city) { City.create!(name: 'Name4') }
+
+        specify { expect(subject.perform).to eq(3) }
+        specify do
+          expect { subject.perform }.to update_index(CitiesIndex::City)
+            .and_reindex(additional_city, cities.last)
+            .and_delete(cities.first).only
+        end
+      end
+
+      context 'does not support outdated sync' do
+        before do
+          stub_index(:cities) do
+            define_type City do
+              field :name
+            end
+          end
+        end
+
+        specify { expect(subject.perform).to eq(0) }
+
+        context do
+          before do
+            cities.first.destroy
+            cities.last.update(name: 'Name5')
+          end
+          let!(:additional_city) { City.create!(name: 'Name4') }
+
+          specify { expect(subject.perform).to eq(2) }
+          specify do
+            expect { subject.perform }.to update_index(CitiesIndex::City)
+              .and_reindex(additional_city)
+              .and_delete(cities.first).only
+          end
+        end
+      end
+    end
+
+    describe '#missing_ids' do
+      specify { expect(subject.missing_ids).to match_array(cities.map(&:id).map(&:to_s)) }
+
+      context do
+        before { CitiesIndex::City.import!(cities) }
+        specify { expect(subject.missing_ids).to eq([]) }
+
+        context do
+          let!(:additional_city) { City.create!(name: 'Name4') }
+          before { cities.first.destroy }
+          specify { expect(subject.missing_ids).to contain_exactly(cities.first.id.to_s, additional_city.id.to_s) }
+        end
+      end
+    end
+
+    describe '#outdated_ids' do
+      specify { expect(subject.outdated_ids).to eq([]) }
+
+      context do
+        before { CitiesIndex::City.import!(cities) }
+        specify { expect(subject.outdated_ids).to eq([]) }
+
+        context do
+          before do
+            sleep(1) if ActiveSupport::VERSION::STRING < '4.1.0'
+            cities.first.update(name: 'Name4')
+            cities.last.update(name: 'Name5')
+          end
+          specify { expect(subject.outdated_ids).to contain_exactly(cities.first.id.to_s, cities.last.id.to_s) }
+        end
+      end
+
+      context 'does not support outdated sync' do
+        before do
+          stub_index(:cities) do
+            define_type City do
+              field :name
+            end
+          end
+        end
+
+        specify { expect(subject.outdated_ids).to eq([]) }
+
+        context do
+          before do
+            cities.first.update(name: 'Name4')
+            cities.last.update(name: 'Name5')
+          end
+          specify { expect(subject.outdated_ids).to eq([]) }
+        end
+      end
+    end
+  end
+
+  include_examples 'sync'
+  include_examples 'sync', parallel: 0
+end

data/spec/chewy/type/witchcraft_spec.rb

@@ -15,7 +15,7 @@ describe Chewy::Type::Witchcraft do
 
   describe '#cauldron' do
     let(:type) { ProductsIndex::Product }
-    let(:object) { }
+    let(:object) {}
 
     context 'empty mapping' do
       mapping {}
@@ -28,7 +28,7 @@ describe Chewy::Type::Witchcraft do
         field :age
         field :tags
       end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+      let(:attributes) { {name: 'Name', age: 13, tags: %w[Ruby RoR]} }
 
       context do
         let(:object) { double(attributes) }
@@ -39,29 +39,45 @@ describe Chewy::Type::Witchcraft do
         let(:object) { attributes }
         specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
       end
+
+      context do
+        let(:object) { double(attributes) }
+        specify do
+          expect(type.cauldron(fields: %i[name tags]).brew(object))
+            .to eq('name' => 'Name', 'tags' => %w[Ruby RoR])
+        end
+      end
+
+      context do
+        let(:object) { attributes }
+        specify do
+          expect(type.cauldron(fields: %i[name tags]).brew(object))
+            .to eq('name' => 'Name', 'tags' => %w[Ruby RoR])
+        end
+      end
     end
 
     context 'simple lambdas' do
       mapping do
         field :name
-        field :age, value: -> (obj) {
+        field :age, value: lambda { |obj|
           obj.age if obj
         }
         field :tags, value: -> { tags.map(&:to_sym) }
       end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
+      let(:attributes) { {name: 'Name', age: 13, tags: %w[Ruby RoR]} }
 
       context do
         let(:object) { double(attributes) }
-        specify { expect(type.cauldron.brew(object)).to eq(attributes.merge(tags: [:Ruby, :RoR]).as_json) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.merge(tags: %i[Ruby RoR]).as_json) }
       end
     end
 
     context 'crutches' do
       mapping do
-        field :name, value: -> (o, c) { c.names[0] }
+        field :name, value: ->(_o, c) { c.names[0] }
       end
-      let(:attributes) { { name: 'Name' } }
+      let(:attributes) { {name: 'Name'} }
 
       context do
         let(:object) { double(attributes) }
@@ -79,14 +95,18 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          {title: 'Title1', body: 'Body1'},
-          {title: 'Title2', body: 'Body2'}
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            {title: 'Title1', body: 'Body1'},
+            {title: 'Title2', body: 'Body2'}
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({queries: [
+            {title: 'Title1', body: 'This Body1'},
+            {title: 'Title2', body: 'This Body2'}
+          ]}.as_json)
+        end
       end
 
       context do
@@ -97,14 +117,18 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            double(title: 'Title1', body: 'Body1'),
+            double(title: 'Title2', body: 'Body2')
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({queries: [
+            {title: 'Title1', body: 'This Body1'},
+            {title: 'Title2', body: 'This Body2'}
+          ]}.as_json)
+        end
       end
 
       context do
@@ -115,39 +139,93 @@ describe Chewy::Type::Witchcraft do
           end
         end
 
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
+        let(:object) do
+          double(queries: [
+            double(title: 'Title1', body: 'Body1'),
+            double(title: 'Title2', body: 'Body2')
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object)).to eq({queries: [
+            {title: 'Title1', body: 'This Body1'},
+            {title: 'Title2', body: 'This Body2'}
+          ]}.as_json)
+        end
       end
 
       context do
         mapping do
           field :queries do
-            field :fields, value: -> (o, q) { q.fields } do
+            field :fields, value: ->(_o, q) { q.fields } do
               field :first
-              field :second, value: -> (o, q, f, c) {
+              field :second, value: lambda { |_o, q, f, c|
                 q.value + (f.respond_to?(:second) ? f.second : c.second)
               }
             end
           end
         end
 
-        let(:object) { double(queries: [
-          double(value: 'Value1', fields: [double(first: 'First1', second: 'Second1'), {first: 'First2'}]),
-          double(value: 'Value2', fields: double(first: 'First3', second: 'Second2', third: 'Third'))
-        ]) }
-        specify { expect(type.cauldron.brew(object, double(second: 'Crutch'))).to eq({queries: [
-          {fields: [
-            {first: 'First1', second: 'Value1Second1'},
-            {first: 'First2', second: 'Value1Crutch'}
-          ]},
-          {fields: {first: 'First3', second: 'Value2Second2'}}
-        ]}.as_json) }
+        let(:object) do
+          double(queries: [
+            double(value: 'Value1', fields: [double(first: 'First1', second: 'Second1'), {first: 'First2'}]),
+            double(value: 'Value2', fields: double(first: 'First3', second: 'Second2', third: 'Third'))
+          ])
+        end
+        specify do
+          expect(type.cauldron.brew(object, double(second: 'Crutch'))).to eq({queries: [
+            {fields: [
+              {first: 'First1', second: 'Value1Second1'},
+              {first: 'First2', second: 'Value1Crutch'}
+            ]},
+            {fields: {first: 'First3', second: 'Value2Second2'}}
+          ]}.as_json)
+        end
+      end
+    end
+
+    context 'dynamic fields' do
+      mapping do
+        [[:name], [:age]].each do |param|
+          field param.first, value: ->(o) { o.send(param[0]) if param[0] }
+        end
+      end
+      let(:attributes) { {name: 'Name', age: 13} }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
+      end
+    end
+
+    context 'dynamic fields' do
+      mapping do
+        def self.custom_value(field)
+          ->(o) { o.send(field) }
+        end
+
+        field :name, value: custom_value(:name)
+      end
+      let(:attributes) { {name: 'Name'} }
+
+      context do
+        let(:object) { double(attributes) }
+        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
+      end
+    end
+
+    context 'symbol value' do
+      mapping do
+        field :name, value: :last_name
+      end
+
+      context do
+        let(:object) { double(last_name: 'Name') }
+        specify { expect(type.cauldron.brew(object)).to eq({name: 'Name'}.as_json) }
+      end
+
+      context do
+        let(:object) { {'last_name' => 'Name'} }
+        specify { expect(type.cauldron.brew(object)).to eq({name: 'Name'}.as_json) }
       end
     end
   end