chewy 0.8.4 → 5.1.0

data/lib/chewy/railtie.rb

@@ -14,6 +14,8 @@ module Chewy
         if Rails.application.config.respond_to?(:assets) && env['PATH_INFO'].start_with?(Rails.application.config.assets.prefix)
           @app.call(env)
         else
+          Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`") if Chewy.logger && @request_strategy != Chewy.request_strategy
+          @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
       end
@@ -41,17 +43,16 @@ module Chewy
     end
 
     console do |app|
-      Chewy.logger = ActiveRecord::Base.logger if defined?(ActiveRecord)
-
       if app.sandbox?
         Chewy.strategy(:bypass)
       else
         Chewy.strategy(:urgent)
       end
+      puts "Chewy console strategy is `#{Chewy.strategy.current.name}`"
     end
 
     initializer 'chewy.logger', after: 'active_record.logger' do
-      ActiveSupport.on_load(:active_record)  { Chewy.logger ||= ActiveRecord::Base.logger }
+      ActiveSupport.on_load(:active_record) { Chewy.logger ||= ActiveRecord::Base.logger }
     end
 
     initializer 'chewy.migration_strategy' do
@@ -67,12 +68,12 @@ module Chewy
     end
 
     initializer 'chewy.request_strategy' do |app|
-      app.config.middleware.insert_after(Rails::Rack::Logger, RequestStrategy)
+      app.config.middleware.insert_before(ActionDispatch::ShowExceptions, RequestStrategy)
     end
 
-    initializer 'chewy.add_app_chewy_path' do |app|
+    initializer 'chewy.add_indices_path' do |_app|
       Chewy::Railtie.all_engines.each do |engine|
-        engine.paths.add 'app/chewy'
+        engine.paths.add Chewy.configuration[:indices_path]
       end
     end
   end

data/lib/chewy/rake_helper.rb

@@ -1,64 +1,302 @@
 module Chewy
   module RakeHelper
+    IMPORT_CALLBACK = lambda do |output, _name, start, finish, _id, payload|
+      duration = (finish - start).ceil
+      stats = payload.fetch(:import, {}).map { |key, count| "#{key} #{count}" }.join(', ')
+      output.puts "  Imported #{payload[:type]} in #{human_duration(duration)}, stats: #{stats}"
+      if payload[:errors]
+        payload[:errors].each do |action, errors|
+          output.puts "    #{action.to_s.humanize} errors:"
+          errors.each do |error, documents|
+            output.puts "      `#{error}`"
+            output.puts "        on #{documents.count} documents: #{documents}"
+          end
+        end
+      end
+    end
+
+    JOURNAL_CALLBACK = lambda do |output, _, _, _, _, payload|
+      count = payload[:groups].values.map(&:size).sum
+      targets = payload[:groups].keys.sort_by(&:derivable_name)
+      output.puts "  Applying journal to #{targets}, #{count} entries, stage #{payload[:stage]}"
+    end
+
     class << self
+      # Performs zero-downtime reindexing of all documents for the specified indexes
+      #
+      # @example
+      #   Chewy::RakeHelper.reset # resets everything
+      #   Chewy::RakeHelper.reset(only: 'cities') # resets only CitiesIndex
+      #   Chewy::RakeHelper.reset(only: ['cities', CountriesIndex]) # resets CitiesIndex and CountriesIndex
+      #   Chewy::RakeHelper.reset(except: CitiesIndex) # resets everything, but CitiesIndex
+      #   Chewy::RakeHelper.reset(only: ['cities', 'countries'], except: CitiesIndex) # resets only CountriesIndex
+      #
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] index or indexes to reset; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] index or indexes to exclude from processing
+      # @param parallel [true, Integer, Hash] any acceptable parallel options for import
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Index>] indexes that were reset
+      def reset(only: nil, except: nil, parallel: nil, output: STDOUT)
+        subscribed_task_stats(output) do
+          indexes_from(only: only, except: except).each do |index|
+            reset_one(index, output, parallel: parallel)
+          end
+        end
+      end
 
-      def subscribed_task_stats(&block)
-        callback = ->(name, start, finish, id, payload) do
-          duration = (finish - start).round(2)
-          puts "  Imported #{payload[:type]} for #{duration}s, documents total: #{payload[:import].try(:[], :index).to_i}"
-          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}"
+      # Performs zero-downtime reindexing of all documents for the specified
+      # indexes only if a particular index specification was changed.
+      #
+      # @example
+      #   Chewy::RakeHelper.upgrade # resets everything
+      #   Chewy::RakeHelper.upgrade(only: 'cities') # resets only CitiesIndex
+      #   Chewy::RakeHelper.upgrade(only: ['cities', CountriesIndex]) # resets CitiesIndex and CountriesIndex
+      #   Chewy::RakeHelper.upgrade(except: CitiesIndex) # resets everything, but CitiesIndex
+      #   Chewy::RakeHelper.upgrade(only: ['cities', 'countries'], except: CitiesIndex) # resets only CountriesIndex
+      #
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] index or indexes to reset; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] index or indexes to exclude from processing
+      # @param parallel [true, Integer, Hash] any acceptable parallel options for import
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Index>] indexes that were actually reset
+      def upgrade(only: nil, except: nil, parallel: nil, output: STDOUT)
+        subscribed_task_stats(output) do
+          indexes = indexes_from(only: only, except: except)
+
+          changed_indexes = indexes.select do |index|
+            index.specification.changed?
+          end
+
+          if changed_indexes.present?
+            indexes.each do |index|
+              if changed_indexes.include?(index)
+                reset_one(index, output, parallel: parallel)
+              else
+                output.puts "Skipping #{index}, the specification didn't change"
+              end
             end
-          end if payload[:errors]
+          else
+            output.puts 'No index specification was changed'
+          end
+
+          changed_indexes
         end
-        ActiveSupport::Notifications.subscribed(callback, 'import_objects.chewy') do
-          yield
+      end
+
+      # Performs full update for each passed type if the corresponding index exists.
+      #
+      # @example
+      #   Chewy::RakeHelper.update # updates everything
+      #   Chewy::RakeHelper.update(only: 'places') # updates only PlacesIndex::City and PlacesIndex::Country
+      #   Chewy::RakeHelper.update(only: 'places#city') # updates PlacesIndex::City only
+      #   Chewy::RakeHelper.update(except: PlacesIndex::Country) # updates everything, but PlacesIndex::Country
+      #   Chewy::RakeHelper.update(only: 'places', except: 'places#country') # updates PlacesIndex::City only
+      #
+      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to update; if nothing is passed - uses all the types defined in the app
+      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param parallel [true, Integer, Hash] any acceptable parallel options for import
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Type>] types that were actually updated
+      def update(only: nil, except: nil, parallel: nil, output: STDOUT)
+        subscribed_task_stats(output) do
+          types_from(only: only, except: except).group_by(&:index).each_with_object([]) do |(index, types), update_types|
+            if index.exists?
+              output.puts "Updating #{index}"
+              types.each { |type| type.import(parallel: parallel) }
+              update_types.concat(types)
+            else
+              output.puts "Skipping #{index}, it does not exists (use rake chewy:reset[#{index.derivable_name}] to create and update it)"
+            end
+          end
+        end
+      end
+
+      # Performs synchronization for each passed index if it exists.
+      #
+      # @example
+      #   Chewy::RakeHelper.sync # synchronizes everything
+      #   Chewy::RakeHelper.sync(only: 'places') # synchronizes only PlacesIndex::City and PlacesIndex::Country
+      #   Chewy::RakeHelper.sync(only: 'places#city') # synchronizes PlacesIndex::City only
+      #   Chewy::RakeHelper.sync(except: PlacesIndex::Country) # synchronizes everything, but PlacesIndex::Country
+      #   Chewy::RakeHelper.sync(only: 'places', except: 'places#country') # synchronizes PlacesIndex::City only
+      #
+      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
+      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param parallel [true, Integer, Hash] any acceptable parallel options for sync
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Type>] types that were actually updated
+      def sync(only: nil, except: nil, parallel: nil, output: STDOUT)
+        subscribed_task_stats(output) do
+          types_from(only: only, except: except).each_with_object([]) do |type, synced_types|
+            output.puts "Synchronizing #{type}"
+            output.puts "  #{type} doesn't support outdated synchronization" unless type.supports_outdated_sync?
+            time = Time.now
+            sync_result = type.sync(parallel: parallel)
+            if !sync_result
+              output.puts "  Something went wrong with the #{type} synchronization"
+            elsif sync_result[:count] > 0
+              output.puts "  Missing documents: #{sync_result[:missing]}" if sync_result[:missing].present?
+              output.puts "  Outdated documents: #{sync_result[:outdated]}" if sync_result[:outdated].present?
+              synced_types.push(type)
+            else
+              output.puts "  Skipping #{type}, up to date"
+            end
+            output.puts "  Took #{human_duration(Time.now - time)}"
+          end
         end
       end
 
-      def eager_load_chewy!
-        dirs = Chewy::Railtie.all_engines.map { |engine| engine.paths['app/chewy'] }.compact.map(&:existent).flatten.uniq
+      # Applies changes that were done after the specified time for the
+      # specified indexes/types or all of them.
+      #
+      # @example
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago) # applies entries created for the last minute
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places') # applies only PlacesIndex::City and PlacesIndex::Country entries reated for the last minute
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places#city') # applies PlacesIndex::City entries reated for the last minute only
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, except: PlacesIndex::Country) # applies everything, but PlacesIndex::Country entries reated for the last minute
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places', except: 'places#country') # applies PlacesIndex::City entries reated for the last minute only
+      #
+      # @param time [Time, DateTime] use only journal entries created after this time
+      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
+      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Type>] types that were actually updated
+      def journal_apply(time: nil, only: nil, except: nil, output: STDOUT)
+        raise ArgumentError, 'Please specify the time to start with' unless time
+        subscribed_task_stats(output) do
+          output.puts "Applying journal entries created after #{time}"
+          count = Chewy::Journal.new(types_from(only: only, except: except)).apply(time)
+          output.puts 'No journal entries were created after the specified time' if count.zero?
+        end
+      end
+
+      # Removes journal records created before the specified timestamp for
+      # the specified indexes/types or all of them.
+      #
+      # @example
+      #   Chewy::RakeHelper.journal_clean # cleans everything
+      #   Chewy::RakeHelper.journal_clean(time: 1.minute.ago) # leaves only entries created for the last minute
+      #   Chewy::RakeHelper.journal_clean(only: 'places') # cleans only PlacesIndex::City and PlacesIndex::Country entries
+      #   Chewy::RakeHelper.journal_clean(only: 'places#city') # cleans PlacesIndex::City entries only
+      #   Chewy::RakeHelper.journal_clean(except: PlacesIndex::Country) # cleans everything, but PlacesIndex::Country entries
+      #   Chewy::RakeHelper.journal_clean(only: 'places', except: 'places#country') # cleans PlacesIndex::City entries only
+      #
+      # @param time [Time, DateTime] clean all the journal entries created before this time
+      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
+      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param output [IO] output io for logging
+      # @return [Array<Chewy::Type>] types that were actually updated
+      def journal_clean(time: nil, only: nil, except: nil, output: STDOUT)
+        subscribed_task_stats(output) do
+          output.puts "Cleaning journal entries created before #{time}" if time
+          response = Chewy::Journal.new(types_from(only: only, except: except)).clean(time)
+          count = response['deleted'] || response['_indices']['_all']['deleted']
+          output.puts "Cleaned up #{count} journal entries"
+        end
+      end
 
-        dirs.each do |dir|
-          Dir.glob(File.join(dir, '**/*.rb')).each do |file|
-            require_dependency file
+      # Eager loads and returns all the indexes defined in the application
+      # except Chewy::Stash::Specification and Chewy::Stash::Journal.
+      #
+      # @return [Array<Chewy::Index>] indexes found
+      def all_indexes
+        Chewy.eager_load!
+        Chewy::Index.descendants - [Chewy::Stash::Journal, Chewy::Stash::Specification]
+      end
+
+      def normalize_indexes(*identifiers)
+        identifiers.flatten(1).map { |identifier| normalize_index(identifier) }
+      end
+
+      def normalize_index(identifier)
+        return identifier if identifier.is_a?(Class) && identifier < Chewy::Index
+        "#{identifier.to_s.gsub(/identifier\z/i, '').camelize}Index".constantize
+      end
+
+      def subscribed_task_stats(output = STDOUT)
+        start = Time.now
+        ActiveSupport::Notifications.subscribed(JOURNAL_CALLBACK.curry[output], 'apply_journal.chewy') do
+          ActiveSupport::Notifications.subscribed(IMPORT_CALLBACK.curry[output], 'import_objects.chewy') do
+            yield
           end
         end
+        output.puts "Total: #{human_duration(Time.now - start)}"
+      end
+
+      def reset_index(*indexes)
+        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.reset_index` is deprecated and will be removed soon, use `Chewy::RakeHelper.reset` instead'
+        reset(only: indexes)
+      end
+
+      def reset_all(*except)
+        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.reset_all` is deprecated and will be removed soon, use `Chewy::RakeHelper.reset` instead'
+        reset(except: except)
       end
 
-      def normalize_index index
-        "#{index.to_s.gsub(/index\z/i, '').camelize}Index".constantize
+      def update_index(*indexes)
+        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.update_index` is deprecated and will be removed soon, use `Chewy::RakeHelper.update` instead'
+        update(only: indexes)
       end
 
-      # Performs zero downtime reindexing of all documents in the specified index.
-      def reset_index index
-        index = normalize_index(index)
-        puts "Resetting #{index}"
-        index.reset! (Time.now.to_f * 1000).round
+      def update_all(*except)
+        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.update_all` is deprecated and will be removed soon, use `Chewy::RakeHelper.update` instead'
+        update(except: except)
       end
 
-      # Performs zero downtime reindexing of all documents across all indices.
-      def reset_all
-        eager_load_chewy!
-        Chewy::Index.descendants.each { |index| reset_index index }
+    private
+
+      def indexes_from(only: nil, except: nil)
+        indexes = if only.present?
+          normalize_indexes(Array.wrap(only))
+        else
+          all_indexes
+        end
+
+        indexes = if except.present?
+          indexes - normalize_indexes(Array.wrap(except))
+        else
+          indexes
+        end
+
+        indexes.sort_by(&:derivable_name)
       end
 
-      def update_index index
-        index = normalize_index(index)
-        puts "Updating #{index}"
-        if index.exists?
-          index.import
+      def types_from(only: nil, except: nil)
+        types = if only.present?
+          normalize_types(Array.wrap(only))
         else
-          puts "Index `#{index.index_name}` does not exists. Use rake chewy:reset[#{index.index_name}] to create and update it."
+          all_indexes.flat_map(&:types)
         end
+
+        types = if except.present?
+          types - normalize_types(Array.wrap(except))
+        else
+          types
+        end
+
+        types.sort_by(&:derivable_name)
+      end
+
+      def normalize_types(*identifiers)
+        identifiers.flatten(1).flat_map { |identifier| normalize_type(identifier) }
+      end
+
+      def normalize_type(identifier)
+        Chewy.derive_types(identifier)
+      end
+
+      def human_duration(seconds)
+        [[60, :s], [60, :m], [24, :h]].map do |amount, unit|
+          if seconds > 0
+            seconds, n = seconds.divmod(amount)
+            "#{n.to_i}#{unit}"
+          end
+        end.compact.reverse.join(' ')
       end
 
-      def update_all
-        eager_load_chewy!
-        Chewy::Index.descendants.each { |index| update_index index }
+      def reset_one(index, output, parallel: false)
+        output.puts "Resetting #{index}"
+        index.reset!((Time.now.to_f * 1000).round, parallel: parallel)
       end
     end
   end

data/lib/chewy/repository.rb

@@ -5,10 +5,10 @@ module Chewy
     attr_reader :analyzers, :tokenizers, :filters, :char_filters
 
     def self.delegated
-      public_instance_methods - self.superclass.public_instance_methods - Singleton.public_instance_methods
+      public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
     end
 
-    def self.repository name
+    def self.repository(name)
       plural_name = name.to_s.pluralize
 
       class_eval <<-METHOD, __FILE__, __LINE__ + 1

data/lib/chewy/rspec/update_index.rb

@@ -20,11 +20,10 @@ require 'i18n/core_ext/hash'
 #   specify { expect { user1.destroy!; user2.save! } }
 #     .to update_index(UsersIndex::User).and_reindex(user2).and_delete(user1) }
 #
-RSpec::Matchers.define :update_index do |type_name, options = {}|
-
+RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disable BlockLength
   if !respond_to?(:failure_message) && respond_to?(:failure_message_for_should)
-    alias :failure_message :failure_message_for_should
-    alias :failure_message_when_negated :failure_message_for_should_not
+    alias_method :failure_message, :failure_message_for_should
+    alias_method :failure_message_when_negated, :failure_message_for_should_not
   end
 
   # Specify indexed records by passing record itself or id.
@@ -83,7 +82,9 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   #   specify { expect { [user1, user2].map(&:save!) }
   #     .to update_index(UsersIndex.user).and_reindex(user1).only }
   #
-  chain(:only) do |*args|
+  chain(:only) do |*_args|
+    raise 'Use `only` in conjunction with `and_reindex` or `and_delete`' if @reindex.blank? && @delete.blank?
+
     @only = true
   end
 
@@ -91,64 +92,60 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     true
   end
 
-  match do |block|
+  match do |block| # rubocop:disable BlockLength
     @reindex ||= {}
     @delete ||= {}
     @missed_reindex = []
     @missed_delete = []
-    @updated = []
 
     type = Chewy.derive_type(type_name)
+    if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
+      Chewy::Type::Import::BulkRequest.stubs(:new).with(type, any_parameters).returns(mock_bulk_request)
+    else
+      mocked_already = ::RSpec::Mocks.space.proxy_for(Chewy::Type::Import::BulkRequest).method_double_if_exists_for_message(:new)
+      allow(Chewy::Type::Import::BulkRequest).to receive(:new).and_call_original unless mocked_already
+      allow(Chewy::Type::Import::BulkRequest).to receive(:new).with(type, any_args).and_return(mock_bulk_request)
+    end
 
-    instance_eval <<-RUBY, __FILE__, __LINE__ + 1
-       #{agnostic_stub} do |bulk_options|
-        @updated += bulk_options[:body].map do |updated_document|
-          updated_document.deep_symbolize_keys
-        end
-        {}
-      end
-    RUBY
-
-    ActiveSupport::Deprecation.warn('`atomic: false` option is removed and not effective anymore, use `strategy: :atomic` option instead') if options.key?(:atomic)
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
 
-    @updated.each do |updated_document|
-      if body = updated_document[:index]
-        if document = @reindex[body[:_id].to_s]
+    mock_bulk_request.updates.each do |updated_document|
+      if (body = updated_document[:index])
+        if (document = @reindex[body[:_id].to_s])
           document[:real_count] += 1
           document[:real_attributes].merge!(body[:data])
-        else
-          @missed_reindex.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_reindex.push(body[:_id].to_s)
         end
-      elsif body = updated_document[:delete]
-        if document = @delete[body[:_id].to_s]
+      elsif (body = updated_document[:delete])
+        if (document = @delete[body[:_id].to_s])
           document[:real_count] += 1
-        else
-          @missed_delete.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_delete.push(body[:_id].to_s)
         end
       end
     end
 
-    @reindex.each do |_, document|
+    @reindex.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
       document[:match_attributes] = document[:expected_attributes].blank? ||
         compare_attributes(document[:expected_attributes], document[:real_attributes])
     end
-    @delete.each do |_, document|
+    @delete.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end
 
-    @updated.present? && @missed_reindex.none? && @missed_delete.none? &&
-    @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
-    @delete.all? { |_, document| document[:match_count] }
+    mock_bulk_request.updates.present? && @missed_reindex.none? && @missed_delete.none? &&
+      @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
+      @delete.all? { |_, document| document[:match_count] }
   end
 
-  failure_message do
+  failure_message do # rubocop:disable BlockLength
     output = ''
 
-    if @updated.none?
+    if mock_bulk_request.updates.none?
       output << "Expected index `#{type_name}` to be updated, but it was not\n"
     elsif @missed_reindex.present? || @missed_delete.present?
       message = "Expected index `#{type_name}` "
@@ -166,28 +163,28 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
       output << message
     end
 
-    output << @reindex.each.with_object('') do |(id, document), output|
+    output << @reindex.each.with_object('') do |(id, document), result|
       unless document[:match_count] && document[:match_attributes]
-        output << "Expected document with id `#{id}` to be reindexed"
+        result << "Expected document with id `#{id}` to be reindexed"
         if document[:real_count] > 0
-          output << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
-          output << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
+          result << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
+          result << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
         else
-          output << ", but it was not"
+          result << ', but it was not'
         end
-        output << "\n"
+        result << "\n"
       end
     end
 
-    output << @delete.each.with_object('') do |(id, document), output|
+    output << @delete.each.with_object('') do |(id, document), result|
       unless document[:match_count]
-        output << "Expected document with id `#{id}` to be deleted"
-        if document[:real_count] > 0 && document[:expected_count] && !document[:match_count]
-          output << "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
-        else
-          output << ", but it was not"
-        end
-        output << "\n"
+        result << "Expected document with id `#{id}` to be deleted"
+        result << if document[:real_count] > 0 && document[:expected_count]
+                    "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
+                  else
+                    ', but it was not'
+                  end
+        result << "\n"
       end
     end
 
@@ -195,24 +192,18 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   end
 
   failure_message_when_negated do
-    if @updated.present?
-      "Expected index `#{type_name}` not to be updated, but it was with #{
-        @updated.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
-          "\n  document id `#{id}` (#{documents.count} times)"
-        end.join
-      }\n"
+    if mock_bulk_request.updates.present?
+      "Expected index `#{type_name}` not to be updated, but it was with #{mock_bulk_request.updates.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
+                                                                            "\n  document id `#{id}` (#{documents.count} times)"
+                                                                          end.join}\n"
     end
   end
 
-  def agnostic_stub
-    if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      "type.stubs(:bulk).with"
-    else
-      "allow(type).to receive(:bulk)"
-    end
+  def mock_bulk_request
+    @mock_bulk_request ||= MockBulkRequest.new
   end
 
-  def extract_documents *args
+  def extract_documents(*args)
     options = args.extract_options!
 
     expected_count = options[:times] || options[:count]
@@ -230,7 +221,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end]
   end
 
-  def compare_attributes expected, real
+  def compare_attributes(expected, real)
     expected.inject(true) do |result, (key, value)|
       equal = if value.is_a?(Array) && real[key].is_a?(Array)
         array_difference(value, real[key]) && array_difference(real[key], value)
@@ -243,13 +234,27 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
   end
 
-  def array_difference first, second
+  def array_difference(first, second)
     difference = first.to_ary.dup
     second.to_ary.each do |element|
-      if index = difference.index(element)
-        difference.delete_at(index)
-      end
+      index = difference.index(element)
+      difference.delete_at(index) if index
     end
     difference.none?
   end
+
+  # Collects request bodies coming through the perform method for
+  # the further analysis.
+  class MockBulkRequest
+    attr_reader :updates
+
+    def initialize
+      @updates = []
+    end
+
+    def perform(body)
+      @updates.concat(body.map(&:deep_symbolize_keys))
+      []
+    end
+  end
 end

data/lib/chewy/rspec.rb

@@ -1 +1 @@
-require 'chewy/rspec/update_index'
+require 'chewy/rspec/update_index'

data/lib/chewy/runtime/version.rb

@@ -4,21 +4,21 @@ module Chewy
       include Comparable
       attr_reader :major, :minor, :patch
 
-      def initialize version
-        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0]*3).first(3).map(&:to_i)
+      def initialize(version)
+        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0] * 3).first(3).map(&:to_i)
       end
 
       def to_s
         [major, minor, patch].join('.')
       end
 
-      def <=> other
+      def <=>(other)
         other = self.class.new(other) unless other.is_a?(self.class)
         [
           major <=> other.major,
           minor <=> other.minor,
           patch <=> other.patch
-        ].detect { |c| c != 0 } || 0
+        ].detect(&:nonzero?) || 0
       end
     end
   end