chewy 0.9.0 → 5.2.0

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

data/spec/chewy/index/specification_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Chewy::Index::Specification do
+  before { Chewy.massacre }
+
+  let(:index1) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :founded_on, type: 'date'
+      end
+    end
+  end
+
+  let(:index2) do
+    stub_index(:places) do
+      settings analyzer: {}
+      define_type(:city) do
+        field :founded_on, type: 'date'
+      end
+    end
+  end
+
+  let(:index3) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :founded_on, type: 'date'
+        field :population, type: 'integer'
+      end
+    end
+  end
+
+  let(:index4) do
+    stub_index(:places) do
+      define_type(:city) do
+        field :population, type: 'integer'
+        field :founded_on, type: 'date'
+      end
+    end
+  end
+
+  let(:index5) do
+    stub_index('namespace/cities') do
+      define_type(:city) do
+        field :population, type: 'integer'
+      end
+    end
+  end
+
+  let(:specification1) { described_class.new(index1) }
+  let(:specification2) { described_class.new(index2) }
+  let(:specification3) { described_class.new(index3) }
+  let(:specification4) { described_class.new(index4) }
+  let(:specification5) { described_class.new(index5) }
+
+  describe '#lock!' do
+    specify do
+      expect { specification1.lock! }.to change { Chewy::Stash::Specification.all.hits }.from([]).to([{
+        '_index' => 'chewy_specifications',
+        '_type' => 'specification',
+        '_id' => 'places',
+        '_score' => 1.0,
+        '_source' => {'specification' => Base64.encode64({
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+        }.to_json)}
+      }])
+    end
+
+    context do
+      before { specification1.lock! }
+
+      specify do
+        expect { specification5.lock! }.to change { Chewy::Stash::Specification.all.hits }.to([{
+          '_index' => 'chewy_specifications',
+          '_type' => 'specification',
+          '_id' => 'places',
+          '_score' => 1.0,
+          '_source' => {'specification' => Base64.encode64({
+            'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+            'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+          }.to_json)}
+        }, {
+          '_index' => 'chewy_specifications',
+          '_type' => 'specification',
+          '_id' => 'namespace/cities',
+          '_score' => 1.0,
+          '_source' => {'specification' => Base64.encode64({
+            'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+            'mappings' => {'city' => {'properties' => {'population' => {'type' => 'integer'}}}}
+          }.to_json)}
+        }])
+      end
+    end
+  end
+
+  describe '#locked' do
+    specify do
+      expect { specification1.lock! }.to change { specification1.locked }.from({}).to(
+        'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+        'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+      )
+    end
+
+    specify do
+      expect { specification5.lock! }.to change { specification5.locked }.from({}).to(
+        'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+        'mappings' => {'city' => {'properties' => {'population' => {'type' => 'integer'}}}}
+      )
+    end
+
+    context do
+      before { specification1.lock! }
+
+      specify do
+        expect { specification2.lock! }.to change { specification2.locked }.from(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+        ).to(
+          'settings' => {'analyzer' => {}, 'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+        )
+      end
+
+      specify do
+        expect { specification3.lock! }.to change { specification3.locked }.from(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}}
+        ).to(
+          'settings' => {'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}},
+          'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}, 'population' => {'type' => 'integer'}}}}
+        )
+      end
+    end
+  end
+
+  describe '#current' do
+    specify do
+      expect(specification2.current).to eq(
+        'mappings' => {'city' => {'properties' => {'founded_on' => {'type' => 'date'}}}},
+        'settings' => {'analyzer' => {}, 'index' => {'number_of_shards' => 1, 'number_of_replicas' => 0}}
+      )
+    end
+  end
+
+  describe '#changed?' do
+    specify { expect(specification1.changed?).to eq(true) }
+    specify { expect { specification1.lock! }.to change { specification1.changed? }.to(false) }
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification2.lock! }.to change { specification2.changed? }.from(true).to(false) }
+    end
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification3.lock! }.to change { specification3.changed? }.from(true).to(false) }
+    end
+
+    context do
+      before { specification1.lock! }
+      specify { expect { specification5.lock! }.to change { specification5.changed? }.from(true) }
+    end
+
+    context do
+      before { specification3.lock! }
+      specify { expect { specification4.lock! }.not_to change { specification4.changed? }.from(false) }
+    end
+  end
+end

data/spec/chewy/index_spec.rb

@@ -61,16 +61,28 @@ describe Chewy::Index do
     specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(suffix: '2013')).to eq('developers_2013') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: '')).to eq('developers') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name(prefix: 'test')).to eq('test_developers') }
+
     context do
-      before { allow(Chewy).to receive_messages(configuration: { prefix: 'testing' }) }
+      before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
       specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
       specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
+      specify { expect(stub_index(:dummies) { index_name :users }.index_name(prefix: '')).to eq('users') }
     end
   end
 
-  describe '.default_prefix' do
-    before { allow(Chewy).to receive_messages(configuration: { prefix: 'testing' }) }
-    specify { expect(Class.new(Chewy::Index).default_prefix).to eq('testing') }
+  describe '.derivable_name' do
+    specify { expect(Class.new(Chewy::Index).derivable_name).to be_nil }
+    specify { expect(stub_index(:places).derivable_name).to eq('places') }
+    specify { expect(stub_index('namespace/places').derivable_name).to eq('namespace/places') }
+  end
+
+  describe '.prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+    specify { expect(Class.new(Chewy::Index).prefix).to eq('testing') }
   end
 
   describe '.define_type' do
@@ -117,15 +129,14 @@ describe Chewy::Index do
     context 'type methods should be deprecated and can\'t redefine existing ones' do
       before do
         stub_index(:places) do
-          def self.city
-          end
+          def self.city; end
           define_type :city
           define_type :country
         end
       end
 
       specify { expect(PlacesIndex.city).to be_nil }
-      specify { expect(PlacesIndex.country).to be < Chewy::Type }
+      specify { expect(PlacesIndex::Country).to be < Chewy::Type }
     end
   end
 
@@ -145,69 +156,86 @@ describe Chewy::Index do
 
   describe '.types' do
     specify { expect(DummiesIndex.types).to eq(DummiesIndex.type_hash.values) }
-    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Query }
-    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Query }
+    specify { expect(DummiesIndex.types(:dummy)).to be_a Chewy::Search::Request }
+    specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Search::Request }
   end
 
   describe '.settings' do
     before do
       allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
-      Chewy.analyzer :name, filter: %w(lowercase icu_folding names_nysiis)
+      Chewy.analyzer :name, filter: %w[lowercase icu_folding names_nysiis]
       Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
       Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
       Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
       Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
     end
 
-    let(:documents) { stub_index(:documents) { settings analysis: { analyzer: [:name, :phone, { sorted: { option: :baz } }] } } }
+    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
 
     specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect) }
     specify do
-      expect(documents.settings_hash).to eq(settings: { analysis: {
-                                              analyzer: { name: { filter: %w(lowercase icu_folding names_nysiis) },
-                                                          phone: { tokenizer: 'ngram', char_filter: ['phone'] },
-                                                          sorted: { option: :baz } },
-                                              tokenizer: { ngram: { type: 'nGram', min_gram: 3, max_gram: 3 } },
-                                              char_filter: { phone: { type: 'pattern_replace', pattern: '[^\d]', replacement: '' } },
-                                              filter: { names_nysiis: { type: 'phonetic', encoder: 'nysiis', replace: false } }
-                                            } })
+      expect(documents.settings_hash).to eq(settings: {analysis: {
+        analyzer: {name: {filter: %w[lowercase icu_folding names_nysiis]},
+                   phone: {tokenizer: 'ngram', char_filter: ['phone']},
+                   sorted: {option: :baz}},
+        tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
+        char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
+        filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
+      }})
     end
   end
 
   describe '.scopes' do
     before do
       stub_index(:places) do
-        def self.by_rating
-        end
+        def self.by_rating; end
 
-        def self.by_name
+        def self.colors(*colors)
+          filter(terms: {colors: colors.flatten(1).map(&:to_s)})
         end
 
         define_type :city do
-          def self.by_id
-          end
+          def self.by_id; end
+          field :colors
         end
       end
     end
 
     specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex.scopes).to match_array([:by_rating, :by_name]) }
-  end
+    specify { expect(PlacesIndex.scopes).to match_array(%i[by_rating colors]) }
 
-  describe '.build_index_name' do
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(suffix: '2013')).to eq('developers_2013') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: '')).to eq('developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(prefix: 'test')).to eq('test_developers') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013')).to eq('test_users_2013') }
+    context do
+      before do
+        Chewy.massacre
+        PlacesIndex::City.import!(
+          double(colors: ['red']),
+          double(colors: %w[red green]),
+          double(colors: %w[green yellow])
+        )
+      end
+
+      specify do
+        # This `blank?`` call is for the messed scopes bug reproduction. See #573
+        PlacesIndex::City.blank?
+        expect(PlacesIndex.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+
+      specify do
+        # This `blank?` call is for the messed scopes bug reproduction. See #573
+        PlacesIndex::City.blank?
+        expect(PlacesIndex::City.colors(:green).map(&:colors))
+          .to contain_exactly(%w[red green], %w[green yellow])
+      end
+    end
   end
 
   describe '.settings_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
     specify { expect(stub_index(:documents).settings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: { number_of_shards: 1 }) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.settings_hash).to eq(settings: {number_of_shards: 1}) }
   end
 
   describe '.mappings_hash' do
@@ -216,78 +244,94 @@ describe Chewy::Index do
     specify do
       expect(stub_index(:documents) do
                define_type :document do
-                 field :name, type: 'string'
+                 field :date, type: 'date'
                end
-             end.mappings_hash).to eq(mappings: { document: { properties: { name: { type: 'string' } } } })
+             end.mappings_hash).to eq(mappings: {document: {properties: {date: {type: 'date'}}}})
     end
     specify do
       expect(stub_index(:documents) do
                define_type :document do
-                 field :name, type: 'string'
+                 field :name
                end
                define_type :document2 do
-                 field :name, type: 'string'
+                 field :name
                end
-             end.mappings_hash[:mappings].keys).to match_array([:document, :document2])
+             end.mappings_hash[:mappings].keys).to match_array(%i[document document2])
     end
   end
 
-  describe '.index_params' do
+  describe '.specification_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-    specify { expect(stub_index(:documents).index_params).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
+    specify { expect(stub_index(:documents).specification_hash).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.specification_hash.keys).to eq([:settings]) }
     specify do
       expect(stub_index(:documents) do
                define_type :document do
-                 field :name, type: 'string'
+                 field :name
                end
-             end.index_params.keys).to eq([:mappings])
+             end.specification_hash.keys).to eq([:mappings])
     end
     specify do
       expect(stub_index(:documents) do
                settings number_of_shards: 1
                define_type :document do
-                 field :name, type: 'string'
+                 field :name
                end
-             end.index_params.keys).to match_array([:mappings, :settings])
+             end.specification_hash.keys).to match_array(%i[mappings settings])
     end
   end
 
-  describe '.journal?' do
-    specify { expect(stub_index(:documents).journal?).to eq false }
+  describe '.specification' do
+    subject { stub_index(:documents) }
+    specify { expect(subject.specification).to be_a(Chewy::Index::Specification) }
+    specify { expect(subject.specification).to equal(subject.specification) }
+  end
+
+  describe '.default_prefix' do
+    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
 
     context do
-      before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
-      specify { expect(stub_index(:documents).journal?).to eq false }
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.default_prefix).to eq('testing') }
     end
 
     context do
-      let(:index) do
-        stub_index(:documents) do
-          define_type :document do
+      before do
+        DummiesIndex.class_eval do
+          def self.default_prefix
+            'borogoves'
           end
         end
       end
 
-      specify { expect(index.journal?).to eq false }
+      before { expect(ActiveSupport::Deprecation).to receive(:warn).once }
+      specify { expect(DummiesIndex.index_name).to eq('borogoves_dummies') }
+    end
+  end
 
-      context do
-        before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
-        specify { expect(index.journal?).to eq true }
+  context 'index call inside index', :orm do
+    before do
+      stub_index(:cities) do
+        define_type :city do
+          field :country_name, value: (lambda do |city|
+            CountriesIndex::Country.filter(term: {_id: city.country_id}).first.name
+          end)
+        end
       end
-    end
 
-    context do
-      let(:index) do
-        stub_index(:documents) do
-          define_type :document do
-            default_import_options journal: true
-          end
+      stub_index(:countries) do
+        define_type :country do
+          field :name
         end
       end
 
-      specify { expect(index.journal?).to eq true }
+      CountriesIndex::Country.import!(double(id: 1, name: 'Country'))
+    end
+
+    specify do
+      expect { CitiesIndex::City.import!(double(country_id: 1)) }
+        .to update_index(CitiesIndex::City).and_reindex(country_name: 'Country')
     end
   end
 end