activesupport 4.2.11.1 → 6.0.3.1

data/lib/active_support/string_inquirer.rb

@@ -1,22 +1,29 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped
-  # in a StringInquirer object so instead of calling this:
+  # in a StringInquirer object, so instead of calling this:
   #
   #   Rails.env == 'production'
   #
   # you can call this:
   #
   #   Rails.env.production?
+  #
+  # == Instantiating a new StringInquirer
+  #
+  #   vehicle = ActiveSupport::StringInquirer.new('car')
+  #   vehicle.car?   # => true
+  #   vehicle.bike?  # => false
   class StringInquirer < String
     private
-
       def respond_to_missing?(method_name, include_private = false)
-        method_name[-1] == '?'
+        (method_name[-1] == "?") || super
       end
 
       def method_missing(method_name, *arguments)
-        if method_name[-1] == '?'
+        if method_name[-1] == "?"
           self == method_name[0..-2]
         else
           super

data/lib/active_support/subscriber.rb

@@ -1,36 +1,37 @@
-require 'active_support/per_thread_registry'
+# frozen_string_literal: true
+
+require "active_support/per_thread_registry"
+require "active_support/notifications"
 
 module ActiveSupport
   # ActiveSupport::Subscriber is an object set to consume
   # ActiveSupport::Notifications. The subscriber dispatches notifications to
   # a registered object based on its given namespace.
   #
-  # An example would be Active Record subscriber responsible for collecting
+  # An example would be an Active Record subscriber responsible for collecting
   # statistics about queries:
   #
   #   module ActiveRecord
   #     class StatsSubscriber < ActiveSupport::Subscriber
+  #       attach_to :active_record
+  #
   #       def sql(event)
   #         Statsd.timing("sql.#{event.payload[:name]}", event.duration)
   #       end
   #     end
   #   end
   #
-  # And it's finally registered as:
-  #
-  #   ActiveRecord::StatsSubscriber.attach_to :active_record
-  #
-  # Since we need to know all instance methods before attaching the log
-  # subscriber, the line above should be called after your subscriber definition.
-  #
   # After configured, whenever a "sql.active_record" notification is published,
   # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
   # the +sql+ method.
+  #
+  # We can detach a subscriber as well:
+  #
+  #   ActiveRecord::StatsSubscriber.detach_from(:active_record)
   class Subscriber
     class << self
-
       # Attach the subscriber to a namespace.
-      def attach_to(namespace, subscriber=new, notifier=ActiveSupport::Notifications)
+      def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications)
         @namespace  = namespace
         @subscriber = subscriber
         @notifier   = notifier
@@ -43,6 +44,25 @@ module ActiveSupport
         end
       end
 
+      # Detach the subscriber from a namespace.
+      def detach_from(namespace, notifier = ActiveSupport::Notifications)
+        @namespace  = namespace
+        @subscriber = find_attached_subscriber
+        @notifier   = notifier
+
+        return unless subscriber
+
+        subscribers.delete(subscriber)
+
+        # Remove event subscribers of all existing methods on the class.
+        subscriber.public_methods(false).each do |event|
+          remove_event_subscriber(event)
+        end
+
+        # Reset notifier so that event subscribers will not add for new methods added to the class.
+        @notifier = nil
+      end
+
       # Adds event subscribers for all new methods added to the class.
       def method_added(event)
         # Only public methods are added as subscribers, and only if a notifier
@@ -57,51 +77,75 @@ module ActiveSupport
         @@subscribers ||= []
       end
 
-      protected
+      private
+        attr_reader :subscriber, :notifier, :namespace
+
+        def add_event_subscriber(event) # :doc:
+          return if invalid_event?(event.to_s)
 
-      attr_reader :subscriber, :notifier, :namespace
+          pattern = prepare_pattern(event)
 
-      def add_event_subscriber(event)
-        return if %w{ start finish }.include?(event.to_s)
+          # Don't add multiple subscribers (eg. if methods are redefined).
+          return if pattern_subscribed?(pattern)
 
-        pattern = "#{event}.#{namespace}"
+          subscriber.patterns[pattern] = notifier.subscribe(pattern, subscriber)
+        end
 
-        # don't add multiple subscribers (eg. if methods are redefined)
-        return if subscriber.patterns.include?(pattern)
+        def remove_event_subscriber(event) # :doc:
+          return if invalid_event?(event.to_s)
 
-        subscriber.patterns << pattern
-        notifier.subscribe(pattern, subscriber)
-      end
+          pattern = prepare_pattern(event)
+
+          return unless pattern_subscribed?(pattern)
+
+          notifier.unsubscribe(subscriber.patterns[pattern])
+          subscriber.patterns.delete(pattern)
+        end
+
+        def find_attached_subscriber
+          subscribers.find { |attached_subscriber| attached_subscriber.instance_of?(self) }
+        end
+
+        def invalid_event?(event)
+          %w{ start finish }.include?(event.to_s)
+        end
+
+        def prepare_pattern(event)
+          "#{event}.#{namespace}"
+        end
+
+        def pattern_subscribed?(pattern)
+          subscriber.patterns.key?(pattern)
+        end
     end
 
     attr_reader :patterns # :nodoc:
 
     def initialize
       @queue_key = [self.class.name, object_id].join "-"
-      @patterns  = []
+      @patterns  = {}
       super
     end
 
     def start(name, id, payload)
-      e = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
+      event = ActiveSupport::Notifications::Event.new(name, nil, nil, id, payload)
+      event.start!
       parent = event_stack.last
-      parent << e if parent
+      parent << event if parent
 
-      event_stack.push e
+      event_stack.push event
     end
 
     def finish(name, id, payload)
-      finished  = Time.now
-      event     = event_stack.pop
-      event.end = finished
+      event = event_stack.pop
+      event.finish!
       event.payload.merge!(payload)
 
-      method = name.split('.').first
+      method = name.split(".").first
       send(method, event)
     end
 
     private
-
       def event_stack
         SubscriberQueueRegistry.instance.get_queue(@queue_key)
       end

data/lib/active_support/tagged_logging.rb

@@ -1,7 +1,9 @@
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/blank'
-require 'logger'
-require 'active_support/logger'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+require "logger"
+require "active_support/logger"
 
 module ActiveSupport
   # Wraps any standard Logger object to provide tagging capabilities.
@@ -43,21 +45,31 @@ module ActiveSupport
       end
 
       def current_tags
-        Thread.current[:activesupport_tagged_logging_tags] ||= []
+        # We use our object ID here to avoid conflicting with other instances
+        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
+        Thread.current[thread_key] ||= []
       end
 
-      private
-        def tags_text
-          tags = current_tags
-          if tags.any?
-            tags.collect { |tag| "[#{tag}] " }.join
-          end
+      def tags_text
+        tags = current_tags
+        if tags.one?
+          "[#{tags[0]}] "
+        elsif tags.any?
+          tags.collect { |tag| "[#{tag}] " }.join
         end
+      end
     end
 
     def self.new(logger)
-      # Ensure we set a default formatter so we aren't extending nil!
-      logger.formatter ||= ActiveSupport::Logger::SimpleFormatter.new
+      logger = logger.dup
+
+      if logger.formatter
+        logger.formatter = logger.formatter.dup
+      else
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
+      end
+
       logger.formatter.extend Formatter
       logger.extend(self)
     end

data/lib/active_support/test_case.rb

@@ -1,15 +1,18 @@
-gem 'minitest' # make sure we get the gem, not stdlib
-require 'minitest'
-require 'active_support/testing/tagged_logging'
-require 'active_support/testing/setup_and_teardown'
-require 'active_support/testing/assertions'
-require 'active_support/testing/deprecation'
-require 'active_support/testing/declarative'
-require 'active_support/testing/isolation'
-require 'active_support/testing/constant_lookup'
-require 'active_support/testing/time_helpers'
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+gem "minitest" # make sure we get the gem, not stdlib
+require "minitest"
+require "active_support/testing/tagged_logging"
+require "active_support/testing/setup_and_teardown"
+require "active_support/testing/assertions"
+require "active_support/testing/deprecation"
+require "active_support/testing/declarative"
+require "active_support/testing/isolation"
+require "active_support/testing/constant_lookup"
+require "active_support/testing/time_helpers"
+require "active_support/testing/file_fixtures"
+require "active_support/testing/parallelization"
+require "concurrent/utility/processor_counter"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
@@ -31,45 +34,112 @@ module ActiveSupport
 
       # Returns the order in which test cases are run.
       #
-      #   ActiveSupport::TestCase.test_order # => :sorted
+      #   ActiveSupport::TestCase.test_order # => :random
       #
       # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
-      # Defaults to +:sorted+.
+      # Defaults to +:random+.
       def test_order
-        test_order = ActiveSupport.test_order
-
-        if test_order.nil?
-          ActiveSupport::Deprecation.warn "You did not specify a value for the " \
-            "configuration option `active_support.test_order`. In Rails 5, " \
-            "the default value of this option will change from `:sorted` to " \
-            "`:random`.\n" \
-            "To disable this warning and keep the current behavior, you can add " \
-            "the following line to your `config/environments/test.rb`:\n" \
-            "\n" \
-            "  Rails.application.configure do\n" \
-            "    config.active_support.test_order = :sorted\n" \
-            "  end\n" \
-            "\n" \
-            "Alternatively, you can opt into the future behavior by setting this " \
-            "option to `:random`."
-
-          test_order = :sorted
-          self.test_order = test_order
+        ActiveSupport.test_order ||= :random
+      end
+
+      # Parallelizes the test suite.
+      #
+      # Takes a +workers+ argument that controls how many times the process
+      # is forked. For each process a new database will be created suffixed
+      # with the worker number.
+      #
+      #   test-database-0
+      #   test-database-1
+      #
+      # If <tt>ENV["PARALLEL_WORKERS"]</tt> is set the workers argument will be ignored
+      # and the environment variable will be used instead. This is useful for CI
+      # environments, or other environments where you may need more workers than
+      # you do for local testing.
+      #
+      # If the number of workers is set to +1+ or fewer, the tests will not be
+      # parallelized.
+      #
+      # If +workers+ is set to +:number_of_processors+, the number of workers will be
+      # set to the actual core count on the machine you are on.
+      #
+      # The default parallelization method is to fork processes. If you'd like to
+      # use threads instead you can pass <tt>with: :threads</tt> to the +parallelize+
+      # method. Note the threaded parallelization does not create multiple
+      # database and will not work with system tests at this time.
+      #
+      #   parallelize(workers: :number_of_processors, with: :threads)
+      #
+      # The threaded parallelization uses minitest's parallel executor directly.
+      # The processes parallelization uses a Ruby DRb server.
+      def parallelize(workers: :number_of_processors, with: :processes)
+        workers = Concurrent.physical_processor_count if workers == :number_of_processors
+        workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
+
+        return if workers <= 1
+
+        executor = case with
+                   when :processes
+                     Testing::Parallelization.new(workers)
+                   when :threads
+                     Minitest::Parallel::Executor.new(workers)
+                   else
+                     raise ArgumentError, "#{with} is not a supported parallelization executor."
         end
 
-        test_order
+        self.lock_threads = false if defined?(self.lock_threads) && with == :threads
+
+        Minitest.parallel_executor = executor
+
+        parallelize_me!
+      end
+
+      # Set up hook for parallel testing. This can be used if you have multiple
+      # databases or any behavior that needs to be run after the process is forked
+      # but before the tests run.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_setup do
+      #       # create databases
+      #     end
+      #   end
+      def parallelize_setup(&block)
+        ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
+          yield worker
+        end
       end
 
-      alias :my_tests_are_order_dependent! :i_suck_and_my_tests_are_order_dependent!
+      # Clean up hook for parallel testing. This can be used to drop databases
+      # if your app uses multiple write/read databases or other clean up before
+      # the tests finish. This runs before the forked process is closed.
+      #
+      # Note: this feature is not available with the threaded parallelization.
+      #
+      # In your +test_helper.rb+ add the following:
+      #
+      #   class ActiveSupport::TestCase
+      #     parallelize_teardown do
+      #       # drop databases
+      #     end
+      #   end
+      def parallelize_teardown(&block)
+        ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
+          yield worker
+        end
+      end
     end
 
     alias_method :method_name, :name
 
     include ActiveSupport::Testing::TaggedLogging
-    include ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::SetupAndTeardown
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::Deprecation
     include ActiveSupport::Testing::TimeHelpers
+    include ActiveSupport::Testing::FileFixtures
     extend ActiveSupport::Testing::Declarative
 
     # test/unit backwards compatibility methods
@@ -88,13 +158,6 @@ module ActiveSupport
     alias :assert_not_respond_to :refute_respond_to
     alias :assert_not_same :refute_same
 
-    # Fails if the block raises an exception.
-    #
-    #   assert_nothing_raised do
-    #     ...
-    #   end
-    def assert_nothing_raised(*args)
-      yield
-    end
+    ActiveSupport.run_load_hooks(:active_support_test_case, self)
   end
 end

data/lib/active_support/testing/assertions.rb

@@ -1,9 +1,11 @@
-require 'active_support/core_ext/object/blank'
+# frozen_string_literal: true
 
 module ActiveSupport
   module Testing
     module Assertions
-      # Assert that an expression is not truthy. Passes if <tt>object</tt> is
+      UNTRACKED = Object.new # :nodoc:
+
+      # Asserts that an expression is not truthy. Passes if <tt>object</tt> is
       # +nil+ or +false+. "Truthy" means "considered true in a conditional"
       # like <tt>if foo</tt>.
       #
@@ -19,79 +21,208 @@ module ActiveSupport
         assert !object, message
       end
 
+      # Assertion that the block should not raise an exception.
+      #
+      # Passes if evaluated code in the yielded block raises no exception.
+      #
+      #   assert_nothing_raised do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_nothing_raised
+        yield
+      end
+
       # Test numeric difference between the return value of an expression as a
       # result of what is evaluated in the yielded block.
       #
       #   assert_difference 'Article.count' do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       # An arbitrary expression is passed in and evaluated.
       #
-      #   assert_difference 'assigns(:article).comments(:reload).size' do
-      #     post :create, comment: {...}
+      #   assert_difference 'Article.last.comments(:reload).size' do
+      #     post :create, params: { comment: {...} }
       #   end
       #
       # An arbitrary positive or negative difference can be specified.
       # The default is <tt>1</tt>.
       #
       #   assert_difference 'Article.count', -1 do
-      #     post :delete, id: ...
+      #     post :delete, params: { id: ... }
       #   end
       #
       # An array of expressions can also be passed in and evaluated.
       #
       #   assert_difference [ 'Article.count', 'Post.count' ], 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
+      #   end
+      #
+      # A hash of expressions/numeric differences can also be passed in and evaluated.
+      #
+      #   assert_difference ->{ Article.count } => 1, ->{ Notification.count } => 2 do
+      #     post :create, params: { article: {...} }
       #   end
       #
       # A lambda or a list of lambdas can be passed in and evaluated:
       #
       #   assert_difference ->{ Article.count }, 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       #   assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
-      #     post :create, article: {...}
+      #     post :create, params: { article: {...} }
       #   end
       #
       # An error message can be specified.
       #
       #   assert_difference 'Article.count', -1, 'An Article should be destroyed' do
-      #     post :delete, id: ...
+      #     post :delete, params: { id: ... }
       #   end
-      def assert_difference(expression, difference = 1, message = nil, &block)
-        expressions = Array(expression)
+      def assert_difference(expression, *args, &block)
+        expressions =
+          if expression.is_a?(Hash)
+            message = args[0]
+            expression
+          else
+            difference = args[0] || 1
+            message = args[1]
+            Hash[Array(expression).map { |e| [e, difference] }]
+          end
 
-        exps = expressions.map { |e|
+        exps = expressions.keys.map { |e|
           e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
         }
-        before = exps.map { |e| e.call }
+        before = exps.map(&:call)
 
-        yield
+        retval = yield
 
-        expressions.zip(exps).each_with_index do |(code, e), i|
-          error  = "#{code.inspect} didn't change by #{difference}"
+        expressions.zip(exps, before) do |(code, diff), exp, before_value|
+          error  = "#{code.inspect} didn't change by #{diff}"
           error  = "#{message}.\n#{error}" if message
-          assert_equal(before[i] + difference, e.call, error)
+          assert_equal(before_value + diff, exp.call, error)
         end
+
+        retval
       end
 
       # Assertion that the numeric result of evaluating an expression is not
       # changed before and after invoking the passed in block.
       #
       #   assert_no_difference 'Article.count' do
-      #     post :create, article: invalid_attributes
+      #     post :create, params: { article: invalid_attributes }
+      #   end
+      #
+      # A lambda can be passed in and evaluated.
+      #
+      #   assert_no_difference -> { Article.count } do
+      #     post :create, params: { article: invalid_attributes }
       #   end
       #
       # An error message can be specified.
       #
       #   assert_no_difference 'Article.count', 'An Article should not be created' do
-      #     post :create, article: invalid_attributes
+      #     post :create, params: { article: invalid_attributes }
+      #   end
+      #
+      # An array of expressions can also be passed in and evaluated.
+      #
+      #   assert_no_difference [ 'Article.count', -> { Post.count } ] do
+      #     post :create, params: { article: invalid_attributes }
       #   end
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
+
+      # Assertion that the result of evaluating an expression is changed before
+      # and after invoking the passed in block.
+      #
+      #   assert_changes 'Status.all_good?' do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      #
+      # You can pass the block as a string to be evaluated in the context of
+      # the block. A lambda can be passed for the block as well.
+      #
+      #   assert_changes -> { Status.all_good? } do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      #
+      # The assertion is useful to test side effects. The passed block can be
+      # anything that can be converted to string with #to_s.
+      #
+      #   assert_changes :@object do
+      #     @object = 42
+      #   end
+      #
+      # The keyword arguments :from and :to can be given to specify the
+      # expected initial value and the expected value after the block was
+      # executed.
+      #
+      #   assert_changes :@object, from: nil, to: :foo do
+      #     @object = :foo
+      #   end
+      #
+      # An error message can be specified.
+      #
+      #   assert_changes -> { Status.all_good? }, 'Expected the status to be bad' do
+      #     post :create, params: { status: { incident: true } }
+      #   end
+      def assert_changes(expression, message = nil, from: UNTRACKED, to: UNTRACKED, &block)
+        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
+
+        before = exp.call
+        retval = yield
+
+        unless from == UNTRACKED
+          error = "#{expression.inspect} isn't #{from.inspect}"
+          error = "#{message}.\n#{error}" if message
+          assert from === before, error
+        end
+
+        after = exp.call
+
+        error = "#{expression.inspect} didn't change"
+        error = "#{error}. It was already #{to}" if before == to
+        error = "#{message}.\n#{error}" if message
+        assert before != after, error
+
+        unless to == UNTRACKED
+          error = "#{expression.inspect} didn't change to as expected\n"
+          error = "#{error}Expected: #{to.inspect}\n"
+          error = "#{error}  Actual: #{after.inspect}"
+          error = "#{message}.\n#{error}" if message
+          assert to === after, error
+        end
+
+        retval
+      end
+
+      # Assertion that the result of evaluating an expression is not changed before
+      # and after invoking the passed in block.
+      #
+      #   assert_no_changes 'Status.all_good?' do
+      #     post :create, params: { status: { ok: true } }
+      #   end
+      #
+      # An error message can be specified.
+      #
+      #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
+      #     post :create, params: { status: { ok: false } }
+      #   end
+      def assert_no_changes(expression, message = nil, &block)
+        exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
+
+        before = exp.call
+        retval = yield
+        after = exp.call
+
+        error = "#{expression.inspect} did change to #{after}"
+        error = "#{message}.\n#{error}" if message
+        assert before == after, error
+
+        retval
+      end
     end
   end
 end