vendor/rails/activeresource/test/base/load_test.rb

   1 require 'abstract_unit'
   2 require "fixtures/person"
   3 require "fixtures/street_address"
   4
   5 module Highrise
   6   class Note < ActiveResource::Base
   7     self.site = "http://37s.sunrise.i:3000"
   8   end
   9
  10   class Comment < ActiveResource::Base
  11     self.site = "http://37s.sunrise.i:3000"
  12   end
  13
  14   module Deeply
  15     module Nested
  16
  17       class Note < ActiveResource::Base
  18         self.site = "http://37s.sunrise.i:3000"
  19       end
  20
  21        class Comment < ActiveResource::Base
  22          self.site = "http://37s.sunrise.i:3000"
  23        end
  24
  25        module TestDifferentLevels
  26
  27          class Note < ActiveResource::Base
  28            self.site = "http://37s.sunrise.i:3000"
  29          end
  30
  31        end
  32
  33     end
  34   end
  35
  36 end
  37
  38
  39 class BaseLoadTest < Test::Unit::TestCase
  40   def setup
  41     @matz  = { :id => 1, :name => 'Matz' }
  42
  43     @first_address = { :id => 1, :street => '12345 Street' }
  44     @addresses = [@first_address, { :id => 2, :street => '67890 Street' }]
  45     @addresses_from_xml = { :street_addresses => @addresses }
  46     @addresses_from_xml_single = { :street_addresses => [ @first_address ] }
  47
  48     @deep  = { :id => 1, :street => {
  49       :id => 1, :state => { :id => 1, :name => 'Oregon',
  50         :notable_rivers => [
  51           { :id => 1, :name => 'Willamette' },
  52           { :id => 2, :name => 'Columbia', :rafted_by => @matz }] }}}
  53
  54     @person = Person.new
  55   end
  56
  57   def test_load_expects_hash
  58     assert_raise(ArgumentError) { @person.load nil }
  59     assert_raise(ArgumentError) { @person.load '<person id="1"/>' }
  60   end
  61
  62   def test_load_simple_hash
  63     assert_equal Hash.new, @person.attributes
  64     assert_equal @matz.stringify_keys, @person.load(@matz).attributes
  65   end
  66
  67   def test_load_one_with_existing_resource
  68     address = @person.load(:street_address => @first_address).street_address
  69     assert_kind_of StreetAddress, address
  70     assert_equal @first_address.stringify_keys, address.attributes
  71   end
  72
  73   def test_load_one_with_unknown_resource
  74     address = silence_warnings { @person.load(:address => @first_address).address }
  75     assert_kind_of Person::Address, address
  76     assert_equal @first_address.stringify_keys, address.attributes
  77   end
  78
  79   def test_load_collection_with_existing_resource
  80     addresses = @person.load(@addresses_from_xml).street_addresses
  81     assert_kind_of Array, addresses
  82     addresses.each { |address| assert_kind_of StreetAddress, address }
  83     assert_equal @addresses.map(&:stringify_keys), addresses.map(&:attributes)
  84   end
  85
  86   def test_load_collection_with_unknown_resource
  87     Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
  88     assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
  89     addresses = silence_warnings { @person.load(:addresses => @addresses).addresses }
  90     assert Person.const_defined?(:Address), "Address should have been autocreated"
  91     addresses.each { |address| assert_kind_of Person::Address, address }
  92     assert_equal @addresses.map(&:stringify_keys), addresses.map(&:attributes)
  93   end
  94
  95   def test_load_collection_with_single_existing_resource
  96     addresses = @person.load(@addresses_from_xml_single).street_addresses
  97     assert_kind_of Array, addresses
  98     addresses.each { |address| assert_kind_of StreetAddress, address }
  99     assert_equal [ @first_address ].map(&:stringify_keys), addresses.map(&:attributes)
 100   end
 101
 102   def test_load_collection_with_single_unknown_resource
 103     Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
 104     assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
 105     addresses = silence_warnings { @person.load(:addresses => [ @first_address ]).addresses }
 106     assert Person.const_defined?(:Address), "Address should have been autocreated"
 107     addresses.each { |address| assert_kind_of Person::Address, address }
 108     assert_equal [ @first_address ].map(&:stringify_keys), addresses.map(&:attributes)
 109   end
 110
 111   def test_recursively_loaded_collections
 112     person = @person.load(@deep)
 113     assert_equal @deep[:id], person.id
 114
 115     street = person.street
 116     assert_kind_of Person::Street, street
 117     assert_equal @deep[:street][:id], street.id
 118
 119     state = street.state
 120     assert_kind_of Person::Street::State, state
 121     assert_equal @deep[:street][:state][:id], state.id
 122
 123     rivers = state.notable_rivers
 124     assert_kind_of Array, rivers
 125     assert_kind_of Person::Street::State::NotableRiver, rivers.first
 126     assert_equal @deep[:street][:state][:notable_rivers].first[:id], rivers.first.id
 127     assert_equal @matz[:id], rivers.last.rafted_by.id
 128   end
 129
 130   def test_nested_collections_within_the_same_namespace
 131     n = Highrise::Note.new(:comments => [{ :name => "1" }])
 132     assert_kind_of Highrise::Comment, n.comments.first
 133   end
 134
 135   def test_nested_collections_within_deeply_nested_namespace
 136     n = Highrise::Deeply::Nested::Note.new(:comments => [{ :name => "1" }])
 137     assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
 138   end
 139
 140   def test_nested_collections_in_different_levels_of_namespaces
 141     n = Highrise::Deeply::Nested::TestDifferentLevels::Note.new(:comments => [{ :name => "1" }])
 142     assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
 143   end
 144
 145
 146 end