ibm_db 3.0.5-x86-mingw32 → 4.0.0-x86-mingw32

data/test/cases/comment_test.rb

@@ -0,0 +1,143 @@
+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

@@ -1,54 +1,56 @@
-require "cases/helper"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class AdapterLeasingTest < ActiveRecord::TestCase
-      class Pool < ConnectionPool
-        def insert_connection_for_test!(c)
-          synchronize do
-            @connections << c
-            @available.add c
-          end
-        end
-      end
-
-      def setup
-        @adapter = AbstractAdapter.new nil, nil
-      end
-
-      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'
-      end
-
-      def test_lease_twice
-        assert @adapter.lease, 'should lease adapter'
-        assert_not @adapter.lease, 'should not lease adapter'
-      end
-
-      def test_expire_mutates_in_use
-        assert @adapter.lease, 'lease adapter'
-        assert @adapter.in_use?, 'adapter is in use'
-        @adapter.expire
-        assert_not @adapter.in_use?, 'adapter is in use'
-      end
-
-      def test_close
-        pool = Pool.new(ConnectionSpecification.new({}, nil))
-        pool.insert_connection_for_test! @adapter
-        @adapter.pool = pool
-
-        # Make sure the pool marks the connection in use
-        assert_equal @adapter, pool.connection
-        assert @adapter.in_use?
-
-        # Close should put the adapter back in the pool
-        @adapter.close
-        assert_not @adapter.in_use?
-
-        assert_equal @adapter, pool.connection
-      end
-    end
-  end
-end
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AdapterLeasingTest < ActiveRecord::TestCase
+      class Pool < ConnectionPool
+        def insert_connection_for_test!(c)
+          synchronize do
+            adopt_connection(c)
+            @available.add c
+          end
+        end
+      end
+
+      def setup
+        @adapter = AbstractAdapter.new nil, nil
+      end
+
+      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'
+      end
+
+      def test_lease_twice
+        assert @adapter.lease, 'should lease adapter'
+        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.expire
+        assert_not @adapter.in_use?, 'adapter is in use'
+      end
+
+      def test_close
+        pool = Pool.new(ConnectionSpecification.new("primary", {}, nil))
+        pool.insert_connection_for_test! @adapter
+        @adapter.pool = pool
+
+        # Make sure the pool marks the connection in use
+        assert_equal @adapter, pool.connection
+        assert @adapter.in_use?
+
+        # Close should put the adapter back in the pool
+        @adapter.close
+        assert_not @adapter.in_use?
+
+        assert_equal @adapter, pool.connection
+      end
+    end
+  end
+end

data/test/cases/connection_adapters/connection_handler_test.rb

@@ -1,53 +1,160 @@
-require "cases/helper"
-
-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)
-      end
-
-      def test_retrieve_connection
-        assert @handler.retrieve_connection(@klass)
-      end
-
-      def test_active_connections?
-        assert !@handler.active_connections?
-        assert @handler.retrieve_connection(@klass)
-        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)
-      end
-
-      def test_retrieve_connection_pool
-        assert_not_nil @handler.retrieve_connection_pool(@klass)
-      end
-
-      def test_retrieve_connection_pool_uses_superclass_when_no_subclass_connection
-        assert_not_nil @handler.retrieve_connection_pool(@subklass)
-      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)
-
-        @handler.remove_connection @subklass
-        assert_same @pool, @handler.retrieve_connection_pool(@subklass)
-      end
-
-      def test_connection_pools
-        assert_deprecated do
-          assert_equal({ Base.connection_pool.spec => @pool }, @handler.connection_pools)
-        end
-      end
-    end
-  end
-end
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlerTest < ActiveRecord::TestCase
+      def setup
+        @handler = ConnectionHandler.new
+        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(@spec_name)
+      end
+
+      def test_active_connections?
+        assert !@handler.active_connections?
+        assert @handler.retrieve_connection(@spec_name)
+        assert @handler.active_connections?
+        @handler.clear_active_connections!
+        assert !@handler.active_connections?
+      end
+
+      def test_retrieve_connection_pool
+        assert_not_nil @handler.retrieve_connection_pool(@spec_name)
+      end
+
+      def test_retrieve_connection_pool_with_invalid_id
+        assert_nil @handler.retrieve_connection_pool("foo")
+      end
+
+      def test_connection_pools
+        assert_equal([@pool], @handler.connection_pools)
+      end
+
+      if Process.respond_to?(:fork)
+        def test_connection_pool_per_pid
+          object_id = ActiveRecord::Base.connection.object_id
+
+          rd, wr = IO.pipe
+          rd.binmode
+          wr.binmode
+
+          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
+  end
+end