ibm_db 5.6.1 → 5.7.0

data/test/cases/callbacks_test.rb

@@ -3,7 +3,6 @@
 require "cases/helper"
 require "models/developer"
 require "models/computer"
-require "active_support/core_ext/symbol/starts_ends_with"
 
 class CallbackDeveloper < ActiveRecord::Base
   self.table_name = "developers"

data/test/cases/clone_test.rb

@@ -10,10 +10,11 @@ module ActiveRecord
     def test_persisted
       topic = Topic.first
       cloned = topic.clone
-      assert topic.persisted?, "topic persisted"
-      assert cloned.persisted?, "topic persisted"
+      assert_predicate topic, :persisted?, "topic persisted"
+      assert_predicate cloned, :persisted?, "topic persisted"
       assert_not cloned.new_record?, "topic is not new"
       assert_not cloned.previously_new_record?, "topic was not previously new"
+      assert_not cloned.previously_persisted?, "topic was not previously persisted"
     end
 
     def test_stays_frozen
@@ -21,9 +22,9 @@ module ActiveRecord
       topic.freeze
 
       cloned = topic.clone
-      assert cloned.persisted?, "topic persisted"
+      assert_predicate cloned, :persisted?, "topic persisted"
       assert_not cloned.new_record?, "topic is not new"
-      assert cloned.frozen?, "topic should be frozen"
+      assert_predicate cloned, :frozen?, "topic should be frozen"
       assert_raise(FrozenError) { cloned.author_name = "Aaron" }
     end
 

data/test/cases/coders/yaml_column_test.rb

@@ -5,6 +5,15 @@ require "cases/helper"
 module ActiveRecord
   module Coders
     class YAMLColumnTest < ActiveRecord::TestCase
+      setup do
+        @use_yaml_unsafe_load = ActiveRecord.use_yaml_unsafe_load
+        ActiveRecord.use_yaml_unsafe_load = true
+      end
+
+      teardown do
+        ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load
+      end
+
       def test_initialize_takes_class
         coder = YAMLColumn.new("attr_name", Object)
         assert_equal Object, coder.object_class
@@ -41,9 +50,11 @@ module ActiveRecord
         assert_equal "foo", coder.load("foo")
       end
 
-      def test_load_handles_other_classes
+      def test_load_raises_on_other_classes
         coder = YAMLColumn.new("attr_name")
-        assert_equal [], coder.load([])
+        assert_raises TypeError do
+          coder.load([])
+        end
       end
 
       def test_load_doesnt_swallow_yaml_exceptions
@@ -62,5 +73,89 @@ module ActiveRecord
         end
       end
     end
+
+    class YAMLColumnTestWithSafeLoad < YAMLColumnTest
+      setup do
+        @use_yaml_unsafe_load = ActiveRecord.use_yaml_unsafe_load
+        @yaml_column_permitted_classes_default = ActiveRecord.yaml_column_permitted_classes
+        ActiveRecord.use_yaml_unsafe_load = false
+      end
+
+      teardown do
+        ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load
+        ActiveRecord.yaml_column_permitted_classes = @yaml_column_permitted_classes_default
+      end
+
+      def test_yaml_column_permitted_classes_are_consumed_by_safe_load
+        ActiveRecord.yaml_column_permitted_classes = [Symbol, Time]
+
+        coder = YAMLColumn.new("attr_name")
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_permitted_classes_are_consumed_by_safe_dump
+        if Gem::Version.new(Psych::VERSION) < Gem::Version.new("5.1")
+          skip "YAML.safe_dump is either missing on unavailable on #{Psych::VERSION}"
+        end
+
+        coder = YAMLColumn.new("attr_name")
+        assert_raises(Psych::DisallowedClass) do
+          coder.dump([Time.new])
+        end
+      end
+
+      def test_yaml_column_permitted_classes_option
+        ActiveRecord.yaml_column_permitted_classes = [Symbol]
+
+        coder = YAMLColumn.new("attr_name", permitted_classes: [Time])
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_unsafe_load_option
+        ActiveRecord.use_yaml_unsafe_load = false
+        ActiveRecord.yaml_column_permitted_classes = []
+
+        coder = YAMLColumn.new("attr_name", unsafe_load: true)
+        time_yaml = YAML.dump(Time.new)
+        symbol_yaml = YAML.dump(:somesymbol)
+
+        assert_nothing_raised do
+          coder.load(time_yaml)
+          coder.load(symbol_yaml)
+        end
+      end
+
+      def test_yaml_column_override_unsafe_load_option
+        ActiveRecord.use_yaml_unsafe_load = true
+        ActiveRecord.yaml_column_permitted_classes = []
+
+        coder = YAMLColumn.new("attr_name", unsafe_load: false)
+        time_yaml = YAML.dump(Time.new)
+
+        assert_raises(Psych::DisallowedClass) do
+          coder.load(time_yaml)
+        end
+      end
+
+      def test_load_doesnt_handle_undefined_class_or_module
+        coder = YAMLColumn.new("attr_name")
+        missing_class_yaml = '--- !ruby/object:DoesNotExistAndShouldntEver {}\n'
+        assert_raises(Psych::DisallowedClass) do
+          coder.load(missing_class_yaml)
+        end
+      end
+    end
   end
 end

data/test/cases/collection_cache_key_test.rb

@@ -27,7 +27,7 @@ module ActiveRecord
 
       assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
     test "cache_key for relation with limit" do
@@ -40,7 +40,7 @@ module ActiveRecord
 
       assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
     test "cache_key for relation with custom select and limit" do
@@ -54,7 +54,7 @@ module ActiveRecord
 
       assert_equal ActiveSupport::Digest.hexdigest(developers_with_select.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
     test "cache_key for loaded relation" do
@@ -67,19 +67,13 @@ module ActiveRecord
 
       assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
     test "cache_key for relation with table alias" do
       table_alias = Developer.arel_table.alias("omg_developers")
-      table_metadata = ActiveRecord::TableMetadata.new(Developer, table_alias)
-      predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)
-
-      developers = ActiveRecord::Relation.create(
-        Developer,
-        table: table_alias,
-        predicate_builder: predicate_builder
-      )
+
+      developers = ActiveRecord::Relation.create(Developer, table: table_alias)
       developers = developers.where(salary: 100000).order(updated_at: :desc)
       last_developer_timestamp = developers.first.updated_at
 
@@ -89,7 +83,7 @@ module ActiveRecord
 
       assert_equal ActiveSupport::Digest.hexdigest(developers.to_sql), $1
       assert_equal developers.count.to_s, $2
-      assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $3
+      assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $3
     end
 
     test "cache_key for relation with includes" do
@@ -150,7 +144,7 @@ module ActiveRecord
     test "it triggers at most one query" do
       developers = Developer.where(name: "David")
 
-      assert_queries(1) { developers.cache_key }
+      assert_queries_count(1) { developers.cache_key }
       assert_no_queries { developers.cache_key }
     end
 
@@ -180,7 +174,7 @@ module ActiveRecord
 
     test "cache_key with custom timestamp column" do
       topics = Topic.where("title like ?", "%Topic%")
-      last_topic_timestamp = topics(:fifth).written_on.utc.to_s(:usec)
+      last_topic_timestamp = topics(:fifth).written_on.utc.to_fs(:usec)
       assert_match(last_topic_timestamp, topics.cache_key(:written_on))
     end
 
@@ -217,6 +211,7 @@ module ActiveRecord
       developers = Developer.distinct.order(:salary).limit(5)
 
       assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\z/, developers.cache_key)
+      assert_not_predicate developers, :loaded?
     end
 
     test "cache_key with a relation having custom select and order" do
@@ -247,7 +242,20 @@ module ActiveRecord
         /(\d+)-(\d+)\z/ =~ developers.cache_version
 
         assert_equal developers.count.to_s, $1
-        assert_equal last_developer_timestamp.to_s(ActiveRecord::Base.cache_timestamp_format), $2
+        assert_equal last_developer_timestamp.to_fs(ActiveRecord::Base.cache_timestamp_format), $2
+      end
+    end
+
+    test "reset will reset cache_version" do
+      with_collection_cache_versioning do
+        developers = Developer.all
+
+        assert_equal Developer.all.cache_version, developers.cache_version
+
+        Developer.update_all(updated_at: Time.now.utc + 1.second)
+        developers.reset
+
+        assert_equal Developer.all.cache_version, developers.cache_version
       end
     end
 

data/test/cases/column_alias_test.rb

@@ -6,14 +6,8 @@ require "models/topic"
 class TestColumnAlias < ActiveRecord::TestCase
   fixtures :topics
 
-  QUERY = if "Oracle" == ActiveRecord::Base.connection.adapter_name
-    "SELECT id AS pk FROM topics WHERE ROWNUM < 2"
-  else
-    "SELECT id AS pk FROM topics"
-  end
-
   def test_column_alias
-    records = Topic.connection.select_all(QUERY)
-    assert_equal "pk", records[0].keys[0]
+    records = Topic.lease_connection.select_all("SELECT id AS pk FROM topics")
+    assert_equal ["pk"], records.columns
   end
 end

data/test/cases/column_definition_test.rb

@@ -5,11 +5,20 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class ColumnDefinitionTest < ActiveRecord::TestCase
-      def setup
-        @adapter = AbstractAdapter.new(nil)
-        def @adapter.native_database_types
+      class DummyAdapter < AbstractAdapter
+        class << self
+          def quote_column_name(column_name)
+            column_name.to_s
+          end
+        end
+
+        def native_database_types
           { string: "varchar" }
         end
+      end
+
+      def setup
+        @adapter = DummyAdapter.new(nil)
         @viz = @adapter.send(:schema_creation)
       end
 

data/test/cases/comment_test.rb

@@ -3,7 +3,7 @@
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if ActiveRecord::Base.connection.supports_comments?
+if ActiveRecord::Base.lease_connection.supports_comments?
   class CommentTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
@@ -18,7 +18,7 @@ if ActiveRecord::Base.connection.supports_comments?
     end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
 
       @connection.create_table("commenteds", comment: "A table with comment", force: true) do |t|
         t.string  "name",    comment: "Comment should help clarify the column purpose"
@@ -72,7 +72,6 @@ if ActiveRecord::Base.connection.supports_comments?
     end
 
     def test_blank_indexes_created_in_block
-      puts "test_blank_indexes_created_in_block"
       @connection.indexes("blank_comments").each do |index|
         assert_nil index.comment
       end
@@ -88,11 +87,9 @@ if ActiveRecord::Base.connection.supports_comments?
     end
 
     def test_add_index_with_comment_later
-      unless current_adapter?(:OracleAdapter)
-        @connection.add_index :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
-        index = @connection.indexes("commenteds").find { |idef| idef.name == "idx_obvious" }
-        assert_equal "We need to see obvious comments", index.comment
-      end
+      @connection.add_index :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
+      index = @connection.indexes("commenteds").find { |idef| idef.name == "idx_obvious" }
+      assert_equal "We need to see obvious comments", index.comment
     end
 
     def test_add_comment_to_column
@@ -123,7 +120,7 @@ if ActiveRecord::Base.connection.supports_comments?
       column = Commented.columns_hash["new_rating"]
 
       assert_equal :string, column.type
-      assert_equal column.comment, "I am running out of imagination"
+      assert_equal "I am running out of imagination", column.comment
     end
 
     def test_schema_dump_with_comments
@@ -137,16 +134,12 @@ if ActiveRecord::Base.connection.supports_comments?
       # And check that these changes are reflected in dump
       output = dump_table_schema "commenteds"
       assert_match %r[create_table "commenteds",.*\s+comment: "A table with comment"], output
-      assert_match %r[t\.string\s+"name",.*\s+comment: "Comment should help clarify the column purpose"], output
-      assert_match %r[t\.string\s+"obvious"], output
-      assert_match %r[t\.string\s+"content",.*\s+comment: "Whoa, content describes itself!"], output
-      if current_adapter?(:OracleAdapter)
-        assert_match %r[t\.integer\s+"rating",\s+precision: 38,\s+comment: "I am running out of imagination"], output
-      else
-        assert_match %r[t\.integer\s+"rating",.*\s+comment: "I am running out of imagination"], output
-        assert_match %r[t\.index\s+.+\s+comment: "\\\"Very important\\\" index that powers all the performance.\\nAnd it's fun!"], output
-        assert_match %r[t\.index\s+.+\s+name: "idx_obvious",.*\s+comment: "We need to see obvious comments"], output
-      end
+      assert_match %r[t\.string\s+"name",\s+comment: "Comment should help clarify the column purpose"], output
+      assert_match %r[t\.string\s+"obvious"\n], output
+      assert_match %r[t\.string\s+"content",\s+comment: "Whoa, content describes itself!"], output
+      assert_match %r[t\.integer\s+"rating",\s+comment: "I am running out of imagination"], output
+      assert_match %r[t\.index\s+.+\s+comment: "\\"Very important\\" index that powers all the performance.\\nAnd it's fun!"], output
+      assert_match %r[t\.index\s+.+\s+name: "idx_obvious",\s+comment: "We need to see obvious comments"], output
     end
 
     def test_schema_dump_omits_blank_comments
@@ -155,16 +148,16 @@ if ActiveRecord::Base.connection.supports_comments?
       assert_match %r[create_table "blank_comments"], output
       assert_no_match %r[create_table "blank_comments",.+comment:], output
 
-      assert_match %r[t\.string\s+"space_comment".*\n], output
+      assert_match %r[t\.string\s+"space_comment"\n], output
       assert_no_match %r[t\.string\s+"space_comment", comment:\n], output
 
-      assert_match %r[t\.string\s+"empty_comment".*\n], output
+      assert_match %r[t\.string\s+"empty_comment"\n], output
       assert_no_match %r[t\.string\s+"empty_comment", comment:\n], output
 
-      assert_match %r[t\.string\s+"nil_comment".*\n], output
+      assert_match %r[t\.string\s+"nil_comment"\n], output
       assert_no_match %r[t\.string\s+"nil_comment", comment:\n], output
 
-      assert_match %r[t\.string\s+"absent_comment".*\n], output
+      assert_match %r[t\.string\s+"absent_comment"\n], output
       assert_no_match %r[t\.string\s+"absent_comment", comment:\n], output
     end
 
@@ -179,9 +172,13 @@ if ActiveRecord::Base.connection.supports_comments?
     end
 
     def test_change_column_comment
-      @connection.change_column_comment :commenteds, :name, "Edited column comment"
-      column = Commented.columns_hash["name"]
+      @connection.change_column_comment :commenteds, :id, "Edited column comment"
+      column = Commented.columns_hash["id"]
       assert_equal "Edited column comment", column.comment
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        assert_predicate column, :auto_increment?
+      end
     end
 
     def test_change_column_comment_to_nil
@@ -198,7 +195,7 @@ if ActiveRecord::Base.connection.supports_comments?
 
     def test_schema_dump_with_primary_key_comment
       output = dump_table_schema "pk_commenteds"
-      assert_match %r[create_table "pk_commenteds", id: { .*comment: "Primary key comment" }.*, comment: "Table comment"], output
+      assert_match %r[create_table "pk_commenteds", id: { comment: "Primary key comment" }.*, comment: "Table comment"], output
     end
   end
 end

data/test/cases/connection_adapters/adapter_leasing_test.rb

@@ -20,40 +20,40 @@ module ActiveRecord
 
       def test_in_use?
         assert_not @adapter.in_use?, "adapter is not in use"
-        assert @adapter.lease, "lease adapter"
-        assert @adapter.in_use?, "adapter is in use"
+        @adapter.lease
+        assert_predicate @adapter, :in_use?, "adapter is in use"
       end
 
       def test_lease_twice
-        assert @adapter.lease, "should lease adapter"
+        @adapter.lease
         assert_raises(ActiveRecordError) do
           @adapter.lease
         end
       end
 
       def test_expire_mutates_in_use
-        assert @adapter.lease, "lease adapter"
-        assert @adapter.in_use?, "adapter is in use"
+        @adapter.lease
+        assert_predicate @adapter, :in_use?, "adapter is in use"
         @adapter.expire
         assert_not @adapter.in_use?, "adapter is in use"
       end
 
       def test_close
-        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", {})
-        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config)
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", adapter: "abstract")
+        pool_config = ActiveRecord::ConnectionAdapters::PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
         pool = Pool.new(pool_config)
         pool.insert_connection_for_test! @adapter
         @adapter.pool = pool
 
         # Make sure the pool marks the connection in use
-        assert_equal @adapter, pool.connection
+        assert_equal @adapter, pool.lease_connection
         assert_predicate @adapter, :in_use?
 
         # Close should put the adapter back in the pool
         @adapter.close
         assert_not_predicate @adapter, :in_use?
 
-        assert_equal @adapter, pool.connection
+        assert_equal @adapter, pool.lease_connection
       end
     end
   end