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

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

@@ -1,154 +1,154 @@
-require "cases/helper"
-require 'support/schema_dumping_helper'
-
-class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
-  include SchemaDumpingHelper
-
-  class PostgresqlSerial < ActiveRecord::Base; end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table "postgresql_serials", force: true do |t|
-      t.serial :seq
-      t.integer :serials_id, default: -> { "nextval('postgresql_serials_id_seq')" }
-    end
-  end
-
-  teardown do
-    @connection.drop_table "postgresql_serials", if_exists: true
-  end
-
-  def test_serial_column
-    column = PostgresqlSerial.columns_hash["seq"]
-    assert_equal :integer, column.type
-    assert_equal "integer", column.sql_type
-    assert column.serial?
-  end
-
-  def test_not_serial_column
-    column = PostgresqlSerial.columns_hash["serials_id"]
-    assert_equal :integer, column.type
-    assert_equal "integer", column.sql_type
-    assert_not column.serial?
-  end
-
-  def test_schema_dump_with_shorthand
-    output = dump_table_schema "postgresql_serials"
-    assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
-  end
-
-  def test_schema_dump_with_not_serial
-    output = dump_table_schema "postgresql_serials"
-    assert_match %r{t\.integer\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_serials_id_seq'::regclass\)" \}$}, output
-  end
-end
-
-class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
-  include SchemaDumpingHelper
-
-  class PostgresqlBigSerial < ActiveRecord::Base; end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table "postgresql_big_serials", force: true do |t|
-      t.bigserial :seq
-      t.bigint :serials_id, default: -> { "nextval('postgresql_big_serials_id_seq')" }
-    end
-  end
-
-  teardown do
-    @connection.drop_table "postgresql_big_serials", if_exists: true
-  end
-
-  def test_bigserial_column
-    column = PostgresqlBigSerial.columns_hash["seq"]
-    assert_equal :integer, column.type
-    assert_equal "bigint", column.sql_type
-    assert column.serial?
-  end
-
-  def test_not_bigserial_column
-    column = PostgresqlBigSerial.columns_hash["serials_id"]
-    assert_equal :integer, column.type
-    assert_equal "bigint", column.sql_type
-    assert_not column.serial?
-  end
-
-  def test_schema_dump_with_shorthand
-    output = dump_table_schema "postgresql_big_serials"
-    assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
-  end
-
-  def test_schema_dump_with_not_bigserial
-    output = dump_table_schema "postgresql_big_serials"
-    assert_match %r{t\.bigint\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_big_serials_id_seq'::regclass\)" \}$}, output
-  end
-end
-
-module SequenceNameDetectionTestCases
-  class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
-    include SchemaDumpingHelper
-
-    def setup
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table :foo_bar, force: true do |t|
-        t.serial :baz_id
-      end
-      @connection.create_table :foo, force: true do |t|
-        t.serial :bar_id
-        t.bigserial :bar_baz_id
-      end
-    end
-
-    def teardown
-      @connection.drop_table :foo_bar, if_exists: true
-      @connection.drop_table :foo, if_exists: true
-    end
-
-    def test_serial_columns
-      columns = @connection.columns(:foo)
-      columns.each do |column|
-        assert_equal :integer, column.type
-        assert column.serial?
-      end
-    end
-
-    def test_schema_dump_with_collided_sequence_name
-      output = dump_table_schema "foo"
-      assert_match %r{t\.serial\s+"bar_id",\s+null: false$}, output
-      assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
-    end
-  end
-
-  class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
-    include SchemaDumpingHelper
-
-    def setup
-      @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table @table_name, force: true do |t|
-        t.serial :seq
-        t.bigserial :bigseq
-      end
-    end
-
-    def teardown
-      @connection.drop_table @table_name, if_exists: true
-    end
-
-    def test_serial_columns
-      columns = @connection.columns(@table_name)
-      columns.each do |column|
-        assert_equal :integer, column.type
-        assert column.serial?
-      end
-    end
-
-    def test_schema_dump_with_long_table_name
-      output = dump_table_schema @table_name
-      assert_match %r{create_table "#{@table_name}", force: :cascade}, output
-      assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
-      assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
-    end
-  end
-end
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class PostgresqlSerial < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table "postgresql_serials", force: true do |t|
+      t.serial :seq
+      t.integer :serials_id, default: -> { "nextval('postgresql_serials_id_seq')" }
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_serials", if_exists: true
+  end
+
+  def test_serial_column
+    column = PostgresqlSerial.columns_hash["seq"]
+    assert_equal :integer, column.type
+    assert_equal "integer", column.sql_type
+    assert column.serial?
+  end
+
+  def test_not_serial_column
+    column = PostgresqlSerial.columns_hash["serials_id"]
+    assert_equal :integer, column.type
+    assert_equal "integer", column.sql_type
+    assert_not column.serial?
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema "postgresql_serials"
+    assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
+  end
+
+  def test_schema_dump_with_not_serial
+    output = dump_table_schema "postgresql_serials"
+    assert_match %r{t\.integer\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_serials_id_seq'::regclass\)" \}$}, output
+  end
+end
+
+class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  class PostgresqlBigSerial < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table "postgresql_big_serials", force: true do |t|
+      t.bigserial :seq
+      t.bigint :serials_id, default: -> { "nextval('postgresql_big_serials_id_seq')" }
+    end
+  end
+
+  teardown do
+    @connection.drop_table "postgresql_big_serials", if_exists: true
+  end
+
+  def test_bigserial_column
+    column = PostgresqlBigSerial.columns_hash["seq"]
+    assert_equal :integer, column.type
+    assert_equal "bigint", column.sql_type
+    assert column.serial?
+  end
+
+  def test_not_bigserial_column
+    column = PostgresqlBigSerial.columns_hash["serials_id"]
+    assert_equal :integer, column.type
+    assert_equal "bigint", column.sql_type
+    assert_not column.serial?
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema "postgresql_big_serials"
+    assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+  end
+
+  def test_schema_dump_with_not_bigserial
+    output = dump_table_schema "postgresql_big_serials"
+    assert_match %r{t\.bigint\s+"serials_id",\s+default: -> \{ "nextval\('postgresql_big_serials_id_seq'::regclass\)" \}$}, output
+  end
+end
+
+module SequenceNameDetectionTestCases
+  class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @connection = ActiveRecord::Base.connection
+      @connection.create_table :foo_bar, force: true do |t|
+        t.serial :baz_id
+      end
+      @connection.create_table :foo, force: true do |t|
+        t.serial :bar_id
+        t.bigserial :bar_baz_id
+      end
+    end
+
+    def teardown
+      @connection.drop_table :foo_bar, if_exists: true
+      @connection.drop_table :foo, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(:foo)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert column.serial?
+      end
+    end
+
+    def test_schema_dump_with_collided_sequence_name
+      output = dump_table_schema "foo"
+      assert_match %r{t\.serial\s+"bar_id",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
+    end
+  end
+
+  class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    def setup
+      @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
+      @connection = ActiveRecord::Base.connection
+      @connection.create_table @table_name, force: true do |t|
+        t.serial :seq
+        t.bigserial :bigseq
+      end
+    end
+
+    def teardown
+      @connection.drop_table @table_name, if_exists: true
+    end
+
+    def test_serial_columns
+      columns = @connection.columns(@table_name)
+      columns.each do |column|
+        assert_equal :integer, column.type
+        assert column.serial?
+      end
+    end
+
+    def test_schema_dump_with_long_table_name
+      output = dump_table_schema @table_name
+      assert_match %r{create_table "#{@table_name}", force: :cascade}, output
+      assert_match %r{t\.serial\s+"seq",\s+null: false$}, output
+      assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
+    end
+  end
+end

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

@@ -1,41 +1,41 @@
-require 'cases/helper'
-
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
-      class InactivePgConnection
-        def query(*args)
-          raise PG::Error
-        end
-
-        def status
-          PG::CONNECTION_BAD
-        end
-      end
-
-      class StatementPoolTest < ActiveRecord::PostgreSQLTestCase
-        if Process.respond_to?(:fork)
-          def test_cache_is_per_pid
-            cache = StatementPool.new nil, 10
-            cache['foo'] = 'bar'
-            assert_equal 'bar', cache['foo']
-
-            pid = fork {
-              lookup = cache['foo'];
-              exit!(!lookup)
-            }
-
-            Process.waitpid pid
-            assert $?.success?, 'process should exit successfully'
-          end
-        end
-
-        def test_dealloc_does_not_raise_on_inactive_connection
-          cache = StatementPool.new InactivePgConnection.new, 10
-          cache['foo'] = 'bar'
-          assert_nothing_raised { cache.clear }
-        end
-      end
-    end
-  end
-end
+require 'cases/helper'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      class InactivePgConnection
+        def query(*args)
+          raise PG::Error
+        end
+
+        def status
+          PG::CONNECTION_BAD
+        end
+      end
+
+      class StatementPoolTest < ActiveRecord::PostgreSQLTestCase
+        if Process.respond_to?(:fork)
+          def test_cache_is_per_pid
+            cache = StatementPool.new nil, 10
+            cache['foo'] = 'bar'
+            assert_equal 'bar', cache['foo']
+
+            pid = fork {
+              lookup = cache['foo'];
+              exit!(!lookup)
+            }
+
+            Process.waitpid pid
+            assert $?.success?, 'process should exit successfully'
+          end
+        end
+
+        def test_dealloc_does_not_raise_on_inactive_connection
+          cache = StatementPool.new InactivePgConnection.new, 10
+          cache['foo'] = 'bar'
+          assert_nothing_raised { cache.clear }
+        end
+      end
+    end
+  end
+end

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

@@ -1,90 +1,90 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/topic'
-
-class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
-  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
-
-  self.use_transactional_tests = false
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
-  end
-
-  teardown do
-    PostgresqlTimestampWithZone.delete_all
-  end
-
-  def test_timestamp_with_zone_values_with_rails_time_zone_support
-    with_timezone_config default: :utc, aware_attributes: true do
-      @connection.reconnect!
-
-      timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
-      assert_instance_of Time, timestamp.time
-    end
-  ensure
-    @connection.reconnect!
-  end
-
-  def test_timestamp_with_zone_values_without_rails_time_zone_support
-    with_timezone_config default: :local, aware_attributes: false do
-      @connection.reconnect!
-      # make sure to use a non-UTC time zone
-      @connection.execute("SET time zone 'America/Jamaica'", 'SCHEMA')
-
-      timestamp = PostgresqlTimestampWithZone.find(1)
-      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
-      assert_instance_of Time, timestamp.time
-    end
-  ensure
-    @connection.reconnect!
-  end
-end
-
-class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
-  fixtures :topics
-
-  def test_group_by_date
-    keys = Topic.group("date_trunc('month', created_at)").count.keys
-    assert_operator keys.length, :>, 0
-    keys.each { |k| assert_kind_of Time, k }
-  end
-
-  def test_load_infinity_and_beyond
-    d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
-    assert d.first.updated_at.infinite?, 'timestamp should be infinite'
-
-    d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
-    time = d.first.updated_at
-    assert time.infinite?, 'timestamp should be infinite'
-    assert_operator time, :<, 0
-  end
-
-  def test_save_infinity_and_beyond
-    d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
-    assert_equal(1.0 / 0.0, d.updated_at)
-
-    d = Developer.create!(:name => 'aaron', :updated_at => -1.0 / 0.0)
-    assert_equal(-1.0 / 0.0, d.updated_at)
-  end
-
-  def test_bc_timestamp
-    date = Date.new(0) - 1.week
-    Developer.create!(:name => "aaron", :updated_at => date)
-    assert_equal date, Developer.find_by_name("aaron").updated_at
-  end
-
-  def test_bc_timestamp_leap_year
-    date = Time.utc(-4, 2, 29)
-    Developer.create!(:name => "taihou", :updated_at => date)
-    assert_equal date, Developer.find_by_name("taihou").updated_at
-  end
-
-  def test_bc_timestamp_year_zero
-    date = Time.utc(0, 4, 7)
-    Developer.create!(:name => "yahagi", :updated_at => date)
-    assert_equal date, Developer.find_by_name("yahagi").updated_at
-  end
-end
+require 'cases/helper'
+require 'models/developer'
+require 'models/topic'
+
+class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support
+    with_timezone_config default: :utc, aware_attributes: true do
+      @connection.reconnect!
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_instance_of Time, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+
+  def test_timestamp_with_zone_values_without_rails_time_zone_support
+    with_timezone_config default: :local, aware_attributes: false do
+      @connection.reconnect!
+      # make sure to use a non-UTC time zone
+      @connection.execute("SET time zone 'America/Jamaica'", 'SCHEMA')
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010,1,1, 11,0,0), timestamp.time
+      assert_instance_of Time, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
+  fixtures :topics
+
+  def test_group_by_date
+    keys = Topic.group("date_trunc('month', created_at)").count.keys
+    assert_operator keys.length, :>, 0
+    keys.each { |k| assert_kind_of Time, k }
+  end
+
+  def test_load_infinity_and_beyond
+    d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
+    assert d.first.updated_at.infinite?, 'timestamp should be infinite'
+
+    d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
+    time = d.first.updated_at
+    assert time.infinite?, 'timestamp should be infinite'
+    assert_operator time, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, d.updated_at)
+
+    d = Developer.create!(:name => 'aaron', :updated_at => -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, d.updated_at)
+  end
+
+  def test_bc_timestamp
+    date = Date.new(0) - 1.week
+    Developer.create!(:name => "aaron", :updated_at => date)
+    assert_equal date, Developer.find_by_name("aaron").updated_at
+  end
+
+  def test_bc_timestamp_leap_year
+    date = Time.utc(-4, 2, 29)
+    Developer.create!(:name => "taihou", :updated_at => date)
+    assert_equal date, Developer.find_by_name("taihou").updated_at
+  end
+
+  def test_bc_timestamp_year_zero
+    date = Time.utc(0, 4, 7)
+    Developer.create!(:name => "yahagi", :updated_at => date)
+    assert_equal date, Developer.find_by_name("yahagi").updated_at
+  end
+end