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

data/test/cases/adapters/sqlite3/sqlite3_create_folder_test.rb

@@ -0,0 +1,24 @@
+require "cases/helper"
+require 'models/owner'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3CreateFolder < ActiveRecord::SQLite3TestCase
+      def test_sqlite_creates_directory
+        Dir.mktmpdir do |dir|
+          begin
+            dir = Pathname.new(dir)
+            @conn = Base.sqlite3_connection :database => dir.join("db/foo.sqlite3"),
+                                 :adapter => 'sqlite3',
+                                 :timeout => 100
+
+            assert Dir.exist? dir.join('db')
+            assert File.exist? dir.join('db/foo.sqlite3')
+          ensure
+            @conn.disconnect! if @conn
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'cases/helper'
+
+class SQLite3StatementPoolTest < ActiveRecord::SQLite3TestCase
+  if Process.respond_to?(:fork)
+    def test_cache_is_per_pid
+
+      cache = ActiveRecord::ConnectionAdapters::SQLite3Adapter::StatementPool.new(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
+end

data/test/cases/aggregations_test.rb

@@ -25,7 +25,7 @@ class AggregationsTest < ActiveRecord::TestCase
 
   def test_immutable_value_objects
     customers(:david).balance = Money.new(100)
-    assert_raise(RuntimeError) { customers(:david).balance.instance_eval { @amount = 20 } }
+    assert_raise(frozen_error_class) { customers(:david).balance.instance_eval { @amount = 20 } }
   end
 
   def test_inferred_mapping
@@ -138,6 +138,16 @@ class AggregationsTest < ActiveRecord::TestCase
     assert_equal 'Barnoit GUMBLEAU', customers(:barney).fullname.to_s
     assert_kind_of Fullname, customers(:barney).fullname
   end
+
+  def test_assigning_hash_to_custom_converter
+    customers(:barney).fullname = { first: "Barney", last: "Stinson" }
+    assert_equal "Barney STINSON", customers(:barney).name
+  end
+
+  def test_assigning_hash_without_custom_converter
+    customers(:barney).fullname_no_converter = { first: "Barney", last: "Stinson" }
+    assert_equal({ first: "Barney", last: "Stinson" }.to_s, customers(:barney).name)
+  end
 end
 
 class OverridingAggregationsTest < ActiveRecord::TestCase

data/test/cases/ar_schema_test.rb

@@ -3,7 +3,7 @@ require "cases/helper"
 if ActiveRecord::Base.connection.supports_migrations?
 
   class ActiveRecordSchemaTest < ActiveRecord::TestCase
-    self.use_transactional_fixtures = false
+    self.use_transactional_tests = false
 
     setup do
       @original_verbose = ActiveRecord::Migration.verbose
@@ -17,14 +17,15 @@ if ActiveRecord::Base.connection.supports_migrations?
       @connection.drop_table :nep_fruits rescue nil
       @connection.drop_table :nep_schema_migrations rescue nil
       @connection.drop_table :has_timestamps rescue nil
+      @connection.drop_table :multiple_indexes rescue nil
       ActiveRecord::SchemaMigration.delete_all rescue nil
       ActiveRecord::Migration.verbose = @original_verbose
     end
 
-    def test_has_no_primary_key
+    def test_has_primary_key
       old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
       ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-      assert_nil ActiveRecord::SchemaMigration.primary_key
+      assert_equal "version", ActiveRecord::SchemaMigration.primary_key
 
       ActiveRecord::SchemaMigration.create_table
       assert_difference "ActiveRecord::SchemaMigration.count", 1 do
@@ -93,69 +94,53 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "20131219224947", ActiveRecord::SchemaMigration.normalize_migration_number("20131219224947")
     end
 
-    def test_timestamps_without_null_is_deprecated_on_create_table
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps do |t|
-            t.timestamps
-          end
+    def test_schema_load_with_multiple_indexes_for_column_of_different_names
+      ActiveRecord::Schema.define do
+        create_table :multiple_indexes do |t|
+          t.string "foo"
+          t.index ["foo"], name: "multiple_indexes_foo_1"
+          t.index ["foo"], name: "multiple_indexes_foo_2"
         end
       end
-    end
 
-    def test_timestamps_without_null_is_deprecated_on_change_table
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
+      indexes = @connection.indexes("multiple_indexes")
 
-          change_table :has_timestamps do |t|
-            t.timestamps
-          end
-        end
-      end
+      assert_equal 2, indexes.length
+      assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
     end
 
-    def test_timestamps_without_null_is_deprecated_on_add_timestamps
-      assert_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
-          add_timestamps :has_timestamps
+    def test_timestamps_without_null_set_null_to_false_on_create_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps do |t|
+          t.timestamps
         end
       end
-    end
 
-    def test_no_deprecation_warning_from_timestamps_on_create_table
-      assert_not_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps do |t|
-            t.timestamps null: true
-          end
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+    end
 
-          drop_table :has_timestamps
+    def test_timestamps_without_null_set_null_to_false_on_change_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
 
-          create_table :has_timestamps do |t|
-            t.timestamps null: false
-          end
+        change_table :has_timestamps do |t|
+          t.timestamps default: Time.now
         end
       end
-    end
-
-    def test_no_deprecation_warning_from_timestamps_on_change_table
-      assert_not_deprecated do
-        ActiveRecord::Schema.define do
-          create_table :has_timestamps
-          change_table :has_timestamps do |t|
-            t.timestamps null: true
-          end
 
-          drop_table :has_timestamps
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
+    end
 
-          create_table :has_timestamps
-          change_table :has_timestamps do |t|
-            t.timestamps null: false, default: Time.now
-          end
-        end
+    def test_timestamps_without_null_set_null_to_false_on_add_timestamps
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+        add_timestamps :has_timestamps, default: Time.now
       end
+
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'created_at' }.null
+      assert !@connection.columns(:has_timestamps).find { |c| c.name == 'updated_at' }.null
     end
   end
 end

data/test/cases/associations/association_scope_test.rb

@@ -8,12 +8,7 @@ module ActiveRecord
       test 'does not duplicate conditions' do
         scope = AssociationScope.scope(Author.new.association(:welcome_posts),
                                         Author.connection)
-        wheres = scope.where_values.map(&:right)
-        binds = scope.bind_values.map(&:last)
-        wheres = scope.where_values.map(&:right).reject { |node|
-          Arel::Nodes::BindParam === node
-        }
-        assert_equal wheres.uniq, wheres
+        binds = scope.where_clause.binds.map(&:value)
         assert_equal binds.uniq, binds
       end
     end

data/test/cases/associations/belongs_to_associations_test.rb

@@ -1,6 +1,5 @@
 require 'cases/helper'
 require 'models/developer'
-require 'models/computer'
 require 'models/project'
 require 'models/company'
 require 'models/topic'
@@ -36,6 +35,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal companies(:first_firm).name, firm.name
   end
 
+  def test_missing_attribute_error_is_raised_when_no_foreign_key_attribute
+    assert_raises(ActiveModel::MissingAttributeError) { Client.select(:id).first.firm }
+  end
+
   def test_belongs_to_does_not_use_order_by
     ActiveRecord::SQLCounter.clear_log
     Client.find(3).firm
@@ -50,7 +53,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_belongs_to_with_primary_key_joins_on_correct_column
     sql = Client.joins(:firm_with_primary_key).to_sql
-    if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+    if current_adapter?(:Mysql2Adapter)
       assert_no_match(/`firm_with_primary_keys_companies`\.`id`/, sql)
       assert_match(/`firm_with_primary_keys_companies`\.`name`/, sql)
     elsif current_adapter?(:OracleAdapter)
@@ -67,6 +70,56 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_optional_relation
+    original_value = ActiveRecord::Base.belongs_to_required_by_default
+    ActiveRecord::Base.belongs_to_required_by_default = true
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      def self.name; "Temp"; end
+      belongs_to :company, optional: true
+    end
+
+    account = model.new
+    assert account.valid?
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = original_value
+  end
+
+  def test_not_optional_relation
+    original_value = ActiveRecord::Base.belongs_to_required_by_default
+    ActiveRecord::Base.belongs_to_required_by_default = true
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      def self.name; "Temp"; end
+      belongs_to :company, optional: false
+    end
+
+    account = model.new
+    assert_not account.valid?
+    assert_equal [{error: :blank}], account.errors.details[:company]
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = original_value
+  end
+
+  def test_required_belongs_to_config
+    original_value = ActiveRecord::Base.belongs_to_required_by_default
+    ActiveRecord::Base.belongs_to_required_by_default = true
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      def self.name; "Temp"; end
+      belongs_to :company
+    end
+
+    account = model.new
+    assert_not account.valid?
+    assert_equal [{error: :blank}], account.errors.details[:company]
+  ensure
+    ActiveRecord::Base.belongs_to_required_by_default = original_value
+  end
+
   def test_default_scope_on_relations_is_not_cached
     counter = 0
 
@@ -242,11 +295,22 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert client.account.new_record?
   end
 
+  def test_reloading_the_belonging_object
+    odegy_account = accounts(:odegy_account)
+
+    assert_equal "Odegy", odegy_account.firm.name
+    Company.where(id: odegy_account.firm_id).update_all(name: "ODEGY")
+    assert_equal "Odegy", odegy_account.firm.name
+
+    assert_equal "ODEGY", odegy_account.reload_firm.name
+  end
+
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
     client.save
-    assert_nil client.firm(true)
+    client.association(:firm).reload
+    assert_nil client.firm
     assert_nil client.client_of
   end
 
@@ -254,7 +318,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     client = Client.create(:name => "Primary key client", :firm_name => companies(:first_firm).name)
     client.firm_with_primary_key = nil
     client.save
-    assert_nil client.firm_with_primary_key(true)
+    client.association(:firm_with_primary_key).reload
+    assert_nil client.firm_with_primary_key
     assert_nil client.client_of
   end
 
@@ -271,11 +336,13 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_polymorphic_association_class
     sponsor = Sponsor.new
     assert_nil sponsor.association(:sponsorable).send(:klass)
-    assert_nil sponsor.sponsorable(force_reload: true)
+    sponsor.association(:sponsorable).reload
+    assert_nil sponsor.sponsorable
 
     sponsor.sponsorable_type = '' # the column doesn't have to be declared NOT NULL
     assert_nil sponsor.association(:sponsorable).send(:klass)
-    assert_nil sponsor.sponsorable(force_reload: true)
+    sponsor.association(:sponsorable).reload
+    assert_nil sponsor.sponsorable
 
     sponsor.sponsorable = Member.new :name => "Bert"
     assert_equal Member, sponsor.association(:sponsorable).send(:klass)
@@ -423,13 +490,33 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) { line_item.touch }
   end
 
+  def test_belongs_to_with_touch_on_multiple_records
+    line_item = LineItem.create!(amount: 1)
+    line_item2 = LineItem.create!(amount: 2)
+    Invoice.create!(line_items: [line_item, line_item2])
+
+    assert_queries(1) do
+      LineItem.transaction do
+        line_item.touch
+        line_item2.touch
+      end
+    end
+
+    assert_queries(2) do
+      line_item.touch
+      line_item2.touch
+    end
+  end
+
   def test_belongs_to_with_touch_option_on_touch_without_updated_at_attributes
     assert_not LineItem.column_names.include?("updated_at")
 
     line_item = LineItem.create!
     invoice = Invoice.create!(line_items: [line_item])
     initial = invoice.updated_at
-    line_item.touch
+    travel(1.second) do
+      line_item.touch
+    end
 
     assert_not_equal initial, invoice.reload.updated_at
   end
@@ -508,7 +595,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert final_cut.persisted?
     assert firm.persisted?
     assert_equal firm, final_cut.firm
-    assert_equal firm, final_cut.firm(true)
+    final_cut.association(:firm).reload
+    assert_equal firm, final_cut.firm
   end
 
   def test_assignment_before_child_saved_with_primary_key
@@ -520,7 +608,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert final_cut.persisted?
     assert firm.persisted?
     assert_equal firm, final_cut.firm_with_primary_key
-    assert_equal firm, final_cut.firm_with_primary_key(true)
+    final_cut.association(:firm_with_primary_key).reload
+    assert_equal firm, final_cut.firm_with_primary_key
   end
 
   def test_new_record_with_foreign_key_but_no_object
@@ -551,6 +640,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_queries(0) { tagging.super_tag }
   end
 
+  def test_dont_find_target_when_saving_foreign_key_after_stale_association_loaded
+    client = Client.create!(name: "Test client", firm_with_basic_id: Firm.find(1))
+    client.firm_id = Firm.create!(name: "Test firm").id
+    assert_queries(1) { client.save! }
+  end
+
   def test_field_name_same_as_foreign_key
     computer = Computer.find(1)
     assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
@@ -625,6 +720,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 17, reply.replies.size
   end
 
+  def test_replace_counter_cache
+    topic = Topic.create(title: "Zoom-zoom-zoom")
+    reply = Reply.create(title: "re: zoom", content: "speedy quick!")
+
+    reply.topic = topic
+    reply.save
+    topic.reload
+
+    assert_equal 1, topic.replies_count
+  end
+
   def test_association_assignment_sticks
     post = Post.first
 
@@ -651,7 +757,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert companies(:first_client).readonly_firm.readonly?
   end
 
-  def test_test_polymorphic_assignment_foreign_key_type_string
+  def test_polymorphic_assignment_foreign_key_type_string
     comment = Comment.first
     comment.author   = Author.first
     comment.resource = Member.first
@@ -1015,6 +1121,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     Column.create! record: record
     assert_equal 1, Column.count
   end
+
+  def test_association_force_reload_with_only_true_is_deprecated
+    client = Client.find(3)
+
+    assert_deprecated { client.firm(true) }
+  end
 end
 
 class BelongsToWithForeignKeyTest < ActiveRecord::TestCase