ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/serialized_attribute_test.rb

@@ -1,16 +1,24 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/traffic_light'
-require 'models/post'
-require 'bcrypt'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/person"
+require "models/traffic_light"
+require "models/post"
+require "models/binary_field"
 
 class SerializedAttributeTest < ActiveRecord::TestCase
   fixtures :topics, :posts
 
   MyObject = Struct.new :attribute1, :attribute2
 
+  class Topic < ActiveRecord::Base
+    serialize :content
+  end
+
+  class ImportantTopic < Topic
+    serialize :important, Hash
+  end
+
   teardown do
     Topic.serialize("content")
   end
@@ -25,7 +33,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attribute
     Topic.serialize("content", MyObject)
 
-    myobj = MyObject.new('value1', 'value2')
+    myobj = MyObject.new("value1", "value2")
     topic = Topic.create("content" => myobj)
     assert_equal(myobj, topic.content)
 
@@ -33,10 +41,31 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     assert_equal(myobj, topic.content)
   end
 
+  def test_serialized_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      serialize(:content, Hash, default: { key: "value" })
+    end
+
+    t = klass.new
+    assert_equal({ key: "value" }, t.content)
+  end
+
+  def test_serialized_attribute_on_custom_attribute_with_default
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = Topic.table_name
+      attribute :content, default: { key: "value" }
+      serialize :content, Hash
+    end
+
+    t = klass.new
+    assert_equal({ key: "value" }, t.content)
+  end
+
   def test_serialized_attribute_in_base_class
     Topic.serialize("content", Hash)
 
-    hash = { 'content1' => 'value1', 'content2' => 'value2' }
+    hash = { "content1" => "value1", "content2" => "value2" }
     important_topic = ImportantTopic.create("content" => hash)
     assert_equal(hash, important_topic.content)
 
@@ -47,10 +76,10 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attributes_from_database_on_subclass
     Topic.serialize :content, Hash
 
-    t = Reply.new(content: { foo: :bar })
+    t = ImportantTopic.new(content: { foo: :bar })
     assert_equal({ foo: :bar }, t.content)
     t.save!
-    t = Reply.last
+    t = ImportantTopic.last
     assert_equal({ foo: :bar }, t.content)
   end
 
@@ -97,7 +126,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialized_attribute_declared_in_subclass
-    hash = { 'important1' => 'value1', 'important2' => 'value2' }
+    hash = { "important1" => "value1", "important2" => "value2" }
     important_topic = ImportantTopic.create("important" => hash)
     assert_equal(hash, important_topic.important)
 
@@ -107,7 +136,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialized_time_attribute
-    myobj = Time.local(2008,1,1,1,0)
+    myobj = Time.local(2008, 1, 1, 1, 0)
     topic = Topic.create("content" => myobj).reload
     assert_equal(myobj, topic.content)
   end
@@ -124,26 +153,26 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_nil_not_serialized_without_class_constraint
-    assert Topic.new(:content => nil).save
-    assert_equal 1, Topic.where(:content => nil).count
+    assert Topic.new(content: nil).save
+    assert_equal 1, Topic.where(content: nil).count
   end
 
   def test_nil_not_serialized_with_class_constraint
     Topic.serialize :content, Hash
-    assert Topic.new(:content => nil).save
-    assert_equal 1, Topic.where(:content => nil).count
+    assert Topic.new(content: nil).save
+    assert_equal 1, Topic.where(content: nil).count
   end
 
   def test_serialized_attribute_should_raise_exception_on_assignment_with_wrong_type
     Topic.serialize(:content, Hash)
     assert_raise(ActiveRecord::SerializationTypeMismatch) do
-      Topic.new(content: 'string')
+      Topic.new(content: "string")
     end
   end
 
   def test_should_raise_exception_on_serialized_attribute_with_type_mismatch
-    myobj = MyObject.new('value1', 'value2')
-    topic = Topic.new(:content => myobj)
+    myobj = MyObject.new("value1", "value2")
+    topic = Topic.new(content: myobj)
     assert topic.save
     Topic.serialize(:content, Hash)
     assert_raise(ActiveRecord::SerializationTypeMismatch) { Topic.find(topic.id).content }
@@ -152,11 +181,32 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   def test_serialized_attribute_with_class_constraint
     settings = { "color" => "blue" }
     Topic.serialize(:content, Hash)
-    topic = Topic.new(:content => settings)
+    topic = Topic.new(content: settings)
     assert topic.save
     assert_equal(settings, Topic.find(topic.id).content)
   end
 
+  def test_where_by_serialized_attribute_with_array
+    settings = [ "color" => "green" ]
+    Topic.serialize(:content, Array)
+    topic = Topic.create!(content: settings)
+    assert_equal topic, Topic.where(content: settings).take
+  end
+
+  def test_where_by_serialized_attribute_with_hash
+    settings = { "color" => "green" }
+    Topic.serialize(:content, Hash)
+    topic = Topic.create!(content: settings)
+    assert_equal topic, Topic.where(content: settings).take
+  end
+
+  def test_where_by_serialized_attribute_with_hash_in_array
+    settings = { "color" => "green" }
+    Topic.serialize(:content, Hash)
+    topic = Topic.create!(content: settings)
+    assert_equal topic, Topic.where(content: [settings]).take
+  end
+
   def test_serialized_default_class
     Topic.serialize(:content, Hash)
     topic = Topic.new
@@ -175,17 +225,17 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialized_boolean_value_true
-    topic = Topic.new(:content => true)
+    topic = Topic.new(content: true)
     assert topic.save
     topic = topic.reload
-    assert_equal topic.content, true
+    assert_equal true, topic.content
   end
 
   def test_serialized_boolean_value_false
-    topic = Topic.new(:content => false)
+    topic = Topic.new(content: false)
     assert topic.save
     topic = topic.reload
-    assert_equal topic.content, false
+    assert_equal false, topic.content
   end
 
   def test_serialize_with_coder
@@ -200,18 +250,18 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     end
 
     Topic.serialize(:content, some_class)
-    topic = Topic.new(:content => some_class.new('my value'))
+    topic = Topic.new(content: some_class.new("my value"))
     topic.save!
     topic.reload
     assert_kind_of some_class, topic.content
-    assert_equal topic.content, some_class.new('my value')
+    assert_equal some_class.new("my value"), topic.content
   end
 
   def test_serialize_attribute_via_select_method_when_time_zone_available
     with_timezone_config aware_attributes: true do
       Topic.serialize(:content, MyObject)
 
-      myobj = MyObject.new('value1', 'value2')
+      myobj = MyObject.new("value1", "value2")
       topic = Topic.create(content: myobj)
 
       assert_equal(myobj, Topic.select(:content).find(topic.id).content)
@@ -220,8 +270,8 @@ class SerializedAttributeTest < ActiveRecord::TestCase
   end
 
   def test_serialize_attribute_can_be_serialized_in_an_integer_column
-    insures = ['life']
-    person = SerializedPerson.new(first_name: 'David', insures: insures)
+    insures = ["life"]
+    person = SerializedPerson.new(first_name: "David", insures: insures)
     assert person.save
     person = person.reload
     assert_equal(insures, person.insures)
@@ -233,6 +283,20 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     assert_equal [], light.long_state
   end
 
+  def test_unexpected_serialized_type
+    Topic.serialize :content, Hash
+    topic = Topic.create!(content: { zomg: true })
+
+    Topic.serialize :content, Array
+
+    topic.reload
+    error = assert_raise(ActiveRecord::SerializationTypeMismatch) do
+      topic.content
+    end
+    expected = "can't load `content`: was supposed to be a Array, but was a Hash. -- {:zomg=>true}"
+    assert_equal expected, error.to_s
+  end
+
   def test_serialized_column_should_unserialize_after_update_column
     t = Topic.create(content: "first")
     assert_equal("first", t.content)
@@ -256,7 +320,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
 
     topic = Topic.new(content: nil)
 
-    assert_not topic.content_changed?
+    assert_not_predicate topic, :content_changed?
   end
 
   def test_classes_without_no_arg_constructors_are_not_supported
@@ -275,6 +339,38 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     assert_equal({}, topic.content)
   end
 
+  if current_adapter?(:Mysql2Adapter)
+    def test_is_not_changed_when_stored_in_mysql_blob
+      value = %w(Fée)
+      model = BinaryField.create!(normal_blob: value, normal_text: value)
+      model.reload
+
+      model.normal_text = value
+      assert_not_predicate model, :normal_text_changed?
+
+      model.normal_blob = value
+      assert_not_predicate model, :normal_blob_changed?
+    end
+
+    class FrozenBinaryField < BinaryField
+      class FrozenCoder < ActiveRecord::Coders::YAMLColumn
+        def dump(obj)
+          super&.freeze
+        end
+      end
+      serialize :normal_blob, FrozenCoder.new(:normal_blob, Array)
+    end
+
+    def test_is_not_changed_when_stored_in_mysql_blob_frozen_payload
+      value = %w(Fée)
+      model = FrozenBinaryField.create!(normal_blob: value, normal_text: value)
+      model.reload
+
+      model.normal_blob = value
+      assert_not_predicate model, :normal_blob_changed?
+    end
+  end
+
   def test_values_cast_from_nil_are_persisted_as_nil
     # This is required to fulfil the following contract, which must be universally
     # true in Active Record:
@@ -285,7 +381,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     topic = Topic.create!(content: {})
     topic2 = Topic.create!(content: nil)
 
-    assert_equal [topic, topic2], Topic.where(content: nil)
+    assert_equal [topic, topic2], Topic.where(content: nil).sort_by(&:id)
   end
 
   def test_nil_is_always_persisted_as_null
@@ -326,18 +422,13 @@ class SerializedAttributeTest < ActiveRecord::TestCase
 
     topic = model.create!(foo: "bar")
     topic.foo
-    refute topic.changed?
+    assert_not_predicate topic, :changed?
   end
-end
-
-class ThreadedSerializedAttributeTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-  fixtures :topics
 
   def test_serialized_attribute_works_under_concurrent_initial_access
-    model = Topic.dup
+    model = Class.new(Topic)
 
-    topic = model.last
+    topic = model.create!
     topic.update group: "1"
 
     model.serialize :group, JSON
@@ -345,9 +436,9 @@ class ThreadedSerializedAttributeTest < ActiveRecord::TestCase
 
     # This isn't strictly necessary for the test, but a little bit of
     # knowledge of internals allows us to make failures far more likely.
-    model.define_singleton_method(:define_attribute) do |*args|
+    model.define_singleton_method(:define_attribute) do |*args, **options|
       Thread.pass
-      super(*args)
+      super(*args, **options)
     end
 
     threads = 4.times.map do

data/test/cases/signed_id_test.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/account"
+require "models/company"
+require "models/toy"
+require "models/matey"
+
+SIGNED_ID_VERIFIER_TEST_SECRET = -> { "This is normally set by the railtie initializer when used with Rails!" }
+
+ActiveRecord::Base.signed_id_verifier_secret = SIGNED_ID_VERIFIER_TEST_SECRET
+
+class SignedIdTest < ActiveRecord::TestCase
+  fixtures :accounts, :toys, :companies
+
+  setup do
+    @account = Account.first
+    @toy = Toy.first
+  end
+
+  test "find signed record" do
+    assert_equal @account, Account.find_signed(@account.signed_id)
+  end
+
+  test "find signed record on relation" do
+    assert_equal @account, Account.where("1=1").find_signed(@account.signed_id)
+
+    assert_nil Account.where("1=0").find_signed(@account.signed_id)
+  end
+
+  test "find signed record with custom primary key" do
+    assert_equal @toy, Toy.find_signed(@toy.signed_id)
+  end
+
+  test "find signed record for single table inheritance (STI Models)" do
+    assert_equal Company.first, Company.find_signed(Company.first.signed_id)
+  end
+
+  test "find signed record raises UnknownPrimaryKey when a model has no primary key" do
+    error = assert_raises(ActiveRecord::UnknownPrimaryKey) do
+      Matey.find_signed("this will not be even verified")
+    end
+    assert_equal "Unknown primary key for table mateys in model Matey.", error.message
+  end
+
+  test "find signed record with a bang" do
+    assert_equal @account, Account.find_signed!(@account.signed_id)
+  end
+
+  test "find signed record with a bang on relation" do
+    assert_equal @account, Account.where("1=1").find_signed!(@account.signed_id)
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Account.where("1=0").find_signed!(@account.signed_id)
+    end
+  end
+
+  test "find signed record with a bang with custom primary key" do
+    assert_equal @toy, Toy.find_signed!(@toy.signed_id)
+  end
+
+  test "find signed record with a bang for single table inheritance (STI Models)" do
+    assert_equal Company.first, Company.find_signed!(Company.first.signed_id)
+  end
+
+  test "fail to find record from broken signed id" do
+    assert_nil Account.find_signed("this won't find anything")
+  end
+
+  test "find signed record within expiration date" do
+    assert_equal @account, Account.find_signed(@account.signed_id(expires_in: 1.minute))
+  end
+
+  test "fail to find signed record within expiration date" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    travel 2.minutes
+    assert_nil Account.find_signed(signed_id)
+  end
+
+  test "fail to find record from that has since been destroyed" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    @account.destroy
+    assert_nil Account.find_signed signed_id
+  end
+
+  test "find signed record with purpose" do
+    assert_equal @account, Account.find_signed(@account.signed_id(purpose: :v1), purpose: :v1)
+  end
+
+  test "fail to find signed record with purpose" do
+    assert_nil Account.find_signed(@account.signed_id(purpose: :v1))
+
+    assert_nil Account.find_signed(@account.signed_id(purpose: :v1), purpose: :v2)
+  end
+
+  test "finding record from broken signed id raises on the bang" do
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed! "this will blow up"
+    end
+  end
+
+  test "find signed record with a bang within expiration date" do
+    assert_equal @account, Account.find_signed!(@account.signed_id(expires_in: 1.minute))
+  end
+
+  test "finding signed record outside expiration date raises on the bang" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    travel 2.minutes
+
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(signed_id)
+    end
+  end
+
+  test "finding signed record that has been destroyed raises on the bang" do
+    signed_id = @account.signed_id(expires_in: 1.minute)
+    @account.destroy
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      Account.find_signed!(signed_id)
+    end
+  end
+
+  test "find signed record with bang with purpose" do
+    assert_equal @account, Account.find_signed!(@account.signed_id(purpose: :v1), purpose: :v1)
+  end
+
+  test "find signed record with bang with purpose raises" do
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(@account.signed_id(purpose: :v1))
+    end
+
+    assert_raises(ActiveSupport::MessageVerifier::InvalidSignature) do
+      Account.find_signed!(@account.signed_id(purpose: :v1), purpose: :v2)
+    end
+  end
+
+  test "fail to work without a signed_id_verifier_secret" do
+    ActiveRecord::Base.signed_id_verifier_secret = nil
+    Account.instance_variable_set :@signed_id_verifier, nil
+
+    assert_raises(ArgumentError) do
+      @account.signed_id
+    end
+  ensure
+    ActiveRecord::Base.signed_id_verifier_secret = SIGNED_ID_VERIFIER_TEST_SECRET
+  end
+
+  test "fail to work without when signed_id_verifier_secret lambda is nil" do
+    ActiveRecord::Base.signed_id_verifier_secret = -> { nil }
+    Account.instance_variable_set :@signed_id_verifier, nil
+
+    assert_raises(ArgumentError) do
+      @account.signed_id
+    end
+  ensure
+    ActiveRecord::Base.signed_id_verifier_secret = SIGNED_ID_VERIFIER_TEST_SECRET
+  end
+
+  test "use a custom verifier" do
+    old_verifier = Account.signed_id_verifier
+    Account.signed_id_verifier = ActiveSupport::MessageVerifier.new("sekret")
+    assert_not_equal ActiveRecord::Base.signed_id_verifier, Account.signed_id_verifier
+    assert_equal @account, Account.find_signed(@account.signed_id)
+  ensure
+    Account.signed_id_verifier = old_verifier
+  end
+end

data/test/cases/statement_cache_test.rb

@@ -1,8 +1,11 @@
-require 'cases/helper'
-require 'models/book'
-require 'models/liquid'
-require 'models/molecule'
-require 'models/electron'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/book"
+require "models/liquid"
+require "models/molecule"
+require "models/numeric_data"
+require "models/electron"
 
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
@@ -10,22 +13,20 @@ module ActiveRecord
       @connection = ActiveRecord::Base.connection
     end
 
-    #Cache v 1.1 tests
     def test_statement_cache
       Book.create(name: "my book")
       Book.create(name: "my other book")
 
       cache = StatementCache.create(Book.connection) do |params|
-        Book.where(:name => params.bind)
+        Book.where(name: params.bind)
       end
 
-      b = cache.execute([ "my book" ], Book, Book.connection)
+      b = cache.execute([ "my book" ], Book.connection)
       assert_equal "my book", b[0].name
-      b = cache.execute([ "my other book" ], Book, Book.connection)
+      b = cache.execute([ "my other book" ], Book.connection)
       assert_equal "my other book", b[0].name
     end
 
-
     def test_statement_cache_id
       b1 = Book.create(name: "my book")
       b2 = Book.create(name: "my other book")
@@ -34,9 +35,9 @@ module ActiveRecord
         Book.where(id: params.bind)
       end
 
-      b = cache.execute([ b1.id ], Book, Book.connection)
+      b = cache.execute([ b1.id ], Book.connection)
       assert_equal b1.name, b[0].name
-      b = cache.execute([ b2.id ], Book, Book.connection)
+      b = cache.execute([ b2.id ], Book.connection)
       assert_equal b2.name, b[0].name
     end
 
@@ -50,8 +51,6 @@ module ActiveRecord
       assert_equal("my other book", b.name)
     end
 
-    #End
-
     def test_statement_cache_with_simple_statement
       cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
         Book.where(name: "my book").where("author_id > 3")
@@ -59,23 +58,28 @@ module ActiveRecord
 
       Book.create(name: "my book", author_id: 4)
 
-      books = cache.execute([], Book, Book.connection)
+      books = cache.execute([], Book.connection)
       assert_equal "my book", books[0].name
     end
 
     def test_statement_cache_with_complex_statement
       cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
-        Liquid.joins(:molecules => :electrons).where('molecules.name' => 'dioxane', 'electrons.name' => 'lepton')
+        Liquid.joins(molecules: :electrons).where("molecules.name" => "dioxane", "electrons.name" => "lepton")
       end
 
-      salty = Liquid.create(name: 'salty')
-      molecule = salty.molecules.create(name: 'dioxane')
-      molecule.electrons.create(name: 'lepton')
+      salty = Liquid.create(name: "salty")
+      molecule = salty.molecules.create(name: "dioxane")
+      molecule.electrons.create(name: "lepton")
 
-      liquids = cache.execute([], Book, Book.connection)
+      liquids = cache.execute([], Book.connection)
       assert_equal "salty", liquids[0].name
     end
 
+    def test_statement_cache_with_strictly_cast_attribute
+      row = NumericData.create(temperature: 1.5)
+      assert_equal row, NumericData.find_by(temperature: 1.5)
+    end
+
     def test_statement_cache_values_differ
       cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
         Book.where(name: "my book")
@@ -85,13 +89,13 @@ module ActiveRecord
         Book.create(name: "my book")
       end
 
-      first_books = cache.execute([], Book, Book.connection)
+      first_books = cache.execute([], Book.connection)
 
       3.times do
         Book.create(name: "my book")
       end
 
-      additional_books = cache.execute([], Book, Book.connection)
+      additional_books = cache.execute([], Book.connection)
       assert first_books != additional_books
     end
 
@@ -104,7 +108,7 @@ module ActiveRecord
         Book.find_by(name: "my other book")
       end
 
-      refute_equal book, other_book
+      assert_not_equal book, other_book
     end
 
     def test_find_by_does_not_use_statement_cache_if_table_name_is_changed
@@ -114,7 +118,7 @@ module ActiveRecord
 
       # changing the table name should change the query that is not cached.
       Book.table_name = :birds
-      assert_nil Book.find_by(name: "my book")
+      assert_nil Book.find_by(name: book.name)
     ensure
       Book.table_name = :books
     end
@@ -132,5 +136,18 @@ module ActiveRecord
     ensure
       Book.table_name = :books
     end
+
+    def test_find_association_does_not_use_statement_cache_if_table_name_is_changed
+      salty = Liquid.create(name: "salty")
+      molecule = salty.molecules.create(name: "dioxane")
+
+      assert_equal salty, molecule.liquid
+
+      Liquid.table_name = :birds
+
+      assert_nil molecule.reload_liquid
+    ensure
+      Liquid.table_name = :liquid
+    end
   end
 end

data/test/cases/statement_invalid_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/book"
+
+module ActiveRecord
+  class StatementInvalidTest < ActiveRecord::TestCase
+    fixtures :books
+
+    class MockDatabaseError < StandardError
+      def result
+        0
+      end
+
+      def error_number
+        0
+      end
+    end
+
+    test "message contains no sql" do
+      sql = Book.where(author_id: 96, cover: "hard").to_sql
+      error = assert_raises(ActiveRecord::StatementInvalid) do
+        Book.connection.send(:log, sql, Book.name) do
+          raise MockDatabaseError
+        end
+      end
+      assert_not error.message.include?("SELECT")
+    end
+
+    test "statement and binds are set on select" do
+      sql = Book.where(author_id: 96, cover: "hard").to_sql
+      binds = [Minitest::Mock.new, Minitest::Mock.new]
+      error = assert_raises(ActiveRecord::StatementInvalid) do
+        Book.connection.send(:log, sql, Book.name, binds) do
+          raise MockDatabaseError
+        end
+      end
+      assert_equal error.sql, sql
+      assert_equal error.binds, binds
+    end
+  end
+end