ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/json_attribute_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+class JsonAttributeTest < ActiveRecord::TestCase
+  include JSONSharedTestCases
+  self.use_transactional_tests = false
+
+  class JsonDataTypeOnText < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    attribute :payload,  :json
+    attribute :settings, :json
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.string "payload"
+      t.string "settings"
+    end
+  end
+
+  private
+    def column_type
+      :string
+    end
+
+    def klass
+      JsonDataTypeOnText
+    end
+end

data/test/cases/json_serialization_test.rb

@@ -1,44 +1,45 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/contact'
-require 'models/post'
-require 'models/author'
-require 'models/tagging'
-require 'models/tag'
-require 'models/comment'
+require "models/contact"
+require "models/post"
+require "models/author"
+require "models/tagging"
+require "models/tag"
+require "models/comment"
 
 module JsonSerializationHelpers
   private
-
-  def set_include_root_in_json(value)
-    original_root_in_json = ActiveRecord::Base.include_root_in_json
-    ActiveRecord::Base.include_root_in_json = value
-    yield
-  ensure
-    ActiveRecord::Base.include_root_in_json = original_root_in_json
-  end
+    def set_include_root_in_json(value)
+      original_root_in_json = ActiveRecord::Base.include_root_in_json
+      ActiveRecord::Base.include_root_in_json = value
+      yield
+    ensure
+      ActiveRecord::Base.include_root_in_json = original_root_in_json
+    end
 end
 
 class JsonSerializationTest < ActiveRecord::TestCase
   include JsonSerializationHelpers
 
   class NamespacedContact < Contact
-    column :name, :string
+    column :name, "string"
   end
 
   def setup
     @contact = Contact.new(
-      :name        => 'Konata Izumi',
-      :age         => 16,
-      :avatar      => 'binarydata',
-      :created_at  => Time.utc(2006, 8, 1),
-      :awesome     => true,
-      :preferences => { :shows => 'anime' }
+      name: "Konata Izumi",
+      age: 16,
+      avatar: "binarydata",
+      created_at: Time.utc(2006, 8, 1),
+      awesome: true,
+      preferences: { shows: "anime" }
     )
   end
 
   def test_should_demodulize_root_in_json
     set_include_root_in_json(true) do
-      @contact = NamespacedContact.new name: 'whatever'
+      @contact = NamespacedContact.new name: "whatever"
       json = @contact.to_json
       assert_match %r{^\{"namespaced_contact":\{}, json
     end
@@ -51,7 +52,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
       assert_match %r{^\{"contact":\{}, json
       assert_match %r{"name":"Konata Izumi"}, json
       assert_match %r{"age":16}, json
-      assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+      assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
       assert_match %r{"awesome":true}, json
       assert_match %r{"preferences":\{"shows":"anime"\}}, json
     end
@@ -62,28 +63,28 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
     assert_match %r{"name":"Konata Izumi"}, json
     assert_match %r{"age":16}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_match %r{"awesome":true}, json
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
   def test_should_allow_attribute_filtering_with_only
-    json = @contact.to_json(:only => [:name, :age])
+    json = @contact.to_json(only: [:name, :age])
 
     assert_match %r{"name":"Konata Izumi"}, json
     assert_match %r{"age":16}, json
     assert_no_match %r{"awesome":true}, json
-    assert !json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_not_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_no_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
   def test_should_allow_attribute_filtering_with_except
-    json = @contact.to_json(:except => [:name, :age])
+    json = @contact.to_json(except: [:name, :age])
 
     assert_no_match %r{"name":"Konata Izumi"}, json
     assert_no_match %r{"age":16}, json
     assert_match %r{"awesome":true}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
@@ -93,10 +94,10 @@ class JsonSerializationTest < ActiveRecord::TestCase
     def @contact.favorite_quote; "Constraints are liberating"; end
 
     # Single method.
-    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(only: :name, methods: :label)
 
     # Both methods.
-    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    methods_json = @contact.to_json(only: :name, methods: [:label, :favorite_quote])
     assert_match %r{"label":"Has cheezburger"}, methods_json
     assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
   end
@@ -113,7 +114,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
   end
 
   def test_uses_serializable_hash_with_only_option
-    def @contact.serializable_hash(options=nil)
+    def @contact.serializable_hash(options = nil)
       super(only: %w(name))
     end
 
@@ -124,7 +125,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
   end
 
   def test_uses_serializable_hash_with_except_option
-    def @contact.serializable_hash(options=nil)
+    def @contact.serializable_hash(options = nil)
       super(except: %w(age))
     end
 
@@ -136,7 +137,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
   def test_does_not_include_inheritance_column_from_sti
     @contact = ContactSti.new(@contact.attributes)
-    assert_equal 'ContactSti', @contact.type
+    assert_equal "ContactSti", @contact.type
 
     json = @contact.to_json
     assert_match %r{"name":"Konata Izumi"}, json
@@ -146,9 +147,9 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
   def test_serializable_hash_with_default_except_option_and_excluding_inheritance_column_from_sti
     @contact = ContactSti.new(@contact.attributes)
-    assert_equal 'ContactSti', @contact.type
+    assert_equal "ContactSti", @contact.type
 
-    def @contact.serializable_hash(options={})
+    def @contact.serializable_hash(options = {})
       super({ except: %w(age) }.merge!(options))
     end
 
@@ -160,15 +161,13 @@ class JsonSerializationTest < ActiveRecord::TestCase
   end
 
   def test_serializable_hash_should_not_modify_options_in_argument
-    options = { :only => :name }
-    @contact.serializable_hash(options)
-
-    assert_nil options[:except]
+    options = { only: :name }.freeze
+    assert_nothing_raised { @contact.serializable_hash(options) }
   end
 end
 
 class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :tags, :taggings
+  fixtures :authors, :author_addresses, :posts, :comments, :tags, :taggings
 
   include JsonSerializationHelpers
 
@@ -178,7 +177,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   end
 
   def test_includes_uses_association_name
-    json = @david.to_json(:include => :posts)
+    json = @david.to_json(include: :posts)
 
     assert_match %r{"posts":\[}, json
 
@@ -194,7 +193,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   end
 
   def test_includes_uses_association_name_and_applies_attribute_filters
-    json = @david.to_json(:include => { :posts => { :only => :title } })
+    json = @david.to_json(include: { posts: { only: :title } })
 
     assert_match %r{"name":"David"}, json
     assert_match %r{"posts":\[}, json
@@ -207,7 +206,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   end
 
   def test_includes_fetches_second_level_associations
-    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
+    json = @david.to_json(include: { posts: { include: { comments: { only: :body } } } })
 
     assert_match %r{"name":"David"}, json
     assert_match %r{"posts":\[}, json
@@ -220,12 +219,12 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
   def test_includes_fetches_nth_level_associations
     json = @david.to_json(
-      :include => {
-        :posts => {
-          :include => {
-            :taggings => {
-              :include => {
-                :tag => { :only => :name }
+      include: {
+        posts: {
+          include: {
+            taggings: {
+              include: {
+                tag: { only: :name }
               }
             }
           }
@@ -241,8 +240,8 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
   def test_includes_doesnt_merge_opts_from_base
     json = @david.to_json(
-      :only => :id,
-      :include => :posts
+      only: :id,
+      include: :posts
     )
 
     assert_match %{"title":"Welcome to the weblog"}, json
@@ -250,11 +249,11 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
   def test_should_not_call_methods_on_associations_that_dont_respond
     def @david.favorite_quote; "Constraints are liberating"; end
-    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
+    json = @david.to_json(include: :posts, methods: :favorite_quote)
 
-    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_not_respond_to @david.posts.first, :favorite_quote
     assert_match %r{"favorite_quote":"Constraints are liberating"}, json
-    assert_equal %r{"favorite_quote":}.match(json).size, 1
+    assert_equal 1, %r{"favorite_quote":}.match(json).size
   end
 
   def test_should_allow_only_option_for_list_of_authors
@@ -278,15 +277,15 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   def test_should_allow_includes_for_list_of_authors
     authors = [@david, @mary]
     json = ActiveSupport::JSON.encode(authors,
-      :only => :name,
-      :include => {
-        :posts => { :only => :id }
+      only: :name,
+      include: {
+        posts: { only: :id }
       }
     )
 
     ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
      '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[', '{"id":7}', '{"id":9}'].each do |fragment|
-      assert json.include?(fragment), json
+       assert_includes json, fragment, json
      end
   end
 

data/test/cases/json_shared_test_cases.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "support/schema_dumping_helper"
+require "pp"
+
+module JSONSharedTestCases
+  include SchemaDumpingHelper
+
+  class JsonDataType < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table :json_data_type, if_exists: true
+    klass.reset_column_information
+  end
+
+  def test_column
+    column = klass.columns_hash["payload"]
+    assert_equal column_type, column.type
+    assert_type_match column_type, column.sql_type
+
+    type = klass.type_for_attribute("payload")
+    assert_not_predicate type, :binary?
+  end
+
+  def test_change_table_supports_json
+    @connection.change_table("json_data_type") do |t|
+      t.public_send column_type, "users"
+    end
+    klass.reset_column_information
+    column = klass.columns_hash["users"]
+    assert_equal column_type, column.type
+    assert_type_match column_type, column.sql_type
+  end
+
+  def test_schema_dumping
+    output = dump_table_schema("json_data_type")
+    assert_match(/t\.#{column_type}\s+"settings"/, output)
+  end
+
+  def test_cast_value_on_write
+    x = klass.new(payload: { "string" => "foo", :symbol => :bar })
+    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
+    x.save!
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
+  end
+
+  def test_type_cast_json
+    type = klass.type_for_attribute("payload")
+
+    data = '{"a_key":"a_value"}'
+    hash = type.deserialize(data)
+    assert_equal({ "a_key" => "a_value" }, hash)
+    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
+
+    assert_equal({}, type.deserialize("{}"))
+    assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
+    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+  end
+
+  def test_rewrite
+    @connection.execute(insert_statement_per_database('{"k":"v"}'))
+    x = klass.first
+    x.payload = { '"a\'' => "b" }
+    assert x.save!
+  end
+
+  def test_select
+    @connection.execute(insert_statement_per_database('{"k":"v"}'))
+    x = klass.first
+    assert_equal({ "k" => "v" }, x.payload)
+  end
+
+  def test_select_multikey
+    @connection.execute(insert_statement_per_database('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}'))
+    x = klass.first
+    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
+  end
+
+  def test_null_json
+    @connection.execute(insert_statement_per_database("null"))
+    x = klass.first
+    assert_nil(x.payload)
+  end
+
+  def test_select_nil_json_after_create
+    json = klass.create!(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json, x)
+  end
+
+  def test_select_nil_json_after_update
+    json = klass.create!(payload: "foo")
+    x = klass.where(payload: nil).first
+    assert_nil(x)
+
+    json.update(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json.reload, x)
+  end
+
+  def test_select_array_json_value
+    @connection.execute(insert_statement_per_database('["v0",{"k1":"v1"}]'))
+    x = klass.first
+    assert_equal(["v0", { "k1" => "v1" }], x.payload)
+  end
+
+  def test_rewrite_array_json_value
+    @connection.execute(insert_statement_per_database('["v0",{"k1":"v1"}]'))
+    x = klass.first
+    x.payload = ["v1", { "k2" => "v2" }, "v3"]
+    assert x.save!
+  end
+
+  def test_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    x.save!
+    x = klass.first
+    assert_equal "320×480", x.resolution
+
+    x.resolution = "640×1136"
+    x.save!
+
+    x = klass.first
+    assert_equal "640×1136", x.resolution
+  end
+
+  def test_duplication_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    y = x.dup
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_yaml_round_trip_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    payload = YAML.dump(x)
+    y = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(payload) : YAML.load(payload)
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_changes_in_place
+    json = klass.new
+    assert_not_predicate json, :changed?
+
+    json.payload = { "one" => "two" }
+    assert_predicate json, :changed?
+    assert_predicate json, :payload_changed?
+
+    json.save!
+    assert_not_predicate json, :changed?
+
+    json.payload["three"] = "four"
+    assert_predicate json, :payload_changed?
+
+    json.save!
+    json.reload
+
+    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
+    assert_not_predicate json, :changed?
+  end
+
+  def test_changes_in_place_ignores_key_order
+    json = klass.new
+    assert_not_predicate json, :changed?
+
+    json.payload = { "three" => "four", "one" => "two" }
+    json.save!
+    json.reload
+
+    json.payload = { "three" => "four", "one" => "two" }
+    assert_not_predicate json, :changed?
+
+    json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
+    json.save!
+    json.reload
+
+    json.payload = [{ "three" => "four", "one" => "two" }, { "seven" => "eight", "five" => "six" }]
+    assert_not_predicate json, :changed?
+  end
+
+  def test_changes_in_place_with_ruby_object
+    time = Time.now.utc
+    json = klass.create!(payload: time)
+
+    json.reload
+    assert_not_predicate json, :changed?
+
+    json.payload = time
+    assert_not_predicate json, :changed?
+  end
+
+  def test_assigning_string_literal
+    json = klass.create!(payload: "foo")
+    assert_equal "foo", json.payload
+  end
+
+  def test_assigning_number
+    json = klass.create!(payload: 1.234)
+    assert_equal 1.234, json.payload
+  end
+
+  def test_assigning_boolean
+    json = klass.create!(payload: true)
+    assert_equal true, json.payload
+  end
+
+  def test_not_compatible_with_serialize_json
+    new_klass = Class.new(klass) do
+      serialize :payload, JSON
+    end
+    assert_raises(ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError) do
+      new_klass.new
+    end
+  end
+
+  class MySettings
+    def initialize(hash); @hash = hash end
+    def to_hash; @hash end
+    def self.load(hash); new(hash) end
+    def self.dump(object); object.to_hash end
+  end
+
+  def test_json_with_serialized_attributes
+    new_klass = Class.new(klass) do
+      serialize :settings, MySettings
+    end
+
+    new_klass.create!(settings: MySettings.new("one" => "two"))
+    record = new_klass.first
+
+    assert_instance_of MySettings, record.settings
+    assert_equal({ "one" => "two" }, record.settings.to_hash)
+
+    record.settings = MySettings.new("three" => "four")
+    record.save!
+
+    assert_equal({ "three" => "four" }, record.reload.settings.to_hash)
+  end
+
+  class JsonDataTypeWithFilter < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    attribute :payload, :json
+
+    def self.filter_attributes
+      # Rails.application.config.filter_parameters += [:password]
+      super + [:password]
+    end
+  end
+
+  def test_pretty_print
+    x = JsonDataTypeWithFilter.create!(payload: {})
+    x.payload[11] = "foo"
+    io = StringIO.new
+    PP.pp(x, io)
+    assert io.string
+  end
+
+  private
+    def klass
+      JsonDataType
+    end
+
+    def assert_type_match(type, sql_type)
+      native_type = ActiveRecord::Base.connection.native_database_types[type][:name]
+      assert_match %r(\A#{native_type}\b), sql_type
+    end
+
+    def insert_statement_per_database(values)
+      if current_adapter?(:OracleAdapter)
+        "insert into json_data_type (id, payload) VALUES (json_data_type_seq.nextval, '#{values}')"
+      else
+        "insert into json_data_type (payload) VALUES ('#{values}')"
+      end
+    end
+end