ibm_db 4.0.0-x86-mingw32 → 5.0.2-x86-mingw32

data/test/cases/adapters/postgresql/change_schema_test.rb

@@ -1,38 +1,38 @@
-require 'cases/helper'
-
-module ActiveRecord
-  class Migration
-    class PGChangeSchemaTest < ActiveRecord::PostgreSQLTestCase
-      attr_reader :connection
-
-      def setup
-        super
-        @connection = ActiveRecord::Base.connection
-        connection.create_table(:strings) do |t|
-          t.string :somedate
-        end
-      end
-
-      def teardown
-        connection.drop_table :strings
-      end
-
-      def test_change_string_to_date
-        connection.change_column :strings, :somedate, :timestamp, using: 'CAST("somedate" AS timestamp)'
-        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
-      end
-
-      def test_change_type_with_symbol
-        connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
-        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
-      end
-
-      def test_change_type_with_array
-        connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
-        column = connection.columns(:strings).find { |c| c.name == 'somedate' }
-        assert_equal :datetime, column.type
-        assert column.array?
-      end
-    end
-  end
-end
+require 'cases/helper'
+
+module ActiveRecord
+  class Migration
+    class PGChangeSchemaTest < ActiveRecord::PostgreSQLTestCase
+      attr_reader :connection
+
+      def setup
+        super
+        @connection = ActiveRecord::Base.connection
+        connection.create_table(:strings) do |t|
+          t.string :somedate
+        end
+      end
+
+      def teardown
+        connection.drop_table :strings
+      end
+
+      def test_change_string_to_date
+        connection.change_column :strings, :somedate, :timestamp, using: 'CAST("somedate" AS timestamp)'
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
+      end
+
+      def test_change_type_with_symbol
+        connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == 'somedate' }.type
+      end
+
+      def test_change_type_with_array
+        connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
+        column = connection.columns(:strings).find { |c| c.name == 'somedate' }
+        assert_equal :datetime, column.type
+        assert column.array?
+      end
+    end
+  end
+end

data/test/cases/adapters/postgresql/cidr_test.rb

@@ -1,25 +1,25 @@
-require "cases/helper"
-require "ipaddr"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
-      class CidrTest < ActiveRecord::PostgreSQLTestCase
-        test "type casting IPAddr for database" do
-          type = OID::Cidr.new
-          ip = IPAddr.new("255.0.0.0/8")
-          ip2 = IPAddr.new("127.0.0.1")
-
-          assert_equal "255.0.0.0/8", type.serialize(ip)
-          assert_equal "127.0.0.1/32", type.serialize(ip2)
-        end
-
-        test "casting does nothing with non-IPAddr objects" do
-          type = OID::Cidr.new
-
-          assert_equal "foo", type.serialize("foo")
-        end
-      end
-    end
-  end
-end
+require "cases/helper"
+require "ipaddr"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      class CidrTest < ActiveRecord::PostgreSQLTestCase
+        test "type casting IPAddr for database" do
+          type = OID::Cidr.new
+          ip = IPAddr.new("255.0.0.0/8")
+          ip2 = IPAddr.new("127.0.0.1")
+
+          assert_equal "255.0.0.0/8", type.serialize(ip)
+          assert_equal "127.0.0.1/32", type.serialize(ip2)
+        end
+
+        test "casting does nothing with non-IPAddr objects" do
+          type = OID::Cidr.new
+
+          assert_equal "foo", type.serialize("foo")
+        end
+      end
+    end
+  end
+end

data/test/cases/adapters/postgresql/citext_test.rb

@@ -1,78 +1,78 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
-
-if ActiveRecord::Base.connection.supports_extensions?
-  class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
-    include SchemaDumpingHelper
-    class Citext < ActiveRecord::Base
-      self.table_name = 'citexts'
-    end
-
-    def setup
-      @connection = ActiveRecord::Base.connection
-
-      enable_extension!('citext', @connection)
-
-      @connection.create_table('citexts') do |t|
-        t.citext 'cival'
-      end
-    end
-
-    teardown do
-      @connection.drop_table 'citexts', if_exists: true
-      disable_extension!('citext', @connection)
-    end
-
-    def test_citext_enabled
-      assert @connection.extension_enabled?('citext')
-    end
-
-    def test_column
-      column = Citext.columns_hash['cival']
-      assert_equal :citext, column.type
-      assert_equal 'citext', column.sql_type
-      assert_not column.array?
-
-      type = Citext.type_for_attribute('cival')
-      assert_not type.binary?
-    end
-
-    def test_change_table_supports_json
-      @connection.transaction do
-        @connection.change_table('citexts') do |t|
-          t.citext 'username'
-        end
-        Citext.reset_column_information
-        column = Citext.columns_hash['username']
-        assert_equal :citext, column.type
-
-        raise ActiveRecord::Rollback # reset the schema change
-      end
-    ensure
-      Citext.reset_column_information
-    end
-
-    def test_write
-      x = Citext.new(cival: 'Some CI Text')
-      x.save!
-      citext = Citext.first
-      assert_equal "Some CI Text", citext.cival
-
-      citext.cival = "Some NEW CI Text"
-      citext.save!
-
-      assert_equal "Some NEW CI Text", citext.reload.cival
-    end
-
-    def test_select_case_insensitive
-      @connection.execute "insert into citexts (cival) values('Cased Text')"
-      x = Citext.where(cival: 'cased text').first
-      assert_equal 'Cased Text', x.cival
-    end
-
-    def test_schema_dump_with_shorthand
-      output = dump_table_schema("citexts")
-      assert_match %r[t\.citext "cival"], output
-    end
-  end
-end
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if ActiveRecord::Base.connection.supports_extensions?
+  class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+    class Citext < ActiveRecord::Base
+      self.table_name = 'citexts'
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.connection
+
+      enable_extension!('citext', @connection)
+
+      @connection.create_table('citexts') do |t|
+        t.citext 'cival'
+      end
+    end
+
+    teardown do
+      @connection.drop_table 'citexts', if_exists: true
+      disable_extension!('citext', @connection)
+    end
+
+    def test_citext_enabled
+      assert @connection.extension_enabled?('citext')
+    end
+
+    def test_column
+      column = Citext.columns_hash['cival']
+      assert_equal :citext, column.type
+      assert_equal 'citext', column.sql_type
+      assert_not column.array?
+
+      type = Citext.type_for_attribute('cival')
+      assert_not type.binary?
+    end
+
+    def test_change_table_supports_json
+      @connection.transaction do
+        @connection.change_table('citexts') do |t|
+          t.citext 'username'
+        end
+        Citext.reset_column_information
+        column = Citext.columns_hash['username']
+        assert_equal :citext, column.type
+
+        raise ActiveRecord::Rollback # reset the schema change
+      end
+    ensure
+      Citext.reset_column_information
+    end
+
+    def test_write
+      x = Citext.new(cival: 'Some CI Text')
+      x.save!
+      citext = Citext.first
+      assert_equal "Some CI Text", citext.cival
+
+      citext.cival = "Some NEW CI Text"
+      citext.save!
+
+      assert_equal "Some NEW CI Text", citext.reload.cival
+    end
+
+    def test_select_case_insensitive
+      @connection.execute "insert into citexts (cival) values('Cased Text')"
+      x = Citext.where(cival: 'cased text').first
+      assert_equal 'Cased Text', x.cival
+    end
+
+    def test_schema_dump_with_shorthand
+      output = dump_table_schema("citexts")
+      assert_match %r[t\.citext "cival"], output
+    end
+  end
+end

data/test/cases/adapters/postgresql/collation_test.rb

@@ -1,53 +1,53 @@
-require "cases/helper"
-require 'support/schema_dumping_helper'
-
-class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
-  include SchemaDumpingHelper
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table :postgresql_collations, force: true do |t|
-      t.string :string_c, collation: 'C'
-      t.text :text_posix, collation: 'POSIX'
-    end
-  end
-
-  def teardown
-    @connection.drop_table :postgresql_collations, if_exists: true
-  end
-
-  test "string column with collation" do
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'string_c' }
-    assert_equal :string, column.type
-    assert_equal 'C', column.collation
-  end
-
-  test "text column with collation" do
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'text_posix' }
-    assert_equal :text, column.type
-    assert_equal 'POSIX', column.collation
-  end
-
-  test "add column with collation" do
-    @connection.add_column :postgresql_collations, :title, :string, collation: 'C'
-
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'title' }
-    assert_equal :string, column.type
-    assert_equal 'C', column.collation
-  end
-
-  test "change column with collation" do
-    @connection.add_column :postgresql_collations, :description, :string
-    @connection.change_column :postgresql_collations, :description, :text, collation: 'POSIX'
-
-    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'description' }
-    assert_equal :text, column.type
-    assert_equal 'POSIX', column.collation
-  end
-
-  test "schema dump includes collation" do
-    output = dump_table_schema("postgresql_collations")
-    assert_match %r{t.string\s+"string_c",\s+collation: "C"$}, output
-    assert_match %r{t.text\s+"text_posix",\s+collation: "POSIX"$}, output
-  end
-end
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :postgresql_collations, force: true do |t|
+      t.string :string_c, collation: 'C'
+      t.text :text_posix, collation: 'POSIX'
+    end
+  end
+
+  def teardown
+    @connection.drop_table :postgresql_collations, if_exists: true
+  end
+
+  test "string column with collation" do
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'string_c' }
+    assert_equal :string, column.type
+    assert_equal 'C', column.collation
+  end
+
+  test "text column with collation" do
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'text_posix' }
+    assert_equal :text, column.type
+    assert_equal 'POSIX', column.collation
+  end
+
+  test "add column with collation" do
+    @connection.add_column :postgresql_collations, :title, :string, collation: 'C'
+
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'title' }
+    assert_equal :string, column.type
+    assert_equal 'C', column.collation
+  end
+
+  test "change column with collation" do
+    @connection.add_column :postgresql_collations, :description, :string
+    @connection.change_column :postgresql_collations, :description, :text, collation: 'POSIX'
+
+    column = @connection.columns(:postgresql_collations).find { |c| c.name == 'description' }
+    assert_equal :text, column.type
+    assert_equal 'POSIX', column.collation
+  end
+
+  test "schema dump includes collation" do
+    output = dump_table_schema("postgresql_collations")
+    assert_match %r{t.string\s+"string_c",\s+collation: "C"$}, output
+    assert_match %r{t.text\s+"text_posix",\s+collation: "POSIX"$}, output
+  end
+end

data/test/cases/adapters/postgresql/composite_test.rb

@@ -1,132 +1,132 @@
-require "cases/helper"
-require 'support/connection_helper'
-
-module PostgresqlCompositeBehavior
-  include ConnectionHelper
-
-  class PostgresqlComposite < ActiveRecord::Base
-    self.table_name = "postgresql_composites"
-  end
-
-  def setup
-    super
-
-    @connection = ActiveRecord::Base.connection
-    @connection.transaction do
-      @connection.execute <<-SQL
-         CREATE TYPE full_address AS
-         (
-             city VARCHAR(90),
-             street VARCHAR(90)
-         );
-        SQL
-      @connection.create_table('postgresql_composites') do |t|
-        t.column :address, :full_address
-      end
-    end
-  end
-
-  def teardown
-    super
-
-    @connection.drop_table 'postgresql_composites', if_exists: true
-    @connection.execute 'DROP TYPE IF EXISTS full_address'
-    reset_connection
-    PostgresqlComposite.reset_column_information
-  end
-end
-
-# Composites are mapped to `OID::Identity` by default. The user is informed by a warning like:
-#   "unknown OID 5653508: failed to recognize type of 'address'. It will be treated as String."
-# To take full advantage of composite types, we suggest you register your own +OID::Type+.
-# See PostgresqlCompositeWithCustomOIDTest
-class PostgresqlCompositeTest < ActiveRecord::PostgreSQLTestCase
-  include PostgresqlCompositeBehavior
-
-  def test_column
-    ensure_warning_is_issued
-
-    column = PostgresqlComposite.columns_hash["address"]
-    assert_nil column.type
-    assert_equal "full_address", column.sql_type
-    assert_not column.array?
-
-    type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
-  end
-
-  def test_composite_mapping
-    ensure_warning_is_issued
-
-    @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
-    composite = PostgresqlComposite.first
-    assert_equal "(Paris,Champs-Élysées)", composite.address
-
-    composite.address = "(Paris,Rue Basse)"
-    composite.save!
-
-    assert_equal '(Paris,"Rue Basse")', composite.reload.address
-  end
-
-  private
-  def ensure_warning_is_issued
-    warning = capture(:stderr) do
-      PostgresqlComposite.columns_hash
-    end
-    assert_match(/unknown OID \d+: failed to recognize type of 'address'\. It will be treated as String\./, warning)
-  end
-end
-
-class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::PostgreSQLTestCase
-  include PostgresqlCompositeBehavior
-
-  class FullAddressType < ActiveRecord::Type::Value
-    def type; :full_address end
-
-    def deserialize(value)
-      if value =~ /\("?([^",]*)"?,"?([^",]*)"?\)/
-        FullAddress.new($1, $2)
-      end
-    end
-
-    def cast(value)
-      value
-    end
-
-    def serialize(value)
-      return if value.nil?
-      "(#{value.city},#{value.street})"
-    end
-  end
-
-  FullAddress = Struct.new(:city, :street)
-
-  def setup
-    super
-
-    @connection.type_map.register_type "full_address", FullAddressType.new
-  end
-
-  def test_column
-    column = PostgresqlComposite.columns_hash["address"]
-    assert_equal :full_address, column.type
-    assert_equal "full_address", column.sql_type
-    assert_not column.array?
-
-    type = PostgresqlComposite.type_for_attribute("address")
-    assert_not type.binary?
-  end
-
-  def test_composite_mapping
-    @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
-    composite = PostgresqlComposite.first
-    assert_equal "Paris", composite.address.city
-    assert_equal "Champs-Élysées", composite.address.street
-
-    composite.address = FullAddress.new("Paris", "Rue Basse")
-    composite.save!
-
-    assert_equal 'Paris', composite.reload.address.city
-    assert_equal 'Rue Basse', composite.reload.address.street
-  end
-end
+require "cases/helper"
+require 'support/connection_helper'
+
+module PostgresqlCompositeBehavior
+  include ConnectionHelper
+
+  class PostgresqlComposite < ActiveRecord::Base
+    self.table_name = "postgresql_composites"
+  end
+
+  def setup
+    super
+
+    @connection = ActiveRecord::Base.connection
+    @connection.transaction do
+      @connection.execute <<-SQL
+         CREATE TYPE full_address AS
+         (
+             city VARCHAR(90),
+             street VARCHAR(90)
+         );
+        SQL
+      @connection.create_table('postgresql_composites') do |t|
+        t.column :address, :full_address
+      end
+    end
+  end
+
+  def teardown
+    super
+
+    @connection.drop_table 'postgresql_composites', if_exists: true
+    @connection.execute 'DROP TYPE IF EXISTS full_address'
+    reset_connection
+    PostgresqlComposite.reset_column_information
+  end
+end
+
+# Composites are mapped to `OID::Identity` by default. The user is informed by a warning like:
+#   "unknown OID 5653508: failed to recognize type of 'address'. It will be treated as String."
+# To take full advantage of composite types, we suggest you register your own +OID::Type+.
+# See PostgresqlCompositeWithCustomOIDTest
+class PostgresqlCompositeTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlCompositeBehavior
+
+  def test_column
+    ensure_warning_is_issued
+
+    column = PostgresqlComposite.columns_hash["address"]
+    assert_nil column.type
+    assert_equal "full_address", column.sql_type
+    assert_not column.array?
+
+    type = PostgresqlComposite.type_for_attribute("address")
+    assert_not type.binary?
+  end
+
+  def test_composite_mapping
+    ensure_warning_is_issued
+
+    @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
+    composite = PostgresqlComposite.first
+    assert_equal "(Paris,Champs-Élysées)", composite.address
+
+    composite.address = "(Paris,Rue Basse)"
+    composite.save!
+
+    assert_equal '(Paris,"Rue Basse")', composite.reload.address
+  end
+
+  private
+  def ensure_warning_is_issued
+    warning = capture(:stderr) do
+      PostgresqlComposite.columns_hash
+    end
+    assert_match(/unknown OID \d+: failed to recognize type of 'address'\. It will be treated as String\./, warning)
+  end
+end
+
+class PostgresqlCompositeWithCustomOIDTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlCompositeBehavior
+
+  class FullAddressType < ActiveRecord::Type::Value
+    def type; :full_address end
+
+    def deserialize(value)
+      if value =~ /\("?([^",]*)"?,"?([^",]*)"?\)/
+        FullAddress.new($1, $2)
+      end
+    end
+
+    def cast(value)
+      value
+    end
+
+    def serialize(value)
+      return if value.nil?
+      "(#{value.city},#{value.street})"
+    end
+  end
+
+  FullAddress = Struct.new(:city, :street)
+
+  def setup
+    super
+
+    @connection.type_map.register_type "full_address", FullAddressType.new
+  end
+
+  def test_column
+    column = PostgresqlComposite.columns_hash["address"]
+    assert_equal :full_address, column.type
+    assert_equal "full_address", column.sql_type
+    assert_not column.array?
+
+    type = PostgresqlComposite.type_for_attribute("address")
+    assert_not type.binary?
+  end
+
+  def test_composite_mapping
+    @connection.execute "INSERT INTO postgresql_composites VALUES (1, ROW('Paris', 'Champs-Élysées'));"
+    composite = PostgresqlComposite.first
+    assert_equal "Paris", composite.address.city
+    assert_equal "Champs-Élysées", composite.address.street
+
+    composite.address = FullAddress.new("Paris", "Rue Basse")
+    composite.save!
+
+    assert_equal 'Paris', composite.reload.address.city
+    assert_equal 'Rue Basse', composite.reload.address.street
+  end
+end