chewy 6.0.0 → 7.6.0

data/lib/chewy/minitest/helpers.rb

@@ -6,7 +6,7 @@ module Chewy
       extend ActiveSupport::Concern
 
       # Assert that an index *changes* during a block.
-      # @param index [Chewy::Type] the index / type to watch, eg EntitiesIndex::Entity.
+      # @param index [Chewy::Index] the index to watch, eg EntitiesIndex.
       # @param strategy [Symbol] the Chewy strategy to use around the block. See Chewy docs.
       # @param bypass_actual_index [true, false]
       #   True to preempt the http call to Elastic, false otherwise.
@@ -14,11 +14,11 @@ module Chewy
       #
       # @return [SearchIndexReceiver] for optional further assertions on the nature of the index changes.
       #
-      def assert_indexes(index, strategy: :atomic, bypass_actual_index: true)
-        type = Chewy.derive_type index
+      def assert_indexes(index, strategy: :atomic, bypass_actual_index: true, &block)
+        index_class = Chewy.derive_name index
         receiver = SearchIndexReceiver.new
 
-        bulk_method = type.method :bulk
+        bulk_method = index_class.method :bulk
         # Manually mocking #bulk because we need to properly capture `self`
         bulk_mock = lambda do |*bulk_args|
           receiver.catch bulk_args, self
@@ -28,13 +28,11 @@ module Chewy
           {}
         end
 
-        type.define_singleton_method :bulk, bulk_mock
+        index_class.define_singleton_method :bulk, bulk_mock
 
-        Chewy.strategy(strategy) do
-          yield
-        end
+        Chewy.strategy(strategy, &block)
 
-        type.define_singleton_method :bulk, bulk_method
+        index_class.define_singleton_method :bulk, bulk_method
 
         assert_includes receiver.updated_indexes, index, "Expected #{index} to be updated but it wasn't"
 
@@ -44,10 +42,85 @@ module Chewy
       # Run indexing for the database changes during the block provided.
       # By default, indexing is run at the end of the block.
       # @param strategy [Symbol] the Chewy index update strategy see Chewy docs.
-      def run_indexing(strategy: :atomic)
-        Chewy.strategy strategy do
-          yield
-        end
+      #
+      def run_indexing(strategy: :atomic, &block)
+        Chewy.strategy strategy, &block
+      end
+
+      # Mock Elasticsearch response
+      # Simple usage - just pass index, expected raw response
+      # and block with the query.
+      #
+      # @param index [Chewy::Index] the index to watch, eg EntitiesIndex.
+      # @param raw_response [Hash] hash with response.
+      #
+      def mock_elasticsearch_response(index, raw_response)
+        mocked_request = Chewy::Search::Request.new(index)
+
+        original_new = Chewy::Search::Request.method(:new)
+
+        Chewy::Search::Request.define_singleton_method(:new) { |*_args| mocked_request }
+
+        original_perform = mocked_request.method(:perform)
+        mocked_request.define_singleton_method(:perform) { raw_response }
+
+        yield
+      ensure
+        mocked_request.define_singleton_method(:perform, original_perform)
+        Chewy::Search::Request.define_singleton_method(:new, original_new)
+      end
+
+      # Mock Elasticsearch response with defined sources
+      # Simple usage - just pass index, expected sources
+      # and block with the query.
+      #
+      # @param index [Chewy::Index] the index to watch, eg EntitiesIndex.
+      # @param hits [Hash] hash with sources.
+      #
+      def mock_elasticsearch_response_sources(index, hits, &block)
+        raw_response = {
+          'took' => 4,
+          'timed_out' => false,
+          '_shards' => {
+            'total' => 1,
+            'successful' => 1,
+            'skipped' => 0,
+            'failed' => 0
+          },
+          'hits' => {
+            'total' => {
+              'value' => hits.count,
+              'relation' => 'eq'
+            },
+            'max_score' => 1.0,
+            'hits' => hits.each_with_index.map do |hit, i|
+              {
+                '_index' => index.index_name,
+                '_type' => '_doc',
+                '_id' => hit[:id] || (i + 1).to_s,
+                '_score' => 3.14,
+                '_source' => hit
+              }
+            end
+          }
+        }
+
+        mock_elasticsearch_response(index, raw_response, &block)
+      end
+
+      # Check the assertion that actual Elasticsearch query is rendered
+      # to the expected query
+      #
+      # @param query [::Query] the actual Elasticsearch query.
+      # @param expected_query [Hash] expected query.
+      #
+      # @return [Boolean]
+      #   True - in the case when actual Elasticsearch query is rendered to the expected query.
+      #   False - in the opposite case.
+      #
+      def assert_elasticsearch_query(query, expected_query)
+        actual_query = query.render
+        assert_equal expected_query, actual_query, "got #{actual_query.inspect} instead of expected query."
       end
 
       module ClassMethods

data/lib/chewy/minitest/search_index_receiver.rb

@@ -1,80 +1,78 @@
 # Test helper class to provide minitest hooks for Chewy::Index testing.
 #
 # @note Intended to be used in conjunction with a test helper which mocks over the #bulk
-#   method on a {Chewy::Type} class. (See SearchTestHelper)
+#   method on a {Chewy::Index} class. (See {Chewy::Minitest::Helpers})
 #
-# The class will capture the data from the *param on the Chewy::Type.bulk method and
+# The class will capture the data from the *param on the Chewy::Index.bulk method and
 # aggregate the data for test analysis.
 class SearchIndexReceiver
+  MUTATION_FOR_CLASS = Struct.new(:indexes, :deletes, keyword_init: true)
+
   def initialize
     @mutations = {}
   end
 
-  # @param bulk_params [Hash] the bulk_params that should be sent to the Chewy::Type.bulk method.
-  # @param type [Chewy::Type] the type executing this query.
-  def catch(bulk_params, type)
+  # @param bulk_params [Hash] the bulk_params that should be sent to the Chewy::Index.bulk method.
+  # @param index [Chewy::Index] the index executing this query.
+  def catch(bulk_params, index)
     Array.wrap(bulk_params).map { |y| y[:body] }.flatten.each do |update|
       if update[:delete]
-        mutation_for(type).deletes << update[:delete][:_id]
+        mutation_for(index).deletes << update[:delete][:_id]
       elsif update[:index]
-        mutation_for(type).indexes << update[:index]
+        mutation_for(index).indexes << update[:index]
       end
     end
   end
 
-  # @param index [Chewy::Index] return only index requests to the specified {Chewy::Type} index.
+  # @param index [Chewy::Index] return only index requests to the specified {Chewy::Index} index.
   # @return [Hash] the index changes captured by the mock.
   def indexes_for(index = nil)
     if index
       mutation_for(index).indexes
     else
-      Hash[
-        @mutations.map { |a, b| [a, b.indexes] }
-      ]
+      @mutations.transform_values(&:indexes)
     end
   end
   alias_method :indexes, :indexes_for
 
-  # @param index [Chewy::Index] return only delete requests to the specified {Chewy::Type} index.
+  # @param index [Chewy::Index] return only delete requests to the specified {Chewy::Index} index.
   # @return [Hash] the index deletes captured by the mock.
   def deletes_for(index = nil)
     if index
       mutation_for(index).deletes
     else
-      Hash[
-        @mutations.map { |a, b| [a, b.deletes] }
-      ]
+      @mutations.transform_values(&:deletes)
     end
   end
   alias_method :deletes, :deletes_for
 
   # Check to see if a given object has been indexed.
   # @param obj [#id] obj the object to look for.
-  # @param type [Chewy::Type] what type the object should be indexed as.
+  # @param index [Chewy::Index] what index the object should be indexed in.
   # @return [true, false] if the object was indexed.
-  def indexed?(obj, type)
-    indexes_for(type).map { |i| i[:_id] }.include? obj.id
+  def indexed?(obj, index)
+    indexes_for(index).map { |i| i[:_id] }.include? obj.id
   end
 
   # Check to see if a given object has been deleted.
   # @param obj [#id] obj the object to look for.
-  # @param type [Chewy::Type] what type the object should have been deleted from.
+  # @param index [Chewy::Index] what index the object should have been deleted from.
   # @return [true, false] if the object was deleted.
-  def deleted?(obj, type)
-    deletes_for(type).include? obj.id
+  def deleted?(obj, index)
+    deletes_for(index).include? obj.id
   end
 
-  # @return [Array<Chewy::Type>] a list of types indexes changed.
+  # @return [Array<Chewy::Index>] a list of indexes changed.
   def updated_indexes
     @mutations.keys
   end
 
 private
 
-  # Get the mutation object for a given type.
-  # @param type [Chewy::Type] the index type to fetch.
+  # Get the mutation object for a given index.
+  # @param index [Chewy::Index] the index to fetch.
   # @return [#indexes, #deletes] an object with a list of indexes and a list of deletes.
-  def mutation_for(type)
-    @mutations[type] ||= OpenStruct.new(indexes: [], deletes: [])
+  def mutation_for(index)
+    @mutations[index] ||= MUTATION_FOR_CLASS.new(indexes: [], deletes: [])
   end
 end

data/lib/chewy/railtie.rb

@@ -14,7 +14,9 @@ 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
+          if Chewy.logger && @request_strategy != Chewy.request_strategy
+            Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`")
+          end
           @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
@@ -22,17 +24,6 @@ module Chewy
     end
 
     module MigrationStrategy
-      extend ActiveSupport::Concern
-      included do
-        alias_method_chain :migrate, :chewy
-      end
-
-      def migrate_with_chewy(*args)
-        Chewy.strategy(:bypass) { migrate_without_chewy(*args) }
-      end
-    end
-
-    module Rails5MigrationStrategy
       def migrate(*args)
         Chewy.strategy(:bypass) { super }
       end
@@ -46,7 +37,7 @@ module Chewy
       if app.sandbox?
         Chewy.strategy(:bypass)
       else
-        Chewy.strategy(:urgent)
+        Chewy.strategy(Chewy.console_strategy)
       end
       puts "Chewy console strategy is `#{Chewy.strategy.current.name}`"
     end
@@ -57,13 +48,8 @@ module Chewy
 
     initializer 'chewy.migration_strategy' do
       ActiveSupport.on_load(:active_record) do
-        if Rails::VERSION::MAJOR >= 5
-          ActiveRecord::Migration.prepend(Rails5MigrationStrategy)
-          ActiveRecord::Migrator.prepend(Rails5MigrationStrategy) if defined? ActiveRecord::Migrator
-        else
-          ActiveRecord::Migration.send(:include, MigrationStrategy)
-          ActiveRecord::Migrator.send(:include, MigrationStrategy) if defined? ActiveRecord::Migrator
-        end
+        ActiveRecord::Migration.prepend(MigrationStrategy)
+        ActiveRecord::Migrator.prepend(MigrationStrategy) if defined? ActiveRecord::Migrator
       end
     end