chewy 0.8.4 → 5.1.0

data/spec/chewy/fields/root_spec.rb

@@ -1,44 +1,150 @@
 require 'spec_helper'
 
 describe Chewy::Fields::Root do
-  specify { expect(described_class.new('name').value).to be_a(Proc) }
-  # TODO: add 'should_behave_like base_field'
-
   subject(:field) { described_class.new('product') }
 
   describe '#dynamic_template' do
     specify do
-      field.dynamic_template 'hello', type: 'string'
+      field.dynamic_template 'hello', type: 'keyword'
       field.dynamic_template 'hello*', :integer
       field.dynamic_template 'hello.*'
-      field.dynamic_template /hello/
-      field.dynamic_template /hello.*/
+      field.dynamic_template(/hello/)
+      field.dynamic_template(/hello.*/)
       field.dynamic_template template_42: {mapping: {}, match: ''}
-      field.dynamic_template /hello\..*/
+      field.dynamic_template(/hello\..*/)
 
-      expect(field.mappings_hash).to eq({product: {dynamic_templates: [
-        {template_1: {mapping: {type: 'string'}, match: 'hello'}},
+      expect(field.mappings_hash).to eq(product: {dynamic_templates: [
+        {template_1: {mapping: {type: 'keyword'}, match: 'hello'}},
         {template_2: {mapping: {}, match_mapping_type: 'integer', match: 'hello*'}},
         {template_3: {mapping: {}, path_match: 'hello.*'}},
         {template_4: {mapping: {}, match: 'hello', match_pattern: 'regexp'}},
         {template_5: {mapping: {}, match: 'hello.*', match_pattern: 'regexp'}},
         {template_42: {mapping: {}, match: ''}},
         {template_7: {mapping: {}, path_match: 'hello\..*', match_pattern: 'regexp'}}
-      ]}})
+      ]})
     end
 
     context do
-      subject(:field) { described_class.new('product', dynamic_templates: [
-        {template_42: {mapping: {}, match: ''}}
-      ]) }
+      subject(:field) do
+        described_class.new('product', dynamic_templates: [
+          {template_42: {mapping: {}, match: ''}}
+        ])
+      end
 
       specify do
-        field.dynamic_template 'hello', type: 'string'
-        expect(field.mappings_hash).to eq({product: {dynamic_templates: [
+        field.dynamic_template 'hello', type: 'keyword'
+        expect(field.mappings_hash).to eq(product: {dynamic_templates: [
           {template_42: {mapping: {}, match: ''}},
-          {template_1: {mapping: {type: 'string'}, match: 'hello'}}
-        ]}})
+          {template_1: {mapping: {type: 'keyword'}, match: 'hello'}}
+        ]})
+      end
+    end
+  end
+
+  describe '#compose' do
+    context 'empty children', :orm do
+      before do
+        stub_model(:city)
+        stub_index(:places) do
+          define_type City
+        end
+      end
+
+      let(:city) { City.new(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city))
+          .to match(hash_including('name' => 'London', 'rating' => 100))
+      end
+      specify do
+        expect(PlacesIndex::City.root.compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'London')
+      end
+    end
+
+    context 'has children' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            field :name, :rating
+          end
+        end
+      end
+
+      let(:city) { double(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city))
+          .to eq('name' => 'London', 'rating' => 100)
+      end
+      specify do
+        expect(PlacesIndex::City.root.compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'London')
+      end
+    end
+
+    context 'root value provided' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            root value: ->(o) { {name: o.name + 'Modified', rating: o.rating.next} }
+          end
+        end
       end
+
+      let(:city) { double(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city))
+          .to eq('name' => 'LondonModified', 'rating' => 101)
+      end
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'LondonModified')
+      end
+    end
+
+    context 'complex evaluations' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            root value: ->(o) { {name: o.name + 'Modified', rating: o.rating.next} } do
+              field :name, value: ->(o) { o[:name] + 'Modified' }
+              field :rating
+            end
+          end
+        end
+      end
+
+      let(:city) { double(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city))
+          .to eq('name' => 'LondonModifiedModified', 'rating' => 101)
+      end
+
+      specify do
+        expect(PlacesIndex::City.root.compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'LondonModifiedModified')
+      end
+    end
+  end
+
+  describe '#child_hash' do
+    before do
+      stub_index(:places) do
+        define_type :city do
+          field :name, :rating
+        end
+      end
+    end
+
+    specify do
+      expect(PlacesIndex::City.root.child_hash).to match(
+        name: an_instance_of(Chewy::Fields::Base).and(have_attributes(name: :name)),
+        rating: an_instance_of(Chewy::Fields::Base).and(have_attributes(name: :rating))
+      )
     end
   end
 end

data/spec/chewy/fields/time_fields_spec.rb

@@ -11,17 +11,18 @@ describe 'Time fields' do
     end
   end
 
-  before { PostsIndex::Post.import(
-    double(published_at: ActiveSupport::TimeZone[-28800].parse('2014/12/18 19:00')),
-    double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/18 20:00')),
-    double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/17 20:00')),
-  ) }
+  before do
+    PostsIndex::Post.import(
+      double(published_at: ActiveSupport::TimeZone[-28_800].parse('2014/12/18 19:00')),
+      double(published_at: ActiveSupport::TimeZone[-21_600].parse('2014/12/18 20:00')),
+      double(published_at: ActiveSupport::TimeZone[-21_600].parse('2014/12/17 20:00'))
+    )
+  end
 
-  let(:time) { ActiveSupport::TimeZone[-14400].parse('2014/12/18 22:00') }
+  let(:time) { ActiveSupport::TimeZone[-14_400].parse('2014/12/18 22:00') }
   let(:range) { (time - 1.minute)..(time + 1.minute) }
 
   specify { expect(PostsIndex.total).to eq(3) }
-  specify { expect(PostsIndex.filter { published_at == o{range} }.count).to eq(1) }
-  specify { expect(PostsIndex.filter { published_at == o{range.min.utc..(range.max + 1.hour).utc} }.count).to eq(2) }
-  specify { expect(PostsIndex.filter { published_at == o{[range.min..range.max]} }.count).to eq(1) }
+  specify { expect(PostsIndex.filter(range: {published_at: {gte: range.min, lte: range.max}}).size).to eq(1) }
+  specify { expect(PostsIndex.filter(range: {published_at: {gt: range.min.utc, lt: (range.max + 1.hour).utc}}).size).to eq(2) }
 end

data/spec/chewy/index/actions_spec.rb

@@ -35,7 +35,7 @@ describe Chewy::Index::Actions do
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
+        specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
       end
     end
 
@@ -55,11 +55,6 @@ describe Chewy::Index::Actions do
     context do
       before { DummiesIndex.create }
       specify do
-        skip_on_version_gte('2.0', 'format of exception changed in 2.x')
-        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies\] already exists\]/)
-      end
-      specify do
-        skip_on_version_lt('2.0', 'format of exception was changed')
         expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies/)
       end
       specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/Invalid alias name \[dummies\]/) }
@@ -72,18 +67,13 @@ describe Chewy::Index::Actions do
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify do
-        skip_on_version_gte('2.0', 'format of exception changed in 2.x')
-        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/\[\[dummies_2013\] already exists\]/)
-      end
-      specify do
-        skip_on_version_lt('2.0', 'format of exception was changed')
         expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies_2013/)
       end
       specify { expect(DummiesIndex.create!('2014')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.create! '2014' }
-        specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
+        specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
       end
     end
 
@@ -287,7 +277,7 @@ describe Chewy::Index::Actions do
         define_type City
       end
     end
-    let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
+    let!(:dummy_cities) { Array.new(3) { |i| City.create(id: i + 1, name: "name#{i}") } }
 
     specify { expect(CitiesIndex.import).to eq(true) }
 
@@ -311,7 +301,7 @@ describe Chewy::Index::Actions do
         define_type City
       end
     end
-    let!(:dummy_cities) { 3.times.map { |i| City.create(id: i + 1, name: "name#{i}") } }
+    let!(:dummy_cities) { Array.new(3) { |i| City.create(id: i + 1, name: "name#{i}") } }
 
     specify { expect(CitiesIndex.import!).to eq(true) }
 
@@ -336,59 +326,254 @@ describe Chewy::Index::Actions do
       end
     end
 
-    before { City.create!(id: 1, name: 'Moscow') }
-
-    specify { expect(CitiesIndex.reset!).to eq(true) }
-    specify { expect(CitiesIndex.reset!('2013')).to eq(true) }
-
     context do
-      before { CitiesIndex.reset! }
+      before { City.create!(id: 1, name: 'Moscow') }
 
-      specify { expect(CitiesIndex.all).to have(1).item }
-      specify { expect(CitiesIndex.aliases).to eq([]) }
-      specify { expect(CitiesIndex.indexes).to eq([]) }
+      specify { expect(CitiesIndex.reset!).to eq(true) }
+      specify { expect(CitiesIndex.reset!('2013')).to eq(true) }
 
       context do
-        before { CitiesIndex.reset!('2013') }
+        before { CitiesIndex.reset! }
 
         specify { expect(CitiesIndex.all).to have(1).item }
         specify { expect(CitiesIndex.aliases).to eq([]) }
-        specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
+        specify { expect(CitiesIndex.indexes).to eq([]) }
+
+        context do
+          before { CitiesIndex.reset!('2013') }
+
+          specify { expect(CitiesIndex.all).to have(1).item }
+          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
+        end
+
+        context do
+          before { CitiesIndex.reset! }
+
+          specify { expect(CitiesIndex.all).to have(1).item }
+          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq([]) }
+        end
       end
 
       context do
-        before { CitiesIndex.reset! }
+        before { CitiesIndex.reset!('2013') }
 
         specify { expect(CitiesIndex.all).to have(1).item }
         specify { expect(CitiesIndex.aliases).to eq([]) }
-        specify { expect(CitiesIndex.indexes).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
+
+        context do
+          before { CitiesIndex.reset!('2014') }
+
+          specify { expect(CitiesIndex.all).to have(1).item }
+          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq(['cities_2014']) }
+          specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
+        end
+
+        context do
+          before { CitiesIndex.reset! }
+
+          specify { expect(CitiesIndex.all).to have(1).item }
+          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq([]) }
+          specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
+        end
       end
     end
 
-    context do
+    context 'reset_disable_refresh_interval' do
+      let(:suffix) { Time.now.to_i }
+      let(:name) { CitiesIndex.index_name(suffix: suffix) }
+      let(:before_import_body) do
+        {
+          index: {refresh_interval: -1}
+        }
+      end
+      let(:after_import_body) do
+        {
+          index: {refresh_interval: '1s'}
+        }
+      end
+
       before { CitiesIndex.reset!('2013') }
+      before { allow(Chewy).to receive(:reset_disable_refresh_interval).and_return(reset_disable_refresh_interval) }
+
+      context 'activated' do
+        let(:reset_disable_refresh_interval) { true }
+        specify do
+          expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: before_import_body).once
+          expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: after_import_body).once
+          expect(CitiesIndex).to receive(:import).with(suffix: suffix, journal: false, refresh: false).and_call_original
+          expect(CitiesIndex.reset!(suffix)).to eq(true)
+        end
+
+        context 'refresh_interval already defined' do
+          before do
+            stub_index(:cities) do
+              settings index: {refresh_interval: '2s'}
+              define_type City
+            end
+          end
 
-      specify { expect(CitiesIndex.all).to have(1).item }
-      specify { expect(CitiesIndex.aliases).to eq([]) }
-      specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
+          let(:after_import_body) do
+            {
+              index: {refresh_interval: '2s'}
+            }
+          end
 
-      context do
-        before { CitiesIndex.reset!('2014') }
+          specify do
+            expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: before_import_body).once
+            expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: after_import_body).once
+            expect(CitiesIndex).to receive(:import).with(suffix: suffix, journal: false, refresh: false).and_call_original
+            expect(CitiesIndex.reset!(suffix)).to eq(true)
+          end
 
-        specify { expect(CitiesIndex.all).to have(1).item }
-        specify { expect(CitiesIndex.aliases).to eq([]) }
-        specify { expect(CitiesIndex.indexes).to eq(['cities_2014']) }
-        specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
+          specify 'uses empty index settings if not defined' do
+            allow(Chewy).to receive(:wait_for_status).and_return(nil)
+            allow(CitiesIndex).to receive(:settings_hash).and_return({})
+            expect(CitiesIndex.reset!(suffix)).to eq(true)
+          end
+        end
       end
 
-      context do
-        before { CitiesIndex.reset! }
+      context 'not activated' do
+        let(:reset_disable_refresh_interval) { false }
+        specify do
+          expect(CitiesIndex.client.indices).not_to receive(:put_settings)
+          expect(CitiesIndex).to receive(:import).with(suffix: suffix, journal: false, refresh: true).and_call_original
+          expect(CitiesIndex.reset!(suffix)).to eq(true)
+        end
+      end
+    end
 
-        specify { expect(CitiesIndex.all).to have(1).item }
-        specify { expect(CitiesIndex.aliases).to eq([]) }
-        specify { expect(CitiesIndex.indexes).to eq([]) }
-        specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
+    context 'reset_no_replicas' do
+      let(:suffix) { Time.now.to_i }
+      let(:name) { CitiesIndex.index_name(suffix: suffix) }
+      let(:before_import_body) do
+        {
+          index: {number_of_replicas: 0}
+        }
+      end
+      let(:after_import_body) do
+        {
+          index: {number_of_replicas: 0}
+        }
+      end
+
+      before { allow(Chewy).to receive(:reset_no_replicas).and_return(reset_no_replicas) }
+
+      context 'activated' do
+        let(:reset_no_replicas) { true }
+        specify do
+          expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: before_import_body).once
+          expect(CitiesIndex.client.indices).to receive(:put_settings).with(index: name, body: after_import_body).once
+          expect(CitiesIndex).to receive(:import).with(suffix: suffix, journal: false, refresh: true).and_call_original
+          expect(CitiesIndex.reset!(suffix)).to eq(true)
+        end
+      end
+
+      context 'not activated' do
+        let(:reset_no_replicas) { false }
+        specify do
+          expect(CitiesIndex.client.indices).not_to receive(:put_settings)
+          expect(CitiesIndex).to receive(:import).with(suffix: suffix, journal: false, refresh: true).and_call_original
+          expect(CitiesIndex.reset!(suffix)).to eq(true)
+        end
       end
     end
+
+    xcontext 'applying journal' do
+      before do
+        stub_index(:cities) do
+          define_type City do
+            field :name, value: (lambda do
+              sleep(rating)
+              name
+            end)
+          end
+        end
+      end
+
+      let!(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "Name#{i + 1}", rating: 1) } }
+
+      let(:parallel_update) do
+        Thread.new do
+          p 'start parallel'
+          sleep(1.5)
+          cities.first.update(name: 'NewName1', rating: 0)
+          cities.last.update(name: 'NewName3', rating: 0)
+          CitiesIndex::City.import!([cities.first, cities.last], journal: true)
+          p 'end parallel'
+        end
+      end
+
+      specify 'with journal application' do
+        cities
+        p 'cities created1'
+        ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
+        [
+          parallel_update,
+          Thread.new do
+            p 'start reset1'
+            CitiesIndex.reset!('suffix')
+            p 'end reset1'
+          end
+        ].map(&:join)
+        ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
+        p 'expect1'
+        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 NewName1], %w[2 Name2], %w[3 NewName3])
+        p 'end expect1'
+      end
+
+      specify 'without journal application' do
+        cities
+        p 'cities created2'
+        ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
+        [
+          parallel_update,
+          Thread.new do
+            p 'start reset2'
+            CitiesIndex.reset!('suffix', apply_journal: false)
+            p 'end reset2'
+          end
+        ].map(&:join)
+        ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
+        p 'expect2'
+        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 Name1], %w[2 Name2], %w[3 Name3])
+        p 'end expect2'
+      end
+    end
+
+    context 'journaling' do
+      before { City.create!(id: 1, name: 'Moscow') }
+
+      specify do
+        CitiesIndex.reset!
+        expect(Chewy::Stash::Journal.count).to eq(0)
+      end
+
+      specify do
+        CitiesIndex.reset! journal: true
+        expect(Chewy::Stash::Journal.count).to be > 0
+      end
+    end
+
+    context 'other options' do
+      specify do
+        expect(CitiesIndex::City).to receive(:import).with(parallel: true, journal: false).once.and_return(true)
+        expect(CitiesIndex.reset!(parallel: true)).to eq(true)
+      end
+
+      specify do
+        expect(CitiesIndex::City).to receive(:import).with(suffix: 'suffix', parallel: true, journal: false, refresh: true).once.and_return(true)
+        expect(CitiesIndex.reset!('suffix', parallel: true)).to eq(true)
+      end
+    end
+  end
+
+  describe '.journal' do
+    specify { expect(DummiesIndex.journal).to be_a(Chewy::Journal) }
   end
 end

data/spec/chewy/index/aliases_spec.rb

@@ -22,7 +22,7 @@ describe Chewy::Index::Aliases do
     context do
       before { DummiesIndex.create! '2013' }
       before { DummiesIndex.create! '2014' }
-      specify { expect(DummiesIndex.indexes).to match_array(['dummies_2013', 'dummies_2014']) }
+      specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
     end
   end
 
@@ -38,7 +38,7 @@ describe Chewy::Index::Aliases do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2014' }
-      specify { expect(DummiesIndex.aliases).to match_array(['dummies_2013', 'dummies_2014']) }
+      specify { expect(DummiesIndex.aliases).to match_array(%w[dummies_2013 dummies_2014]) }
     end
 
     context do