oj 3.16.9 → 3.16.10

data/test/activesupport6/test_helper.rb

@@ -1,163 +0,0 @@
-# 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
-    Assertion = Minitest::Assertion
-
-    class << self
-      # Sets the order in which test cases are run.
-      #
-      #   ActiveSupport::TestCase.test_order = :random # => :random
-      #
-      # Valid values are:
-      # * +:random+   (to run tests in random order)
-      # * +:parallel+ (to run tests in parallel)
-      # * +:sorted+   (to run tests alphabetically by method name)
-      # * +:alpha+    (equivalent to +:sorted+)
-      def test_order=(new_order)
-        ActiveSupport.test_order = new_order
-      end
-
-      # Returns the order in which test cases are run.
-      #
-      #   ActiveSupport::TestCase.test_order # => :random
-      #
-      # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
-      # Defaults to +:random+.
-      def 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
-
-        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
-
-      # 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
-    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
-    alias :assert_raise :assert_raises
-    alias :assert_not_empty :refute_empty
-    alias :assert_not_equal :refute_equal
-    alias :assert_not_in_delta :refute_in_delta
-    alias :assert_not_in_epsilon :refute_in_epsilon
-    alias :assert_not_includes :refute_includes
-    alias :assert_not_instance_of :refute_instance_of
-    alias :assert_not_kind_of :refute_kind_of
-    alias :assert_no_match :refute_match
-    alias :assert_not_nil :refute_nil
-    alias :assert_not_operator :refute_operator
-    alias :assert_not_predicate :refute_predicate
-    alias :assert_not_respond_to :refute_respond_to
-    alias :assert_not_same :refute_same
-
-    ActiveSupport.run_load_hooks(:active_support_test_case, self)
-  end
-end

data/test/activesupport6/time_zone_test_helpers.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module TimeZoneTestHelpers
-  def with_tz_default(tz = nil)
-    old_tz = Time.zone
-    Time.zone = tz
-    yield
-  ensure
-    Time.zone = old_tz
-  end
-
-  def with_env_tz(new_tz = "US/Eastern")
-    old_tz, ENV["TZ"] = ENV["TZ"], new_tz
-    yield
-  ensure
-    old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
-  end
-
-  def with_preserve_timezone(value)
-    old_preserve_tz = ActiveSupport.to_time_preserves_timezone
-    ActiveSupport.to_time_preserves_timezone = value
-    yield
-  ensure
-    ActiveSupport.to_time_preserves_timezone = old_preserve_tz
-  end
-
-  def with_tz_mappings(mappings)
-    old_mappings = ActiveSupport::TimeZone::MAPPING.dup
-    ActiveSupport::TimeZone.clear
-    ActiveSupport::TimeZone::MAPPING.clear
-    ActiveSupport::TimeZone::MAPPING.merge!(mappings)
-
-    yield
-  ensure
-    ActiveSupport::TimeZone.clear
-    ActiveSupport::TimeZone::MAPPING.clear
-    ActiveSupport::TimeZone::MAPPING.merge!(old_mappings)
-  end
-end

data/test/activesupport7/abstract_unit.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-ORIG_ARGV = ARGV.dup
-
-require "bundler/setup"
-require "active_support/core_ext/kernel/reporting"
-
-silence_warnings do
-  Encoding.default_internal = Encoding::UTF_8
-  Encoding.default_external = Encoding::UTF_8
-end
-
-require "active_support/testing/autorun"
-require "active_support/testing/method_call_assertions"
-
-ENV["NO_RELOAD"] = "1"
-require "active_support"
-
-Thread.abort_on_exception = true
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-if ActiveSupport::Deprecation.respond_to?(:debug)
-  # Rails 7.2 does not have ActiveSupport::Deprecation.debug
-  ActiveSupport::Deprecation.debug = true
-end
-
-# Default to old to_time behavior but allow running tests with new behavior
-ActiveSupport.to_time_preserves_timezone = ENV["PRESERVE_TIMEZONES"] == "1"
-
-# Disable available locale checks to avoid warnings running the test suite.
-I18n.enforce_available_locales = false
-
-class ActiveSupport::TestCase
-  if Process.respond_to?(:fork) && !Gem.win_platform?
-    parallelize
-  else
-    parallelize(with: :threads)
-  end
-
-  include ActiveSupport::Testing::MethodCallAssertions
-
-  private
-    # Skips the current run on Rubinius using Minitest::Assertions#skip
-    def rubinius_skip(message = "")
-      skip message if RUBY_ENGINE == "rbx"
-    end
-
-    # Skips the current run on JRuby using Minitest::Assertions#skip
-    def jruby_skip(message = "")
-      skip message if defined?(JRUBY_VERSION)
-    end
-end

data/test/activesupport7/decoding_test.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "abstract_unit"
-require "active_support/json"
-require "active_support/time"
-require_relative "time_zone_test_helpers"
-
-class TestJSONDecoding < ActiveSupport::TestCase
-  include TimeZoneTestHelpers
-
-  class Foo
-    def self.json_create(object)
-      "Foo"
-    end
-  end
-
-  TESTS = {
-    %q({"returnTo":{"\/categories":"\/"}})        => { "returnTo" => { "/categories" => "/" } },
-    %q({"return\\"To\\":":{"\/categories":"\/"}}) => { "return\"To\":" => { "/categories" => "/" } },
-    %q({"returnTo":{"\/categories":1}}) => { "returnTo" => { "/categories" => 1 } },
-    %({"returnTo":[1,"a"]})                    => { "returnTo" => [1, "a"] },
-    %({"returnTo":[1,"\\"a\\",", "b"]})        => { "returnTo" => [1, "\"a\",", "b"] },
-    %({"a": "'", "b": "5,000"})                  => { "a" => "'", "b" => "5,000" },
-    %({"a": "a's, b's and c's", "b": "5,000"})   => { "a" => "a's, b's and c's", "b" => "5,000" },
-    # multibyte
-    %({"matzue": "松江", "asakusa": "浅草"}) => { "matzue" => "松江", "asakusa" => "浅草" },
-    %({"a": "2007-01-01"})                       => { "a" => Date.new(2007, 1, 1) },
-    %({"a": "2007-01-01 01:12:34 Z"})            => { "a" => Time.utc(2007, 1, 1, 1, 12, 34) },
-    %(["2007-01-01 01:12:34 Z"])                 => [Time.utc(2007, 1, 1, 1, 12, 34)],
-    %(["2007-01-01 01:12:34 Z", "2007-01-01 01:12:35 Z"]) => [Time.utc(2007, 1, 1, 1, 12, 34), Time.utc(2007, 1, 1, 1, 12, 35)],
-    # no time zone
-    %({"a": "2007-01-01 01:12:34"})              => { "a" => Time.new(2007, 1, 1, 1, 12, 34, "-05:00") },
-    # invalid date
-    %({"a": "1089-10-40"})                       => { "a" => "1089-10-40" },
-    # xmlschema date notation
-    %({"a": "2009-08-10T19:01:02"})              => { "a" => Time.new(2009, 8, 10, 19, 1, 2, "-04:00") },
-    %({"a": "2009-08-10T19:01:02Z"})             => { "a" => Time.utc(2009, 8, 10, 19, 1, 2) },
-    %({"a": "2009-08-10T19:01:02+02:00"})        => { "a" => Time.utc(2009, 8, 10, 17, 1, 2) },
-    %({"a": "2009-08-10T19:01:02-05:00"})        => { "a" => Time.utc(2009, 8, 11, 00, 1, 2) },
-    # needs to be *exact*
-    %({"a": " 2007-01-01 01:12:34 Z "})          => { "a" => " 2007-01-01 01:12:34 Z " },
-    %({"a": "2007-01-01 : it's your birthday"})  => { "a" => "2007-01-01 : it's your birthday" },
-    %({"a": "Today is:\\n2020-05-21"})           => { "a" => "Today is:\n2020-05-21" },
-    %({"a": "2007-01-01 01:12:34 Z\\nwas my birthday"}) => { "a" => "2007-01-01 01:12:34 Z\nwas my birthday" },
-    %([])    => [],
-    %({})    => {},
-    %({"a":1}) => { "a" => 1 },
-    %({"a": ""}) => { "a" => "" },
-    %({"a":"\\""}) => { "a" => "\"" },
-    %({"a": null})  => { "a" => nil },
-    %({"a": true})  => { "a" => true },
-    %({"a": false}) => { "a" => false },
-    '{"bad":"\\\\","trailing":""}' => { "bad" => "\\", "trailing" => "" },
-    %q({"a": "http:\/\/test.host\/posts\/1"}) => { "a" => "http://test.host/posts/1" },
-    %q({"a": "\u003cunicode\u0020escape\u003e"}) => { "a" => "<unicode escape>" },
-    '{"a": "\\\\u0020skip double backslashes"}' => { "a" => "\\u0020skip double backslashes" },
-    %q({"a": "\u003cbr /\u003e"}) => { "a" => "<br />" },
-    %q({"b":["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => { "b" => ["<i>", "<b>", "<u>"] },
-    # test combination of dates and escaped or unicode encoded data in arrays
-    %q([{"d":"1970-01-01", "s":"\u0020escape"},{"d":"1970-01-01", "s":"\u0020escape"}]) =>
-      [{ "d" => Date.new(1970, 1, 1), "s" => " escape" }, { "d" => Date.new(1970, 1, 1), "s" => " escape" }],
-    %q([{"d":"1970-01-01","s":"http:\/\/example.com"},{"d":"1970-01-01","s":"http:\/\/example.com"}]) =>
-      [{ "d" => Date.new(1970, 1, 1), "s" => "http://example.com" },
-       { "d" => Date.new(1970, 1, 1), "s" => "http://example.com" }],
-    # tests escaping of "\n" char with Yaml backend
-    %q({"a":"\n"}) => { "a" => "\n" },
-    %q({"a":"\u000a"}) => { "a" => "\n" },
-    %q({"a":"Line1\u000aLine2"}) => { "a" => "Line1\nLine2" },
-    # prevent json unmarshalling
-    '{"json_class":"TestJSONDecoding::Foo"}' => { "json_class" => "TestJSONDecoding::Foo" },
-    # json "fragments" - these are invalid JSON, but ActionPack relies on this
-    '"a string"' => "a string",
-    "1.1" => 1.1,
-    "1" => 1,
-    "-1" => -1,
-    "true" => true,
-    "false" => false,
-    "null" => nil
-  }
-
-  TESTS.each_with_index do |(json, expected), index|
-    fail_message = "JSON decoding failed for #{json}"
-
-    test "json decodes #{index}" do
-      with_tz_default "Eastern Time (US & Canada)" do
-        with_parse_json_times(true) do
-          silence_warnings do
-            if expected.nil?
-              assert_nil ActiveSupport::JSON.decode(json), fail_message
-            else
-              assert_equal expected, ActiveSupport::JSON.decode(json), fail_message
-            end
-          end
-        end
-      end
-    end
-  end
-
-  test "json decodes time json with time parsing disabled" do
-    with_parse_json_times(false) do
-      expected = { "a" => "2007-01-01 01:12:34 Z" }
-      assert_equal expected, ActiveSupport::JSON.decode(%({"a": "2007-01-01 01:12:34 Z"}))
-    end
-  end
-
-  def test_failed_json_decoding
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%(undefined)) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%({a: 1})) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%({: 1})) }
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%()) }
-  end
-
-  def test_cannot_pass_unsupported_options
-    assert_raise(ArgumentError) { ActiveSupport::JSON.decode("", create_additions: true) }
-  end
-
-  private
-    def with_parse_json_times(value)
-      old_value = ActiveSupport.parse_json_times
-      ActiveSupport.parse_json_times = value
-      yield
-    ensure
-      ActiveSupport.parse_json_times = old_value
-    end
-end