chewy 0.8.4 → 0.9.0

data/spec/chewy/fields/root_spec.rb

@@ -11,33 +11,35 @@ describe Chewy::Fields::Root do
       field.dynamic_template 'hello', type: 'string'
       field.dynamic_template 'hello*', :integer
       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/)
+      field.dynamic_template(/hello.*/)
+      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) { 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: [
-          {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

data/spec/chewy/fields/time_fields_spec.rb

@@ -11,17 +11,19 @@ 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 { 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) }
 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
 
@@ -83,7 +83,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
 
@@ -287,7 +287,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 +311,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) }
 
@@ -390,5 +390,28 @@ describe Chewy::Index::Actions do
         specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
       end
     end
+
+    context 'journaling' do
+      before do
+        begin
+          Chewy.client.indices.delete(index: Chewy::Journal.index_name)
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          nil
+        end
+      end
+
+      specify do
+        CitiesIndex.reset!
+
+        expect(Chewy.client.indices.exists?(index: Chewy::Journal.index_name)).to eq false
+      end
+
+      specify do
+        CitiesIndex.reset! journal: true
+
+        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
+      end
+    end
   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

data/spec/chewy/index/settings_spec.rb

@@ -6,77 +6,99 @@ 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: { analyser: ['analyzer1'] }).to_hash)
+        .to eq(settings: { number_of_nodes: 3, analysis: {} })
+    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 { allow(Chewy).to receive_messages(configuration: { index: { number_of_shards: 7, number_of_replicas: 2 } }) }
 
-        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

data/spec/chewy/index_spec.rb

@@ -18,8 +18,8 @@ describe Chewy::Index do
       end
     end
 
-    let!(:cities) { 2.times.map { |i| City.create! id: i + 1 } }
-    let!(:countries) { 2.times.map { |i| Country.create! id: i + 1 } }
+    let!(:cities) { Array.new(2) { |i| City.create! id: i + 1 } }
+    let!(:countries) { Array.new(2) { |i| Country.create! id: i + 1 } }
 
     specify do
       expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
@@ -62,14 +62,14 @@ describe Chewy::Index do
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('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') }
     end
   end
 
   describe '.default_prefix' do
-    before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+    before { allow(Chewy).to receive_messages(configuration: { prefix: 'testing' }) }
     specify { expect(Class.new(Chewy::Index).default_prefix).to eq('testing') }
   end
 
@@ -92,29 +92,29 @@ describe Chewy::Index do
       before { stub_class('City::District', City) }
 
       specify do
-        expect {
+        expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex < Chewy::Index
               define_type City
               define_type City::District
             end
           DUMMY_CITY_INDEX
-        }.not_to raise_error
+        end.not_to raise_error
       end
 
       specify do
-        expect {
+        expect do
           Kernel.eval <<-DUMMY_CITY_INDEX
             class DummyCityIndex2 < Chewy::Index
               define_type City
               define_type City::Nothing
             end
           DUMMY_CITY_INDEX
-        }.to raise_error(NameError)
+        end.to raise_error(NameError)
       end
     end
 
-    context 'type methods should be deprecated and can\'t redefine existion ones' do
+    context 'type methods should be deprecated and can\'t redefine existing ones' do
       before do
         stub_index(:places) do
           def self.city
@@ -136,6 +136,11 @@ describe Chewy::Index do
     specify { expect(DummiesIndex.type_hash['dummy'].type_name).to eq('dummy') }
   end
 
+  describe '.type' do
+    specify { expect(DummiesIndex.type('dummy')).to eq(DummiesIndex::Dummy) }
+    specify { expect { DummiesIndex.type('not-the-dummy') }.to raise_error(Chewy::UndefinedType) }
+  end
+
   specify { expect(DummiesIndex.type_names).to eq(DummiesIndex.type_hash.keys) }
 
   describe '.types' do
@@ -148,24 +153,26 @@ describe Chewy::Index do
     before do
       allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
-      Chewy.analyzer :name, filter: ['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 { expect(documents.settings_hash).to eq({settings: {analysis: {
-      analyzer: {name: {filter: ['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}}
-    }}}) }
+    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 } }
+                                            } })
+    end
   end
 
   describe '.scopes' do
@@ -200,25 +207,29 @@ describe Chewy::Index 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
     specify { expect(stub_index(:documents).mappings_hash).to eq({}) }
     specify { expect(stub_index(:documents) { define_type :document }.mappings_hash).to eq({}) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
-      end
-    end.mappings_hash).to eq({mappings: {document: {properties: {name: {type: 'string'}}}}}) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
-      end
-      define_type :document2 do
-        field :name, type: 'string'
-      end
-    end.mappings_hash[:mappings].keys).to match_array([:document, :document2]) }
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :name, type: 'string'
+               end
+             end.mappings_hash).to eq(mappings: { document: { properties: { name: { type: 'string' } } } })
+    end
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :name, type: 'string'
+               end
+               define_type :document2 do
+                 field :name, type: 'string'
+               end
+             end.mappings_hash[:mappings].keys).to match_array([:document, :document2])
+    end
   end
 
   describe '.index_params' do
@@ -226,16 +237,57 @@ describe Chewy::Index do
 
     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) do
-      define_type :document do
-        field :name, type: 'string'
+    specify do
+      expect(stub_index(:documents) do
+               define_type :document do
+                 field :name, type: 'string'
+               end
+             end.index_params.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'
+               end
+             end.index_params.keys).to match_array([:mappings, :settings])
+    end
+  end
+
+  describe '.journal?' do
+    specify { expect(stub_index(:documents).journal?).to eq false }
+
+    context do
+      before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
+      specify { expect(stub_index(:documents).journal?).to eq false }
+    end
+
+    context do
+      let(:index) do
+        stub_index(:documents) do
+          define_type :document do
+          end
+        end
       end
-    end.index_params.keys).to eq([:mappings]) }
-    specify { expect(stub_index(:documents) do
-      settings number_of_shards: 1
-      define_type :document do
-        field :name, type: 'string'
+
+      specify { expect(index.journal?).to eq false }
+
+      context do
+        before { allow(Chewy).to receive_messages(configuration: { journal: true }) }
+        specify { expect(index.journal?).to eq true }
       end
-    end.index_params.keys).to match_array([:mappings, :settings]) }
+    end
+
+    context do
+      let(:index) do
+        stub_index(:documents) do
+          define_type :document do
+            default_import_options journal: true
+          end
+        end
+      end
+
+      specify { expect(index.journal?).to eq true }
+    end
   end
 end