has_addresses 0.0.2 → 0.5.0

data/test/unit/address_test.rb

@@ -1,171 +1,302 @@
 require "#{File.dirname(__FILE__)}/../test_helper"
 
-class AddressTest < Test::Unit::TestCase
-  fixtures :companies, :countries, :regions, :addresses
+class AddressByDefaultTest < ActiveRecord::TestCase
+  def setup
+    @address = Address.new
+  end
+  
+  def test_should_not_have_an_addressable_id
+    assert_nil @address.addressable_id
+  end
   
-  def test_address_in_known_region_should_be_valid
-    assert_valid addresses(:in_known_region)
+  def test_should_not_have_an_addressable_type
+    assert @address.addressable_type.blank?
   end
   
-  def test_address_in_unknown_region_should_be_valid
-    assert_valid addresses(:in_unknown_region)
+  def test_should_not_have_a_street_1
+    assert @address.street_1.blank?
   end
   
-  def test_should_require_addressable_id
-    assert_invalid addresses(:google_headquarters), :addressable_id, nil
+  def test_should_not_have_a_street_2
+    assert @address.street_2.blank?
   end
   
-  def test_should_require_addressable_type
-    assert_invalid addresses(:google_headquarters), :addressable_type, nil
+  def test_should_not_have_a_city
+    assert @address.city.blank?
   end
   
-  def test_should_require_street_1
-    assert_invalid addresses(:google_headquarters), :street_1, nil
+  def test_should_not_have_a_region
+    assert_nil @address.region_id
   end
   
-  def test_should_require_city
-    assert_invalid addresses(:google_headquarters), :city, nil
+  def test_should_not_have_a_custom_region
+    assert @address.custom_region.blank?
   end
   
-  def test_should_require_postal_code
-    assert_invalid addresses(:google_headquarters), :postal_code, nil
+  def test_should_not_have_a_region_name
+    assert @address.region_name.blank?
   end
   
-  def test_should_require_five_digit_postal_codes
-    assert_invalid addresses(:google_headquarters), :postal_code, '123456', '1234', 'abcdef'
+  def test_should_not_have_a_postal_code
+    assert @address.postal_code.blank?
   end
   
-  def test_should_require_region_id_if_country_has_regions
-    assert_invalid addresses(:in_known_region), :region_id, nil
+  def test_should_not_have_a_country
+    assert_nil @address.country_id
   end
   
-  def test_should_not_require_custom_region_if_country_has_regions
-    assert_valid addresses(:in_known_region), :custom_region, nil
+  def test_should_not_have_any_address_lines
+    assert @address.multi_line.empty?
+  end
+end
+
+class AddressTest < ActiveRecord::TestCase
+  def test_should_be_valid_with_a_set_of_valid_attributes
+    address = new_address
+    assert address.valid?
   end
   
-  def test_should_require_custom_region_if_country_has_no_regions
-    assert_invalid addresses(:in_unknown_region), :custom_region, nil
+  def test_should_require_an_addressable_id
+    address = new_address(:addressable => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:addressable_id)
   end
   
-  def test_should_not_require_region_id_if_country_has_no_regions
-    assert_valid addresses(:in_unknown_region), :region_id, nil
+  def test_should_require_an_addressable_type
+    address = new_address(:addressable => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:addressable_type)
   end
   
-  def test_should_have_addressable_association
-    assert_not_nil addresses(:google_headquarters).addressable
+  def test_should_require_a_street_1
+    address = new_address(:street_1 => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:street_1)
   end
   
-  def test_known_region_should_have_region_association
-    assert_not_nil addresses(:in_known_region).region
+  def test_should_not_require_a_street_2
+    address = new_address(:street_2 => nil)
+    assert address.valid?
   end
   
-  def test_unknown_region_should_not_have_region_association
-    assert_nil addresses(:in_unknown_region).region
+  def test_should_require_a_city
+    address = new_address(:city => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:city)
   end
   
-  def test_known_region_should_have_country_association
-    assert_nil addresses(:in_known_region).country_id
-    assert_not_nil addresses(:in_known_region).country
-    assert_equal countries(:united_states), addresses(:in_known_region).country
+  def test_should_require_a_postal_code
+    address = new_address(:postal_code => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:postal_code)
   end
   
-  def test_unknown_region_should_have_country_association
-    assert_not_nil addresses(:in_unknown_region).country_id
-    assert_not_nil addresses(:in_unknown_region).country
-    assert_equal countries(:canada), addresses(:in_unknown_region).country
+  def test_should_require_a_region_if_country_has_regions
+    country = create_country
+    create_region(:country => country)
+    
+    address = new_address(:country => country, :region => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:region_id)
   end
   
-  def test_should_clear_country_id_with_known_region
-    address = addresses(:in_known_region)
-    address.country = countries(:united_states)
+  def test_should_not_require_a_region_if_country_has_no_regions
+    country = create_country
     
-    assert_not_nil address.country_id
-    address.save!
-    assert_nil address.country_id
+    address = new_address(:country => country, :region => nil, :custom_region => 'Somewhere')
+    assert address.valid?
   end
   
-  def test_should_clear_custom_region_with_known_region
-    address = addresses(:in_known_region)
-    address.custom_region = 'Somewhere'
+  def test_should_require_a_custom_region_if_country_has_no_regions
+    country = create_country
     
-    assert_not_nil address.custom_region
-    address.save!
-    assert_nil address.custom_region
+    address = new_address(:country => country, :region => nil, :custom_region => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:custom_region)
+  end
+  
+  def test_should_not_require_a_custom_region_if_country_has_regions
+    country = create_country
+    region = create_region(:country => country)
+    
+    address = new_address(:country => country, :region => region, :custom_region => nil)
+    assert address.valid?
+  end
+  
+  def test_should_require_a_country
+    address = new_address(:country => nil, :region => nil)
+    assert !address.valid?
+    assert address.errors.invalid?(:country_id)
+  end
+  
+  def test_should_protect_attributes_from_mass_assignment
+    country = create_country
+    region = create_region(:country => country)
+    
+    address = Address.new(
+      :id => 1,
+      :addressable_id => 1,
+      :addressable_type => 'User',
+      :street_1 => '1600 Amphitheatre Parkway',
+      :street_2 => 'Apt. 1',
+      :city => 'Mountain View',
+      :region => region,
+      :custom_region => 'Anywhere',
+      :postal_code => '94043',
+      :country => country
+    )
+    
+    assert_nil address.id
+    assert_nil address.addressable_id
+    assert address.addressable_type.blank?
+    assert_equal '1600 Amphitheatre Parkway', address.street_1
+    assert_equal 'Apt. 1', address.street_2
+    assert_equal 'Mountain View', address.city
+    assert_equal region, address.region
+    assert_equal 'Anywhere', address.custom_region
+    assert_equal '94043', address.postal_code
+    assert_equal country, address.country
+  end
+end
+
+class AddressAfterBeingCreatedTest < ActiveRecord::TestCase
+  def setup
+    @company = create_company
+    @address = create_address(:addressable => @company)
+  end
+  
+  def test_should_have_an_addressable_association
+    assert_equal @company, @address.addressable
+  end
+end
+
+class AddressInKnownRegionTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country
+    @region = create_region(:country => @country, :name => 'California')
+    @address = create_address(:region => @region)
   end
   
-  def test_region_name_shouild_use_region_association_when_known
-    assert_equal 'California', addresses(:in_known_region).region_name
+  def test_should_have_a_region
+    assert_not_nil @address.region
   end
   
-  def test_region_name_should_use_custom_region_when_unknown
-    assert_equal 'Anywhere', addresses(:in_unknown_region).region_name
+  def test_should_have_a_region_name
+    assert_equal 'California', @address.region_name
   end
   
-  def test_multiline
-    a = Address.new
-    a.street_1 = '123 Fake Street'
-    assert_equal ['123 Fake Street'], a.multi_line
+  def test_should_have_a_country
+    assert_equal @country, @address.country
+  end
+  
+  def test_should_clear_custom_region
+    @address.custom_region = 'Somewhere'
+    @address.valid?
+    assert_nil @address.custom_region
+  end
+end
+
+class AddressInUnknownRegionTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country
+    @address = create_address(:country => @country, :region => nil, :custom_region => 'Somewhere')
+  end
+  
+  def test_should_not_have_a_region
+    assert_nil @address.region
+  end
+  
+  def test_should_have_a_country
+    assert_equal @country, @address.country
+  end
+  
+  def test_should_have_a_region_name
+    assert_equal 'Somewhere', @address.region_name
+  end
+end
+
+class AddressConstructionTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country(:alpha_2_code => 'US', :name => 'United States')
+    @region = create_region(:country => @country, :abbreviation => 'CA', :name => 'California')
+  end
+  
+  def test_should_construct_multiline_based_on_current_information
+    address = Address.new
+    address.street_1 = '123 Fake Street'
+    assert_equal ['123 Fake Street'], address.multi_line
     
-    a.street_2 = 'Apartment 456'
+    address.street_2 = 'Apartment 456'
     expected = [
       '123 Fake Street',
       'Apartment 456'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
     
-    a.city = 'Somewhere'
+    address.city = 'Somewhere'
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Somewhere'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
     
-    a.region = regions(:california)
+    address.region = @region
+    address.country = @country
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Somewhere, California',
       'United States'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
     
-    a.postal_code = '12345'
+    address.postal_code = '12345'
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Somewhere, California  12345',
       'United States'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
+    
+    address.region = nil
+    address.custom_region = 'Anywhere'
+    expected = [
+      '123 Fake Street',
+      'Apartment 456',
+      'Somewhere, Anywhere  12345',
+      'United States'
+    ]
+    assert_equal expected, address.multi_line
     
-    a.region = nil
-    a.custom_region = 'Anywhere'
+    address.country = nil
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Somewhere, Anywhere  12345'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
     
-    a.city = nil
+    address.city = nil
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Anywhere  12345'
     ]
-    assert_equal expected, a.multi_line
+    assert_equal expected, address.multi_line
     
-    a.postal_code = nil
+    address.postal_code = nil
     expected = [
       '123 Fake Street',
       'Apartment 456',
       'Anywhere'
     ]
-    assert_equal expected, a.multi_line
-  end
+    assert_equal expected, address.multi_line
+ end
   
-  def test_single_line
-    assert_equal '1600 Amphitheatre Parkway, Mountain View, California  94043, United States', addresses(:google_headquarters).single_line
+  def test_should_construct_single_line_based_on_current_information
+    address = create_address(:street_1 => '1600 Amphitheatre Parkway', :city => 'Mountain View', :region => @region, :postal_code => '94043')
+    assert_equal '1600 Amphitheatre Parkway, Mountain View, California  94043, United States', address.single_line
   end
-end
+end

data/test/unit/country_test.rb

@@ -1,119 +1,148 @@
 require "#{File.dirname(__FILE__)}/../test_helper"
 
-unless ENV['LIVE']
-  Country::ISO_3166_URL = "#{RAILS_ROOT}/../files/iso_3166.xml"
-end
-
-class CountryTest < Test::Unit::TestCase
-  fixtures :countries, :regions
-  
-  def test_should_download_and_parse_countries_from_iso_standard
-    countries = Country.download_all
-    assert_instance_of Array, countries
-    assert !countries.empty?
+class CountryByDefaultTest < ActiveRecord::TestCase
+  def setup
+    @country = Country.new
   end
   
-  def test_bootstrap_should_remove_existing_records
-    country = Country.create(:name => 'Test', :alpha_2_code => 'TE', :alpha_3_code => 'TES')
-    assert !country.new_record?
-    Country.bootstrap
-    assert_nil Country.find_by_name('Test')
+  def test_should_not_have_a_name
+    assert_nil @country.name
   end
   
-  def test_bootstrap_should_insert_downloaded_countries
-    Country.bootstrap
-    assert Country.count > 2
+  def test_should_not_have_an_official_name
+    assert_nil @country.official_name
   end
   
-  def test_bootstrap_should_return_true_if_successful
-    assert Country.bootstrap
+  def test_should_not_have_an_alpha_2_code
+    assert_nil @country.alpha_2_code
   end
   
-  def test_should_use_default_path_for_created_fixture
-    Country.create_fixtures
-    assert File.exists?("#{RAILS_ROOT}/db/bootstrap/countries.yml")
+  def test_should_not_have_an_alpha_3_code
+    assert_nil @country.alpha_3_code
   end
   
-  def test_should_allow_custom_path_for_created_fixture
-    Country.create_fixtures('db/bootstrap/the_countries.yml')
-    assert File.exists?("#{RAILS_ROOT}/db/bootstrap/the_countries.yml")
+  def test_should_use_name_for_official_name
+    country = Country.new(:name => 'United States')
+    assert_equal 'United States', country.official_name
   end
   
-  def test_created_fixture_should_load_into_table
-    Country.create_fixtures
-    Fixtures.create_fixtures("#{RAILS_ROOT}/db/bootstrap", 'countries')
-    assert Country.count > 2
+  def test_should_not_use_name_for_official_name_if_specified
+    country = Country.new(:official_name => nil)
+    assert_nil country.official_name
   end
-  
-  def test_should_be_valid
-    assert_valid countries(:united_states)
+end
+
+class CountryTest < ActiveRecord::TestCase
+  def test_should_be_valid_with_a_set_of_valid_attributes
+    country = new_country
+    assert country.valid?
   end
   
-  def test_should_require_name
-    assert_invalid countries(:united_states), :name, nil
+  def test_should_require_a_name
+    country = new_country(:name => nil)
+    assert !country.valid?
+    assert country.errors.invalid?(:name)
   end
   
-  def test_should_restrict_name_length
-    assert_invalid countries(:united_states), :name, 'U', 'U' * 81
-    assert_valid countries(:united_states), :name, 'US', 'U' * 80
+  def test_should_not_require_an_official_name
+    country = new_country(:official_name => nil)
+    assert country.valid?
   end
   
-  def test_should_require_unique_name
-    assert_invalid countries(:united_states).clone, :name
+  def test_should_require_an_alpha_2_code
+    country = new_country(:alpha_2_code => nil)
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_2_code)
   end
   
-  def test_should_require_alpha_2_code
-    assert_invalid countries(:united_states), :alpha_2_code, nil
+  def test_should_require_a_unique_alpha_2_code
+    create_country(:alpha_2_code => 'US')
+    
+    country = new_country(:alpha_2_code => 'US')
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_2_code)
   end
   
-  def test_should_restrict_alpha_2_code_length
-    assert_invalid countries(:united_states), :alpha_2_code, 'U', 'USA'
-    assert_valid countries(:united_states), :alpha_2_code, 'US'
+  def test_should_not_allow_alpha_2_codes_shorter_or_longer_than_2_characters
+    country = new_country(:alpha_2_code => 'a')
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_2_code)
+    
+    country.alpha_2_code += 'a'
+    assert country.valid?
+    
+    country.alpha_2_code += 'a'
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_2_code)
   end
   
-  def test_should_require_unique_alpha_2_code
-    assert_invalid countries(:united_states).clone, :alpha_2_code
+  def test_should_require_an_alpha_3_code
+    country = new_country(:alpha_3_code => nil)
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_3_code)
   end
   
-  def test_should_require_alpha_3_code
-    assert_invalid countries(:united_states), :alpha_3_code, nil
+  def test_should_not_allow_alpha_3_codes_shorter_or_longer_than_3_characters
+    country = new_country(:alpha_3_code => 'aa')
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_3_code)
+    
+    country.alpha_3_code += 'a'
+    assert country.valid?
+    
+    country.alpha_3_code += 'a'
+    assert !country.valid?
+    assert country.errors.invalid?(:alpha_3_code)
   end
   
-  def test_should_restrict_alpha_3_code_length
-    assert_invalid countries(:united_states), :alpha_3_code, 'US', 'USAC'
-    assert_valid countries(:united_states), :alpha_3_code, 'USA'
+  def test_should_use_alpha_2_code_for_abbreviation_2
+    country = new_country(:alpha_2_code => 'US')
+    assert_equal 'US', country.abbreviation_2
   end
   
-  def test_should_require_unique_alpha_3_code
-    assert_invalid countries(:united_states).clone, :alpha_3_code
+  def test_should_use_alpha_3_code_for_abbreviation_3
+    country = new_country(:alpha_3_code => 'USA')
+    assert_equal 'USA', country.abbreviation_3
   end
   
-  def test_abbreviation_2_should_be_same_as_alpha_2_code
-    assert_equal 'US', countries(:united_states).abbreviation_2
+  def test_should_use_alpha_2_code_for_stringification
+    country = new_country(:alpha_2_code => 'US')
+    assert_equal 'US', country.to_s
   end
-  
-  def test_abbreviation_3_should_be_same_as_alpha_3_code
-    assert_equal 'USA', countries(:united_states).abbreviation_3
+end
+
+class CountryAfterBeingCreatedTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country
   end
   
-  def test_should_have_an_official_name
-    assert_equal 'United States of America', countries(:united_states).official_name
+  def test_should_not_have_any_regions
+    assert @country.regions.empty?
   end
   
-  def test_should_use_name_when_official_name_is_not_present
-    assert_equal 'Canada', countries(:canada).official_name
+  def test_should_not_have_any_addresses
+    assert @country.addresses.empty?
   end
-  
-  def test_should_return_name_for_to_s
-    assert_equal 'United States', countries(:united_states).to_s
-    assert_equal 'Canada', countries(:canada).to_s
+end
+
+class CountryWithRegionsTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country
+    @region = create_region(:country => @country)
   end
   
-  def test_regions
-    assert_equal [regions(:california)], countries(:united_states).regions
+  def test_should_have_regions
+    assert_equal [@region], @country.regions
+  end
+end
+
+class CountryWithAddressesTest < ActiveRecord::TestCase
+  def setup
+    @country = create_country
+    @address = create_address(:country => @country)
   end
   
-  def teardown
-    FileUtils.rmtree("#{RAILS_ROOT}/db/bootstrap")
+  def test_should_have_addresses
+    assert_equal [@address], @country.addresses
   end
 end