oj 2.18.3 → 3.13.14

data/test/activesupport5/encoding_test_cases.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "time"
+require "pathname"
+require "uri"
+
+module JSONTest
+  class Foo
+    def initialize(a, b)
+      @a, @b = a, b
+    end
+  end
+
+  class Hashlike
+    def to_hash
+      { foo: "hello", bar: "world" }
+    end
+  end
+
+  class Custom
+    def initialize(serialized)
+      @serialized = serialized
+    end
+
+    def as_json(options = nil)
+      @serialized
+    end
+  end
+
+  MyStruct = Struct.new(:name, :value) do
+    def initialize(*)
+      @unused = "unused instance variable"
+      super
+    end
+  end
+
+  module EncodingTestCases
+    TrueTests     = [[ true,  %(true)  ]]
+    FalseTests    = [[ false, %(false) ]]
+    NilTests      = [[ nil,   %(null)  ]]
+    NumericTests  = [[ 1,     %(1)     ],
+                     [ 2.5,   %(2.5)   ],
+                     [ 0.0 / 0.0,   %(null) ],
+                     [ 1.0 / 0.0,   %(null) ],
+                     [ -1.0 / 0.0,  %(null) ],
+                     [ BigDecimal("0.0") / BigDecimal("0.0"),  %(null) ],
+                     [ BigDecimal("2.5"), %("#{BigDecimal('2.5')}") ]]
+
+    StringTests   = [[ "this is the <string>",     %("this is the \\u003cstring\\u003e")],
+                     [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
+                     [ "http://test.host/posts/1", %("http://test.host/posts/1")],
+                     [ "Control characters: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\u2028\u2029",
+                       %("Control characters: \\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u2028\\u2029") ]]
+
+    ArrayTests    = [[ ["a", "b", "c"],          %([\"a\",\"b\",\"c\"])        ],
+                     [ [1, "a", :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
+
+    HashTests     = [[ { foo: "bar" }, %({\"foo\":\"bar\"}) ],
+                     [ { 1 => 1, 2 => "a", 3 => :b, 4 => nil, 5 => false }, %({\"1\":1,\"2\":\"a\",\"3\":\"b\",\"4\":null,\"5\":false}) ]]
+
+    RangeTests    = [[ 1..2,     %("1..2")],
+                     [ 1...2,    %("1...2")],
+                     [ 1.5..2.5, %("1.5..2.5")]]
+
+    SymbolTests   = [[ :a,     %("a")    ],
+                     [ :this,  %("this") ],
+                     [ :"a b", %("a b")  ]]
+
+    ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
+    HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
+    StructTests   = [[ MyStruct.new(:foo, "bar"), %({\"name\":\"foo\",\"value\":\"bar\"}) ],
+                     [ MyStruct.new(nil, nil), %({\"name\":null,\"value\":null}) ]]
+    CustomTests   = [[ Custom.new("custom"), '"custom"' ],
+                     [ Custom.new(nil), "null" ],
+                     [ Custom.new(:a), '"a"' ],
+                     [ Custom.new([ :foo, "bar" ]), '["foo","bar"]' ],
+                     [ Custom.new(foo: "hello", bar: "world"), '{"bar":"world","foo":"hello"}' ],
+                     [ Custom.new(Hashlike.new), '{"bar":"world","foo":"hello"}' ],
+                     [ Custom.new(Custom.new(Custom.new(:a))), '"a"' ]]
+
+    RegexpTests   = [[ /^a/, '"(?-mix:^a)"' ], [/^\w{1,2}[a-z]+/ix, '"(?ix-m:^\\\\w{1,2}[a-z]+)"']]
+
+    URITests      = [[ URI.parse("http://example.com"), %("http://example.com") ]]
+
+    PathnameTests = [[ Pathname.new("lib/index.rb"), %("lib/index.rb") ]]
+
+    DateTests     = [[ Date.new(2005, 2, 1), %("2005/02/01") ]]
+    TimeTests     = [[ Time.utc(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]
+    DateTimeTests = [[ DateTime.civil(2005, 2, 1, 15, 15, 10), %("2005/02/01 15:15:10 +0000") ]]
+
+    StandardDateTests     = [[ Date.new(2005, 2, 1), %("2005-02-01") ]]
+    StandardTimeTests     = [[ Time.utc(2005, 2, 1, 15, 15, 10), %("2005-02-01T15:15:10.000Z") ]]
+    StandardDateTimeTests = [[ DateTime.civil(2005, 2, 1, 15, 15, 10), %("2005-02-01T15:15:10.000+00:00") ]]
+    StandardStringTests   = [[ "this is the <string>", %("this is the <string>")]]
+  end
+end

data/test/activesupport5/test_helper.rb

@@ -0,0 +1,72 @@
+# 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"
+
+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
+    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/activesupport5/time_zone_test_helpers.rb

@@ -0,0 +1,39 @@
+# 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/activesupport6/abstract_unit.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+ORIG_ARGV = ARGV.dup
+
+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.
+ActiveSupport::Deprecation.debug = true
+
+# 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
+  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
+
+require_relative "test_common"

data/test/activesupport6/decoding_test.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "abstract_unit"
+require "active_support/json"
+require "active_support/time"
+require_relative "time_zone_test_helpers"
+
+require 'oj'
+
+Oj::Rails.set_decoder()
+
+class TestJSONDecoding < ActiveSupport::TestCase
+  include TimeZoneTestHelpers
+
+  # Added for testing if Oj is used.
+  test "oj is used as an encoder" do
+    assert_equal ActiveSupport.json_encoder, Oj::Rails::Encoder
+  end
+
+  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":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