chewy 0.10.1 → 7.3.2

data/lib/chewy/strategy/lazy_sidekiq.rb

@@ -0,0 +1,64 @@
+module Chewy
+  class Strategy
+    # The strategy works the same way as sidekiq, but performs
+    # async evaluation of all index callbacks on model create and update
+    # driven by sidekiq
+    #
+    #   Chewy.strategy(:lazy_sidekiq) do
+    #     User.all.map(&:save) # Does nothing here
+    #     Post.all.map(&:save) # And here
+    #     # It schedules import of all the changed users and posts right here
+    #   end
+    #
+    class LazySidekiq < Sidekiq
+      class IndicesUpdateWorker
+        include ::Sidekiq::Worker
+
+        def perform(models)
+          Chewy.strategy(strategy) do
+            models.each do |model_type, model_ids|
+              model_type.constantize.where(id: model_ids).each(&:run_chewy_callbacks)
+            end
+          end
+        end
+
+      private
+
+        def strategy
+          Chewy.disable_refresh_async ? :atomic_no_refresh : :atomic
+        end
+      end
+
+      def initialize
+        # Use parent's @stash to store destroyed records, since callbacks for them have to
+        # be run immediately on the strategy block end because we won't be able to fetch
+        # records further in IndicesUpdateWorker. This will be done by avoiding of
+        # LazySidekiq#update_chewy_indices call and calling LazySidekiq#update instead.
+        super
+
+        # @lazy_stash is used to store all the lazy evaluated callbacks with call of
+        # strategy's #update_chewy_indices.
+        @lazy_stash = {}
+      end
+
+      def leave
+        # Fallback to Sidekiq#leave implementation for destroyed records stored in @stash.
+        super
+
+        # Proceed with other records stored in @lazy_stash
+        return if @lazy_stash.empty?
+
+        ::Sidekiq::Client.push(
+          'queue' => sidekiq_queue,
+          'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+          'args'  => [@lazy_stash]
+        )
+      end
+
+      def update_chewy_indices(object)
+        @lazy_stash[object.class.name] ||= []
+        @lazy_stash[object.class.name] |= Array.wrap(object.id)
+      end
+    end
+  end
+end

data/lib/chewy/strategy/sidekiq.rb

@@ -15,13 +15,14 @@ module Chewy
 
         def perform(type, ids, options = {})
           options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async
-          type.constantize.import!(ids, options)
+          type.constantize.import!(ids, **options)
         end
       end
 
       def leave
         @stash.each do |type, ids|
           next if ids.empty?
+
           ::Sidekiq::Client.push(
             'queue' => sidekiq_queue,
             'class' => Chewy::Strategy::Sidekiq::Worker,
@@ -33,7 +34,7 @@ module Chewy
     private
 
       def sidekiq_queue
-        Chewy.settings.fetch(:sidekiq, {})[:queue] || 'chewy'
+        Chewy.settings.dig(:sidekiq, :queue) || 'chewy'
       end
     end
   end

data/lib/chewy/strategy.rb

@@ -2,24 +2,13 @@ require 'chewy/strategy/base'
 require 'chewy/strategy/bypass'
 require 'chewy/strategy/urgent'
 require 'chewy/strategy/atomic'
-
-begin
-  require 'resque'
-  require 'chewy/strategy/resque'
-rescue LoadError
-  nil
-end
+require 'chewy/strategy/atomic_no_refresh'
 
 begin
   require 'sidekiq'
   require 'chewy/strategy/sidekiq'
-rescue LoadError
-  nil
-end
-
-begin
-  require 'shoryuken'
-  require 'chewy/strategy/shoryuken'
+  require 'chewy/strategy/lazy_sidekiq'
+  require 'chewy/strategy/delayed_sidekiq'
 rescue LoadError
   nil
 end
@@ -60,6 +49,7 @@ module Chewy
 
     def pop
       raise "Can't pop root strategy" if @stack.one?
+
       result = @stack.pop.tap(&:leave)
       debug "[#{@stack.size}] -> #{result.name}, now #{current.name}" if @stack.size > 1
       result
@@ -75,17 +65,14 @@ module Chewy
   private
 
     def debug(string)
-      return unless Chewy.logger && Chewy.logger.debug?
+      return unless Chewy.logger&.debug?
+
       line = caller.detect { |l| l !~ %r{lib/chewy/strategy.rb:|lib/chewy.rb:} }
       Chewy.logger.debug(["Chewy strategies stack: #{string}", line.sub(/:in\s.+$/, '')].join(' @ '))
     end
 
     def resolve(name)
       "Chewy::Strategy::#{name.to_s.camelize}".safe_constantize or raise "Can't find update strategy `#{name}`"
-    rescue NameError => ex
-      # WORKAROUND: Strange behavior of `safe_constantize` with mongoid gem
-      raise "Can't find update strategy `#{name}`" if ex.name.to_s.demodulize == name.to_s.camelize
-      raise
     end
   end
 end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.10.1'.freeze
+  VERSION = '7.3.2'.freeze
 end

data/lib/chewy.rb

@@ -4,19 +4,20 @@ require 'active_support/deprecation'
 require 'active_support/json'
 require 'active_support/log_subscriber'
 
+require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR >= 7
 require 'active_support/core_ext/array/access'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/numeric/bytes'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/inclusion'
 require 'active_support/core_ext/string/inflections'
 
-require 'i18n/core_ext/hash'
-require 'chewy/backports/deep_dup' unless Object.respond_to?(:deep_dup)
 require 'singleton'
+require 'base64'
 
 require 'elasticsearch'
 
@@ -28,20 +29,12 @@ end
 
 try_require 'kaminari'
 try_require 'kaminari/core'
-try_require 'will_paginate'
-try_require 'will_paginate/collection'
 try_require 'parallel'
 
 ActiveSupport.on_load(:active_record) do
-  try_require 'will_paginate/active_record'
   try_require 'kaminari/activerecord'
 end
 
-ActiveSupport.on_load(:mongoid) do
-  try_require 'will_paginate/mongoid'
-  try_require 'kaminari/mongoid'
-end
-
 require 'chewy/version'
 require 'chewy/errors'
 require 'chewy/config'
@@ -51,100 +44,59 @@ require 'chewy/runtime'
 require 'chewy/log_subscriber'
 require 'chewy/strategy'
 require 'chewy/index'
-require 'chewy/type'
 require 'chewy/fields/base'
 require 'chewy/fields/root'
 require 'chewy/journal'
 require 'chewy/railtie' if defined?(::Rails::Railtie)
 
 ActiveSupport.on_load(:active_record) do
-  extend Chewy::Type::Observe::ActiveRecordMethods
-end
-
-ActiveSupport.on_load(:mongoid) do
-  module Mongoid
-    module Document
-      module ClassMethods
-        include Chewy::Type::Observe::MongoidMethods
-      end
-    end
-  end
+  include Chewy::Index::Observe::ActiveRecordMethods
 end
 
 module Chewy
   @adapters = [
-    Chewy::Type::Adapter::ActiveRecord,
-    Chewy::Type::Adapter::Mongoid,
-    Chewy::Type::Adapter::Sequel,
-    Chewy::Type::Adapter::Object
+    Chewy::Index::Adapter::ActiveRecord,
+    Chewy::Index::Adapter::Object
   ]
 
   class << self
     attr_accessor :adapters
 
-    # Derives a single type for the passed string identifier if possible.
-    #
-    # @example
-    #   Chewy.derive_types(UsersIndex::User) # => UsersIndex::User
-    #   Chewy.derive_types('namespace/users') # => Namespace::UsersIndex::User
-    #   Chewy.derive_types('places') # => raises Chewy::UnderivableType
-    #   Chewy.derive_types('places#city') # => PlacesIndex::City
-    #
-    # @param name [String, Chewy::Type] string type identifier
-    # @raise [Chewy::UnderivableType] in cases when it is impossble to find index or type or more than one type found
-    # @return [Chewy::Type] an array of derived types
-    def derive_type(name)
-      return name if name.is_a?(Class) && name < Chewy::Type
-
-      types = derive_types(name)
-      raise Chewy::UnderivableType, "Index `#{types.first.index}` has more than one type, please specify type via `#{types.first.index.derivable_name}#type_name`" unless types.one?
-      types.first
+    # A thread-local variables accessor
+    # @return [Hash]
+    def current
+      unless Thread.current.thread_variable?(:chewy)
+        Thread.current.thread_variable_set(:chewy, {})
+      end
+
+      Thread.current.thread_variable_get(:chewy)
     end
 
-    # Derives all the types for the passed string identifier if possible.
+    # Derives an index for the passed string identifier if possible.
     #
     # @example
-    #   Chewy.derive_types('namespace/users') # => [Namespace::UsersIndex::User]
-    #   Chewy.derive_types('places') # => [PlacesIndex::City, PlacesIndex::Country]
-    #   Chewy.derive_types('places#city') # => [PlacesIndex::City]
+    #   Chewy.derive_name(UsersIndex) # => UsersIndex
+    #   Chewy.derive_name('namespace/users') # => Namespace::UsersIndex
+    #   Chewy.derive_name('missing') # => raises Chewy::UndefinedIndex
     #
-    # @param from [String] string type identifier
-    # @raise [Chewy::UnderivableType] in cases when it is impossible to find index or type
-    # @return [Array<Chewy::Type>] an array of derived types
-    def derive_types(from)
-      return from.types if from.is_a?(Class) && (from < Chewy::Index || from < Chewy::Type)
+    # @param index_name [String, Chewy::Index] index identifier or class
+    # @raise [Chewy::UndefinedIndex] in cases when it is impossible to find index
+    # @return [Chewy::Index]
+    def derive_name(index_name)
+      return index_name if index_name.is_a?(Class) && index_name < Chewy::Index
 
-      index_name, type_name = from.split('#', 2)
       class_name = "#{index_name.camelize.gsub(/Index\z/, '')}Index"
       index = class_name.safe_constantize
-      raise Chewy::UnderivableType, "Can not find index named `#{class_name}`" unless index && index < Chewy::Index
-      if type_name.present?
-        type = index.type_hash[type_name] or raise Chewy::UnderivableType, "Index `#{class_name}` doesn`t have type named `#{type_name}`"
-        [type]
-      else
-        index.types
-      end
-    end
 
-    # Creates Chewy::Type ancestor defining index and adapter methods.
-    #
-    def create_type(index, target, options = {}, &block)
-      type = Class.new(Chewy::Type)
-
-      adapter = adapters.find { |klass| klass.accepts?(target) }.new(target, options)
-
-      index.const_set(adapter.name, type)
-      type.send(:define_singleton_method, :index) { index }
-      type.send(:define_singleton_method, :adapter) { adapter }
+      return index if index && index < Chewy::Index
 
-      type.class_eval(&block) if block
-      type
+      raise Chewy::UndefinedIndex, "Can not find index named `#{class_name}`"
     end
 
     # Main elasticsearch-ruby client instance
     #
     def client
-      Thread.current[:chewy_client] ||= begin
+      Chewy.current[:chewy_client] ||= begin
         client_configuration = configuration.deep_dup
         client_configuration.delete(:prefix) # used by Chewy, not relevant to Elasticsearch::Client
         block = client_configuration[:transport_options].try(:delete, :proc)
@@ -158,7 +110,9 @@ module Chewy
     # Does nothing in case of config `wait_for_status` is undefined.
     #
     def wait_for_status
-      client.cluster.health wait_for_status: Chewy.configuration[:wait_for_status] if Chewy.configuration[:wait_for_status].present?
+      if Chewy.configuration[:wait_for_status].present?
+        client.cluster.health wait_for_status: Chewy.configuration[:wait_for_status]
+      end
     end
 
     # Deletes all corresponding indexes with current prefix from ElasticSearch.
@@ -194,15 +148,15 @@ module Chewy
     #   city3.do_update! # index updated again
     #
     def strategy(name = nil, &block)
-      Thread.current[:chewy_strategy] ||= Chewy::Strategy.new
+      Chewy.current[:chewy_strategy] ||= Chewy::Strategy.new
       if name
         if block
-          Thread.current[:chewy_strategy].wrap name, &block
+          Chewy.current[:chewy_strategy].wrap name, &block
         else
-          Thread.current[:chewy_strategy].push name
+          Chewy.current[:chewy_strategy].push name
         end
       else
-        Thread.current[:chewy_strategy]
+        Chewy.current[:chewy_strategy]
       end
     end
 
@@ -226,7 +180,10 @@ module Chewy
 
     def eager_load!
       return unless defined?(Chewy::Railtie)
-      dirs = Chewy::Railtie.all_engines.map { |engine| engine.paths[Chewy.configuration[:indices_path]] }.compact.map(&:existent).flatten.uniq
+
+      dirs = Chewy::Railtie.all_engines.map do |engine|
+        engine.paths[Chewy.configuration[:indices_path]]
+      end.compact.map(&:existent).flatten.uniq
 
       dirs.each do |dir|
         Dir.glob(File.join(dir, '**/*.rb')).each do |file|

data/lib/generators/chewy/install_generator.rb

@@ -1,7 +1,7 @@
 module Chewy
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('../../templates', __FILE__)
+      source_root File.expand_path('../templates', __dir__)
 
       def copy_configuration
         template 'chewy.yml', 'config/chewy.yml'

data/lib/tasks/chewy.rake

@@ -23,22 +23,22 @@ end
 namespace :chewy do
   desc 'Destroys, recreates and imports data for the specified indexes or all of them'
   task reset: :environment do |_task, args|
-    Chewy::RakeHelper.reset(parse_classes(args.extras))
+    Chewy::RakeHelper.reset(**parse_classes(args.extras))
   end
 
   desc 'Resets data for the specified indexes or all of them only if the index specification is changed'
   task upgrade: :environment do |_task, args|
-    Chewy::RakeHelper.upgrade(parse_classes(args.extras))
+    Chewy::RakeHelper.upgrade(**parse_classes(args.extras))
   end
 
   desc 'Updates data for the specified indexes/types or all of them'
   task update: :environment do |_task, args|
-    Chewy::RakeHelper.update(parse_classes(args.extras))
+    Chewy::RakeHelper.update(**parse_classes(args.extras))
   end
 
   desc 'Synchronizes data for the specified indexes/types or all of them'
   task sync: :environment do |_task, args|
-    Chewy::RakeHelper.sync(parse_classes(args.extras))
+    Chewy::RakeHelper.sync(**parse_classes(args.extras))
   end
 
   desc 'Resets all the indexes with the specification changed and synchronizes the rest of them'
@@ -47,25 +47,35 @@ namespace :chewy do
     Chewy::RakeHelper.sync(except: processed)
   end
 
+  desc 'Reindex data from source index to destination index'
+  task :reindex, %i[source dest] => :environment do |_task, args|
+    Chewy::RakeHelper.reindex(source: args[:source], dest: args[:dest])
+  end
+
+  desc 'Update mapping of exising index with body hash'
+  task :update_mapping, %i[index_name] => :environment do |_task, args|
+    Chewy::RakeHelper.update_mapping(name: args[:index_name])
+  end
+
   namespace :parallel do
     desc 'Parallel version of `rake chewy:reset`'
     task reset: :environment do |_task, args|
-      Chewy::RakeHelper.reset(parse_parallel_args(args.extras))
+      Chewy::RakeHelper.reset(**parse_parallel_args(args.extras))
     end
 
     desc 'Parallel version of `rake chewy:upgrade`'
     task upgrade: :environment do |_task, args|
-      Chewy::RakeHelper.upgrade(parse_parallel_args(args.extras))
+      Chewy::RakeHelper.upgrade(**parse_parallel_args(args.extras))
     end
 
     desc 'Parallel version of `rake chewy:update`'
     task update: :environment do |_task, args|
-      Chewy::RakeHelper.update(parse_parallel_args(args.extras))
+      Chewy::RakeHelper.update(**parse_parallel_args(args.extras))
     end
 
     desc 'Parallel version of `rake chewy:sync`'
     task sync: :environment do |_task, args|
-      Chewy::RakeHelper.sync(parse_parallel_args(args.extras))
+      Chewy::RakeHelper.sync(**parse_parallel_args(args.extras))
     end
 
     desc 'Parallel version of `rake chewy:deploy`'
@@ -79,34 +89,18 @@ namespace :chewy do
   namespace :journal do
     desc 'Applies changes that were done after the specified time for the specified indexes/types or all of them'
     task apply: :environment do |_task, args|
-      Chewy::RakeHelper.journal_apply(parse_journal_args(args.extras))
+      Chewy::RakeHelper.journal_apply(**parse_journal_args(args.extras))
     end
 
     desc 'Removes journal records created before the specified timestamp for the specified indexes/types or all of them'
     task clean: :environment do |_task, args|
-      Chewy::RakeHelper.journal_clean(parse_journal_args(args.extras))
-    end
-  end
-
-  task apply_changes_from: :environment do |_task, args|
-    ActiveSupport::Deprecation.warn '`rake chewy:apply_changes_from` is deprecated and will be removed soon, use `rake chewy:journal:apply` instead'
-
-    Chewy::RakeHelper.subscribed_task_stats do
-      params = args.extras
-
-      if params.empty?
-        puts 'Please specify a timestamp like chewy:apply_changes_from[1469528705]'
-      else
-        timestamp, retries = params
-        time = Time.at(timestamp.to_i)
-        Chewy::Journal.new.apply(time, retries: (retries.to_i if retries))
-      end
+      delete_options = Chewy::RakeHelper.delete_by_query_options_from_env(ENV)
+      Chewy::RakeHelper.journal_clean(
+        **[
+          parse_journal_args(args.extras),
+          {delete_by_query_options: delete_options}
+        ].reduce({}, :merge)
+      )
     end
   end
-
-  task clean_journal: :environment do |_task, args|
-    ActiveSupport::Deprecation.warn '`rake chewy:clean_journal` is deprecated and will be removed soon, use `rake chewy:journal:clean` instead'
-
-    Chewy::Journal.new.clean(args.extras.first)
-  end
 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/7.17/breaking-changes-7.0.html), 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 updating to Chewy 7.1 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,11 +6,9 @@ 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(:console_strategy) { should == :urgent }
   its(:use_after_commit_callbacks) { should == true }
   its(:indices_path) { should == 'app/chewy' }
   its(:reset_disable_refresh_interval) { should == false }
@@ -54,88 +52,60 @@ 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
         hide_const('Kaminari')
-        hide_const('WillPaginate')
       end
 
       specify do
         expect(subject.search_class.included_modules)
           .not_to include(Chewy::Search::Pagination::Kaminari)
       end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
-      end
     end
 
     context 'kaminari' do
-      before { hide_const('WillPaginate') }
-
       specify do
         expect(subject.search_class.included_modules)
           .to include(Chewy::Search::Pagination::Kaminari)
       end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
-      end
     end
+  end
 
-    context 'will_paginate' do
-      before { hide_const('Kaminari') }
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::Kaminari)
-      end
+  describe '#configuration' do
+    before { subject.settings = {indices_path: 'app/custom_indices_path'} }
 
-      specify do
-        expect(subject.search_class.included_modules)
-          .to include(Chewy::Search::Pagination::WillPaginate)
-      end
+    specify do
+      expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')
     end
 
-    context 'both are defined' do
-      specify do
-        expect(subject.search_class.included_modules)
-          .to include(Chewy::Search::Pagination::Kaminari)
-      end
+    context 'when Rails::VERSION constant is defined' do
+      it 'looks for configuration in "config/chewy.yml"' do
+        module Rails
+          VERSION = '5.1.1'.freeze
 
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
+          def self.root
+            Pathname.new(__dir__)
+          end
+        end
+
+        expect(File).to receive(:exist?)
+          .with(Pathname.new(__dir__).join('config', 'chewy.yml'))
+        subject.configuration
       end
     end
   end
 
-  describe '#configuration' do
-    before { subject.settings = {indices_path: 'app/custom_indices_path'} }
+  describe '.console_strategy' do
+    context 'sets .console_strategy' do
+      let(:default_strategy) { subject.console_strategy }
+      let(:new_strategy) { :atomic }
+      after { subject.console_strategy = default_strategy }
 
-    specify do
-      expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')
+      specify do
+        expect { subject.console_strategy = new_strategy }
+          .to change { subject.console_strategy }.to(new_strategy)
+      end
     end
   end
 end