activesupport 1.2.4 → 8.1.2

data/lib/active_support/testing/error_reporter_assertions.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module ErrorReporterAssertions
+      module ErrorCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        Report = Struct.new(:error, :handled, :severity, :context, :source, keyword_init: true)
+        class Report
+          alias_method :handled?, :handled
+        end
+
+        class << self
+          def record
+            subscribe
+            recorders = ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions] ||= []
+            reports = []
+            recorders << reports
+            begin
+              yield
+              reports
+            ensure
+              recorders.delete_if { |r| reports.equal?(r) }
+            end
+          end
+
+          def report(error, **kwargs)
+            report = Report.new(error: error, **kwargs)
+            ActiveSupport::IsolatedExecutionState[:active_support_error_reporter_assertions]&.each do |reports|
+              reports << report
+            end
+            true
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+              @mutex.synchronize do
+                return if @subscribed
+
+                if ActiveSupport.error_reporter
+                  ActiveSupport.error_reporter.subscribe(self)
+                  @subscribed = true
+                else
+                  flunk("No error reporter is configured")
+                end
+              end
+            end
+        end
+      end
+
+      # Assertion that the block should not cause an exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if evaluated code in the yielded block reports no exception.
+      #
+      #   assert_no_error_reported do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_no_error_reported(&block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_no_error_reported", &block)
+        end
+        assert_predicate(reports, :empty?)
+      end
+
+      # Assertion that the block should cause at least one exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching exception.
+      #
+      #   assert_error_reported(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #   end
+      #
+      # To test further details about the reported exception, you can use the return
+      # value.
+      #
+      #   report = assert_error_reported(IOError) do
+      #     # ...
+      #   end
+      #   assert_equal "Oops", report.error.message
+      #   assert_equal "admin", report.context[:section]
+      #   assert_equal :warning, report.severity
+      #   assert_predicate report, :handled?
+      def assert_error_reported(error_class = StandardError, &block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_error_reported", &block)
+        end
+
+        if reports.empty?
+          assert(false, "Expected a #{error_class.name} to be reported, but there were no errors reported.")
+        elsif (report = reports.find { |r| error_class === r.error })
+          self.assertions += 1
+          report
+        else
+          message = "Expected a #{error_class.name} to be reported, but none of the " \
+            "#{reports.size} reported errors matched:  \n" \
+            "#{reports.map { |r| r.error.class.name }.join("\n  ")}"
+          assert(false, message)
+        end
+      end
+
+      # Captures reported errors from within the block that match the given
+      # error class.
+      #
+      #   reports = capture_error_reports(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #     Rails.error.report(IOError.new("Oh no"))
+      #     Rails.error.report(StandardError.new)
+      #   end
+      #
+      #   assert_equal 2, reports.size
+      #   assert_equal "Oops", reports.first.error.message
+      #   assert_equal "Oh no", reports.last.error.message
+      def capture_error_reports(error_class = StandardError, &block)
+        reports = ErrorCollector.record(&block)
+        reports.select { |r| error_class === r.error }
+      end
+    end
+  end
+end

data/lib/active_support/testing/event_reporter_assertions.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    # Provides test helpers for asserting on ActiveSupport::EventReporter events.
+    module EventReporterAssertions
+      module EventCollector # :nodoc:
+        @subscribed = false
+        @mutex = Mutex.new
+
+        class Event # :nodoc:
+          attr_reader :event_data
+
+          def initialize(event_data)
+            @event_data = event_data
+          end
+
+          def inspect
+            "#{event_data[:name]} (payload: #{event_data[:payload].inspect}, tags: #{event_data[:tags].inspect})"
+          end
+
+          def matches?(name, payload, tags)
+            return false unless name.to_s == event_data[:name]
+
+            if payload && payload.is_a?(Hash)
+              return false unless matches_hash?(payload, :payload)
+            end
+
+            return false unless matches_hash?(tags, :tags)
+            true
+          end
+
+          private
+            def matches_hash?(expected_hash, event_key)
+              expected_hash.all? do |k, v|
+                if v.is_a?(Regexp)
+                  event_data.dig(event_key, k).to_s.match?(v)
+                else
+                  event_data.dig(event_key, k) == v
+                end
+              end
+            end
+        end
+
+        class << self
+          def emit(event)
+            event_recorders&.each do |events|
+              events << Event.new(event)
+            end
+            true
+          end
+
+          def record
+            subscribe
+            events = []
+            event_recorders << events
+            begin
+              yield
+              events
+            ensure
+              event_recorders.delete_if { |r| events.equal?(r) }
+            end
+          end
+
+          private
+            def subscribe
+              return if @subscribed
+
+              @mutex.synchronize do
+                unless @subscribed
+                  if ActiveSupport.event_reporter
+                    ActiveSupport.event_reporter.subscribe(self)
+                    @subscribed = true
+                  else
+                    raise Minitest::Assertion, "No event reporter is configured"
+                  end
+                end
+              end
+            end
+
+            def event_recorders
+              ActiveSupport::IsolatedExecutionState[:active_support_event_reporter_assertions] ||= []
+            end
+        end
+      end
+
+      # Asserts that the block does not cause an event to be reported to +Rails.event+.
+      #
+      # If no name is provided, passes if evaluated code in the yielded block reports no events.
+      #
+      #   assert_no_event_reported do
+      #     service_that_does_not_report_events.perform
+      #   end
+      #
+      # If a name is provided, passes if evaluated code in the yielded block reports no events
+      # with that name.
+      #
+      #   assert_no_event_reported("user.created") do
+      #     service_that_does_not_report_events.perform
+      #   end
+      def assert_no_event_reported(name = nil, payload: {}, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if name.nil?
+          assert_predicate(events, :empty?)
+        else
+          matching_event = events.find { |event| event.matches?(name, payload, tags) }
+          if matching_event
+            message = "Expected no '#{name}' event to be reported, but found:\n  " \
+              "#{matching_event.inspect}"
+            flunk(message)
+          end
+          assert(true)
+        end
+      end
+
+      # Asserts that the block causes an event with the given name to be reported
+      # to +Rails.event+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching event.
+      #
+      #   assert_event_reported("user.created") do
+      #     Rails.event.notify("user.created", { id: 123 })
+      #   end
+      #
+      # To test further details about the reported event, you can specify payload and tag matchers.
+      #
+      #   assert_event_reported("user.created",
+      #     payload: { id: 123, name: "John Doe" },
+      #     tags: { request_id: /[0-9]+/ }
+      #   ) do
+      #     Rails.event.tagged(request_id: "123") do
+      #       Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #     end
+      #   end
+      #
+      # The matchers support partial matching - only the specified keys need to match.
+      #
+      #   assert_event_reported("user.created", payload: { id: 123 }) do
+      #     Rails.event.notify("user.created", { id: 123, name: "John Doe" })
+      #   end
+      def assert_event_reported(name, payload: nil, tags: {}, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty?
+          flunk("Expected an event to be reported, but there were no events reported.")
+        elsif (event = events.find { |event| event.matches?(name, payload, tags) })
+          assert(true)
+          event.event_data
+        else
+          message = "Expected an event to be reported matching:\n  " \
+            "name: #{name.inspect}\n  " \
+            "payload: #{payload.inspect}\n  " \
+            "tags: #{tags.inspect}\n" \
+            "but none of the #{events.size} reported events matched:\n  " \
+            "#{events.map(&:inspect).join("\n  ")}"
+          flunk(message)
+        end
+      end
+
+      # Asserts that the provided events were reported, regardless of order.
+      #
+      #   assert_events_reported([
+      #     { name: "user.created", payload: { id: 123 } },
+      #     { name: "email.sent", payload: { to: "user@example.com" } }
+      #   ]) do
+      #     create_user_and_send_welcome_email
+      #   end
+      #
+      # Supports the same payload and tag matching as +assert_event_reported+.
+      #
+      #   assert_events_reported([
+      #     {
+      #       name: "process.started",
+      #       payload: { id: 123 },
+      #       tags: { request_id: /[0-9]+/ }
+      #     },
+      #     { name: "process.completed" }
+      #   ]) do
+      #     Rails.event.tagged(request_id: "456") do
+      #       start_and_complete_process(123)
+      #     end
+      #   end
+      def assert_events_reported(expected_events, &block)
+        events = EventCollector.record(&block)
+
+        if events.empty? && expected_events.size > 0
+          flunk("Expected #{expected_events.size} events to be reported, but there were no events reported.")
+        end
+
+        events_copy = events.dup
+
+        expected_events.each do |expected_event|
+          name = expected_event[:name]
+          payload = expected_event[:payload] || {}
+          tags = expected_event[:tags] || {}
+
+          matching_event_index = events_copy.find_index { |event| event.matches?(name, payload, tags) }
+
+          if matching_event_index
+            events_copy.delete_at(matching_event_index)
+          else
+            message = "Expected an event to be reported matching:\n  " \
+              "name: #{name.inspect}\n  " \
+              "payload: #{payload.inspect}\n  " \
+              "tags: #{tags.inspect}\n" \
+              "but none of the #{events.size} reported events matched:\n  " \
+              "#{events.map(&:inspect).join("\n  ")}"
+            flunk(message)
+          end
+        end
+
+        assert(true)
+      end
+
+      # Allows debug events to be reported to +Rails.event+ for the duration of a given block.
+      #
+      #   with_debug_event_reporting do
+      #     service_that_reports_debug_events.perform
+      #   end
+      #
+      def with_debug_event_reporting(&block)
+        ActiveSupport.event_reporter.with_debug(&block)
+      end
+    end
+  end
+end

data/lib/active_support/testing/file_fixtures.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ActiveSupport
+  module Testing
+    # Adds simple access to sample files called file fixtures.
+    # File fixtures are normal files stored in
+    # <tt>ActiveSupport::TestCase.file_fixture_path</tt>.
+    #
+    # File fixtures are represented as +Pathname+ objects.
+    # This makes it easy to extract specific information:
+    #
+    #   file_fixture("example.txt").read # get the file's content
+    #   file_fixture("example.mp3").size # get the file size
+    module FileFixtures
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :file_fixture_path, instance_writer: false
+      end
+
+      # Returns a +Pathname+ to the fixture file named +fixture_name+.
+      #
+      # Raises +ArgumentError+ if +fixture_name+ can't be found.
+      def file_fixture(fixture_name)
+        path = Pathname.new(File.join(file_fixture_path, fixture_name))
+
+        if path.exist?
+          path
+        else
+          msg = "the directory '%s' does not contain a file named '%s'"
+          raise ArgumentError, msg % [file_fixture_path, fixture_name]
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/isolation.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "active_support/testing/parallelize_executor"
+
+module ActiveSupport
+  module Testing
+    module Isolation
+      SubprocessCrashed = Class.new(StandardError)
+
+      def self.included(klass) # :nodoc:
+        klass.class_eval do
+          parallelize_me! unless Minitest.parallel_executor.is_a?(ActiveSupport::Testing::ParallelizeExecutor)
+        end
+      end
+
+      def self.forking_env?
+        !ENV["NO_FORK"] && Process.respond_to?(:fork)
+      end
+
+      def run
+        status, serialized = run_in_isolation do
+          super
+        end
+
+        unless status&.success?
+          error = SubprocessCrashed.new("Subprocess exited with an error: #{status.inspect}\noutput: #{serialized.inspect}")
+          error.set_backtrace(caller)
+          self.failures << Minitest::UnexpectedError.new(error)
+          return defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+        end
+
+        Marshal.load(serialized)
+      end
+
+      module Forking
+        def run_in_isolation(&blk)
+          IO.pipe do |read, write|
+            read.binmode
+            write.binmode
+
+            pid = fork do
+              read.close
+              yield
+              begin
+                if error?
+                  failures.map! { |e|
+                    begin
+                      Marshal.dump e
+                      e
+                    rescue TypeError
+                      ex = Exception.new e.message
+                      ex.set_backtrace e.backtrace
+                      Minitest::UnexpectedError.new ex
+                    end
+                  }
+                end
+                test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+                result = Marshal.dump(test_result)
+              end
+
+              write.puts [result].pack("m")
+              exit!(0)
+            end
+
+            write.close
+            result = read.read
+            _, status = Process.wait2(pid)
+            return status, result.unpack1("m")
+          end
+        end
+      end
+
+      module Subprocess
+        ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
+
+        # Complicated H4X to get this working in Windows / JRuby with
+        # no forking.
+        def run_in_isolation(&blk)
+          require "tempfile"
+
+          if ENV["ISOLATION_TEST"]
+            yield
+            test_result = defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
+              file.puts [Marshal.dump(test_result)].pack("m")
+            end
+            exit!(0)
+          else
+            Tempfile.open("isolation") do |tmpfile|
+              env = {
+                "ISOLATION_TEST" => self.class.name,
+                "ISOLATION_OUTPUT" => tmpfile.path
+              }
+
+              test_opts = "-n#{self.class.name}##{name}"
+
+              load_path_args = []
+              $-I.each do |p|
+                load_path_args << "-I"
+                load_path_args << File.expand_path(p)
+              end
+
+              child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
+
+              status = nil
+              begin
+                _, status = Process.wait2(child.pid)
+              rescue Errno::ECHILD # The child process may exit before we wait
+                nil
+              end
+
+              return status, tmpfile.read.unpack1("m")
+            end
+          end
+        end
+      end
+
+      include forking_env? ? Forking : Subprocess
+    end
+  end
+end

data/lib/active_support/testing/method_call_assertions.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "minitest/mock"
+
+module ActiveSupport
+  module Testing
+    module MethodCallAssertions # :nodoc:
+      private
+        def assert_called(object, method_name, message = nil, times: 1, returns: nil, &block)
+          times_called = 0
+
+          object.stub(method_name, proc { times_called += 1; returns }, &block)
+
+          error = "Expected #{method_name} to be called #{times} times, " \
+            "but was called #{times_called} times"
+          error = "#{message}.\n#{error}" if message
+          assert_equal times, times_called, error
+        end
+
+        def assert_called_with(object, method_name, args, returns: false, **kwargs, &block)
+          mock = Minitest::Mock.new
+          expect_called_with(mock, args, returns: returns, **kwargs)
+
+          object.stub(method_name, mock, &block)
+
+          assert_mock(mock)
+        end
+
+        def assert_not_called(object, method_name, message = nil, &block)
+          assert_called(object, method_name, message, times: 0, &block)
+        end
+
+        def expect_called_with(mock, args, returns: false, **kwargs)
+          mock.expect(:call, returns, args, **kwargs)
+        end
+
+        def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)
+          times_called = 0
+          klass.define_method("stubbed_#{method_name}") do |*|
+            times_called += 1
+
+            returns
+          end
+
+          klass.alias_method "original_#{method_name}", method_name
+          klass.alias_method method_name, "stubbed_#{method_name}"
+
+          yield
+
+          error = "Expected #{method_name} to be called #{times} times, but was called #{times_called} times"
+          error = "#{message}.\n#{error}" if message
+
+          assert_equal times, times_called, error
+        ensure
+          klass.alias_method method_name, "original_#{method_name}"
+          klass.undef_method "original_#{method_name}"
+          klass.undef_method "stubbed_#{method_name}"
+        end
+
+        def assert_not_called_on_instance_of(klass, method_name, message = nil, &block)
+          assert_called_on_instance_of(klass, method_name, message, times: 0, &block)
+        end
+
+        def stub_any_instance(klass, instance: klass.new)
+          klass.stub(:new, instance) { yield instance }
+        end
+    end
+  end
+end

data/lib/active_support/testing/notification_assertions.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    module NotificationAssertions
+      # Assert a notification was emitted with a given +pattern+ and optional +payload+.
+      #
+      # You can assert that a notification was emitted by passing a pattern, which accepts
+      # either a string or regexp, an optional payload, and a block. While the block
+      # is executed, if a matching notification is emitted, the assertion will pass
+      # and the notification will be returned.
+      #
+      # Note that the payload is matched as a subset, meaning that the notification must
+      # contain at least the specified keys and values, but may contain additional ones.
+      #
+      #     assert_notification("post.submitted", title: "Cool Post") do
+      #       post.submit(title: "Cool Post", body: "Cool Body") # => emits matching notification
+      #     end
+      #
+      # Using the returned notification, you can make more customized assertions.
+      #
+      #     notification = assert_notification("post.submitted", title: "Cool Post") do
+      #       ActiveSupport::Notifications.instrument("post.submitted", title: "Cool Post", body: Body.new("Cool Body"))
+      #     end
+      #
+      #     assert_instance_of(Body, notification.payload[:body])
+      #
+      def assert_notification(pattern, payload = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        assert_not_empty(notifications, "No #{pattern} notifications were found")
+
+        return notifications.first if payload.nil?
+
+        notification = notifications.find { |notification| notification.payload.slice(*payload.keys) == payload }
+        assert_not_nil(notification, "No #{pattern} notification with payload #{payload} was found")
+
+        notification
+      end
+
+      # Assert the number of notifications emitted with a given +pattern+.
+      #
+      # You can assert the number of notifications emitted by passing a pattern, which accepts
+      # either a string or regexp, a count, and a block. While the block is executed,
+      # the number of matching notifications emitted will be counted. After the block's
+      # execution completes, the assertion will pass if the count matches.
+      #
+      #     assert_notifications_count("post.submitted", 1) do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def assert_notifications_count(pattern, count, &block)
+        actual_count = capture_notifications(pattern, &block).count
+        assert_equal(count, actual_count, "Expected #{count} instead of #{actual_count} notifications for #{pattern}")
+      end
+
+      # Assert no notifications were emitted for a given +pattern+.
+      #
+      # You can assert no notifications were emitted by passing a pattern, which accepts
+      # either a string or regexp, and a block. While the block is executed, if no
+      # matching notifications are emitted, the assertion will pass.
+      #
+      #     assert_no_notifications("post.submitted") do
+      #       post.destroy # => emits non-matching notification
+      #     end
+      #
+      def assert_no_notifications(pattern = nil, &block)
+        notifications = capture_notifications(pattern, &block)
+        error_message = if pattern
+          "Expected no notifications for #{pattern} but found #{notifications.size}"
+        else
+          "Expected no notifications but found #{notifications.size}"
+        end
+        assert_empty(notifications, error_message)
+      end
+
+      # Capture emitted notifications, optionally filtered by a +pattern+.
+      #
+      # You can capture emitted notifications, optionally filtered by a pattern,
+      # which accepts either a string or regexp, and a block.
+      #
+      #     notifications = capture_notifications("post.submitted") do
+      #       post.submit(title: "Cool Post") # => emits matching notification
+      #     end
+      #
+      def capture_notifications(pattern = nil, &block)
+        notifications = []
+        ActiveSupport::Notifications.subscribed(->(n) { notifications << n }, pattern, &block)
+        notifications
+      end
+    end
+  end
+end