chewy 0.9.0 → 0.10.0

data/spec/chewy/fields/root_spec.rb

@@ -1,9 +1,6 @@
 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
@@ -13,34 +10,94 @@ describe Chewy::Fields::Root do
       field.dynamic_template 'hello.*'
       field.dynamic_template(/hello/)
       field.dynamic_template(/hello.*/)
-      field.dynamic_template template_42: { mapping: {}, match: '' }
+      field.dynamic_template template_42: {mapping: {}, match: ''}
       field.dynamic_template(/hello\..*/)
 
-      expect(field.mappings_hash).to eq(product: { dynamic_templates: [
-        { template_1: { mapping: { type: 'string' }, 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' } }
-      ] })
+      expect(field.mappings_hash).to eq(product: {dynamic_templates: [
+        {template_1: {mapping: {type: 'string'}, 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) do
         described_class.new('product', dynamic_templates: [
-          { template_42: { mapping: {}, match: '' } }
+          {template_42: {mapping: {}, match: ''}}
         ])
       end
 
       specify do
         field.dynamic_template 'hello', type: 'string'
-        expect(field.mappings_hash).to eq(product: { dynamic_templates: [
-          { template_42: { mapping: {}, match: '' } },
-          { template_1: { mapping: { type: 'string' }, match: 'hello' } }
-        ] })
+        expect(field.mappings_hash).to eq(product: {dynamic_templates: [
+          {template_42: {mapping: {}, match: ''}},
+          {template_1: {mapping: {type: 'string'}, 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.send(:build_root).compose(city))
+          .to match(hash_including('name' => 'London', 'rating' => 100))
+      end
+      specify do
+        expect(PlacesIndex::City.send(:build_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.send(:build_root).compose(city))
+          .to eq('name' => 'London', 'rating' => 100)
+      end
+      specify do
+        expect(PlacesIndex::City.send(:build_root).compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'London')
+      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.send(:build_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

@@ -23,7 +23,6 @@ describe 'Time fields' do
   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(%w(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(%w(dummies_2013 dummies_2014)) }
+        specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
       end
     end
 
@@ -336,82 +326,222 @@ 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
 
-      specify { expect(CitiesIndex.all).to have(1).item }
-      specify { expect(CitiesIndex.aliases).to eq([]) }
-      specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
+        context 'refresh_interval already defined' do
+          before do
+            stub_index(:cities) do
+              settings index: {refresh_interval: '2s'}
+              define_type City
+            end
+          end
 
-      context do
-        before { CitiesIndex.reset!('2014') }
+          let(:after_import_body) do
+            {
+              index: {refresh_interval: '2s'}
+            }
+          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 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
+        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
 
-    context 'journaling' do
+    context 'applying journal' do
       before do
-        begin
-          Chewy.client.indices.delete(index: Chewy::Journal.index_name)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          nil
+        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
+          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)
+        end
+      end
+
+      specify 'with journal application' do
+        parallel_update
+        CitiesIndex.reset!('suffix')
+        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 NewName1], %w[2 Name2], %w[3 NewName3])
+      end
+
+      specify 'without journal application' do
+        parallel_update
+        CitiesIndex.reset!('suffix', apply_journal: false)
+        expect(CitiesIndex::City.pluck(:_id, :name)).to contain_exactly(%w[1 Name1], %w[2 Name2], %w[3 Name3])
+      end
+    end
+
+    context 'journaling' do
+      before { City.create!(id: 1, name: 'Moscow') }
+
       specify do
         CitiesIndex.reset!
-
-        expect(Chewy.client.indices.exists?(index: Chewy::Journal.index_name)).to eq false
+        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
 
-        expect(Chewy.client.indices.exists?(index: Chewy::Journal.index_name)).to eq true
-        expect(Chewy.client.count(index: Chewy::Journal.index_name)['count']).not_to eq 0
+    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(%w(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(%w(dummies_2013 dummies_2014)) }
+      specify { expect(DummiesIndex.aliases).to match_array(%w[dummies_2013 dummies_2014]) }
     end
 
     context do

data/spec/chewy/index/settings_spec.rb

@@ -6,30 +6,59 @@ 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).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: {} })
+        .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: {} } } })
+      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: {} } } })
+      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) } }
-               } })
+        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: { analyser: ['analyzer1'] }).to_hash)
-        .to eq(settings: { number_of_nodes: 3, analysis: {} })
+      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
@@ -37,12 +66,12 @@ describe Chewy::Index::Settings do
 
       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 } }
-                 } })
+          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
 
@@ -55,13 +84,13 @@ describe Chewy::Index::Settings do
 
       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 } }
-                 } })
+          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
 
@@ -73,31 +102,31 @@ describe Chewy::Index::Settings do
 
       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 } }
-                 } })
+          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 do
-        expect(described_class.new(index: { number_of_shards: 3 }).to_hash)
-          .to eq(settings: { index: { number_of_shards: 3 } })
+        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 { allow(Chewy).to receive_messages(configuration: {index: {number_of_shards: 7, number_of_replicas: 2}}) }
 
         specify do
           expect(described_class.new.to_hash)
-            .to eq(settings: { index: { number_of_shards: 7, number_of_replicas: 2 } })
+            .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 } })
+          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