chewy 5.0.0 → 7.0.1

data/lib/chewy/type/adapter/sequel.rb

@@ -22,7 +22,7 @@ module Chewy
         end
 
         def import_scope(scope, options)
-          pluck_in_batches(scope, options.slice(:batch_size)).inject(true) do |result, ids|
+          pluck_in_batches(scope, **options.slice(:batch_size)).inject(true) do |result, ids|
             result & yield(grouped_objects(default_scope_where_ids_in(ids).all))
           end
         end

data/lib/chewy/type/import.rb

@@ -10,7 +10,7 @@ module Chewy
 
       IMPORT_WORKER = lambda do |type, options, total, ids, index|
         ::Process.setproctitle("chewy [#{type}]: import data (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
+        routine = Routine.new(type, **options)
         type.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
         end
@@ -19,7 +19,7 @@ module Chewy
 
       LEFTOVERS_WORKER = lambda do |type, options, total, body, index|
         ::Process.setproctitle("chewy [#{type}]: import leftovers (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
+        routine = Routine.new(type, **options)
         routine.perform_bulk(body)
         routine.errors
       end
@@ -67,6 +67,7 @@ module Chewy
         # @option options [String] suffix an index name suffix, used for zero-downtime reset mostly, no suffix by default
         # @option options [Integer] bulk_size bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
         # @option options [Integer] batch_size passed to the adapter import method, used to split imported objects in chunks, 1000 by default
+        # @option options [Boolean] direct_import skips object reloading in ORM adapter, `false` by default
         # @option options [true, false] journal enables imported objects journaling, false by default
         # @option options [Array<Symbol, String>] update_fields list of fields for the partial import, empty by default
         # @option options [true, false] update_failover enables full objects reimport in cases of partial update errors, `true` by default
@@ -126,8 +127,9 @@ module Chewy
       private
 
         def import_routine(*args)
-          return if args.first.blank? && !args.first.nil?
-          routine = Routine.new(self, args.extract_options!)
+          return if !args.first.nil? && empty_objects_or_scope?(args.first)
+
+          routine = Routine.new(self, **args.extract_options!)
           routine.create_indexes!
 
           if routine.parallel_options
@@ -137,6 +139,14 @@ module Chewy
           end
         end
 
+        def empty_objects_or_scope?(objects_or_scope)
+          if objects_or_scope.respond_to?(:empty?)
+            objects_or_scope.empty?
+          else
+            objects_or_scope.blank?
+          end
+        end
+
         def import_linear(objects, routine)
           ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
             adapter.import(*objects, routine.options) do |action_objects|

data/lib/chewy/type/import/bulk_request.rb

@@ -54,15 +54,17 @@ module Chewy
 
         def request_bodies(body)
           if @bulk_size
+            serializer = ::Elasticsearch::API.serializer
             pieces = body.each_with_object(['']) do |piece, result|
               operation, meta = piece.to_a.first
               data = meta.delete(:data)
-              piece = [{operation => meta}, data].compact.map(&:to_json).join("\n")
+              piece = serializer.dump(operation => meta)
+              piece << "\n" << serializer.dump(data) if data.present?
 
               if result.last.bytesize + piece.bytesize > @bulk_size
                 result.push(piece)
               else
-                result[-1] = [result[-1], piece].reject(&:blank?).join("\n")
+                result[-1].blank? ? (result[-1] = piece) : (result[-1] << "\n" << piece)
               end
             end
             pieces.each { |piece| piece << "\n" }

data/lib/chewy/type/import/journal_builder.rb

@@ -31,7 +31,7 @@ module Chewy
             index_name: @type.index.derivable_name,
             type_name: @type.type_name,
             action: action,
-            references: identify(objects).map(&:to_json).map(&Base64.method(:encode64)),
+            references: identify(objects).map { |item| Base64.encode64(::Elasticsearch::API.serializer.dump(item)) },
             created_at: Time.now.utc
           }
         end

data/lib/chewy/type/import/routine.rb

@@ -66,7 +66,7 @@ module Chewy
         def create_indexes!
           Chewy::Stash::Journal.create if @options[:journal]
           return if Chewy.configuration[:skip_index_creation_on_import]
-          @type.index.create!(@bulk_options.slice(:suffix)) unless @type.index.exists?
+          @type.index.create!(**@bulk_options.slice(:suffix)) unless @type.index.exists?
         end
 
         # The main process method. Converts passed objects to thr bulk request body,

data/lib/chewy/type/mapping.rb

@@ -35,8 +35,8 @@ module Chewy
         #   end
         #
         def root(**options)
-          self.root_object ||= Chewy::Fields::Root.new(type_name, Chewy.default_root_options.merge(options))
-          root_object.update_options!(options)
+          self.root_object ||= Chewy::Fields::Root.new(type_name, **Chewy.default_root_options.merge(options))
+          root_object.update_options!(**options)
           yield if block_given?
           root_object
         end
@@ -126,9 +126,9 @@ module Chewy
         #
         def field(*args, **options, &block)
           if args.size > 1
-            args.map { |name| field(name, options) }
+            args.map { |name| field(name, **options) }
           else
-            expand_nested(Chewy::Fields::Base.new(args.first, options), &block)
+            expand_nested(Chewy::Fields::Base.new(args.first, **options), &block)
           end
         end
 

data/lib/chewy/type/observe.rb

@@ -63,10 +63,10 @@ module Chewy
           update_proc = Observe.update_proc(type_name, *args, &block)
 
           if Chewy.use_after_commit_callbacks
-            after_commit(callback_options, &update_proc)
+            after_commit(**callback_options, &update_proc)
           else
-            after_save(callback_options, &update_proc)
-            after_destroy(callback_options, &update_proc)
+            after_save(**callback_options, &update_proc)
+            after_destroy(**callback_options, &update_proc)
           end
         end
       end

data/lib/chewy/type/syncer.rb

@@ -2,7 +2,7 @@ module Chewy
   class Type
     # This class is able to find missing and outdated documents in the ES
     # comparing ids from the data source and the ES index. Also, if `outdated_sync_field`
-    # existss in the index definition, it performs comparison of this field
+    # exists in the index definition, it performs comparison of this field
     # values for each source object and corresponding ES document. Usually,
     # this field is `updated_at` and if its value in the source is not equal
     # to the value in the index - this means that this document outdated and
@@ -205,10 +205,9 @@ module Chewy
         return @outdated_sync_field_type if instance_variable_defined?(:@outdated_sync_field_type)
         return unless @type.outdated_sync_field
 
-        mappings = @type.client.indices.get_mapping(
-          index: @type.index_name,
-          type: @type.type_name
-        ).values.first.fetch('mappings', {})
+        args = {index: @type.index_name, type: @type.type_name}
+        args[:include_type_name] = true if Runtime.version >= '6.7.0'
+        mappings = @type.client.indices.get_mapping(**args).values.first.fetch('mappings', {})
 
         @outdated_sync_field_type = mappings
           .fetch(@type.type_name, {})

data/lib/chewy/type/witchcraft.rb

@@ -58,7 +58,7 @@ module Chewy
       private
 
         def alicorn
-          @alicorn ||= class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          @alicorn ||= singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             -> (locals, object0, crutches) do
               #{composed_values(@type.root, 0)}
             end
@@ -79,7 +79,9 @@ module Chewy
           if field.children.present? && !field.multi_field?
             <<-RUBY
               (result#{nesting} = #{fetcher}
-              if result#{nesting}.respond_to?(:to_ary)
+              if result#{nesting}.nil?
+                nil
+              elsif result#{nesting}.respond_to?(:to_ary)
                 result#{nesting}.map do |object#{nesting}|
                   #{composed_values(field, nesting)}
                 end

data/lib/chewy/type/wrapper.rb

@@ -41,7 +41,7 @@ module Chewy
 
       %w[_id _type _index].each do |name|
         define_method name do
-          data[name]
+          _data[name]
         end
       end
 
@@ -49,6 +49,8 @@ module Chewy
         m = method.to_s
         if (name = highlight_name(m))
           highlight(name)
+        elsif (name = highlight_names(m))
+          highlights(name)
         elsif @attributes.key?(m)
           @attributes[m]
         elsif attribute_defined?(m)
@@ -60,7 +62,7 @@ module Chewy
 
       def respond_to_missing?(method, include_private = false)
         m = method.to_s
-        highlight_name(m) || @attributes.key?(m) || attribute_defined?(m) || super
+        highlight_name(m) || highlight_names(m) || @attributes.key?(m) || attribute_defined?(m) || super
       end
 
     private
@@ -69,6 +71,10 @@ module Chewy
         method.sub(/_highlight\z/, '') if method.end_with?('_highlight')
       end
 
+      def highlight_names(method)
+        method.sub(/_highlights\z/, '') if method.end_with?('_highlights')
+      end
+
       def attribute_defined?(attribute)
         self.class.root && self.class.root.children.find { |a| a.name.to_s == attribute }.present?
       end
@@ -77,6 +83,10 @@ module Chewy
         _data['highlight'][attribute].first if highlight?(attribute)
       end
 
+      def highlights(attribute)
+        _data['highlight'][attribute] if highlight?(attribute)
+      end
+
       def highlight?(attribute)
         _data.key?('highlight') && _data['highlight'].key?(attribute)
       end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '5.0.0'.freeze
+  VERSION = '7.0.1'.freeze
 end

data/migration_guide.md

@@ -0,0 +1,56 @@
+# 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
+  * The “total hits” counter is an integer for ES versions < 7 and an object (hash) for the versions starting from 7.0.0. Elasticsearch added a special option, `rest_total_hits_as_int`, to ease the upgrade, that could be appended to any request and results in the old “total hits” format. Unfortunately, this option is not recognized by ES versions prior to 7.0.0, which means that we have to check the version to decide if we need this option.
+    Normally Chewy does memoization of the current ES version, but this might be inappropriate for the upgrade, as the version changes live.
+    To handle that we have 2 versions of Chewy for this stage of the upgrade: 7.0.0 and 7.0.1. Version 7.0.0 does the memoization and version 7.0.1 requests the current version on every search request. 
+  * You can use the 7.0.0 version if it's fine for you to have an application restart immediately after ES cluster upgrade.
+  * If you're using the 7.0.1 version you might be interested in keeping the timeframe between this step and the last one as small as possible, as version 7.0.1 skips ES version memoization for search requests to help dynamically detect ES version. This leads to an extra version request on each search request, i.e. could affect the overall performance/latency of the search and a load of ES cluster.
+* 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
+* Upgrade to Chewy 7.2:
+  * Remove all the the `Chewy::Type` class usages, e.g. remove `CitiesIndex::City` / `CitiesIndex.city`
+    * `CitiesIndex::City.import! ...` becomes `CitiesIndex.import! ...`
+  * Update indexes with simplified DSL:
+    * `define_type` block -> `index_scope` clause
+      * it can be omitted completely, if you don't need to specify the scope or options, e.g. `name`
+  * Remove type names from string representations:
+    * in `update_index` ActiveRecord helper and RSpec matcher, e.g.
+      * `update_index('cities#city')` -> `update_index('cities')`
+      * `update_index(UsersIndex::User)` -> `update_index(UsersIndex)`
+    * in rake tasks (e.g. `rake chewy:update[cities#city]` -> `rake chewy:update[cities]`)
+    * rake tasks output is also changed (e.g. `Imported CitiesIndex::City in 1s, stats: index 3` -> `Imported CitiesIndex in 1s, stats: index 3`)
+  * Use index name instead of type name in loader additional scope
+    * e.g. `CitiesIndex.filter(...).load(city: {scope: City.where(...)})` -> `CitiesIndex.filter(...).load(cities: {scope: City.where(...)})`
+
+## 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

@@ -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(

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