chewy 0.1.0 → 0.2.0

data/lib/chewy/query/loading.rb

@@ -16,7 +16,7 @@ module Chewy
 
       def _load_objects(options)
         loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
-          loaded = type.adapter.load(objects, options[type.type_name.to_sym] || {})
+          loaded = type.adapter.load(objects, options.merge(_type: type))
           [type, loaded.index_by.with_index { |loaded, i| objects[i] }]
         end]
 

data/lib/chewy/query/nodes/has_child.rb

@@ -0,0 +1,14 @@
+require 'chewy/query/nodes/has_relation'
+
+module Chewy
+  class Query
+    module Nodes
+      class HasChild < HasRelation
+      private
+        def _relation
+          :has_child
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query/nodes/has_parent.rb

@@ -0,0 +1,14 @@
+require 'chewy/query/nodes/has_relation'
+
+module Chewy
+  class Query
+    module Nodes
+      class HasParent < HasRelation
+      private
+        def _relation
+          :has_parent
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query/nodes/has_relation.rb

@@ -0,0 +1,61 @@
+require 'chewy/query/compose'
+
+module Chewy
+  class Query
+    module Nodes
+      class HasRelation < Expr
+        include Compose
+
+        def initialize type, outer = nil
+          @type = type.to_s
+          @outer = outer
+          @query_mode = :must
+          @filter_mode = :and
+          @queries = []
+          @filters = []
+        end
+
+        def query_mode mode
+          @query_mode = mode
+          self
+        end
+
+        def filter_mode mode
+          @filter_mode = mode
+          self
+        end
+
+        def query params = nil, &block
+          if block
+            raise 'Query DLS is not supported yet'
+          else
+            @queries.push(params)
+          end
+          self
+        end
+
+        def filter params = nil, &block
+          if block
+            @filters.push(Chewy::Query::Filters.new(@outer, &block).__render__)
+          else
+            @filters.push(params)
+          end
+          self
+        end
+
+        def __render__
+          queries = _queries_join @queries, @query_mode
+          filters = _filters_join @filters, @filter_mode
+
+          body = if filters && !queries
+            {filter: filters}
+          else
+            _composed_query(queries, filters)
+          end || {}
+
+          {_relation => body.merge(type: @type)} if body
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query/nodes/match_all.rb

@@ -0,0 +1,11 @@
+module Chewy
+  class Query
+    module Nodes
+      class MatchAll < Expr
+        def __render__
+          {match_all: {}}
+        end
+      end
+    end
+  end
+end

data/lib/chewy/railtie.rb

@@ -11,12 +11,12 @@ module Chewy
     initializer 'chewy.add_requests_logging' do |app|
       ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
         duration = ((finish - start).to_f * 10000).round / 10.0
-        Rails.logger.debug("  \e[1m\e[33m#{payload[:type]} Import (#{duration}ms)\e[0m #{payload[:import]}")
+        Rails.logger.debug("  \e[1m\e[32m#{payload[:type]} Import (#{duration}ms)\e[0m #{payload[:import]}")
       end
 
       ActiveSupport::Notifications.subscribe('search_query.chewy') do |name, start, finish, id, payload|
         duration = ((finish - start).to_f * 10000).round / 10.0
-        Rails.logger.debug("  \e[1m\e[33m#{payload[:index]} Search (#{duration}ms)\e[0m #{payload[:request]}")
+        Rails.logger.debug("  \e[1m\e[32m#{payload[:index]} Search (#{duration}ms)\e[0m #{payload[:request]}")
       end
     end
   end

data/lib/chewy/rspec/update_index.rb

@@ -28,6 +28,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
         body[:data] = body[:data].symbolize_keys if body[:data]
         updated_document
       end
+      {}
     end
 
     if options[:atomic] == false

data/lib/chewy/type.rb

@@ -8,7 +8,7 @@ module Chewy
       adapter = if (target.is_a?(Class) && target < ActiveRecord::Base) || target.is_a?(::ActiveRecord::Relation)
         Chewy::Type::Adapter::ActiveRecord.new(target, options)
       else
-        Chewy::Type::Adapter::Object.new(target)
+        Chewy::Type::Adapter::Object.new(target, options)
       end
 
       index.const_set(adapter.name, type)

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

@@ -23,22 +23,36 @@ module Chewy
           @type_name ||= (options[:name].presence || model.model_name).to_s.underscore
         end
 
+        # Import method fo ActiveRecord takes import data and import options
+        #
+        # Import data types:
+        #
+        #   * Nothing passed - imports all the model data
+        #   * ActiveRecord scope
+        #   * Objects collection
+        #   * Ids collection
+        #
+        # Import options:
+        #
+        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
+        #
         def import *args, &block
           import_options = args.extract_options!
           import_options[:batch_size] ||= BATCH_SIZE
           collection = args.none? ? model_all :
             (args.one? && args.first.is_a?(::ActiveRecord::Relation) ? args.first : args.flatten)
+
           if collection.is_a?(::ActiveRecord::Relation)
-            result = false
+            result = true
             merged_scope(collection).find_in_batches(import_options.slice(:batch_size)) do |group|
-              result = block.call grouped_objects(group)
+              result &= block.call grouped_objects(group)
             end
             result
           else
             if collection.all? { |object| object.respond_to?(:id) }
-              collection.in_groups_of(import_options[:batch_size], false).all? do |group|
+              collection.in_groups_of(import_options[:batch_size], false).map do |group|
                 block.call grouped_objects(group)
-              end
+              end.all?
             else
               import_ids(collection, import_options, &block)
             end
@@ -49,11 +63,13 @@ module Chewy
           load_options = args.extract_options!
           objects = args.flatten
 
+          additional_scope = load_options[load_options[:_type].type_name.to_sym].try(:[], :scope) || load_options[:scope]
+
           scope = model.where(id: objects.map(&:id))
-          loaded_objects = if load_options[:scope].is_a?(Proc)
-            scope.instance_eval(&load_options[:scope])
-          elsif load_options[:scope].is_a?(::ActiveRecord::Relation)
-            scope.merge(load_options[:scope])
+          loaded_objects = if additional_scope.is_a?(Proc)
+            scope.instance_exec(&additional_scope)
+          elsif additional_scope.is_a?(::ActiveRecord::Relation)
+            scope.merge(additional_scope)
           else
             scope
           end.index_by { |object| object.id.to_s }
@@ -68,15 +84,15 @@ module Chewy
         def import_ids(ids, import_options = {}, &block)
           ids = ids.map(&:to_i).uniq
 
-          indexed = false
+          indexed = true
           merged_scope(model.where(id: ids)).find_in_batches(import_options.slice(:batch_size)) do |objects|
             ids -= objects.map(&:id)
-            indexed = block.call index: objects
+            indexed &= block.call index: objects
           end
 
-          deleted = ids.in_groups_of(import_options[:batch_size], false).all? do |group|
+          deleted = ids.in_groups_of(import_options[:batch_size], false).map do |group|
             block.call(delete: group)
-          end
+          end.all?
 
           indexed && deleted
         end

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

@@ -17,18 +17,28 @@ module Chewy
           @type_name ||= (options[:name] || target).to_s.underscore
         end
 
+        # Imports passed data with options
+        #
+        # Import data types:
+        #
+        #   * Array ob objects
+        #
+        # Import options:
+        #
+        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
+        #
         def import *args, &block
           import_options = args.extract_options!
           batch_size = import_options.delete(:batch_size) || BATCH_SIZE
           objects = args.flatten
 
-          objects.in_groups_of(batch_size, false).all? do |group|
+          objects.in_groups_of(batch_size, false).map do |group|
             action_groups = group.group_by do |object|
               raise "Object is not a `#{target}`" if class_target? && !object.is_a?(target)
               object.respond_to?(:destroyed?) && object.destroyed? ? :delete : :index
             end
             block.call action_groups
-          end
+          end.all?
         end
 
         def load *args

data/lib/chewy/type/import.rb

@@ -4,35 +4,75 @@ module Chewy
       extend ActiveSupport::Concern
 
       module ClassMethods
-        def bulk(options = {})
-          client.bulk options.merge(index: index.index_name, type: type_name)
+        def bulk options = {}
+          suffix = options.delete(:suffix)
+          result = client.bulk options.merge(index: index.build_index_name(suffix: suffix), type: type_name)
+
+          extract_errors result
         end
 
-        def import(*args)
+        def import *args
           import_options = args.extract_options!
-          bulk_options = import_options.extract!(:refresh).reverse_merge!(refresh: true)
-          identify = {_index: index.index_name, _type: type_name}
-
-          adapter.import(*args, import_options) do |action_objects|
-            payload = {type: self}
-            payload.merge! import: Hash[action_objects.map { |action, objects| [action, objects.count] }]
-
-            ActiveSupport::Notifications.instrument 'import_objects.chewy', payload do
-              body = action_objects.each.with_object([]) do |(action, objects), result|
-                result.concat(if action == :delete
-                  objects.map { |object| { action => identify.merge(_id: object.respond_to?(:id) ? object.id : object) } }
-                else
-                  objects.map { |object| { action => identify.merge(_id: object.id, data: object_data(object)) } }
-                end)
-              end
-              body.any? ? !!bulk(bulk_options.merge(body: body)) : true
+          bulk_options = import_options.extract!(:refresh, :suffix).reverse_merge!(refresh: true)
+
+          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
+            adapter.import(*args, import_options) do |action_objects|
+              body = bulk_body(action_objects)
+              errors = bulk(bulk_options.merge(body: body)) if body.any?
+
+              fill_payload_import payload, action_objects
+              fill_payload_errors payload, errors if errors.present?
+              !errors.present?
             end
           end
         end
 
       private
 
-        def object_data(object)
+        def extract_errors result
+          result && result['items'].map do |item|
+            action = item.keys.first.to_sym
+            data = item.values.first
+            {action: action, id: data['_id'], error: data['error']} if data['error']
+          end.compact.group_by { |item| item[:action] }.map do |action, items|
+            errors = items.group_by { |item| item[:error] }.map do |error, items|
+              {error => items.map { |item| item[:id] }}
+            end.reduce(&:merge)
+            {action => errors}
+          end.reduce(&:merge) || {}
+        end
+
+        def bulk_body action_objects
+          action_objects.each.with_object([]) do |(action, objects), result|
+            result.concat(if action == :delete
+              objects.map { |object| { action => {_id: object.respond_to?(:id) ? object.id : object} } }
+            else
+              objects.map { |object| { action => {_id: object.id, data: object_data(object)} } }
+            end)
+          end
+        end
+
+        def fill_payload_import payload, action_objects
+          imported = Hash[action_objects.map { |action, objects| [action, objects.count] }]
+          imported.each do |action, count|
+            payload[:import] ||= {}
+            payload[:import][action] ||= 0
+            payload[:import][action] += count
+          end
+        end
+
+        def fill_payload_errors payload, errors
+          errors.each do |action, errors|
+            errors.each do |error, documents|
+              payload[:errors] ||= {}
+              payload[:errors][action] ||= {}
+              payload[:errors][action][error] ||= []
+              payload[:errors][action][error] |= documents
+            end
+          end
+        end
+
+        def object_data object
           (self.root_object ||= build_root).compose(object)[type_name.to_sym]
         end
       end

data/lib/chewy/type/wrapper.rb

@@ -23,7 +23,7 @@ module Chewy
         if @attributes.key?(method.to_s)
           @attributes[method.to_s]
         else
-          super
+          nil
         end
       end
 

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/tasks/chewy.rake

@@ -1,27 +1,60 @@
+def subscribe_task_stats!
+  ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+    duration = ((finish - start).to_f * 100).round / 100.0
+    puts "  Imported #{payload[:type]} for #{duration}s, documents total: #{payload[:import]}"
+    payload[:errors].each do |action, errors|
+      puts "    #{action.to_s.humanize} errors:"
+      errors.each do |error, documents|
+        puts "      `#{error}`"
+        puts "        on #{documents.count} documents: #{documents}"
+      end
+    end if payload[:errors]
+  end
+end
+
 namespace :chewy do
+  desc 'Destroy, recreate and import data to specified index'
+  task :reset, [:index] => :environment do |task, args|
+    subscribe_task_stats!
+    "#{args[:index].camelize}Index".constantize.reset! (Time.now.to_f * 1000).round
+  end
+
   namespace :reset do
     desc 'Destroy, recreate and import data for all found indexes'
     task all: :environment do
+      subscribe_task_stats!
       Rails.application.config.paths['app/chewy'].existent.each do |dir|
         Dir.glob(File.join(dir, '**/*.rb')).each { |file| require file }
       end
 
       Chewy::Index.descendants.each do |index|
         puts "Resetting #{index}"
-        index.reset
+        index.reset! (Time.now.to_f * 1000).round
       end
     end
   end
 
-  desc 'Destroy, recreate and import data to specified index'
-  task :reset, [:index] => :environment do |task, args|
-    "#{args[:index].camelize}Index".constantize.reset
-  end
-
-  desc 'Updates specified index'
+  desc 'Updates data specified index'
   task :update, [:index] => :environment do |task, args|
+    subscribe_task_stats!
     index = "#{args[:index].camelize}Index".constantize
-    raise "Index `#{index.index_name}` does not exists. Use rake chewy:reset[index] to create and update it." unless index.exists?
+    raise "Index `#{index.index_name}` does not exists. Use rake chewy:reset[#{index.index_name}] to create and update it." unless index.exists?
     index.import
   end
+
+  namespace :update do
+    desc 'Updates data for all found indexes'
+    task all: :environment do
+      subscribe_task_stats!
+      Rails.application.config.paths['app/chewy'].existent.each do |dir|
+        Dir.glob(File.join(dir, '**/*.rb')).each { |file| require file }
+      end
+
+      Chewy::Index.descendants.each do |index|
+        puts "Updating #{index}"
+        puts "Index `#{index.index_name}` does not exists. Use rake chewy:reset[#{index.index_name}] to create and update it." unless index.exists?
+        index.import
+      end
+    end
+  end
 end

data/spec/chewy/index/actions_spec.rb

@@ -17,37 +17,317 @@ describe Chewy::Index::Actions do
 
   describe '.create' do
     specify { DummiesIndex.create.should be_true }
+    specify { DummiesIndex.create('2013').should be_true }
 
     context do
       before { DummiesIndex.create }
       specify { DummiesIndex.create.should be_false }
+      specify { DummiesIndex.create('2013').should be_false }
+    end
+
+    context do
+      before { DummiesIndex.create '2013' }
+      specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      specify { DummiesIndex.create('2013').should be_false }
+      specify { DummiesIndex.create('2014').should be_true }
+
+      context do
+        before { DummiesIndex.create '2014' }
+        specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+      end
+    end
+
+    context do
+      before { DummiesIndex.create '2013', alias: false }
+      specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == [] }
     end
   end
 
   describe '.create!' do
-    specify { expect { DummiesIndex.create! }.not_to raise_error }
+    specify { DummiesIndex.create!.should be_true }
+    specify { DummiesIndex.create!('2013').should be_true }
 
     context do
       before { DummiesIndex.create }
       specify { expect { DummiesIndex.create! }.to raise_error }
+      specify { expect { DummiesIndex.create!('2013') }.to raise_error }
+    end
+
+    context do
+      before { DummiesIndex.create! '2013' }
+      specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      specify { expect { DummiesIndex.create!('2013') }.to raise_error }
+      specify { DummiesIndex.create!('2014').should be_true }
+
+      context do
+        before { DummiesIndex.create! '2014' }
+        specify { DummiesIndex.indexes.should =~ ['dummies_2013', 'dummies_2014'] }
+      end
+    end
+
+    context do
+      before { DummiesIndex.create! '2013', alias: false }
+      specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == [] }
     end
   end
 
   describe '.delete' do
     specify { DummiesIndex.delete.should be_false }
+    specify { DummiesIndex.delete('dummies_2013').should be_false }
 
     context do
       before { DummiesIndex.create }
       specify { DummiesIndex.delete.should be_true }
+
+      context do
+        before { DummiesIndex.delete }
+        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+      end
+    end
+
+    context do
+      before { DummiesIndex.create '2013' }
+      specify { DummiesIndex.delete('2013').should be_true }
+
+      context do
+        before { DummiesIndex.delete('2013') }
+        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+      end
+
+      context do
+        before { DummiesIndex.create '2014' }
+        specify { DummiesIndex.delete.should be_true }
+
+        context do
+          before { DummiesIndex.delete }
+          specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+        end
+
+        context do
+          before { DummiesIndex.delete('2014') }
+          specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+        end
+      end
     end
   end
 
   describe '.delete!' do
     specify { expect { DummiesIndex.delete! }.to raise_error }
+    specify { expect { DummiesIndex.delete!('2013') }.to raise_error }
 
     context do
       before { DummiesIndex.create }
-      specify { expect { DummiesIndex.delete! }.not_to raise_error }
+      specify { DummiesIndex.delete!.should be_true }
+
+      context do
+        before { DummiesIndex.delete! }
+        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+      end
+    end
+
+    context do
+      before { DummiesIndex.create '2013' }
+      specify { DummiesIndex.delete!('2013').should be_true }
+
+      context do
+        before { DummiesIndex.delete!('2013') }
+        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+      end
+
+      context do
+        before { DummiesIndex.create '2014' }
+        specify { DummiesIndex.delete!.should be_true }
+
+        context do
+          before { DummiesIndex.delete! }
+          specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+        end
+
+        context do
+          before { DummiesIndex.delete!('2014') }
+          specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+        end
+      end
+    end
+  end
+
+  describe '.purge' do
+    specify { DummiesIndex.purge.should be_true }
+    specify { DummiesIndex.purge('2013').should be_true }
+
+    context do
+      before { DummiesIndex.purge }
+      specify { DummiesIndex.should be_exists }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == [] }
+
+      context do
+        before { DummiesIndex.purge }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == [] }
+      end
+
+      context do
+        before { DummiesIndex.purge('2013') }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      end
+    end
+
+    context do
+      before { DummiesIndex.purge('2013') }
+      specify { DummiesIndex.should be_exists }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+
+      context do
+        before { DummiesIndex.purge }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == [] }
+      end
+
+      context do
+        before { DummiesIndex.purge('2014') }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == ['dummies_2014'] }
+      end
+    end
+  end
+
+  describe '.purge!' do
+    specify { DummiesIndex.purge!.should be_true }
+    specify { DummiesIndex.purge!('2013').should be_true }
+
+    context do
+      before { DummiesIndex.purge! }
+      specify { DummiesIndex.should be_exists }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == [] }
+
+      context do
+        before { DummiesIndex.purge! }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == [] }
+      end
+
+      context do
+        before { DummiesIndex.purge!('2013') }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+      end
+    end
+
+    context do
+      before { DummiesIndex.purge!('2013') }
+      specify { DummiesIndex.should be_exists }
+      specify { DummiesIndex.aliases.should == [] }
+      specify { DummiesIndex.indexes.should == ['dummies_2013'] }
+
+      context do
+        before { DummiesIndex.purge! }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == [] }
+      end
+
+      context do
+        before { DummiesIndex.purge!('2014') }
+        specify { DummiesIndex.should be_exists }
+        specify { DummiesIndex.aliases.should == [] }
+        specify { DummiesIndex.indexes.should == ['dummies_2014'] }
+      end
+    end
+  end
+
+  describe '.reset!' do
+    before do
+      stub_model(:city)
+      stub_index(:cities) do
+        define_type City
+      end
+    end
+
+    before { City.create!(name: 'Moscow') }
+
+    specify { CitiesIndex.reset!.should be_true }
+    specify { CitiesIndex.reset!('2013').should be_true }
+
+    context do
+      before { CitiesIndex.reset! }
+
+      specify { CitiesIndex.all.should have(1).item }
+      specify { CitiesIndex.aliases.should == [] }
+      specify { CitiesIndex.indexes.should == [] }
+
+      context do
+        before { CitiesIndex.reset!('2013') }
+
+        specify { CitiesIndex.all.should have(1).item }
+        specify { CitiesIndex.aliases.should == [] }
+        specify { CitiesIndex.indexes.should == ['cities_2013'] }
+      end
+
+      context do
+        before { CitiesIndex.reset! }
+
+        specify { CitiesIndex.all.should have(1).item }
+        specify { CitiesIndex.aliases.should == [] }
+        specify { CitiesIndex.indexes.should == [] }
+      end
+    end
+
+    context do
+      before { CitiesIndex.reset!('2013') }
+
+      specify { CitiesIndex.all.should have(1).item }
+      specify { CitiesIndex.aliases.should == [] }
+      specify { CitiesIndex.indexes.should == ['cities_2013'] }
+
+      context do
+        before { CitiesIndex.reset!('2014') }
+
+        specify { CitiesIndex.all.should have(1).item }
+        specify { CitiesIndex.aliases.should == [] }
+        specify { CitiesIndex.indexes.should == ['cities_2014'] }
+        specify { Chewy.client.indices.exists(index: 'cities_2013').should be_false }
+      end
+
+      context do
+        before { CitiesIndex.reset! }
+
+        specify { CitiesIndex.all.should have(1).item }
+        specify { CitiesIndex.aliases.should == [] }
+        specify { CitiesIndex.indexes.should == [] }
+        specify { Chewy.client.indices.exists(index: 'cities_2013').should be_false }
+      end
     end
   end
 end