oj 3.8.0 → 3.10.0

data/test/activesupport6/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/activesupport6/test_common.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+if ENV["BUILDKITE"]
+  require "minitest/reporters"
+  require "fileutils"
+
+  module Minitest
+    def self.plugin_rails_ci_junit_format_test_report_for_buildkite_init(*)
+      dir = File.join(__dir__, "../test-reports/#{ENV['BUILDKITE_JOB_ID']}")
+      reporter << Minitest::Reporters::JUnitReporter.new(dir, false)
+      FileUtils.mkdir_p(dir)
+    end
+  end
+
+  Minitest.load_plugins
+  Minitest.extensions.unshift "rails_ci_junit_format_test_report_for_buildkite"
+end

data/test/activesupport6/test_helper.rb

@@ -0,0 +1,163 @@
+# 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

@@ -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/bar.rb

@@ -7,19 +7,16 @@ $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
   $: << File.join($oj_dir, dir)
 end
 
-require 'oj'
-
-#Oj.load_file(ARGV[0], mode: :strict) { |obj|
-#  puts Oj.dump(obj, indent: 2)
-#}
+require 'rails'
+require 'active_support'
+require 'active_support/json'
 
-data = open('invalid_unicode.data').read
+require 'oj'
 
-puts data
+puts Rails::VERSION::STRING
 
-puts Oj.dump(data)
+#Oj.optimize_rails
 
-Oj.mimic_JSON
-puts Oj.dump(data, escape_mode: :json)
+h = {foo: "bar"}
 
-puts Oj.default_options
+puts Oj.dump(h, mode: :rails)

data/test/baz.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$: << File.dirname(__FILE__)
+$oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
+%w(lib ext).each do |dir|
+  $: << File.join($oj_dir, dir)
+end
+
+require 'oj'
+Oj.mimic_JSON()
+
+begin
+::JSON.load('name=&email=&subject=&comment=&submit=Send+Message')
+rescue ::JSON::ParserError
+  puts "*** Pass"
+end

data/test/test_compat.rb

@@ -147,16 +147,9 @@ class CompatJuice < Minitest::Test
 
   def test_encode
     opts = Oj.default_options
-    Oj.default_options = { :ascii_only => false }
-    unless 'jruby' == $ruby
-      dump_and_load("ぴーたー", false)
-    end
     Oj.default_options = { :ascii_only => true }
     json = Oj.dump("ぴーたー")
     assert_equal(%{"\\u3074\\u30fc\\u305f\\u30fc"}, json)
-    unless 'jruby' == $ruby
-      dump_and_load("ぴーたー", false)
-    end
     Oj.default_options = opts
   end
 

data/test/test_custom.rb

@@ -20,11 +20,12 @@ class CustomJuice < Minitest::Test
   end
 
   class Jeez
-    attr_accessor :x, :y
+    attr_accessor :x, :y, :_z
 
     def initialize(x, y)
       @x = x
       @y = y
+      @_z = x.to_s
     end
     def ==(o)
       self.class == o.class && @x == o.x && @y = o.y
@@ -247,7 +248,10 @@ class CustomJuice < Minitest::Test
 
   def test_object
     obj = Jeez.new(true, 58)
-    Oj.dump(obj, :create_id => "^o", :use_to_json => false, :use_as_json => false, :use_to_hash => false)
+    json = Oj.dump(obj, create_id: "^o", use_to_json: false, use_as_json: false, use_to_hash: false)
+    assert_equal(%|{"x":true,"y":58,"_z":"true"}|, json)
+    json = Oj.dump(obj, create_id: "^o", use_to_json: false, use_as_json: false, use_to_hash: false, ignore_under: true)
+    assert_equal(%|{"x":true,"y":58}|, json)
     dump_and_load(obj, false, :create_id => "^o", :create_additions => true)
   end
 

data/test/test_integer_range.rb

@@ -15,7 +15,7 @@ class IntegerRangeTest < Minitest::Test
   def setup
     @default_options = Oj.default_options
     # in null mode other options other than the number formats are not used.
-    Oj.default_options = { :mode => :null }
+    Oj.default_options = { :mode => :null, bigdecimal_as_decimal: true }
   end
 
   def teardown
@@ -70,4 +70,3 @@ class IntegerRangeTest < Minitest::Test
     assert_equal(exp, Oj.dump(test, integer_range: false))
   end
 end
-

data/test/test_object.rb

@@ -7,11 +7,12 @@ require 'helper'
 
 class ObjectJuice < Minitest::Test
   class Jeez
-    attr_accessor :x, :y
+    attr_accessor :x, :y, :_z
 
     def initialize(x, y)
       @x = x
       @y = y
+      @_z = x.to_s
     end
 
     def eql?(o)
@@ -687,7 +688,7 @@ class ObjectJuice < Minitest::Test
 
   def test_json_object_object
     obj = Jeez.new(true, 58)
-    json = Oj.dump(obj, :mode => :object, :indent => 2)
+    json = Oj.dump(obj, mode: :object, indent: 2, ignore_under: true)
     assert(%{{
   "^o":"ObjectJuice::Jeez",
   "x":true,
@@ -799,7 +800,7 @@ class ObjectJuice < Minitest::Test
       @xyz = 123
     end
   end
-  
+
   def test_exception_subclass
     err = nil
     begin