oj 3.9.2 → 3.10.18

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

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
 
 $: << File.dirname(__FILE__)
 $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
@@ -7,19 +6,30 @@ $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
   $: << File.join($oj_dir, dir)
 end
 
-require 'oj'
+require 'active_support'
+require "active_support/json"
+
+$s = "\u2014 & \n \u{1F618}"
 
-#Oj.load_file(ARGV[0], mode: :strict) { |obj|
-#  puts Oj.dump(obj, indent: 2)
-#}
+=begin
+def check(label)
+  puts "\n--- #{label} --------------------"
 
-data = open('invalid_unicode.data').read
+  ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
+  puts "with standard_json == true: t.to_json - #{$t.to_json}"
+  ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
+  puts "with standard_json == false: t.to_json - #{$t.to_json}"
+end
 
-puts data
+check('Before Oj')
+=end
+
+require 'oj'
 
-puts Oj.dump(data)
+ActiveSupport::JSON::Encoding.escape_html_entities_in_json = false
+puts "ActiveSupport.encode(s) - #{ActiveSupport::JSON.encode($s)}"
 
-Oj.mimic_JSON
-puts Oj.dump(data, escape_mode: :json)
+Oj.optimize_rails
+Oj.default_options = { mode: :rails }
 
-puts Oj.default_options
+puts "Oj.dump(s) - #{Oj.dump($s)}"

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/foo.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
 
 $: << File.dirname(__FILE__)
 $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
@@ -7,15 +6,47 @@ $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
   $: << File.join($oj_dir, dir)
 end
 
+require 'json'
+
+t = [Time.now.utc]
+
+puts "t.to_json - #{t.to_json}"
+
+puts "--- active support"
+
+require 'active_support'
+require "active_support/json"
+
+ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
+
+puts "t.as_json - #{t.as_json}"
+puts "t.to_json - #{t.to_json}"
+
 require 'oj'
+
+t = [Time.now.utc]
+
+puts "-----------------------"
+
+#puts "t.as_json - #{t.as_json}"
+puts "t.to_json - #{t.to_json}"
+
+#Oj.mimic_JSON
+
+#puts "Oj - t.as_json - #{t.as_json}"
+
+puts "--- active support"
+
 require 'active_support'
-require 'active_support/json'
-#require 'tracer'
+require "active_support/json"
+
+ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
 
-Oj::Rails.set_encoder()
-Oj::Rails.set_decoder()
-Oj::Rails.optimize()
+puts "t.as_json - #{t.as_json}"
+puts "t.to_json - #{t.to_json}"
 
-#Oj::mimic_JSON
+puts "--- optimize"
+Oj.optimize_rails
 
-puts JSON.parse('{"a":1}', symbolize_names: true)
+puts "t.as_json - #{t.as_json}"
+puts "t.to_json - #{t.to_json}"

data/test/json_gem/json_common_interface_test.rb

@@ -15,7 +15,7 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
   def setup
     @hash = {
       'a' => 2,
-      'b' => 3.141,
+      #'b' => 5.23683071,
       'c' => 'c',
       'd' => [ 1, "b", 3.14 ],
       'e' => { 'foo' => 'bar' },
@@ -23,8 +23,13 @@ class JSONCommonInterfaceTest < Test::Unit::TestCase
       'h' => 1000.0,
       'i' => 0.001
     }
-    @json = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
-      '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+    # Tired of chasing floating point rounding and precision. Oj now uses the
+    # Ruby float parser in compat mode yet on i386 machines there are issues
+    # with this test when the float is included.
+    #@json = '{"a":2,"b":5.23683071,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
+    #'"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
+    @json = '{"a":2,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},'\
+	    '"g":"\\"\\u0000\\u001f","h":1000.0,"i":0.001}'
   end
 
   def test_index

data/test/prec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+extras = {"locationLng" => -97.14690769100295}
+
+Oj.default_options = {float_precision: 17}
+
+encoded = Oj.dump(extras)
+puts encoded
+puts Oj.load(encoded)
+
+require "active_record"
+
+Oj::Rails.set_encoder()
+Oj::Rails.set_decoder()
+
+Oj.default_options = {float_precision: 17}
+# Using Oj rails encoder, gets the correct value: {"locationLng":-97.14690769100295}
+encoded = ActiveSupport::JSON.encode(extras)
+puts encoded
+puts ActiveSupport::JSON.decode(encoded)
+puts Oj.load(encoded)

data/test/sample_json.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby -wW2
+#!/usr/bin/env ruby
 
 if $0 == __FILE__
   $: << '.'

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
 
@@ -243,6 +236,12 @@ class CompatJuice < Minitest::Test
     assert_equal({"a\nb" => true, "c\td" => false}, obj)
   end
 
+  def test_invalid_escapes_handled
+    json = '{"subtext":"\"404er\” \w \k \3 \a"}'
+    obj = Oj.compat_load(json)
+    assert_equal({"subtext" => "\"404er” w k 3 a"}, obj)
+  end
+
   def test_hash_escaping
     json = Oj.to_json({'<>' => '<>'}, mode: :compat)
     assert_equal(json, '{"<>":"<>"}')
@@ -278,12 +277,19 @@ class CompatJuice < Minitest::Test
   # BigDecimal
   def test_bigdecimal
     # BigDecimals are dumped as strings and can not be restored to the
-    # original value.
+    # original value without using an undocumented feature of the JSON gem.
     json = Oj.dump(BigDecimal('3.14159265358979323846'))
     # 2.4.0 changes the exponent to lowercase
     assert_equal('"0.314159265358979323846e1"', json.downcase)
   end
 
+  def test_bigdecimal_load
+    big = BigDecimal('3.14159265358979323846')
+    # :decimal_class is the undocumented feature.
+    json = Oj.load('3.14159265358979323846', mode: :compat, decimal_class: BigDecimal)
+    assert_equal(big, json)
+  end
+
   def test_infinity
     assert_raises(Oj::ParseError) { Oj.load('Infinity', :mode => :strict) }
     x = Oj.load('Infinity', :mode => :compat)

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
@@ -117,6 +118,17 @@ class CustomJuice < Minitest::Test
     dump_and_load(-2.48e100 * 1.0e10, false)
   end
 
+  def test_float_parse
+    f = Oj.load("12.123456789012345678", mode: :custom, bigdecimal_load: :float);
+    assert_equal(Float, f.class)
+  end
+
+  def test_float_parse_fast
+    f = Oj.load("12.123456789012345678", mode: :custom, bigdecimal_load: :fast);
+    assert_equal(Float, f.class)
+    assert(12.12345678901234 <= f && f < 12.12345678901236)
+  end
+
   def test_nan_dump
     assert_equal('null', Oj.dump(0/0.0, :nan => :null))
     assert_equal('3.3e14159265358979323846', Oj.dump(0/0.0, :nan => :huge))
@@ -247,7 +259,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
 
@@ -466,10 +481,10 @@ class CustomJuice < Minitest::Test
 
   def test_time
     obj = Time.now()
-    dump_and_load(obj, false, :time_format => :unix, :create_id => "^o", :create_additions => true)
-    dump_and_load_inspect(obj, false, :time_format => :unix_zone, :create_id => "^o", :create_additions => true)
-    dump_and_load_inspect(obj, false, :time_format => :xmlschema, :create_id => "^o", :create_additions => true)
-    dump_and_load_inspect(obj, false, :time_format => :ruby, :create_id => "^o", :create_additions => true)
+    dump_load_dump(obj, false, :time_format => :unix, :create_id => "^o", :create_additions => true)
+    dump_load_dump(obj, false, :time_format => :unix_zone, :create_id => "^o", :create_additions => true)
+    dump_load_dump(obj, false, :time_format => :xmlschema, :create_id => "^o", :create_additions => true)
+    dump_load_dump(obj, false, :time_format => :ruby, :create_id => "^o", :create_additions => true)
   end
 
   def dump_and_load(obj, trace=false, options={})
@@ -500,4 +515,19 @@ class CustomJuice < Minitest::Test
     loaded
   end
 
+  def dump_load_dump(obj, trace=false, options={})
+    options = options.merge(:indent => 2, :mode => :custom)
+    json = Oj.dump(obj, options)
+    puts json if trace
+
+    loaded = Oj.load(json, options);
+    if obj.nil?
+      assert_nil(loaded)
+    else
+      json2 = Oj.dump(loaded, options)
+      assert_equal(json, json2)
+    end
+    loaded
+  end
+
 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
@@ -868,6 +869,14 @@ class ObjectJuice < Minitest::Test
     assert_equal(a2[1].__id__, a2.__id__)
   end
 
+  def test_circular_array3
+    a = ['^r1']
+    json = Oj.dump(a, mode: :object, circular: true)
+    assert_equal(%{["^i1","\\u005er1"]}, json)
+    a2 = Oj.load(json, mode: :object, circular: true)
+    assert_equal(a, a2)
+  end
+
   def test_circular_hash2
     h = { 'a' => 7 }
     h['b'] = h

data/test/test_rails.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.dirname(__FILE__)
+
+require 'helper'
+
+class RailsJuice < Minitest::Test
+
+  def test_bigdecimal_dump
+    orig = Oj.default_options
+    Oj.default_options = { mode: :rails, bigdecimal_as_decimal: true }
+    bd = BigDecimal('123')
+    json = Oj.dump(bd)
+    Oj.default_options = orig
+
+    assert_equal('0.123e3', json.downcase)
+
+    json = Oj.dump(bd, mode: :rails, bigdecimal_as_decimal: false)
+    assert_equal('"0.123e3"', json.downcase)
+
+    json = Oj.dump(bd, mode: :rails, bigdecimal_as_decimal: true)
+    assert_equal('0.123e3', json.downcase)
+  end
+
+  def test_invalid_encoding
+    assert_raises(EncodingError) {
+      Oj.dump("\"\xf3j", mode: :rails)
+    }
+    assert_raises(EncodingError) {
+      Oj.dump("\xf3j", mode: :rails)
+    }
+  end
+
+end

data/test/test_strict.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# encoding: utf-8
 
 $: << File.dirname(__FILE__)
 $oj_dir = File.dirname(File.expand_path(File.dirname(__FILE__)))
@@ -379,6 +379,29 @@ class StrictJuice < Minitest::Test
     assert_equal([{ 'x' => 1 }, { 'y' => 2 }], results)
   end
 
+  def test_invalid_decimal_dot_start
+    assert_raises(Oj::ParseError) {
+      Oj.load('.123', mode: :strict)
+    }
+    assert_raises(Oj::ParseError) {
+      Oj.load('-.123', mode: :strict)
+    }
+  end
+
+  def test_invalid_decimal_dot_end
+    json = '123.'
+    assert_raises(Oj::ParseError) {
+      Oj.load(json, mode: :strict)
+    }
+  end
+
+  def test_invalid_decimal_plus
+    json = '+12'
+    assert_raises(Oj::ParseError) {
+      Oj.load(json, mode: :strict)
+    }
+  end
+
   def test_circular_hash
     h = { 'a' => 7 }
     h['b'] = h