chewy 5.0.0 → 7.1.0

data/migration_guide.md

@@ -0,0 +1,37 @@
+# Migration guide
+
+This document outlines the steps you need to take when migrating between major versions of
+Chewy and Elasticsearch. For simplicity's sake the guide will assume that you're using
+Chewy alongside a matching Elasticsearch version.
+
+## Chewy 6/Elasticsearch 6 to Chewy 7/Elasticsearch 7
+
+In order to upgrade Chewy 6/Elasticsearch 6 to Chewy 7/Elasticsearch 7 in the most seamless manner you have to:
+
+* Upgrade to the latest 6.x stable releases, namely Chewy 6.0, Elasticsearch 6.8
+* Study carefully [Breaking changes in 7.0](https://www.elastic.co/guide/en/elasticsearch/reference/current/breaking-changes-7.0.htmll), make sure your application conforms.
+* Run your test suite on Chewy 7.0 / Elasticsearch 7
+* Run manual tests on Chewy 7.0 / Elasticsearch 7
+* Upgrade to Chewy 7.0
+* Perform a [rolling upgrade](https://www.elastic.co/guide/en/elasticsearch/reference//rolling-upgrades.html) of Elasticsearch
+* Run your test suite on Chewy 7.1 / Elasticsearch 7
+* Run manual tests on Chewy 7.1 / Elasticsearch 7
+* Upgrade to Chewy 7.1
+
+## Chewy 5/Elasticsearch 5 to Chewy 6/Elasticsearch 6
+
+In order to upgrade Chewy 5/Elasticsearch 5 to Chewy 6/Elasticsearch 6 in the most seamless manner you have to:
+
+* Upgrade to the latest 5.x stable releases, namely Chewy 5.2, Elasticsearch 5.6
+* [Migrate any multi-typed indexes into single-typed](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/removal-of-types.html)
+  * Using [multi-index queries](https://github.com/toptal/chewy/pull/657) could be helpful
+  * Parent/Child [relationship is deprecated](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/removal-of-types.html#parent-child-mapping-types) in favor of the [join field](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/parent-join.html)
+* Handle deprecation of `string` type & `not_analyzed` value for the `index` mapping parameter:
+  * replace fields with `{ type: 'string', index: 'not_analyzed'}` by `{type: 'keyword'}`
+  * replace fields with `{ type: 'string', index: 'analyzed'}` by `{type: 'text'}`
+* `PathHierarchy` tokenizer' param `delimiter` now accepts only one argument, [others should be replaced by character filter ](https://discuss.elastic.co/t/multichar-delimiter-in-path-hierarchy-tokenizer/16203)
+* Make sure you don't use any other of the [deprecated Elasticsearch 5 features](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/breaking-changes-6.0.html)
+* Run your test suite on Chewy 6 / Elasticsearch 6
+* Run manual tests on Chewy 6 / Elasticsearch 6
+* Upgrade to Chewy 6
+* Perform a [rolling upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/rolling-upgrades.html) of Elasticsearch

data/spec/chewy/config_spec.rb

@@ -6,9 +6,6 @@ describe Chewy::Config do
   its(:logger) { should be_nil }
   its(:transport_logger) { should be_nil }
   its(:transport_logger) { should be_nil }
-  its(:query_mode) { should == :must }
-  its(:filter_mode) { should == :and }
-  its(:post_filter_mode) { should be_nil }
   its(:root_strategy) { should == :base }
   its(:request_strategy) { should == :atomic }
   its(:use_after_commit_callbacks) { should == true }
@@ -54,24 +51,6 @@ describe Chewy::Config do
     end
   end
 
-  describe '#search_class=' do
-    specify do
-      expect { subject.search_class = Chewy::Query }
-        .to change { subject.search_class }
-        .from(be < Chewy::Search::Request)
-        .to(be < Chewy::Query)
-    end
-
-    context do
-      before { hide_const('Kaminari') }
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .to include(Chewy::Search::Pagination::WillPaginate)
-      end
-    end
-  end
-
   describe '#search_class' do
     context 'nothing is defined' do
       before do
@@ -141,7 +120,7 @@ describe Chewy::Config do
     context 'when Rails::VERSION constant is defined' do
       it 'looks for configuration in "config/chewy.yml"' do
         module Rails
-          VERSION = '5.1.0'.freeze
+          VERSION = '5.1.1'.freeze
 
           def self.root
             Pathname.new(__dir__)

data/spec/chewy/fields/base_spec.rb

@@ -143,7 +143,7 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(EventsIndex::Event.mappings_hash).to eq(event: {
+        expect(EventsIndex::Event.mappings_hash).to eq(
           properties: {
             id: {type: 'integer'},
             category: {
@@ -160,7 +160,7 @@ describe Chewy::Fields::Base do
               }
             }
           }
-        })
+        )
       end
     end
 
@@ -180,43 +180,45 @@ describe Chewy::Fields::Base do
         end
       end
 
+      # rubocop:disable Style/BracesAroundHashParameters
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
-        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
+        expect(EventsIndex::Event.root.compose({
+          id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
+        })).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(id: 1, category: [
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
           {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
           {id: 4, licenses: nil}
-        ])).to eq('id' => 1, 'category' => [
+        ]})).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
           {'id' => 4, 'licenses' => nil.as_json}
         ])
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose('id' => 1, category: {id: 2, licenses: [
+        expect(EventsIndex::Event.root.compose({'id' => 1, category: {id: 2, licenses: [
           {id: 3, name: 'Name1'}, {id: 4, name: 'Name2'}
-        ]})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+        ]}})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
           {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
         ]})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(id: 1, category: [
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
           {id: 2, licenses: [
             {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
           ]},
           {id: 5, licenses: []}
-        ])).to eq('id' => 1, 'category' => [
+        ]})).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => [
             {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
           ]},
           {'id' => 5, 'licenses' => []}
         ])
       end
+      # rubocop:enable Style/BracesAroundHashParameters
 
       specify do
         expect(EventsIndex::Event.root.compose(
@@ -294,7 +296,7 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(EventsIndex::Event.mappings_hash).to eq(event: {
+        expect(EventsIndex::Event.mappings_hash).to eq(
           properties: {
             id: {type: 'integer'},
             name: {
@@ -305,7 +307,7 @@ describe Chewy::Fields::Base do
             },
             category: {type: 'object'}
           }
-        })
+        )
       end
 
       specify do

data/spec/chewy/fields/root_spec.rb

@@ -13,7 +13,7 @@ describe Chewy::Fields::Root do
       field.dynamic_template template_42: {mapping: {}, match: ''}
       field.dynamic_template(/hello\..*/)
 
-      expect(field.mappings_hash).to eq(product: {dynamic_templates: [
+      expect(field.mappings_hash).to eq(dynamic_templates: [
         {template_1: {mapping: {type: 'keyword'}, match: 'hello'}},
         {template_2: {mapping: {}, match_mapping_type: 'integer', match: 'hello*'}},
         {template_3: {mapping: {}, path_match: 'hello.*'}},
@@ -21,7 +21,7 @@ describe Chewy::Fields::Root do
         {template_5: {mapping: {}, match: 'hello.*', match_pattern: 'regexp'}},
         {template_42: {mapping: {}, match: ''}},
         {template_7: {mapping: {}, path_match: 'hello\..*', match_pattern: 'regexp'}}
-      ]})
+      ])
     end
 
     context do
@@ -33,10 +33,10 @@ describe Chewy::Fields::Root do
 
       specify do
         field.dynamic_template 'hello', type: 'keyword'
-        expect(field.mappings_hash).to eq(product: {dynamic_templates: [
+        expect(field.mappings_hash).to eq(dynamic_templates: [
           {template_42: {mapping: {}, match: ''}},
           {template_1: {mapping: {type: 'keyword'}, match: 'hello'}}
-        ]})
+        ])
       end
     end
   end

data/spec/chewy/index/actions_spec.rb

@@ -3,7 +3,10 @@ require 'spec_helper'
 describe Chewy::Index::Actions do
   before { Chewy.massacre }
 
-  before { stub_index :dummies }
+  before do
+    stub_index :dummies
+    stub_index :dummies_suffixed
+  end
 
   describe '.exists?' do
     specify { expect(DummiesIndex.exists?).to eq(false) }
@@ -25,26 +28,40 @@ describe Chewy::Index::Actions do
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify { expect(DummiesIndex.create('2013')).to eq(false) }
       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]) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013', alias: false }
+      before do
+        DummiesIndex.create '2013', alias: false
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.exists?).to eq(false) }
+      # Unfortunately, without alias we can't figure out that this dummies_2013 index is related to DummiesIndex
+      # it would be awesome to have the following specs passing
+      # specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
+      # specify { expect(DummiesIndex.exists?).to eq(true) }
     end
   end
 
@@ -53,36 +70,54 @@ describe Chewy::Index::Actions do
     specify { expect(DummiesIndex.create!('2013')['acknowledged']).to eq(true) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify do
-        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies/)
+        expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*dummies/)
       end
       specify { expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/Invalid alias name \[dummies\]/) }
     end
 
     context do
-      before { DummiesIndex.create! '2013' }
+      before do
+        DummiesIndex.create! '2013'
+        DummiesSuffixedIndex.create! 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify do
-        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/index_already_exists_exception.*dummies_2013/)
+        expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*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]) }
       end
     end
 
     context do
-      before { DummiesIndex.create! '2013', alias: false }
+      before do
+        DummiesIndex.create! '2013', alias: false
+        DummiesSuffixedIndex.create! 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.exists?).to eq(false) }
+      # Unfortunately, without alias we can't figure out that this dummies_2013 index is related to DummiesIndex
+      # it would be awesome to have the following specs passing
+      # specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
+      # specify { expect(DummiesIndex.exists?).to eq(true) }
     end
   end
 
@@ -91,27 +126,40 @@ describe Chewy::Index::Actions do
     specify { expect(DummiesIndex.delete('dummies_2013')).to eq(false) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete('2013') }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
         specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
 
       context do
-        before { DummiesIndex.create '2014' }
+        before do
+          DummiesIndex.create '2014'
+        end
+
         specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
         context do
@@ -119,6 +167,7 @@ describe Chewy::Index::Actions do
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
 
         context do
@@ -126,6 +175,7 @@ describe Chewy::Index::Actions do
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
       end
     end
@@ -136,27 +186,38 @@ describe Chewy::Index::Actions do
     specify { expect { DummiesIndex.delete!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete! }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete!('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete!('2013') }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
         specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
+
         specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
         context do
@@ -164,6 +225,7 @@ describe Chewy::Index::Actions do
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
 
         context do
@@ -171,6 +233,7 @@ describe Chewy::Index::Actions do
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
       end
     end
@@ -184,19 +247,19 @@ describe Chewy::Index::Actions do
       before { DummiesIndex.purge }
       specify { expect(DummiesIndex).to be_exists }
       specify { expect(DummiesIndex.aliases).to eq([]) }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
 
       context do
         before { DummiesIndex.purge }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge('2013') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
@@ -204,20 +267,20 @@ describe Chewy::Index::Actions do
     context do
       before { DummiesIndex.purge('2013') }
       specify { expect(DummiesIndex).to be_exists }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge('2014') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
@@ -231,19 +294,19 @@ describe Chewy::Index::Actions do
       before { DummiesIndex.purge! }
       specify { expect(DummiesIndex).to be_exists }
       specify { expect(DummiesIndex.aliases).to eq([]) }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
 
       context do
         before { DummiesIndex.purge! }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge!('2013') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
@@ -251,20 +314,20 @@ describe Chewy::Index::Actions do
     context do
       before { DummiesIndex.purge!('2013') }
       specify { expect(DummiesIndex).to be_exists }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge! }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge!('2014') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
@@ -281,6 +344,18 @@ describe Chewy::Index::Actions do
 
     specify { expect(CitiesIndex.import).to eq(true) }
 
+    specify 'with an empty array' do
+      expect(CitiesIndex).not_to receive(:exists?)
+      expect(CitiesIndex).not_to receive(:create!)
+      expect(CitiesIndex.import([])).to eq(true)
+    end
+
+    specify 'with an empty relation' do
+      expect(CitiesIndex).not_to receive(:exists?)
+      expect(CitiesIndex).not_to receive(:create!)
+      expect(CitiesIndex.import(City.where('1 = 2'))).to eq(true)
+    end
+
     context do
       before do
         stub_index(:cities) do
@@ -305,6 +380,18 @@ describe Chewy::Index::Actions do
 
     specify { expect(CitiesIndex.import!).to eq(true) }
 
+    specify 'with an empty array' do
+      expect(CitiesIndex).not_to receive(:exists?)
+      expect(CitiesIndex).not_to receive(:create!)
+      expect(CitiesIndex.import!([])).to eq(true)
+    end
+
+    specify 'with an empty relation' do
+      expect(CitiesIndex).not_to receive(:exists?)
+      expect(CitiesIndex).not_to receive(:create!)
+      expect(CitiesIndex.import!(City.where('1 = 2'))).to eq(true)
+    end
+
     context do
       before do
         stub_index(:cities) do
@@ -337,13 +424,13 @@ describe Chewy::Index::Actions do
 
         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']) }
 
         context do
           before { CitiesIndex.reset!('2013') }
 
           specify { expect(CitiesIndex.all).to have(1).item }
-          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.aliases).to eq(['cities']) }
           specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
         end
 
@@ -352,7 +439,7 @@ describe Chewy::Index::Actions do
 
           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']) }
         end
       end
 
@@ -360,14 +447,14 @@ describe Chewy::Index::Actions do
         before { CitiesIndex.reset!('2013') }
 
         specify { expect(CitiesIndex.all).to have(1).item }
-        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.aliases).to eq(['cities']) }
         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.aliases).to eq(['cities']) }
           specify { expect(CitiesIndex.indexes).to eq(['cities_2014']) }
           specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
         end
@@ -377,7 +464,7 @@ describe Chewy::Index::Actions do
 
           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']) }
           specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
         end
       end