chewy 0.8.4 → 7.3.4

data/spec/chewy/index/mapping_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Chewy::Index::Mapping do
+  let(:product) { ProductsIndex }
+  let(:review)  { ReviewsIndex }
+
+  before do
+    stub_index(:products) do
+      root do
+        field :name, 'surname'
+        field :title, type: 'text' do
+          field :subfield1
+        end
+        field 'price', type: 'float' do
+          field :subfield2
+        end
+        agg :named_agg do
+          {avg: {field: 'title.subfield1'}}
+        end
+      end
+    end
+    stub_index(:reviews) 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
+
+  context 'no root element call' do
+    before do
+      stub_index(:products) do
+        field :title, type: 'text' do
+          field :subfield1
+        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[:mappings]).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'}) }
+  end
+
+  describe '.field' do
+    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.children[0].children.map(&:name)).to eq([]) }
+    specify { expect(product.root.children[1].children.map(&:name)).to eq([]) }
+
+    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.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(product.mappings_hash[:mappings]).to eq(product.root.mappings_hash) }
+
+    context 'root merging' do
+      context do
+        before do
+          stub_index(:products) do
+            root other_option: 'nothing' do
+              field :name do
+                field :last_name # will be redefined in the following root flock
+              end
+            end
+            root other_option: 'option_value' do
+              field :identifier
+              field :name, type: 'integer'
+            end
+          end
+        end
+
+        specify do
+          expect(product.mappings_hash).to eq(
+            mappings: {
+              properties: {
+                name: {type: 'integer'},
+                identifier: {type: Chewy.default_field_type}
+              },
+              other_option: 'option_value'
+            }
+          )
+        end
+      end
+    end
+  end
+
+  describe '.supports_outdated_sync?' do
+    def index(&block)
+      stub_index(:cities, &block)
+      CitiesIndex
+    end
+
+    specify { expect(index.supports_outdated_sync?).to eq(false) }
+    specify { expect(index { field :updated_at }.supports_outdated_sync?).to eq(true) }
+    specify { expect(index { field :updated_at, value: -> {} }.supports_outdated_sync?).to eq(false) }
+    specify do
+      expect(index do
+        self.outdated_sync_field = :version
+        field :updated_at
+      end.supports_outdated_sync?).to eq(false)
+    end
+    specify do
+      expect(index do
+        self.outdated_sync_field = :version
+        field :version
+      end.supports_outdated_sync?).to eq(true)
+    end
+  end
+end

data/spec/chewy/index/observe/active_record_methods_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::ActiveRecordMethods do
+  describe '.update_index' do
+    before { stub_model(:city) }
+
+    it 'initializes chewy callbacks when first update_index is evaluated' do
+      expect(City).to receive(:initialize_chewy_callbacks).once
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+    end
+
+    it 'adds chewy callbacks to model' do
+      expect(City.chewy_callbacks.count).to eq(0)
+
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+
+      expect(City.chewy_callbacks.count).to eq(2)
+    end
+  end
+
+  describe 'callbacks' do
+    before { stub_model(:city) { update_index 'cities', :self } }
+    before { stub_index(:cities) { index_scope City } }
+    before { allow(Chewy).to receive(:use_after_commit_callbacks).and_return(use_after_commit_callbacks) }
+
+    let(:city) do
+      Chewy.strategy(:bypass) do
+        City.create!
+      end
+    end
+
+    shared_examples 'handles callbacks correctly' do
+      it 'handles callbacks with strategy for possible lazy evaluation on save!' do
+        Chewy.strategy(:urgent) do
+          expect(city).to receive(:update_chewy_indices).and_call_original
+          expect(Chewy.strategy.current).to receive(:update_chewy_indices).with(city)
+          expect(city).not_to receive(:run_chewy_callbacks)
+
+          city.save!
+        end
+      end
+
+      it 'runs callbacks at the moment on destroy' do
+        Chewy.strategy(:urgent) do
+          expect(city).not_to receive(:update_chewy_indices)
+          expect(Chewy.strategy.current).not_to receive(:update_chewy_indices)
+          expect(city).to receive(:run_chewy_callbacks)
+
+          city.destroy
+        end
+      end
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is true' do
+      let(:use_after_commit_callbacks) { true }
+
+      include_examples 'handles callbacks correctly'
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is false' do
+      let(:use_after_commit_callbacks) { false }
+
+      include_examples 'handles callbacks correctly'
+    end
+  end
+end

data/spec/chewy/index/observe/callback_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::Callback do
+  subject(:callback) { described_class.new(executable) }
+
+  before do
+    stub_model(:city) do
+      attr_accessor :population
+    end
+  end
+
+  let(:city) { City.create!(population: 100) }
+
+  describe '#call' do
+    context 'when executable is has arity 0' do
+      let(:executable) { -> { population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    context 'when executable is has arity 1' do
+      let(:executable) { ->(record) { record.population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    describe 'filters' do
+      let(:executable) { ->(_) {} }
+
+      describe 'if' do
+        subject(:callback) { described_class.new(executable, if: filter) }
+
+        shared_examples 'an if filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an if filter'
+        end
+      end
+
+      describe 'unless' do
+        subject(:callback) { described_class.new(executable, unless: filter) }
+
+        shared_examples 'an unless filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an unless filter'
+        end
+      end
+    end
+  end
+end

data/spec/chewy/index/observe_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe do
+  describe '.update_index' do
+    before do
+      stub_index(:dummies)
+    end
+
+    let(:backreferenced) { Array.new(3) { |i| double(id: i) } }
+
+    specify do
+      expect { DummiesIndex.update_index(backreferenced) }
+        .to raise_error Chewy::UndefinedUpdateStrategy
+    end
+    specify do
+      expect { DummiesIndex.update_index([]) }
+        .not_to update_index('dummies')
+    end
+    specify do
+      expect { DummiesIndex.update_index(nil) }
+        .not_to update_index('dummies')
+    end
+  end
+
+  context 'integration', :orm do
+    let(:update_condition) { true }
+
+    before do
+      stub_model(:city) do
+        update_index(-> { 'cities' }, :self)
+        update_index('countries') { changes['country_id'] || previous_changes['country_id'] || country }
+      end
+
+      stub_model(:country) do
+        update_index('cities', if: -> { update_condition }) { cities }
+        update_index(-> { 'countries' }, :self)
+        attr_accessor :update_condition
+      end
+
+      City.belongs_to :country
+      Country.has_many :cities
+
+      stub_index(:cities) do
+        index_scope City
+      end
+
+      stub_index(:countries) do
+        index_scope Country
+      end
+    end
+
+    context do
+      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').and_reindex(city).only }
+      specify { expect { city.save! }.to update_index('countries').and_reindex(country1).only }
+
+      specify { expect { city.destroy }.to update_index('cities') }
+      specify { expect { city.destroy }.to update_index('countries').and_reindex(country1).only }
+
+      specify { expect { city.update!(country: nil) }.to update_index('cities').and_reindex(city).only }
+      specify { expect { city.update!(country: nil) }.to update_index('countries').and_reindex(country1).only }
+
+      specify { expect { city.update!(country: country2) }.to update_index('cities').and_reindex(city).only }
+      specify do
+        expect { city.update!(country: country2) }
+          .to update_index('countries').and_reindex(country1, country2).only
+      end
+    end
+
+    context do
+      let!(:country) do
+        Chewy.strategy(:atomic) do
+          cities = Array.new(2) { |i| City.create!(id: i) }
+          Country.create!(id: 1, cities: cities, update_condition: update_condition)
+        end
+      end
+
+      specify { expect { country.save! }.to update_index('cities').and_reindex(country.cities).only }
+      specify { expect { country.save! }.to update_index('countries').and_reindex(country).only }
+
+      specify { expect { country.destroy }.to update_index('cities').and_reindex(country.cities).only }
+      specify { expect { country.destroy }.to update_index('countries') }
+
+      context 'conditional update' do
+        let(:update_condition) { false }
+        specify { expect { country.save! }.not_to update_index('cities') }
+        specify { expect { country.destroy }.not_to update_index('cities') }
+      end
+    end
+  end
+
+  context 'transactions', :active_record do
+    context do
+      before { stub_model(:city) { update_index 'cities', :self } }
+      before { stub_index(:cities) { index_scope City } }
+
+      specify do
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { City.create! }.not_to update_index('cities')
+          end
+        end
+      end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.not_to update_index('cities')
+          end
+        end
+      end
+    end
+
+    context do
+      before { allow(Chewy).to receive_messages(use_after_commit_callbacks: false) }
+      before { stub_model(:city) { update_index 'cities', :self } }
+      before { stub_index(:cities) { index_scope City } }
+
+      specify do
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { City.create! }.to update_index('cities')
+          end
+        end
+      end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.to update_index('cities')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/chewy/index/settings_spec.rb

@@ -6,77 +6,130 @@ describe Chewy::Index::Settings do
     before { allow(Chewy).to receive_messages(repository: Chewy::Repository.send(:new)) }
 
     specify { expect(described_class.new.to_hash).to eq({}) }
-    specify { expect(described_class.new(number_of_nodes: 3).to_hash).to eq({settings: {number_of_nodes: 3}}) }
-    specify { expect(described_class.new(number_of_nodes: 3, analysis: {}).to_hash)
-      .to eq({settings: {number_of_nodes: 3, analysis: {}}}) }
-    specify { expect(described_class.new(number_of_nodes: 3, analysis: {filter: {filter1: {}}}).to_hash)
-      .to eq({settings: {number_of_nodes: 3, analysis: {filter: {filter1: {}}}}}) }
-    specify { expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}).to_hash)
-      .to eq({settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}}}) }
-    specify { expect(described_class.new(number_of_nodes: 3, analysis: {
-      analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-    }).to_hash)
-      .to eq({settings: {number_of_nodes: 3, analysis: {
-        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-      }}}) }
-    specify { expect(described_class.new(number_of_nodes: 3, analysis: {analyser: ['analyzer1']}).to_hash)
-      .to eq({settings: {number_of_nodes: 3, analysis: {}}}) }
+    specify { expect(described_class.new(number_of_nodes: 3).to_hash).to eq(settings: {number_of_nodes: 3}) }
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {}})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {filter: {filter1: {}}}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {filter: {filter1: {}}}})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}}})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {
+        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}}
+      }).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}}
+        }})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: ['analyzer1']}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {}})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}, normalizer: {}}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {analyzer: {analyzer1: {}}, normalizer: {}}})
+    end
+    specify do
+      expect(described_class.new(number_of_nodes: 3, analysis: {analyzer: ['analyzer1'], normalizer: {}}).to_hash)
+        .to eq(settings: {number_of_nodes: 3, analysis: {normalizer: {}}})
+    end
+
+    specify do
+      stub_const('Synonyms', Class.new do
+        def self.synonyms
+          ['kaftan => dress']
+        end
+      end)
+      expect(
+        described_class.new do
+          {
+            analysis: {filter: {synonym: {type: 'synonym', synonyms: Synonyms.synonyms}}}
+          }
+        end.to_hash
+      ).to eq(settings: {
+        analysis: {filter: {
+          synonym: {
+            type: 'synonym', synonyms: ['kaftan => dress']
+          }
+        }}
+      })
+    end
 
     context do
-      before { Chewy.tokenizer :tokenizer1, {options: 42} }
+      before { Chewy.tokenizer :tokenizer1, options: 42 }
 
-      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
-        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}}
-      }).to_hash)
-        .to eq({settings: {number_of_nodes: 3, analysis: {
-          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
-          tokenizer: {tokenizer1: {options: 42}}
-        }}}) }
+      specify do
+        expect(described_class.new(number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}}
+        }).to_hash)
+          .to eq(settings: {number_of_nodes: 3, analysis: {
+            analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}},
+            tokenizer: {tokenizer1: {options: 42}}
+          }})
+      end
     end
 
     context do
       before do
-        Chewy.filter :filter2, {options: 42}
-        Chewy.filter :filter3, {options: 43}
-        Chewy.filter :filter5, {options: 44}
+        Chewy.filter :filter2, options: 42
+        Chewy.filter :filter3, options: 43
+        Chewy.filter :filter5, options: 44
       end
 
-      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
-        analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
-        filter: ['filter3', {filter4: {options: 45}}]
-      }).to_hash)
-        .to eq({settings: {number_of_nodes: 3, analysis: {
-          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: ['filter1', 'filter2']}},
-          filter: {filter2: {options: 42}, filter3: {options: 43}, filter4: {options: 45}}
-        }}}) }
+      specify do
+        expect(described_class.new(number_of_nodes: 3, analysis: {
+          analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}},
+          filter: ['filter3', {filter4: {options: 45}}]
+        }).to_hash)
+          .to eq(settings: {number_of_nodes: 3, analysis: {
+            analyzer: {analyzer1: {tokenizer: 'tokenizer1', filter: %w[filter1 filter2]}},
+            filter: {filter2: {options: 42}, filter3: {options: 43}, filter4: {options: 45}}
+          }})
+      end
     end
 
     context do
       before do
-        Chewy.analyzer :analyzer1, {options: 42, tokenizer: 'tokenizer1'}
-        Chewy.tokenizer :tokenizer1, {options: 43}
+        Chewy.analyzer :analyzer1, options: 42, tokenizer: 'tokenizer1'
+        Chewy.tokenizer :tokenizer1, options: 43
       end
 
-      specify { expect(described_class.new(number_of_nodes: 3, analysis: {
-        analyzer: ['analyzer1', {analyzer2: {options: 44}}]
-      }).to_hash)
-        .to eq({settings: {number_of_nodes: 3, analysis: {
-          analyzer: {analyzer1: {options: 42, tokenizer: 'tokenizer1'}, analyzer2: {options: 44}},
-          tokenizer: {tokenizer1: {options: 43}}
-        }}}) }
+      specify do
+        expect(described_class.new(number_of_nodes: 3, analysis: {
+          analyzer: ['analyzer1', {analyzer2: {options: 44}}]
+        }).to_hash)
+          .to eq(settings: {number_of_nodes: 3, analysis: {
+            analyzer: {analyzer1: {options: 42, tokenizer: 'tokenizer1'}, analyzer2: {options: 44}},
+            tokenizer: {tokenizer1: {options: 43}}
+          }})
+      end
     end
 
     context ':index' do
-      specify { expect(described_class.new(index: {number_of_shards: 3}).to_hash)
-        .to eq({settings: {index: {number_of_shards: 3}}}) }
+      specify do
+        expect(described_class.new(index: {number_of_shards: 3}).to_hash)
+          .to eq(settings: {index: {number_of_shards: 3}})
+      end
 
       context do
-        before { allow(Chewy).to receive_messages(configuration: {index: {number_of_shards: 7, number_of_replicas: 2}}) }
+        before do
+          allow(Chewy).to receive_messages(configuration: {index: {number_of_shards: 7, number_of_replicas: 2}})
+        end
 
-        specify { expect(described_class.new.to_hash)
-          .to eq({settings: {index: {number_of_shards: 7, number_of_replicas: 2}}}) }
-        specify { expect(described_class.new(index: {number_of_shards: 3}).to_hash)
-          .to eq({settings: {index: {number_of_shards: 3, number_of_replicas: 2}}}) }
+        specify do
+          expect(described_class.new.to_hash)
+            .to eq(settings: {index: {number_of_shards: 7, number_of_replicas: 2}})
+        end
+        specify do
+          expect(described_class.new(index: {number_of_shards: 3}).to_hash)
+            .to eq(settings: {index: {number_of_shards: 3, number_of_replicas: 2}})
+        end
       end
     end
   end