ibm_db 3.0.4 → 5.0.4

data/test/cases/connection_specification/resolver_test.rb

@@ -57,6 +57,12 @@ module ActiveRecord
             "encoding" => "utf8" }, spec)
         end
 
+        def test_url_missing_scheme
+          spec = resolve 'foo'
+          assert_equal({
+            "database" => "foo" }, spec)
+        end
+
         def test_url_host_db
           spec = resolve 'abstract://foo/bar?encoding=utf8'
           assert_equal({
@@ -110,6 +116,15 @@ module ActiveRecord
             "encoding" => "utf8" }, spec)
         end
 
+        def test_spec_name_on_key_lookup
+          spec = spec(:readonly, 'readonly' => {'adapter' => 'sqlite3'})
+          assert_equal "readonly", spec.name
+        end
+
+        def test_spec_name_with_inline_config
+          spec = spec({'adapter' => 'sqlite3'})
+          assert_equal "primary", spec.name, "should default to primary id"
+        end
       end
     end
   end

data/test/cases/counter_cache_test.rb

@@ -1,6 +1,7 @@
 require 'cases/helper'
 require 'models/topic'
 require 'models/car'
+require 'models/aircraft'
 require 'models/wheel'
 require 'models/engine'
 require 'models/reply'
@@ -150,7 +151,7 @@ class CounterCacheTest < ActiveRecord::TestCase
 
   test "reset the right counter if two have the same foreign key" do
     michael = people(:michael)
-    assert_nothing_raised(ActiveRecord::StatementInvalid) do
+    assert_nothing_raised do
       Person.reset_counters(michael.id, :friends_too)
     end
   end
@@ -199,11 +200,15 @@ class CounterCacheTest < ActiveRecord::TestCase
     assert_equal 2, car.reload.engines_count
   end
 
-  test "counter caches are not updated in memory when not selected" do
-    car = Car.select(:id).first
+  test "update counters in a polymorphic relationship" do
+    aircraft = Aircraft.create!
 
-    assert_nothing_raised do
-      car.engines << Engine.new
+    assert_difference 'aircraft.reload.wheels_count' do
+      aircraft.wheels << Wheel.create!
+    end
+
+    assert_difference 'aircraft.reload.wheels_count', -1 do
+      aircraft.wheels.first.destroy
     end
   end
 end

data/test/cases/custom_locking_test.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     fixtures :people
 
     def test_custom_lock
-      if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+      if current_adapter?(:Mysql2Adapter)
         assert_match 'SHARE MODE', Person.lock('LOCK IN SHARE MODE').to_sql
         assert_sql(/LOCK IN SHARE MODE/) do
           Person.all.merge!(:lock => 'LOCK IN SHARE MODE').find(1)

data/test/cases/database_statements_test.rb

@@ -6,14 +6,29 @@ class DatabaseStatementsTest < ActiveRecord::TestCase
   end
 
   def test_insert_should_return_the_inserted_id
+    assert_not_nil return_the_inserted_id(method: :insert)
+  end
+
+  def test_create_should_return_the_inserted_id
+    assert_not_nil return_the_inserted_id(method: :create)
+  end
+
+  def test_insert_update_delete_sql_is_deprecated
+    assert_deprecated { @connection.insert_sql("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)") }
+    assert_deprecated { @connection.update_sql("UPDATE accounts SET credit_limit = 6000 WHERE firm_id = 42") }
+    assert_deprecated { @connection.delete_sql("DELETE FROM accounts WHERE firm_id = 42") }
+  end
+
+  private
+
+  def return_the_inserted_id(method:)
     # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
     if current_adapter?(:OracleAdapter)
       sequence_name = "accounts_seq"
       id_value = @connection.next_sequence_value(sequence_name)
-      id = @connection.insert("INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
+      @connection.send(method, "INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
     else
-      id = @connection.insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
+      @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
     end
-    assert_not_nil id
   end
 end

data/test/cases/{invalid_date_test.rb → date_test.rb}

@@ -1,7 +1,19 @@
 require 'cases/helper'
 require 'models/topic'
 
-class InvalidDateTest < ActiveRecord::TestCase
+class DateTest < ActiveRecord::TestCase
+  def test_date_with_time_value
+    time_value = Time.new(2016, 05, 11, 19, 0, 0)
+    topic = Topic.create(last_read: time_value)
+    assert_equal topic, Topic.find_by(last_read: time_value)
+  end
+
+  def test_date_with_string_value
+    string_value = '2016-05-11 19:00:00'
+    topic = Topic.create(last_read: string_value)
+    assert_equal topic, Topic.find_by(last_read: string_value)
+  end
+
   def test_assign_valid_dates
     valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
 

data/test/cases/date_time_precision_test.rb

@@ -0,0 +1,107 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if subsecond_precision_supported?
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  class Foo < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    Foo.reset_column_information
+  end
+
+  teardown do
+    @connection.drop_table :foos
+	#, if_exists: true
+  end
+
+  def test_datetime_data_type_with_precision
+    @connection.create_table(:foos, force: true)
+    @connection.add_column :foos, :created_at, :datetime, precision: 0
+    @connection.add_column :foos, :updated_at, :datetime, precision: 5
+    assert_equal 0, Foo.columns_hash['created_at'].precision
+    assert_equal 5, Foo.columns_hash['updated_at'].precision
+  end
+
+  def test_datetime_precision_is_truncated_on_assignment
+    @connection.create_table(:foos, force: true)
+    @connection.add_column :foos, :created_at,  :datetime, precision: 0
+    @connection.add_column :foos, :updated_at, :datetime, precision: 6
+
+    time = ::Time.now.change(nsec: 123456789)
+    foo = Foo.new(created_at: time, updated_at: time)
+
+    assert_equal 0, foo.created_at.nsec
+    assert_equal 123456000, foo.updated_at.nsec
+
+    foo.save!
+    foo.reload
+
+    assert_equal 0, foo.created_at.nsec
+    assert_equal 123456000, foo.updated_at.nsec
+  end
+
+  def test_timestamps_helper_with_custom_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps precision: 4
+    end
+    assert_equal 4, Foo.columns_hash['created_at'].precision
+    assert_equal 4, Foo.columns_hash['updated_at'].precision
+  end
+
+  def test_passing_precision_to_datetime_does_not_set_limit
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps precision: 4
+    end
+    assert_nil Foo.columns_hash['created_at'].limit
+    assert_nil Foo.columns_hash['updated_at'].limit
+  end
+
+  def test_invalid_datetime_precision_raises_error
+    assert_raises ActiveRecord::ActiveRecordError do
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 7
+      end
+    end
+  end
+
+  def test_formatting_datetime_according_to_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.datetime :created_at, precision: 0
+      t.datetime :updated_at, precision: 4
+    end
+    date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+    Foo.create!(created_at: date, updated_at: date)
+    assert foo = Foo.find_by(created_at: date)
+    assert_equal 1, Foo.where(updated_at: date).count
+    assert_equal date.to_s, foo.created_at.to_s
+    assert_equal date.to_s, foo.updated_at.to_s
+    assert_equal 000000, foo.created_at.usec
+    assert_equal 999900, foo.updated_at.usec
+  end
+
+  def test_schema_dump_includes_datetime_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps precision: 6
+    end
+    output = dump_table_schema("foos")
+    assert_match %r{t\.datetime\s+"created_at",\s+precision: 6,\s+null: false$}, output
+    assert_match %r{t\.datetime\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+  end
+
+  if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+    def test_datetime_precision_with_zero_should_be_dumped
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 0
+      end
+      output = dump_table_schema("foos")
+      assert_match %r{t\.datetime\s+"created_at",\s+precision: 0,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+precision: 0,\s+null: false$}, output
+    end
+  end
+
+end
+end

data/test/cases/defaults_test.rb

@@ -1,46 +1,60 @@
 require "cases/helper"
+require 'support/schema_dumping_helper'
 require 'models/default'
 require 'models/entrant'
 
 class DefaultTest < ActiveRecord::TestCase
   def test_nil_defaults_for_not_null_columns
-    column_defaults =
-      if current_adapter?(:MysqlAdapter) && (Mysql.client_version < 50051 || (50100..50122).include?(Mysql.client_version))
-        { 'id' => nil, 'name' => '',  'course_id' => nil }
-      else
-        { 'id' => nil, 'name' => nil, 'course_id' => nil }
-      end
-
-    column_defaults.each do |name, default|
+    %w(id name course_id).each do |name|
       column = Entrant.columns_hash[name]
       assert !column.null, "#{name} column should be NOT NULL"
-      assert_equal default, column.default, "#{name} column should be DEFAULT #{default.inspect}"
-    end
-  end
-
-  if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-    def test_default_integers
-      default = Default.new
-      assert_instance_of Fixnum, default.positive_integer
-      assert_equal 1, default.positive_integer
-      assert_instance_of Fixnum, default.negative_integer
-      assert_equal(-1, default.negative_integer)
-      assert_instance_of BigDecimal, default.decimal_number
-      assert_equal BigDecimal.new("2.78"), default.decimal_number
+      assert_not column.default, "#{name} column should be DEFAULT 'nil'"
     end
   end
 
   if current_adapter?(:PostgreSQLAdapter)
     def test_multiline_default_text
+      record = Default.new
       # older postgres versions represent the default with escapes ("\\012" for a newline)
-      assert( "--- []\n\n" == Default.columns_hash['multiline_default'].default ||
-               "--- []\\012\\012" == Default.columns_hash['multiline_default'].default)
+      assert("--- []\n\n" == record.multiline_default || "--- []\\012\\012" == record.multiline_default)
     end
+  end
+end
+
+class DefaultNumbersTest < ActiveRecord::TestCase
+  class DefaultNumber < ActiveRecord::Base; end
 
-    def test_default_negative_integer
-      assert_equal "-1", Default.columns_hash['negative_integer'].default
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :default_numbers do |t|
+      t.integer :positive_integer, default: 7
+      t.integer :negative_integer, default: -5
+      t.decimal :decimal_number, default: "2.78", precision: 5, scale: 2
     end
   end
+
+  teardown do
+    @connection.drop_table :default_numbers
+	#, if_exists: true
+  end
+
+  def test_default_positive_integer
+    record = DefaultNumber.new
+    assert_equal 7, record.positive_integer
+    assert_equal "7", record.positive_integer_before_type_cast
+  end
+
+  def test_default_negative_integer
+    record = DefaultNumber.new
+    assert_equal (-5), record.negative_integer
+    assert_equal "-5", record.negative_integer_before_type_cast
+  end
+
+  def test_default_decimal_number
+    record = DefaultNumber.new
+    assert_equal BigDecimal.new("2.78"), record.decimal_number
+    assert_equal "2.78", record.decimal_number_before_type_cast
+  end
 end
 
 class DefaultStringsTest < ActiveRecord::TestCase
@@ -68,17 +82,42 @@ class DefaultStringsTest < ActiveRecord::TestCase
   end
 end
 
-if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+if current_adapter?(:PostgreSQLAdapter)
+  class PostgresqlDefaultExpressionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    test "schema dump includes default expression" do
+      output = dump_table_schema("defaults")
+      assert_match %r/t\.date\s+"modified_date",\s+default: -> { "\('now'::text\)::date" }/, output
+      assert_match %r/t\.date\s+"modified_date_function",\s+default: -> { "now\(\)" }/, output
+      assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "now\(\)" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
+    end
+  end
+end
+
+if current_adapter?(:Mysql2Adapter)
+  class MysqlDefaultExpressionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    if ActiveRecord::Base.connection.version >= '5.6.0'
+      test "schema dump includes default expression" do
+        output = dump_table_schema("datetime_defaults")
+        assert_match %r/t\.datetime\s+"modified_datetime",\s+default: -> { "CURRENT_TIMESTAMP" }/, output
+      end
+    end
+  end
+
   class DefaultsTestWithoutTransactionalFixtures < ActiveRecord::TestCase
     # ActiveRecord::Base#create! (and #save and other related methods) will
-    # open a new transaction. When in transactional fixtures mode, this will
+    # open a new transaction. When in transactional tests mode, this will
     # cause Active Record to create a new savepoint. However, since MySQL doesn't
     # support DDL transactions, creating a table will result in any created
     # savepoints to be automatically released. This in turn causes the savepoint
     # release code in AbstractAdapter#transaction to fail.
     #
-    # We don't want that to happen, so we disable transactional fixtures here.
-    self.use_transactional_fixtures = false
+    # We don't want that to happen, so we disable transactional tests here.
+    self.use_transactional_tests = false
 
     def using_strict(strict)
       connection = ActiveRecord::Base.remove_connection
@@ -103,19 +142,21 @@ if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
     def test_mysql_text_not_null_defaults_non_strict
       using_strict(false) do
         with_text_blob_not_null_table do |klass|
-          assert_equal '', klass.columns_hash['non_null_blob'].default
-          assert_equal '', klass.columns_hash['non_null_text'].default
+          record = klass.new
+          assert_equal '', record.non_null_blob
+          assert_equal '', record.non_null_text
 
-          assert_nil klass.columns_hash['null_blob'].default
-          assert_nil klass.columns_hash['null_text'].default
+          assert_nil record.null_blob
+          assert_nil record.null_text
 
-          instance = klass.create!
+          record.save!
+          record.reload
 
-          assert_equal '', instance.non_null_text
-          assert_equal '', instance.non_null_blob
+          assert_equal '', record.non_null_text
+          assert_equal '', record.non_null_blob
 
-          assert_nil instance.null_text
-          assert_nil instance.null_blob
+          assert_nil record.null_text
+          assert_nil record.null_blob
         end
       end
     end
@@ -123,10 +164,11 @@ if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
     def test_mysql_text_not_null_defaults_strict
       using_strict(true) do
         with_text_blob_not_null_table do |klass|
-          assert_nil klass.columns_hash['non_null_blob'].default
-          assert_nil klass.columns_hash['non_null_text'].default
-          assert_nil klass.columns_hash['null_blob'].default
-          assert_nil klass.columns_hash['null_text'].default
+          record = klass.new
+          assert_nil record.non_null_blob
+          assert_nil record.non_null_text
+          assert_nil record.null_blob
+          assert_nil record.null_text
 
           assert_raises(ActiveRecord::StatementInvalid) { klass.create }
         end
@@ -160,8 +202,7 @@ if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
 
       assert_equal '0', klass.columns_hash['zero'].default
       assert !klass.columns_hash['zero'].null
-      # 0 in MySQL 4, nil in 5.
-      assert [0, nil].include?(klass.columns_hash['omit'].default)
+      assert_equal nil, klass.columns_hash['omit'].default
       assert !klass.columns_hash['omit'].null
 
       assert_raise(ActiveRecord::StatementInvalid) { klass.create! }
@@ -176,48 +217,3 @@ if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
     end
   end
 end
-
-if current_adapter?(:PostgreSQLAdapter)
-  class DefaultsUsingMultipleSchemasAndDomainTest < ActiveSupport::TestCase
-    def setup
-      @connection = ActiveRecord::Base.connection
-
-      @old_search_path = @connection.schema_search_path
-      @connection.schema_search_path = "schema_1, pg_catalog"
-      @connection.create_table "defaults" do |t|
-        t.text "text_col", :default => "some value"
-        t.string "string_col", :default => "some value"
-      end
-      Default.reset_column_information
-    end
-
-    def test_text_defaults_in_new_schema_when_overriding_domain
-      assert_equal "some value", Default.new.text_col, "Default of text column was not correctly parse"
-    end
-
-    def test_string_defaults_in_new_schema_when_overriding_domain
-      assert_equal "some value", Default.new.string_col, "Default of string column was not correctly parse"
-    end
-
-    def test_bpchar_defaults_in_new_schema_when_overriding_domain
-      @connection.execute "ALTER TABLE defaults ADD bpchar_col bpchar DEFAULT 'some value'"
-      Default.reset_column_information
-      assert_equal "some value", Default.new.bpchar_col, "Default of bpchar column was not correctly parse"
-    end
-
-    def test_text_defaults_after_updating_column_default
-      @connection.execute "ALTER TABLE defaults ALTER COLUMN text_col SET DEFAULT 'some text'::schema_1.text"
-      assert_equal "some text", Default.new.text_col, "Default of text column was not correctly parse after updating default using '::text' since postgreSQL will add parens to the default in db"
-    end
-
-    def test_default_containing_quote_and_colons
-      @connection.execute "ALTER TABLE defaults ALTER COLUMN string_col SET DEFAULT 'foo''::bar'"
-      assert_equal "foo'::bar", Default.new.string_col
-    end
-
-    teardown do
-      @connection.schema_search_path = @old_search_path
-      Default.reset_column_information
-    end
-  end
-end