From ddb00f10781e808360a189b46a421f1d18a0360b Mon Sep 17 00:00:00 2001 From: Michael Koziarski Date: Sun, 15 Jul 2007 01:16:40 +0000 Subject: Remove spurious tests from deprecated_associations_test, most of these aren't deprecated, and are duplicated in associations_test. Closes #8987 [lifofifo] git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@7187 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- activerecord/CHANGELOG | 2 + activerecord/test/deprecated_associations_test.rb | 222 +--------------------- 2 files changed, 4 insertions(+), 220 deletions(-) diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG index cc0f1c924d..a10a5069ac 100644 --- a/activerecord/CHANGELOG +++ b/activerecord/CHANGELOG @@ -1,5 +1,7 @@ *SVN* +* Remove spurious tests from deprecated_associations_test, most of these aren't deprecated, and are duplicated in associations_test. Closes #8987 [lifofifo] + * Make create! on a has_many :through association return the association object. Not the collection. Closes #8786 [lifofifo] * Move from select * to select tablename.* to avoid clobbering IDs. Closes #8889 [dasil003] diff --git a/activerecord/test/deprecated_associations_test.rb b/activerecord/test/deprecated_associations_test.rb index 5887a7b53d..e40ff9b4c4 100755 --- a/activerecord/test/deprecated_associations_test.rb +++ b/activerecord/test/deprecated_associations_test.rb @@ -30,37 +30,7 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase @firm = companies(:first_firm) end - def test_has_many_find - assert_equal 2, @firm.clients.length - end - - def test_has_many_orders - assert_equal "Summit", @firm.clients.first.name - end - - def test_has_many_class_name - assert_equal "Microsoft", @firm.clients_sorted_desc.first.name - end - - def test_has_many_foreign_key - assert_equal "Microsoft", @firm.clients_of_firm.first.name - end - - def test_has_many_conditions - assert_equal "Microsoft", @firm.clients_like_ms.first.name - end - - def test_has_many_sql - assert_equal "Microsoft", @firm.clients_using_sql.first.name - assert_equal 1, @firm.clients_using_sql.count - assert_equal 1, @firm.clients_using_sql.count - end - - def test_has_many_counter_sql - assert_equal 1, @firm.clients_using_counter_sql.count - end - - def test_has_many_queries + def test_has_many assert !@firm.clients.loaded? assert_deprecated 'has_clients?' do assert_queries(1) { assert @firm.has_clients? } @@ -69,46 +39,6 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase assert_deprecated 'clients_count' do assert_queries(1) { assert_equal 2, @firm.clients_count } end - assert !@firm.clients.loaded? - assert_queries(1) { @firm.clients.size } - assert !@firm.clients.loaded? - assert_queries(0) { @firm.clients } - assert !@firm.clients.loaded? - assert_queries(1) { @firm.clients.reload } - assert @firm.clients.loaded? - assert_queries(0) { @firm.clients.size } - assert_queries(1) { @firm.clients.count } - end - - def test_has_many_dependence - count = Client.count - Firm.find(:first).destroy - assert_equal count - 2, Client.count - end - - uses_transaction :test_has_many_dependence_with_transaction_support_on_failure - def test_has_many_dependence_with_transaction_support_on_failure - count = Client.count - - clients = @firm.clients - clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end } - - @firm.destroy rescue "do nothing" - - assert_equal count, Client.count - end - - def test_has_one_dependence - num_accounts = Account.count - assert_not_nil @firm.account - @firm.destroy - assert_equal num_accounts - 1, Account.count - end - - def test_has_one_dependence_with_missing_association - Account.destroy_all - assert_nil @firm.account - @firm.destroy end def test_belongs_to @@ -119,18 +49,6 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase assert_equal companies(:first_firm), client.firm, "Microsoft should have a firm" end - def test_belongs_to_with_different_class_name - assert_equal @firm, companies(:second_client).firm_with_other_name - end - - def test_belongs_to_with_condition - assert_equal @firm, companies(:second_client).firm_with_condition - end - - def test_belongs_to_equality - assert_equal @firm, companies(:second_client).firm, 'Microsoft should have 37signals as firm' - end - def test_has_one assert_equal accounts(:signals37), @firm.account assert_deprecated 'has_account?' do @@ -146,12 +64,6 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase assert_nil accounts(:unknown).firm, "Unknown isn't linked" end - def test_has_many_dependence_on_account - num_accounts = Account.count - @firm.destroy - assert_equal num_accounts - 1, Account.count - end - def test_find_in assert_deprecated 'find_in_clients' do assert_equal companies(:first_client), @firm.find_in_clients(2) @@ -159,32 +71,6 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase end end - def test_force_reload - ActiveSupport::Deprecation.silence do - firm = Firm.new("name" => "A New Firm, Inc") - firm.save - firm.clients.each {|c|} # forcing to load all clients - assert firm.clients.empty?, "New firm shouldn't have client objects" - assert !firm.has_clients?, "New firm shouldn't have clients" - assert_equal 0, firm.clients_count, "New firm should have 0 clients" - - client = Client.new("name" => "TheClient.com", "firm_id" => firm.id) - client.save - - assert firm.clients.empty?, "New firm should have cached no client objects" - assert !firm.has_clients?, "New firm should have cached a no-clients response" - assert_equal 0, firm.clients_count, "New firm should have cached 0 clients count" - - assert !firm.clients(true).empty?, "New firm should have reloaded client objects" - assert firm.has_clients?(true), "New firm should have reloaded with a have-clients response" - assert_equal 1, firm.clients_count(true), "New firm should have reloaded clients count" - end - end - - def test_included_in_collection - assert @firm.clients.include?(Client.find(2)) - end - def test_build_to_collection count = @firm.clients_of_firm.count new_client = nil @@ -285,109 +171,5 @@ class DeprecatedAssociationsTest < Test::Unit::TestCase reply.destroy assert_equal 0, Topic.find(topic.id).send(:read_attribute, "replies_count"), "First reply deleted" end - - def test_natural_assignment_of_has_one - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - apple.account = citibank - assert_equal apple.id, citibank.firm_id - end - - def test_natural_assignment_of_belongs_to - apple = Firm.create("name" => "Apple") - citibank = Account.create("credit_limit" => 10) - citibank.firm = apple - assert_equal apple.id, citibank.firm_id - end - - def test_natural_assignment_of_has_many - apple = Firm.create("name" => "Apple") - natural = Client.create("name" => "Natural Company") - apple.clients << natural - assert_equal apple.id, natural.firm_id - assert_equal Client.find(natural.id), Firm.find(apple.id).clients.find(natural.id) - apple.clients.delete natural - assert_raises(ActiveRecord::RecordNotFound) { - Firm.find(apple.id).clients.find(natural.id) - } - end - - def test_natural_adding_of_has_and_belongs_to_many - rails = Project.create("name" => "Rails") - ap = Project.create("name" => "Action Pack") - john = Developer.create("name" => "John") - mike = Developer.create("name" => "Mike") - rails.developers << john - rails.developers << mike - - assert_equal Developer.find(john.id), Project.find(rails.id).developers.find(john.id) - assert_equal Developer.find(mike.id), Project.find(rails.id).developers.find(mike.id) - assert_equal Project.find(rails.id), Developer.find(mike.id).projects.find(rails.id) - assert_equal Project.find(rails.id), Developer.find(john.id).projects.find(rails.id) - ap.developers << john - assert_equal Developer.find(john.id), Project.find(ap.id).developers.find(john.id) - assert_equal Project.find(ap.id), Developer.find(john.id).projects.find(ap.id) - - ap.developers.delete john - assert_raises(ActiveRecord::RecordNotFound) { - Project.find(ap.id).developers.find(john.id) - } - assert_raises(ActiveRecord::RecordNotFound) { - Developer.find(john.id).projects.find(ap.id) - } - end - - def test_storing_in_pstore - require "pstore" - require "tmpdir" - apple = Firm.create("name" => "Apple") - natural = Client.new("name" => "Natural Company") - apple.clients << natural - - db = PStore.new(File.join(Dir.tmpdir, "ar-pstore-association-test")) - db.transaction do - db["apple"] = apple - end - - db = PStore.new(File.join(Dir.tmpdir, "ar-pstore-association-test")) - db.transaction do - assert_equal "Natural Company", db["apple"].clients.first.name - end - end - - def test_has_many_find_all - assert_raise(NoMethodError) do - @firm.find_all_in_clients("#{QUOTED_TYPE} = 'Client'") - end - end - - def test_has_one - assert_equal Account.find(1), @firm.account, "37signals should have an account" - assert_equal @firm, Account.find(1).firm, "37signals account should be able to backtrack" - assert_nil Account.find(2).firm, "Unknown isn't linked" - end - - def test_has_one_build - firm = Firm.new("name" => "GlobalMegaCorp") - assert firm.save - - account = firm.build_account(:credit_limit => 1000) - assert account.save - assert_equal account, firm.account - end - - def test_has_one_failing_build_association - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - - account = firm.build_account - assert !account.save - assert_equal "can't be empty", account.errors.on("credit_limit") - end - - def test_has_one_create - firm = Firm.new("name" => "GlobalMegaCorp") - firm.save - assert_equal firm.create_account("credit_limit" => 1000), firm.account - end + end -- cgit v1.2.3