ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/test/cases/coders/json_test.rb

@@ -0,0 +1,15 @@
+require "cases/helper"
+
+module ActiveRecord
+  module Coders
+    class JSONTest < ActiveRecord::TestCase
+      def test_returns_nil_if_empty_string_given
+        assert_nil JSON.load("")
+      end
+
+      def test_returns_nil_if_nil_given
+        assert_nil JSON.load(nil)
+      end
+    end
+  end
+end

data/test/cases/collection_cache_key_test.rb

@@ -0,0 +1,115 @@
+require "cases/helper"
+require "models/computer"
+require "models/developer"
+require "models/project"
+require "models/topic"
+require "models/post"
+require "models/comment"
+
+module ActiveRecord
+  class CollectionCacheKeyTest < ActiveRecord::TestCase
+    fixtures :developers, :projects, :developers_projects, :topics, :comments, :posts
+
+    test "collection_cache_key on model" do
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, Developer.collection_cache_key)
+    end
+
+    test "cache_key for relation" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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
+    end
+
+    test "cache_key for relation with limit" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5)
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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
+    end
+
+    test "cache_key for loaded relation" do
+      developers = Developer.where(salary: 100000).order(updated_at: :desc).limit(5).load
+      last_developer_timestamp = developers.first.updated_at
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+
+      /\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/ =~ developers.cache_key
+
+      assert_equal Digest::MD5.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
+    end
+
+    test "it triggers at most one query" do
+      developers =  Developer.where(name: "David")
+
+      assert_queries(1) { developers.cache_key }
+      assert_queries(0) { developers.cache_key }
+    end
+
+    test "it doesn't trigger any query if the relation is already loaded" do
+      developers =  Developer.where(name: "David").load
+      assert_queries(0) { developers.cache_key }
+    end
+
+    test "relation cache_key changes when the sql query changes" do
+      developers = Developer.where(name: "David")
+      other_relation =  Developer.where(name: "David").where("1 = 1")
+
+      assert_not_equal developers.cache_key, other_relation.cache_key
+    end
+
+    test "cache_key for empty relation" do
+      developers = Developer.where(name: "Non Existent Developer")
+      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+    end
+
+    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)
+      assert_match(last_topic_timestamp, topics.cache_key(:written_on))
+    end
+
+    test "cache_key with unknown timestamp column" do
+      topics = Topic.where("title like ?", "%Topic%")
+      assert_raises(ActiveRecord::StatementInvalid) { topics.cache_key(:published_at) }
+    end
+
+    test "collection proxy provides a cache_key" do
+      developers = projects(:active_record).developers
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+    end
+
+    test "cache_key for loaded collection with zero size" do
+      Comment.delete_all
+      posts = Post.includes(:comments)
+      empty_loaded_collection = posts.first.comments
+
+      assert_match(/\Acomments\/query-(\h+)-0\Z/, empty_loaded_collection.cache_key)
+    end
+
+    test "cache_key for queries with offset which return 0 rows" do
+      developers = Developer.offset(20)
+      assert_match(/\Adevelopers\/query-(\h+)-0\Z/, developers.cache_key)
+    end
+
+    test "cache_key with a relation having selected columns" do
+      developers = Developer.select(:salary)
+
+      assert_match(/\Adevelopers\/query-(\h+)-(\d+)-(\d+)\Z/, developers.cache_key)
+    end
+  end
+end

data/test/cases/column_definition_test.rb

@@ -14,7 +14,7 @@ module ActiveRecord
       # Avoid column definitions in create table statements like:
       # `title` varchar(255) DEFAULT NULL
       def test_should_not_include_default_clause_when_default_is_null
-        column = Column.new("title", nil, Type::String.new(limit: 20))
+        column = Column.new("title", nil, SqlTypeMetadata.new(limit: 20))
         column_def = ColumnDefinition.new(
           column.name, "string",
           column.limit, column.precision, column.scale, column.default, column.null)
@@ -22,7 +22,7 @@ module ActiveRecord
       end
 
       def test_should_include_default_clause_when_default_is_present
-        column = Column.new("title", "Hello", Type::String.new(limit: 20))
+        column = Column.new("title", "Hello", SqlTypeMetadata.new(limit: 20))
         column_def = ColumnDefinition.new(
           column.name, "string",
           column.limit, column.precision, column.scale, column.default, column.null)
@@ -30,94 +30,63 @@ module ActiveRecord
       end
 
       def test_should_specify_not_null_if_null_option_is_false
-        column = Column.new("title", "Hello", Type::String.new(limit: 20), "varchar(20)", false)
+        type_metadata = SqlTypeMetadata.new(limit: 20)
+        column = Column.new("title", "Hello", type_metadata, false)
         column_def = ColumnDefinition.new(
           column.name, "string",
           column.limit, column.precision, column.scale, column.default, column.null)
           assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, @viz.accept(column_def)
       end
 
-      if current_adapter?(:MysqlAdapter)
+      if current_adapter?(:Mysql2Adapter)
         def test_should_set_default_for_mysql_binary_data_types
-          binary_column = MysqlAdapter::Column.new("title", "a", Type::Binary.new, "binary(1)")
+          type = SqlTypeMetadata.new(type: :binary, sql_type: "binary(1)")
+          binary_column = MySQL::Column.new("title", "a", type)
           assert_equal "a", binary_column.default
 
-          varbinary_column = MysqlAdapter::Column.new("title", "a", Type::Binary.new, "varbinary(1)")
+          type = SqlTypeMetadata.new(type: :binary, sql_type: "varbinary")
+          varbinary_column = MySQL::Column.new("title", "a", type)
           assert_equal "a", varbinary_column.default
         end
 
-        def test_should_not_set_default_for_blob_and_text_data_types
-          assert_raise ArgumentError do
-            MysqlAdapter::Column.new("title", "a", Type::Binary.new, "blob")
-          end
-
-          assert_raise ArgumentError do
-            MysqlAdapter::Column.new("title", "Hello", Type::Text.new)
-          end
+        def test_should_be_empty_string_default_for_mysql_binary_data_types
+          type = SqlTypeMetadata.new(type: :binary, sql_type: "binary(1)")
+          binary_column = MySQL::Column.new("title", "", type, false)
+          assert_equal "", binary_column.default
 
-          text_column = MysqlAdapter::Column.new("title", nil, Type::Text.new)
-          assert_equal nil, text_column.default
-
-          not_null_text_column = MysqlAdapter::Column.new("title", nil, Type::Text.new, "text", false)
-          assert_equal "", not_null_text_column.default
-        end
-
-        def test_has_default_should_return_false_for_blob_and_text_data_types
-          blob_column = MysqlAdapter::Column.new("title", nil, Type::Binary.new, "blob")
-          assert !blob_column.has_default?
-
-          text_column = MysqlAdapter::Column.new("title", nil, Type::Text.new)
-          assert !text_column.has_default?
-        end
-      end
-
-      if current_adapter?(:Mysql2Adapter)
-        def test_should_set_default_for_mysql_binary_data_types
-          binary_column = Mysql2Adapter::Column.new("title", "a", Type::Binary.new, "binary(1)")
-          assert_equal "a", binary_column.default
-
-          varbinary_column = Mysql2Adapter::Column.new("title", "a", Type::Binary.new, "varbinary(1)")
-          assert_equal "a", varbinary_column.default
+          type = SqlTypeMetadata.new(type: :binary, sql_type: "varbinary")
+          varbinary_column = MySQL::Column.new("title", "", type, false)
+          assert_equal "", varbinary_column.default
         end
 
         def test_should_not_set_default_for_blob_and_text_data_types
           assert_raise ArgumentError do
-            Mysql2Adapter::Column.new("title", "a", Type::Binary.new, "blob")
+            MySQL::Column.new("title", "a", SqlTypeMetadata.new(sql_type: "blob"))
           end
 
+          text_type = MySQL::TypeMetadata.new(
+            SqlTypeMetadata.new(type: :text))
           assert_raise ArgumentError do
-            Mysql2Adapter::Column.new("title", "Hello", Type::Text.new)
+            MySQL::Column.new("title", "Hello", text_type)
           end
 
-          text_column = Mysql2Adapter::Column.new("title", nil, Type::Text.new)
+          text_column = MySQL::Column.new("title", nil, text_type)
           assert_equal nil, text_column.default
 
-          not_null_text_column = Mysql2Adapter::Column.new("title", nil, Type::Text.new, "text", false)
+          not_null_text_column = MySQL::Column.new("title", nil, text_type, false)
           assert_equal "", not_null_text_column.default
         end
 
         def test_has_default_should_return_false_for_blob_and_text_data_types
-          blob_column = Mysql2Adapter::Column.new("title", nil, Type::Binary.new, "blob")
+          binary_type = SqlTypeMetadata.new(sql_type: "blob")
+          blob_column = MySQL::Column.new("title", nil, binary_type)
           assert !blob_column.has_default?
 
-          text_column = Mysql2Adapter::Column.new("title", nil, Type::Text.new)
+          text_type = SqlTypeMetadata.new(type: :text)
+          text_column = MySQL::Column.new("title", nil, text_type)
           assert !text_column.has_default?
         end
       end
-
-      if current_adapter?(:PostgreSQLAdapter)
-        def test_bigint_column_should_map_to_integer
-          oid = PostgreSQLAdapter::OID::Integer.new
-          bigint_column = PostgreSQLColumn.new('number', nil, oid, "bigint")
-          assert_equal :integer, bigint_column.type
-        end
-
-        def test_smallint_column_should_map_to_integer
-          oid = PostgreSQLAdapter::OID::Integer.new
-          smallint_column = PostgreSQLColumn.new('number', nil, oid, "smallint")
-          assert_equal :integer, smallint_column.type
-        end
-      end
     end
   end
 end

data/test/cases/comment_test.rb

@@ -0,0 +1,145 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if ActiveRecord::Base.connection.supports_comments?
+
+class CommentTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  class Commented < ActiveRecord::Base
+    self.table_name = 'commenteds'
+  end
+
+  class BlankComment < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.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'
+      t.boolean 'obvious', comment: 'Question is: should you comment obviously named objects?'
+      t.string  'content'
+      t.index   'name',    comment: %Q["Very important" index that powers all the performance.\nAnd it's fun!]
+    end
+
+    @connection.create_table('blank_comments', comment: ' ', force: true) do |t|
+      t.string :space_comment, comment: ' '
+      t.string :empty_comment, comment: ''
+      t.string :nil_comment, comment: nil
+      t.string :absent_comment
+      t.index :space_comment, comment: ' '
+      t.index :empty_comment, comment: ''
+      t.index :nil_comment, comment: nil
+      t.index :absent_comment
+    end
+
+    Commented.reset_column_information
+    BlankComment.reset_column_information
+  end
+
+  teardown do
+    @connection.drop_table 'commenteds'
+	#, if_exists: true
+    @connection.drop_table 'blank_comments'
+	#, if_exists: true
+  end
+
+  def test_column_created_in_block
+    column = Commented.columns_hash['name']
+    assert_equal :string, column.type
+    assert_equal 'Comment should help clarify the column purpose', column.comment
+  end
+
+  def test_blank_columns_created_in_block
+    %w[ space_comment empty_comment nil_comment absent_comment ].each do |field|
+      column = BlankComment.columns_hash[field]
+      assert_equal :string, column.type
+      assert_nil column.comment
+    end
+  end
+
+  def test_blank_indexes_created_in_block
+    @connection.indexes('blank_comments').each do |index|
+      assert_nil index.comment
+    end
+  end
+
+  def test_add_column_with_comment_later
+    @connection.add_column :commenteds, :rating, :integer, comment: 'I am running out of imagination'
+    Commented.reset_column_information
+    column = Commented.columns_hash['rating']
+
+    assert_equal :integer, column.type
+    assert_equal 'I am running out of imagination', column.comment
+  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
+  end
+
+  def test_add_comment_to_column
+    @connection.change_column :commenteds, :content, :string, comment: 'Whoa, content describes itself!'
+
+    Commented.reset_column_information
+    column = Commented.columns_hash['content']
+
+    assert_equal :string, column.type
+    assert_equal 'Whoa, content describes itself!', column.comment
+  end
+
+  def test_remove_comment_from_column
+    @connection.change_column :commenteds, :obvious, :string, comment: nil
+
+    Commented.reset_column_information
+    column = Commented.columns_hash['obvious']
+
+    assert_equal :string, column.type
+    assert_nil column.comment
+  end
+
+  def test_schema_dump_with_comments
+    # Do all the stuff from other tests
+    @connection.add_column    :commenteds, :rating, :integer, comment: 'I am running out of imagination'
+    @connection.change_column :commenteds, :content, :string, comment: 'Whoa, content describes itself!'
+    @connection.change_column :commenteds, :obvious, :string, comment: nil
+    @connection.add_index     :commenteds, :obvious, name: 'idx_obvious', comment: 'We need to see obvious 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"\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
+    unless current_adapter?(:OracleAdapter)
+      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
+  end
+
+  def test_schema_dump_omits_blank_comments
+    output = dump_table_schema 'blank_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_no_match %r[t\.string\s+"space_comment", 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_no_match %r[t\.string\s+"nil_comment", 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
+end
+
+end

data/test/cases/connection_adapters/adapter_leasing_test.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       class Pool < ConnectionPool
         def insert_connection_for_test!(c)
           synchronize do
-            @connections << c
+            adopt_connection(c)
             @available.add c
           end
         end
@@ -24,7 +24,9 @@ module ActiveRecord
 
       def test_lease_twice
         assert @adapter.lease, 'should lease adapter'
-        assert_not @adapter.lease, 'should not lease adapter'
+        assert_raises(ActiveRecordError) do
+          @adapter.lease
+        end
       end
 
       def test_expire_mutates_in_use
@@ -35,7 +37,7 @@ module ActiveRecord
       end
 
       def test_close
-        pool = Pool.new(ConnectionSpecification.new({}, nil))
+        pool = Pool.new(ConnectionSpecification.new("primary", {}, nil))
         pool.insert_connection_for_test! @adapter
         @adapter.pool = pool
 

data/test/cases/connection_adapters/connection_handler_test.rb

@@ -4,48 +4,155 @@ module ActiveRecord
   module ConnectionAdapters
     class ConnectionHandlerTest < ActiveRecord::TestCase
       def setup
-        @klass    = Class.new(Base)   { def self.name; 'klass';    end }
-        @subklass = Class.new(@klass) { def self.name; 'subklass'; end }
-
         @handler = ConnectionHandler.new
-        @pool    = @handler.establish_connection(@klass, Base.connection_pool.spec)
+        resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new Base.configurations
+        @spec_name = "primary"
+        @pool    = @handler.establish_connection(resolver.spec(:arunit, @spec_name))
+      end
+
+      def test_establish_connection_uses_spec_name
+        config = {"readonly" => {"adapter" => 'sqlite3'}}
+        resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
+        spec =   resolver.spec(:readonly)
+        @handler.establish_connection(spec)
+
+        assert_not_nil @handler.retrieve_connection_pool('readonly')
+      ensure
+        @handler.remove_connection('readonly')
       end
 
       def test_retrieve_connection
-        assert @handler.retrieve_connection(@klass)
+        assert @handler.retrieve_connection(@spec_name)
       end
 
       def test_active_connections?
         assert !@handler.active_connections?
-        assert @handler.retrieve_connection(@klass)
+        assert @handler.retrieve_connection(@spec_name)
         assert @handler.active_connections?
         @handler.clear_active_connections!
         assert !@handler.active_connections?
       end
 
-      def test_retrieve_connection_pool_with_ar_base
-        assert_nil @handler.retrieve_connection_pool(ActiveRecord::Base)
+      def test_retrieve_connection_pool
+        assert_not_nil @handler.retrieve_connection_pool(@spec_name)
       end
 
-      def test_retrieve_connection_pool
-        assert_not_nil @handler.retrieve_connection_pool(@klass)
+      def test_retrieve_connection_pool_with_invalid_id
+        assert_nil @handler.retrieve_connection_pool("foo")
       end
 
-      def test_retrieve_connection_pool_uses_superclass_when_no_subclass_connection
-        assert_not_nil @handler.retrieve_connection_pool(@subklass)
+      def test_connection_pools
+        assert_equal([@pool], @handler.connection_pools)
       end
 
-      def test_retrieve_connection_pool_uses_superclass_pool_after_subclass_establish_and_remove
-        sub_pool = @handler.establish_connection(@subklass, Base.connection_pool.spec)
-        assert_same sub_pool, @handler.retrieve_connection_pool(@subklass)
+      if Process.respond_to?(:fork)
+        def test_connection_pool_per_pid
+          object_id = ActiveRecord::Base.connection.object_id
 
-        @handler.remove_connection @subklass
-        assert_same @pool, @handler.retrieve_connection_pool(@subklass)
-      end
+          rd, wr = IO.pipe
+          rd.binmode
+          wr.binmode
 
-      def test_connection_pools
-        assert_deprecated do
-          assert_equal({ Base.connection_pool.spec => @pool }, @handler.connection_pools)
+          pid = fork {
+            rd.close
+            wr.write Marshal.dump ActiveRecord::Base.connection.object_id
+            wr.close
+            exit!
+          }
+
+          wr.close
+
+          Process.waitpid pid
+          assert_not_equal object_id, Marshal.load(rd.read)
+          rd.close
+        end
+
+        def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
+          @pool.schema_cache = @pool.connection.schema_cache
+          @pool.schema_cache.add('posts')
+
+          rd, wr = IO.pipe
+          rd.binmode
+          wr.binmode
+
+          pid = fork {
+            rd.close
+            pool = @handler.retrieve_connection_pool(@spec_name)
+            wr.write Marshal.dump pool.schema_cache.size
+            wr.close
+            exit!
+          }
+
+          wr.close
+
+          Process.waitpid pid
+          assert_equal @pool.schema_cache.size, Marshal.load(rd.read)
+          rd.close
+        end
+
+        def test_pool_from_any_process_for_uses_most_recent_spec
+          skip unless current_adapter?(:SQLite3Adapter)
+
+          file = Tempfile.new "lol.sqlite3"
+
+          rd, wr = IO.pipe
+          rd.binmode
+          wr.binmode
+
+          pid = fork do
+            ActiveRecord::Base.configurations["arunit"]["database"] = file.path
+            ActiveRecord::Base.establish_connection(:arunit)
+
+            pid2 = fork do
+              wr.write ActiveRecord::Base.connection_config[:database]
+              wr.close
+            end
+
+            Process.waitpid pid2
+          end
+
+          Process.waitpid pid
+
+          wr.close
+
+          assert_equal file.path, rd.read
+
+          rd.close
+        ensure
+          if file
+            file.close
+            file.unlink
+          end
+        end
+
+        def test_a_class_using_custom_pool_and_switching_back_to_primary
+          klass2 = Class.new(Base) { def self.name; 'klass2'; end }
+
+          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+
+          pool = klass2.establish_connection(ActiveRecord::Base.connection_pool.spec.config)
+          assert_equal klass2.connection.object_id, pool.connection.object_id
+          refute_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+
+          klass2.remove_connection
+
+          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
+        end
+
+        def test_connection_specification_name_should_fallback_to_parent
+          klassA = Class.new(Base)
+          klassB = Class.new(klassA)
+
+          assert_equal klassB.connection_specification_name, klassA.connection_specification_name
+          klassA.connection_specification_name = "readonly"
+          assert_equal "readonly", klassB.connection_specification_name
+        end
+
+        def test_remove_connection_should_not_remove_parent
+          klass2 = Class.new(Base) { def self.name; 'klass2'; end }
+          klass2.remove_connection
+          refute_nil ActiveRecord::Base.connection.object_id
+          assert_equal klass2.connection.object_id, ActiveRecord::Base.connection.object_id
         end
       end
     end