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

data/test/cases/persistence_test.rb

@@ -17,7 +17,10 @@ require 'models/minivan'
 require 'models/owner'
 require 'models/person'
 require 'models/pet'
+require 'models/ship'
 require 'models/toy'
+require 'models/admin'
+require 'models/admin/user'
 require 'rexml/document'
 
 class PersistenceTest < ActiveRecord::TestCase
@@ -42,8 +45,7 @@ class PersistenceTest < ActiveRecord::TestCase
         end
       end
 
-      if !current_adapter?(:IBM_DBAdapter) && test_update_with_order_succeeds.call('id DESC')
-        # The update below goes on successfully in DB2.
+      if test_update_with_order_succeeds.call('id DESC')
         assert !test_update_with_order_succeeds.call('id ASC') # test that this wasn't a fluke and using an incorrect order results in an exception
       else
         # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
@@ -120,15 +122,24 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_equal 59, accounts(:signals37, :reload).credit_limit
   end
 
+  def test_increment_updates_counter_in_db_using_offset
+    a1 = accounts(:signals37)
+    initial_credit = a1.credit_limit
+    a2 = Account.find(accounts(:signals37).id)
+    a1.increment!(:credit_limit)
+    a2.increment!(:credit_limit)
+    assert_equal initial_credit + 2, a1.reload.credit_limit
+  end
+
   def test_destroy_all
     conditions = "author_name = 'Mary'"
     topics_by_mary = Topic.all.merge!(:where => conditions, :order => 'id').to_a
     assert ! topics_by_mary.empty?
 
     assert_difference('Topic.count', -topics_by_mary.size) do
-      destroyed = Topic.destroy_all(conditions).sort_by(&:id)
+      destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
       assert_equal topics_by_mary, destroyed
-      assert destroyed.all? { |topic| topic.frozen? }, "destroyed topics should be frozen"
+      assert destroyed.all?(&:frozen?), "destroyed topics should be frozen"
     end
   end
 
@@ -138,7 +149,7 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_difference('Client.count', -2) do
       destroyed = Client.destroy([2, 3]).sort_by(&:id)
       assert_equal clients, destroyed
-      assert destroyed.all? { |client| client.frozen? }, "destroyed clients should be frozen"
+      assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
     end
   end
 
@@ -152,10 +163,27 @@ class PersistenceTest < ActiveRecord::TestCase
     assert !company.valid?
     original_errors = company.errors
     client = company.becomes(Client)
-    assert_equal original_errors, client.errors
+    assert_equal original_errors.keys, client.errors.keys
+  end
+
+  def test_becomes_errors_base
+    child_class = Class.new(Admin::User) do
+      store_accessor :settings, :foo
+
+      def self.name; 'Admin::ChildUser'; end
+    end
+
+    admin = Admin::User.new
+    admin.errors.add :token, :invalid
+    child = admin.becomes(child_class)
+
+    assert_equal [:token], child.errors.keys
+    assert_nothing_raised do
+      child.errors.add :foo, :invalid
+    end
   end
 
-  def test_dupd_becomes_persists_changes_from_the_original
+  def test_duped_becomes_persists_changes_from_the_original
     original = topics(:first)
     copy = original.dup.becomes(Reply)
     copy.save!
@@ -253,8 +281,10 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_create_columns_not_equal_attributes
     topic = Topic.instantiate(
-      'title'          => 'Another New Topic',
-      'does_not_exist' => 'test'
+      'attributes' => {
+        'title'          => 'Another New Topic',
+        'does_not_exist' => 'test'
+      }
     )
     assert_nothing_raised { topic.save }
   end
@@ -355,6 +385,22 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_equal("David", topic_reloaded.author_name)
   end
 
+  def test_update_attribute_does_not_run_sql_if_attribute_is_not_changed
+    klass = Class.new(Topic) do
+      def self.name; 'Topic'; end
+    end
+    topic = klass.create(title: 'Another New Topic')
+    assert_queries(0) do
+      assert topic.update_attribute(:title, "Another New Topic")
+    end
+  end
+
+  def test_update_does_not_run_sql_if_record_has_not_changed
+    topic = Topic.create(title: "Another New Topic")
+    assert_queries(0) { assert topic.update(title: "Another New Topic") }
+    assert_queries(0) { assert topic.update_attributes(title: "Another New Topic") }
+  end
+
   def test_delete
     topic = Topic.find(1)
     assert_equal topic, topic.delete, 'topic.delete did not return self'
@@ -717,9 +763,10 @@ class PersistenceTest < ActiveRecord::TestCase
     assert !topic.approved?
     assert_equal "The First Topic", topic.title
 
-    assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
+    error = assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
       topic.update_attributes(id: 3, title: "Hm is it possible?")
     end
+    assert_not_nil error.cause
     assert_not_equal "Hm is it possible?", Topic.find(3).title
 
     topic.update_attributes(id: 1234)
@@ -906,4 +953,49 @@ class PersistenceTest < ActiveRecord::TestCase
   ensure
     ActiveRecord::Base.connection.disable_query_cache!
   end
+
+  class SaveTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def test_save_touch_false
+      widget = Class.new(ActiveRecord::Base) do
+        connection.create_table :widgets, force: true do |t|
+          t.string :name
+          t.timestamps null: false
+        end
+
+        self.table_name = :widgets
+      end
+
+      instance  = widget.create!({
+        name: 'Bob',
+        created_at: 1.day.ago,
+        updated_at: 1.day.ago
+      })
+
+      created_at = instance.created_at
+      updated_at = instance.updated_at
+
+      instance.name = 'Barb'
+      instance.save!(touch: false)
+      assert_equal instance.created_at, created_at
+      assert_equal instance.updated_at, updated_at
+    ensure
+      ActiveRecord::Base.connection.drop_table widget.table_name
+      widget.reset_column_information
+    end
+  end
+
+  def test_reset_column_information_resets_children
+    child = Class.new(Topic)
+    child.new # force schema to load
+
+    ActiveRecord::Base.connection.add_column(:topics, :foo, :string)
+    Topic.reset_column_information
+
+    assert_equal "bar", child.new(foo: :bar).foo
+  ensure
+    ActiveRecord::Base.connection.remove_column(:topics, :foo)
+    Topic.reset_column_information
+  end
 end

data/test/cases/pooled_connections_test.rb

@@ -3,7 +3,7 @@ require "models/project"
 require "timeout"
 
 class PooledConnectionsTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   def setup
     @per_test_teardown = []
@@ -13,7 +13,7 @@ class PooledConnectionsTest < ActiveRecord::TestCase
   teardown do
     ActiveRecord::Base.clear_all_connections!
     ActiveRecord::Base.establish_connection(@connection)
-    @per_test_teardown.each {|td| td.call }
+    @per_test_teardown.each(&:call)
   end
 
   # Will deadlock due to lack of Monitor timeouts in 1.9
@@ -44,7 +44,7 @@ class PooledConnectionsTest < ActiveRecord::TestCase
         conn = ActiveRecord::Base.connection_pool.checkout
         ActiveRecord::Base.connection_pool.checkin conn
         @connection_count += 1
-        ActiveRecord::Base.connection.tables
+        ActiveRecord::Base.connection.data_sources
       rescue ActiveRecord::ConnectionTimeoutError
         @timed_out += 1
       end

data/test/cases/primary_keys_test.rb

@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'support/schema_dumping_helper'
 require 'models/topic'
 require 'models/reply'
 require 'models/subscriber'
@@ -6,6 +7,7 @@ require 'models/movie'
 require 'models/keyboard'
 require 'models/mixed_case_monkey'
 require 'models/dashboard'
+require 'models/non_primary_key'
 
 class PrimaryKeysTest < ActiveRecord::TestCase
   fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
@@ -88,6 +90,12 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     assert_equal("John Doe", subscriberReloaded.name)
   end
 
+  def test_id_column_that_is_not_primary_key
+    NonPrimaryKey.create!(id: 100)
+    actual = NonPrimaryKey.find_by(id: 100)
+    assert_match %r{<NonPrimaryKey id: 100}, actual.inspect
+  end
+
   def test_find_with_more_than_one_string_key
     assert_equal 2, Subscriber.find(subscribers(:first).nick, subscribers(:second).nick).length
   end
@@ -113,7 +121,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     assert_nothing_raised { MixedCaseMonkey.delete(1) }
   end
   def test_update_counters_should_quote_pkey_and_quote_counter_columns
-    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleacount => 99) }
+    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleaCount => 99) }
   end
   def test_find_with_one_id_should_quote_pkey
     assert_nothing_raised { MixedCaseMonkey.find(1) }
@@ -129,27 +137,25 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   end
 
   def test_supports_primary_key
-    assert_nothing_raised NoMethodError do
+    assert_nothing_raised do
       ActiveRecord::Base.connection.supports_primary_key?
     end
   end
 
-  def test_primary_key_returns_value_if_it_exists
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers'
-    end
+  if ActiveRecord::Base.connection.supports_primary_key?
+    def test_primary_key_returns_value_if_it_exists
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = 'developers'
+      end
 
-    if ActiveRecord::Base.connection.supports_primary_key?
       assert_equal 'id', klass.primary_key
     end
-  end
 
-  def test_primary_key_returns_nil_if_it_does_not_exist
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = 'developers_projects'
-    end
+    def test_primary_key_returns_nil_if_it_does_not_exist
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = 'developers_projects'
+      end
 
-    if ActiveRecord::Base.connection.supports_primary_key?
       assert_nil klass.primary_key
     end
   end
@@ -163,8 +169,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_auto_detect_primary_key_from_schema
     MixedCaseMonkey.reset_primary_key
-    #assert_equal "monkeyID", MixedCaseMonkey.primary_key
-	assert_equal "monkeyid", MixedCaseMonkey.primary_key
+    assert_equal "monkeyID", MixedCaseMonkey.primary_key
   end
 
   def test_primary_key_update_with_custom_key_name
@@ -175,10 +180,24 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     dashboard = Dashboard.first
     assert_equal '2', dashboard.id
   end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_serial_with_quoted_sequence_name
+      column = MixedCaseMonkey.columns_hash[MixedCaseMonkey.primary_key]
+      assert_equal "nextval('\"mixed_case_monkeys_monkeyID_seq\"'::regclass)", column.default_function
+      assert column.serial?
+    end
+
+    def test_serial_with_unquoted_sequence_name
+      column = Topic.columns_hash[Topic.primary_key]
+      assert_equal "nextval('topics_id_seq'::regclass)", column.default_function
+      assert column.serial?
+    end
+  end
 end
 
 class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   unless in_memory_db?
     def test_set_primary_key_with_no_connection
@@ -196,42 +215,162 @@ class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
   end
 end
 
-if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-  class PrimaryKeyWithAnsiQuotesTest < ActiveRecord::TestCase
-    self.use_transactional_fixtures = false
+class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:barcodes, primary_key: "code", id: :string, limit: 42, force: true)
+  end
+
+  teardown do
+    @connection.drop_table(:barcodes)
+	#, if_exists: true)
+  end
+
+  def test_any_type_primary_key
+    assert_equal "code", Barcode.primary_key
+
+    column = Barcode.column_for_attribute(Barcode.primary_key)
+    assert_not column.null
+    assert_equal :string, column.type
+    assert_equal 42, column.limit
+  end
+
+  test "schema dump primary key includes type and options" do
+    schema = dump_table_schema "barcodes"
+    assert_match %r{create_table "barcodes", primary_key: "code", id: :string, limit: 42}, schema
+  end
+end
+
+class CompositePrimaryKeyTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.schema_cache.clear!
+    @connection.create_table(:barcodes, primary_key: ["region", "code"], force: true) do |t|
+      t.string :region, null: false
+      t.integer :code, null: false
+    end
+  end
+
+  def teardown
+    @connection.drop_table(:barcodes)
+	#, if_exists: true)
+  end
+
+  def test_composite_primary_key
+    assert_equal ["region", "code"], @connection.primary_keys("barcodes")
+  end
+
+  def test_primary_key_issues_warning
+    model = Class.new(ActiveRecord::Base) do
+      def self.table_name
+        "barcodes"
+      end
+    end
+    warning = capture(:stderr) do
+      assert_nil model.primary_key
+    end
+    assert_match(/WARNING: Active Record does not support composite primary key\./, warning)
+  end
+
+  def test_collectly_dump_composite_primary_key
+    schema = dump_table_schema "barcodes"
+    assert_match %r{create_table "barcodes", primary_key: \["region", "code"\]}, schema
+  end
+end
+
+if current_adapter?(:Mysql2Adapter)
+  class PrimaryKeyBigintNilDefaultTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
 
-    def test_primary_key_method_with_ansi_quotes
-      con = ActiveRecord::Base.connection
-      con.execute("SET SESSION sql_mode='ANSI_QUOTES'")
-      assert_equal "id", con.primary_key("topics")
-    ensure
-      con.reconnect!
+    def setup
+      @connection = ActiveRecord::Base.connection
+      @connection.create_table(:bigint_defaults, id: :bigint, default: nil, force: true)
+    end
+
+    def teardown
+      @connection.drop_table :bigint_defaults
+	  #, if_exists: true
+    end
+
+    test "primary key with bigint allows default override via nil" do
+      column = @connection.columns(:bigint_defaults).find { |c| c.name == 'id' }
+      assert column.bigint?
+      assert_not column.auto_increment?
+    end
+
+    test "schema dump primary key with bigint default nil" do
+      schema = dump_table_schema "bigint_defaults"
+      assert_match %r{create_table "bigint_defaults", id: :bigint, default: nil}, schema
     end
   end
 end
 
-if current_adapter?(:PostgreSQLAdapter)
+if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
   class PrimaryKeyBigSerialTest < ActiveRecord::TestCase
-    self.use_transactional_fixtures = false
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
 
     class Widget < ActiveRecord::Base
     end
 
     setup do
       @connection = ActiveRecord::Base.connection
-      @connection.create_table(:widgets, id: :bigserial) { |t| }
+      if current_adapter?(:PostgreSQLAdapter)
+        @connection.create_table(:widgets, id: :bigserial, force: true)
+      else
+        @connection.create_table(:widgets, id: :bigint, force: true)
+      end
     end
 
     teardown do
       @connection.drop_table :widgets
+	  #, if_exists: true
+      Widget.reset_column_information
     end
 
-    def test_bigserial_primary_key
-      assert_equal "id", Widget.primary_key
-      assert_equal :integer, Widget.columns_hash[Widget.primary_key].type
+    test "primary key column type with bigserial" do
+      column_type = Widget.type_for_attribute(Widget.primary_key)
+      assert_equal :integer, column_type.type
+      assert_equal 8, column_type.limit
+    end
 
+    test "primary key with bigserial are automatically numbered" do
       widget = Widget.create!
       assert_not_nil widget.id
     end
+
+    test "schema dump primary key with bigserial" do
+      schema = dump_table_schema "widgets"
+      if current_adapter?(:PostgreSQLAdapter)
+        assert_match %r{create_table "widgets", id: :bigserial, force: :cascade}, schema
+      else
+        assert_match %r{create_table "widgets", id: :bigint, force: :cascade}, schema
+      end
+    end
+
+    if current_adapter?(:Mysql2Adapter)
+      test "primary key column type with options" do
+        @connection.create_table(:widgets, id: :primary_key, limit: 8, unsigned: true, force: true)
+        column = @connection.columns(:widgets).find { |c| c.name == 'id' }
+        assert column.auto_increment?
+        assert_equal :integer, column.type
+        assert_equal 8, column.limit
+        assert column.unsigned?
+      end
+    end
   end
 end