Merge pull request #6743 from steveklabnik/remove_composed_of

Removing composed_of

5 files changed, 0 insertions, 401 deletions

diff --git a/activerecord/test/cases/aggregations_test.rb b/activerecord/test/cases/aggregations_test.rb
deleted file mode 100644
index 5bd8f76ba2..0000000000
--- a/activerecord/test/cases/aggregations_test.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-require "cases/helper"
-require 'models/customer'
-require 'active_support/core_ext/exception'
-
-class AggregationsTest < ActiveRecord::TestCase
-  fixtures :customers
-
-  def test_find_single_value_object
-    assert_equal 50, customers(:david).balance.amount
-    assert_kind_of Money, customers(:david).balance
-    assert_equal 300, customers(:david).balance.exchange_to("DKK").amount
-  end
-
-  def test_find_multiple_value_object
-    assert_equal customers(:david).address_street, customers(:david).address.street
-    assert(
-      customers(:david).address.close_to?(Address.new("Different Street", customers(:david).address_city, customers(:david).address_country))
-    )
-  end
-
-  def test_change_single_value_object
-    customers(:david).balance = Money.new(100)
-    customers(:david).save
-    assert_equal 100, customers(:david).reload.balance.amount
-  end
-
-  def test_immutable_value_objects
-    customers(:david).balance = Money.new(100)
-    assert_raise(ActiveSupport::FrozenObjectError) { customers(:david).balance.instance_eval { @amount = 20 } }
-  end
-
-  def test_inferred_mapping
-    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
-    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
-
-    customers(:david).gps_location = GpsLocation.new("39x-110")
-
-    assert_equal "39", customers(:david).gps_location.latitude
-    assert_equal "-110", customers(:david).gps_location.longitude
-
-    customers(:david).save
-
-    customers(:david).reload
-
-    assert_equal "39", customers(:david).gps_location.latitude
-    assert_equal "-110", customers(:david).gps_location.longitude
-  end
-
-  def test_reloaded_instance_refreshes_aggregations
-    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
-    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
-
-    Customer.update_all("gps_location = '24x113'")
-    customers(:david).reload
-    assert_equal '24x113', customers(:david)['gps_location']
-
-    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location
-  end
-
-  def test_gps_equality
-    assert_equal GpsLocation.new('39x110'), GpsLocation.new('39x110')
-  end
-
-  def test_gps_inequality
-    assert_not_equal GpsLocation.new('39x110'), GpsLocation.new('39x111')
-  end
-
-  def test_allow_nil_gps_is_nil
-    assert_nil customers(:zaphod).gps_location
-  end
-
-  def test_allow_nil_gps_set_to_nil
-    customers(:david).gps_location = nil
-    customers(:david).save
-    customers(:david).reload
-    assert_nil customers(:david).gps_location
-  end
-
-  def test_allow_nil_set_address_attributes_to_nil
-    customers(:zaphod).address = nil
-    assert_nil customers(:zaphod).attributes[:address_street]
-    assert_nil customers(:zaphod).attributes[:address_city]
-    assert_nil customers(:zaphod).attributes[:address_country]
-  end
-
-  def test_allow_nil_address_set_to_nil
-    customers(:zaphod).address = nil
-    customers(:zaphod).save
-    customers(:zaphod).reload
-    assert_nil customers(:zaphod).address
-  end
-
-  def test_nil_raises_error_when_allow_nil_is_false
-    assert_raise(NoMethodError) { customers(:david).balance = nil }
-  end
-
-  def test_allow_nil_address_loaded_when_only_some_attributes_are_nil
-    customers(:zaphod).address_street = nil
-    customers(:zaphod).save
-    customers(:zaphod).reload
-    assert_kind_of Address, customers(:zaphod).address
-    assert_nil customers(:zaphod).address.street
-  end
-
-  def test_nil_assignment_results_in_nil
-    customers(:david).gps_location = GpsLocation.new('39x111')
-    assert_not_nil customers(:david).gps_location
-    customers(:david).gps_location = nil
-    assert_nil customers(:david).gps_location
-  end
-
-  def test_nil_return_from_converter_is_respected_when_allow_nil_is_true
-    customers(:david).non_blank_gps_location = ""
-    customers(:david).save
-    customers(:david).reload
-    assert_nil customers(:david).non_blank_gps_location
-  end
-
-  def test_nil_return_from_converter_results_in_failure_when_allow_nil_is_false
-    assert_raises(NoMethodError) do
-      customers(:barney).gps_location = ""
-    end
-  end
-
-  def test_do_not_run_the_converter_when_nil_was_set
-    customers(:david).non_blank_gps_location = nil
-    assert_nil Customer.gps_conversion_was_run
-  end
-
-  def test_custom_constructor
-    assert_equal 'Barney GUMBLE', customers(:barney).fullname.to_s
-    assert_kind_of Fullname, customers(:barney).fullname
-  end
-
-  def test_custom_converter
-    customers(:barney).fullname = 'Barnoit Gumbleau'
-    assert_equal 'Barnoit GUMBLEAU', customers(:barney).fullname.to_s
-    assert_kind_of Fullname, customers(:barney).fullname
-  end
-end
-
-class OverridingAggregationsTest < ActiveRecord::TestCase
-  class Name; end
-  class DifferentName; end
-
-  class Person < ActiveRecord::Base
-    composed_of :composed_of, :mapping => %w(person_first_name first_name)
-  end
-
-  class DifferentPerson < Person
-    composed_of :composed_of, :class_name => 'DifferentName', :mapping => %w(different_person_first_name first_name)
-  end
-
-  def test_composed_of_aggregation_redefinition_reflections_should_differ_and_not_inherited
-    assert_not_equal Person.reflect_on_aggregation(:composed_of),
-                     DifferentPerson.reflect_on_aggregation(:composed_of)
-  end
-end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index a9d4481186..2fee553cef 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -888,22 +888,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
   end
 
-  def test_multiparameter_assignment_of_aggregation
-    customer = Customer.new
-    address = Address.new("The Street", "The City", "The Country")
-    attributes = { "address(1)" => address.street, "address(2)" => address.city, "address(3)" => address.country }
-    customer.attributes = attributes
-    assert_equal address, customer.address
-  end
-
-  def test_multiparameter_assignment_of_aggregation_out_of_order
-    customer = Customer.new
-    address = Address.new("The Street", "The City", "The Country")
-    attributes = { "address(3)" => address.country, "address(2)" => address.city, "address(1)" => address.street }
-    customer.attributes = attributes
-    assert_equal address, customer.address
-  end
-
   def test_multiparameter_assignment_of_aggregation_with_missing_values
     ex = assert_raise(ActiveRecord::MultiparameterAssignmentErrors) do
       customer = Customer.new
@@ -914,14 +898,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal("address", ex.errors[0].attribute)
   end
 
-  def test_multiparameter_assignment_of_aggregation_with_blank_values
-    customer = Customer.new
-    address = Address.new("The Street", "The City", "The Country")
-    attributes = { "address(1)" => "", "address(2)" => address.city, "address(3)" => address.country }
-    customer.attributes = attributes
-    assert_equal Address.new(nil, "The City", "The Country"), customer.address
-  end
-
   def test_multiparameter_assignment_of_aggregation_with_large_index
     ex = assert_raise(ActiveRecord::MultiparameterAssignmentErrors) do
       customer = Customer.new
@@ -1021,26 +997,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal("c", duped_topic.title)
   end
 
-  def test_dup_with_aggregate_of_same_name_as_attribute
-    dev = DeveloperWithAggregate.find(1)
-    assert_kind_of DeveloperSalary, dev.salary
-
-    dup = nil
-    assert_nothing_raised { dup = dev.dup }
-    assert_kind_of DeveloperSalary, dup.salary
-    assert_equal dev.salary.amount, dup.salary.amount
-    assert !dup.persisted?
-
-    # test if the attributes have been dupd
-    original_amount = dup.salary.amount
-    dev.salary.amount = 1
-    assert_equal original_amount, dup.salary.amount
-
-    assert dup.save
-    assert dup.persisted?
-    assert_not_equal dup.id, dev.id
-  end
-
   def test_dup_does_not_copy_associations
     author = authors(:david)
     assert_not_equal [], author.posts
diff --git a/activerecord/test/cases/deprecated_dynamic_methods_test.rb b/activerecord/test/cases/deprecated_dynamic_methods_test.rb
index 77a609f49a..7c108b983e 100644
--- a/activerecord/test/cases/deprecated_dynamic_methods_test.rb
+++ b/activerecord/test/cases/deprecated_dynamic_methods_test.rb
@@ -45,32 +45,6 @@ class DeprecatedDynamicMethodsTest < ActiveRecord::TestCase
     assert_equal [], Topic.find_all_by_title("The First Topic!!")
   end
 
-  def test_find_all_by_one_attribute_that_is_an_aggregate
-    balance = customers(:david).balance
-    assert_kind_of Money, balance
-    found_customers = Customer.find_all_by_balance(balance)
-    assert_equal 1, found_customers.size
-    assert_equal customers(:david), found_customers.first
-  end
-
-  def test_find_all_by_two_attributes_that_are_both_aggregates
-    balance = customers(:david).balance
-    address = customers(:david).address
-    assert_kind_of Money, balance
-    assert_kind_of Address, address
-    found_customers = Customer.find_all_by_balance_and_address(balance, address)
-    assert_equal 1, found_customers.size
-    assert_equal customers(:david), found_customers.first
-  end
-
-  def test_find_all_by_two_attributes_with_one_being_an_aggregate
-    balance = customers(:david).balance
-    assert_kind_of Money, balance
-    found_customers = Customer.find_all_by_balance_and_name(balance, customers(:david).name)
-    assert_equal 1, found_customers.size
-    assert_equal customers(:david), found_customers.first
-  end
-
   def test_find_all_by_one_attribute_with_options
     topics = Topic.find_all_by_content("Have a nice day", :order => "id DESC")
     assert_equal topics(:first), topics.last
@@ -137,14 +111,6 @@ class DeprecatedDynamicMethodsTest < ActiveRecord::TestCase
     assert_equal 17, sig38.firm_id
   end
 
-  def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
-    number_of_customers = Customer.count
-    created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
-    assert_equal number_of_customers + 1, Customer.count
-    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
-    assert created_customer.persisted?
-  end
-
   def test_find_or_create_from_one_attribute_and_hash
     number_of_companies = Company.count
     sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
@@ -167,38 +133,12 @@ class DeprecatedDynamicMethodsTest < ActiveRecord::TestCase
     assert_equal 23, sig38.client_of
   end
 
-  def test_find_or_create_from_one_aggregate_attribute
-    number_of_customers = Customer.count
-    created_customer = Customer.find_or_create_by_balance(Money.new(123))
-    assert_equal number_of_customers + 1, Customer.count
-    assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
-    assert created_customer.persisted?
-  end
-
-  def test_find_or_create_from_one_aggregate_attribute_and_hash
-    number_of_customers = Customer.count
-    balance = Money.new(123)
-    name = "Elizabeth"
-    created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
-    assert_equal number_of_customers + 1, Customer.count
-    assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
-    assert created_customer.persisted?
-    assert_equal balance, created_customer.balance
-    assert_equal name, created_customer.name
-  end
-
   def test_find_or_initialize_from_one_attribute
     sig38 = Company.find_or_initialize_by_name("38signals")
     assert_equal "38signals", sig38.name
     assert !sig38.persisted?
   end
 
-  def test_find_or_initialize_from_one_aggregate_attribute
-    new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
-    assert_equal 123, new_customer.balance.amount
-    assert !new_customer.persisted?
-  end
-
   def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
     c = Company.find_or_initialize_by_name({:name => "Fortune 1000", :rating => 1000})
     assert_equal "Fortune 1000", c.name
@@ -285,13 +225,6 @@ class DeprecatedDynamicMethodsTest < ActiveRecord::TestCase
     assert_raise(ArgumentError) { Topic.find_or_initialize_by_title_and_author_name("Another topic") }
   end
 
-  def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
-    new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
-    assert_equal 123, new_customer.balance.amount
-    assert_equal "Elizabeth", new_customer.name
-    assert !new_customer.persisted?
-  end
-
   def test_find_or_initialize_from_one_attribute_and_hash
     sig38 = Company.find_or_initialize_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
     assert_equal "38signals", sig38.name
@@ -300,15 +233,6 @@ class DeprecatedDynamicMethodsTest < ActiveRecord::TestCase
     assert !sig38.persisted?
   end
 
-  def test_find_or_initialize_from_one_aggregate_attribute_and_hash
-    balance = Money.new(123)
-    name = "Elizabeth"
-    new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
-    assert_equal balance, new_customer.balance
-    assert_equal name, new_customer.name
-    assert !new_customer.persisted?
-  end
-
   def test_find_last_by_one_attribute
     assert_equal Topic.last, Topic.find_last_by_title(Topic.last.title)
     assert_nil Topic.find_last_by_title("A title with no matches")
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index aa44307bc2..df21585961 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -79,21 +79,6 @@ class FinderTest < ActiveRecord::TestCase
     assert !Topic.exists?
   end
 
-  def test_exists_with_aggregate_having_three_mappings
-    existing_address = customers(:david).address
-    assert Customer.exists?(:address => existing_address)
-  end
-
-  def test_exists_with_aggregate_having_three_mappings_with_one_difference
-    existing_address = customers(:david).address
-    assert !Customer.exists?(:address =>
-      Address.new(existing_address.street, existing_address.city, existing_address.country + "1"))
-    assert !Customer.exists?(:address =>
-      Address.new(existing_address.street, existing_address.city + "1", existing_address.country))
-    assert !Customer.exists?(:address =>
-      Address.new(existing_address.street + "1", existing_address.city, existing_address.country))
-  end
-
   def test_exists_does_not_instantiate_records
     Developer.expects(:instantiate).never
     Developer.exists?
@@ -312,14 +297,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal companies(:rails_core), firms.first
   end
 
-  def test_find_on_hash_conditions_with_explicit_table_name_and_aggregate
-    david = customers(:david)
-    assert Customer.scoped(:where => { 'customers.name' => david.name, :address => david.address }).find(david.id)
-    assert_raise(ActiveRecord::RecordNotFound) {
-      Customer.scoped(:where => { 'customers.name' => david.name + "1", :address => david.address }).find(david.id)
-    }
-  end
-
   def test_find_on_association_proxy_conditions
     assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12], Comment.where(post_id: authors(:david).posts).map(&:id).sort
   end
@@ -394,48 +371,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_nil topic.last_read
   end
 
-  def test_hash_condition_find_with_aggregate_having_one_mapping
-    balance = customers(:david).balance
-    assert_kind_of Money, balance
-    found_customer = Customer.scoped(:where => {:balance => balance}).first
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_aggregate
-    gps_location = customers(:david).gps_location
-    assert_kind_of GpsLocation, gps_location
-    found_customer = Customer.scoped(:where => {:gps_location => gps_location}).first
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_hash_condition_find_with_aggregate_having_one_mapping_and_key_value_being_attribute_value
-    balance = customers(:david).balance
-    assert_kind_of Money, balance
-    found_customer = Customer.scoped(:where => {:balance => balance.amount}).first
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_attribute_value
-    gps_location = customers(:david).gps_location
-    assert_kind_of GpsLocation, gps_location
-    found_customer = Customer.scoped(:where => {:gps_location => gps_location.gps_location}).first
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_hash_condition_find_with_aggregate_having_three_mappings
-    address = customers(:david).address
-    assert_kind_of Address, address
-    found_customer = Customer.scoped(:where => {:address => address}).first
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_hash_condition_find_with_one_condition_being_aggregate_and_another_not
-    address = customers(:david).address
-    assert_kind_of Address, address
-    found_customer = Customer.scoped(:where => {:address => address, :name => customers(:david).name}).first
-    assert_equal customers(:david), found_customer
-  end
-
   def test_condition_utc_time_interpolation_with_default_timezone_local
     with_env_tz 'America/New_York' do
       with_active_record_default_timezone :local do
@@ -604,40 +539,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal accounts(:rails_core_account), Account.where('firm_id = ?', 6).find_by_credit_limit(50)
   end
 
-  def test_find_by_one_attribute_that_is_an_aggregate
-    address = customers(:david).address
-    assert_kind_of Address, address
-    found_customer = Customer.find_by_address(address)
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_find_by_one_attribute_that_is_an_aggregate_with_one_attribute_difference
-    address = customers(:david).address
-    assert_kind_of Address, address
-    missing_address = Address.new(address.street, address.city, address.country + "1")
-    assert_nil Customer.find_by_address(missing_address)
-    missing_address = Address.new(address.street, address.city + "1", address.country)
-    assert_nil Customer.find_by_address(missing_address)
-    missing_address = Address.new(address.street + "1", address.city, address.country)
-    assert_nil Customer.find_by_address(missing_address)
-  end
-
-  def test_find_by_two_attributes_that_are_both_aggregates
-    balance = customers(:david).balance
-    address = customers(:david).address
-    assert_kind_of Money, balance
-    assert_kind_of Address, address
-    found_customer = Customer.find_by_balance_and_address(balance, address)
-    assert_equal customers(:david), found_customer
-  end
-
-  def test_find_by_two_attributes_with_one_being_an_aggregate
-    balance = customers(:david).balance
-    assert_kind_of Money, balance
-    found_customer = Customer.find_by_balance_and_name(balance, customers(:david).name)
-    assert_equal customers(:david), found_customer
-  end
-
   def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
     # ensure this test can run independently of order
     class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.include?(:find_by_credit_limit)
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 7dd5698dcf..bac3376c9f 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -83,30 +83,6 @@ class ReflectionTest < ActiveRecord::TestCase
     end
   end
 
-  def test_aggregation_reflection
-    reflection_for_address = AggregateReflection.new(
-      :composed_of, :address, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
-    )
-
-    reflection_for_balance = AggregateReflection.new(
-      :composed_of, :balance, { :class_name => "Money", :mapping => %w(balance amount) }, Customer
-    )
-
-    reflection_for_gps_location = AggregateReflection.new(
-      :composed_of, :gps_location, { }, Customer
-    )
-
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
-
-    assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
-
-    assert_equal Address, Customer.reflect_on_aggregation(:address).klass
-
-    assert_equal Money, Customer.reflect_on_aggregation(:balance).klass
-  end
-
   def test_reflect_on_all_autosave_associations
     expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
     received = Pirate.reflect_on_all_autosave_associations