aboutsummaryrefslogtreecommitdiffstats
path: root/activeresource/test/cases
diff options
context:
space:
mode:
Diffstat (limited to 'activeresource/test/cases')
-rw-r--r--activeresource/test/cases/authorization_test.rb122
-rw-r--r--activeresource/test/cases/base/custom_methods_test.rb101
-rw-r--r--activeresource/test/cases/base/equality_test.rb52
-rw-r--r--activeresource/test/cases/base/load_test.rb163
-rw-r--r--activeresource/test/cases/base_errors_test.rb83
-rw-r--r--activeresource/test/cases/base_test.rb969
-rw-r--r--activeresource/test/cases/finder_test.rb195
-rw-r--r--activeresource/test/cases/format_test.rb112
-rw-r--r--activeresource/test/cases/observing_test.rb53
-rw-r--r--activeresource/test/cases/validations_test.rb55
10 files changed, 1905 insertions, 0 deletions
diff --git a/activeresource/test/cases/authorization_test.rb b/activeresource/test/cases/authorization_test.rb
new file mode 100644
index 0000000000..ca25f437e3
--- /dev/null
+++ b/activeresource/test/cases/authorization_test.rb
@@ -0,0 +1,122 @@
+require 'abstract_unit'
+
+class AuthorizationTest < Test::Unit::TestCase
+ Response = Struct.new(:code)
+
+ def setup
+ @conn = ActiveResource::Connection.new('http://localhost')
+ @matz = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+ @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+ @authenticated_conn = ActiveResource::Connection.new("http://david:test123@localhost")
+ @authorization_request_header = { 'Authorization' => 'Basic ZGF2aWQ6dGVzdDEyMw==' }
+
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/2.xml", @authorization_request_header, @david
+ mock.put "/people/2.xml", @authorization_request_header, nil, 204
+ mock.delete "/people/2.xml", @authorization_request_header, nil, 200
+ mock.post "/people/2/addresses.xml", @authorization_request_header, nil, 201, 'Location' => '/people/1/addresses/5'
+ end
+ end
+
+ def test_authorization_header
+ authorization_header = @authenticated_conn.__send__(:authorization_header)
+ assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["david", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_with_username_but_no_password
+ @conn = ActiveResource::Connection.new("http://david:@localhost")
+ authorization_header = @conn.__send__(:authorization_header)
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["david"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_with_password_but_no_username
+ @conn = ActiveResource::Connection.new("http://:test123@localhost")
+ authorization_header = @conn.__send__(:authorization_header)
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_with_decoded_credentials_from_url
+ @conn = ActiveResource::Connection.new("http://my%40email.com:%31%32%33@localhost")
+ authorization_header = @conn.__send__(:authorization_header)
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["my@email.com", "123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_explicitly_setting_username_and_password
+ @authenticated_conn = ActiveResource::Connection.new("http://@localhost")
+ @authenticated_conn.user = 'david'
+ @authenticated_conn.password = 'test123'
+ authorization_header = @authenticated_conn.__send__(:authorization_header)
+ assert_equal @authorization_request_header['Authorization'], authorization_header['Authorization']
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["david", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_explicitly_setting_username_but_no_password
+ @conn = ActiveResource::Connection.new("http://@localhost")
+ @conn.user = "david"
+ authorization_header = @conn.__send__(:authorization_header)
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["david"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_authorization_header_explicitly_setting_password_but_no_username
+ @conn = ActiveResource::Connection.new("http://@localhost")
+ @conn.password = "test123"
+ authorization_header = @conn.__send__(:authorization_header)
+ authorization = authorization_header["Authorization"].to_s.split
+
+ assert_equal "Basic", authorization[0]
+ assert_equal ["", "test123"], ActiveSupport::Base64.decode64(authorization[1]).split(":")[0..1]
+ end
+
+ def test_get
+ david = @authenticated_conn.get("/people/2.xml")
+ assert_equal "David", david["name"]
+ end
+
+ def test_post
+ response = @authenticated_conn.post("/people/2/addresses.xml")
+ assert_equal "/people/1/addresses/5", response["Location"]
+ end
+
+ def test_put
+ response = @authenticated_conn.put("/people/2.xml")
+ assert_equal 204, response.code
+ end
+
+ def test_delete
+ response = @authenticated_conn.delete("/people/2.xml")
+ assert_equal 200, response.code
+ end
+
+ def test_raises_invalid_request_on_unauthorized_requests
+ assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2.xml") }
+ assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.xml") }
+ assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.xml") }
+ assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.xml") }
+ end
+
+ protected
+ def assert_response_raises(klass, code)
+ assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
+ @conn.__send__(:handle_response, Response.new(code))
+ end
+ end
+end
diff --git a/activeresource/test/cases/base/custom_methods_test.rb b/activeresource/test/cases/base/custom_methods_test.rb
new file mode 100644
index 0000000000..2d81549a65
--- /dev/null
+++ b/activeresource/test/cases/base/custom_methods_test.rb
@@ -0,0 +1,101 @@
+require 'abstract_unit'
+require 'fixtures/person'
+require 'fixtures/street_address'
+require 'active_support/core_ext/hash/conversions'
+
+class CustomMethodsTest < Test::Unit::TestCase
+ def setup
+ @matz = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+ @matz_deep = { :id => 1, :name => 'Matz', :other => 'other' }.to_xml(:root => 'person')
+ @matz_array = [{ :id => 1, :name => 'Matz' }].to_xml(:root => 'people')
+ @ryan = { :name => 'Ryan' }.to_xml(:root => 'person')
+ @addy = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
+ @addy_deep = { :id => 1, :street => '12345 Street', :zip => "27519" }.to_xml(:root => 'address')
+
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, @matz
+ mock.get "/people/1/shallow.xml", {}, @matz
+ mock.get "/people/1/deep.xml", {}, @matz_deep
+ mock.get "/people/retrieve.xml?name=Matz", {}, @matz_array
+ mock.get "/people/managers.xml", {}, @matz_array
+ mock.post "/people/hire.xml?name=Matz", {}, nil, 201
+ mock.put "/people/1/promote.xml?position=Manager", {}, nil, 204
+ mock.put "/people/promote.xml?name=Matz", {}, nil, 204, {}
+ mock.put "/people/sort.xml?by=name", {}, nil, 204
+ mock.delete "/people/deactivate.xml?name=Matz", {}, nil, 200
+ mock.delete "/people/1/deactivate.xml", {}, nil, 200
+ mock.post "/people/new/register.xml", {}, @ryan, 201, 'Location' => '/people/5.xml'
+ mock.post "/people/1/register.xml", {}, @matz, 201
+ mock.get "/people/1/addresses/1.xml", {}, @addy
+ mock.get "/people/1/addresses/1/deep.xml", {}, @addy_deep
+ mock.put "/people/1/addresses/1/normalize_phone.xml?locale=US", {}, nil, 204
+ mock.put "/people/1/addresses/sort.xml?by=name", {}, nil, 204
+ mock.post "/people/1/addresses/new/link.xml", {}, { :street => '12345 Street' }.to_xml(:root => 'address'), 201, 'Location' => '/people/1/addresses/2.xml'
+ end
+
+ Person.user = nil
+ Person.password = nil
+ end
+
+ def teardown
+ ActiveResource::HttpMock.reset!
+ end
+
+ def test_custom_collection_method
+ # GET
+ assert_equal([{ "id" => 1, "name" => 'Matz' }], Person.get(:retrieve, :name => 'Matz'))
+
+ # POST
+ assert_equal(ActiveResource::Response.new("", 201, {}), Person.post(:hire, :name => 'Matz'))
+
+ # PUT
+ assert_equal ActiveResource::Response.new("", 204, {}),
+ Person.put(:promote, {:name => 'Matz'}, 'atestbody')
+ assert_equal ActiveResource::Response.new("", 204, {}), Person.put(:sort, :by => 'name')
+
+ # DELETE
+ Person.delete :deactivate, :name => 'Matz'
+
+ # Nested resource
+ assert_equal ActiveResource::Response.new("", 204, {}), StreetAddress.put(:sort, :person_id => 1, :by => 'name')
+ end
+
+ def test_custom_element_method
+ # Test GET against an element URL
+ assert_equal Person.find(1).get(:shallow), {"id" => 1, "name" => 'Matz'}
+ assert_equal Person.find(1).get(:deep), {"id" => 1, "name" => 'Matz', "other" => 'other'}
+
+ # Test PUT against an element URL
+ assert_equal ActiveResource::Response.new("", 204, {}), Person.find(1).put(:promote, {:position => 'Manager'}, 'body')
+
+ # Test DELETE against an element URL
+ assert_equal ActiveResource::Response.new("", 200, {}), Person.find(1).delete(:deactivate)
+
+ # With nested resources
+ assert_equal StreetAddress.find(1, :params => { :person_id => 1 }).get(:deep),
+ { "id" => 1, "street" => '12345 Street', "zip" => "27519" }
+ assert_equal ActiveResource::Response.new("", 204, {}),
+ StreetAddress.find(1, :params => { :person_id => 1 }).put(:normalize_phone, :locale => 'US')
+ end
+
+ def test_custom_new_element_method
+ # Test POST against a new element URL
+ ryan = Person.new(:name => 'Ryan')
+ assert_equal ActiveResource::Response.new(@ryan, 201, {'Location' => '/people/5.xml'}), ryan.post(:register)
+ expected_request = ActiveResource::Request.new(:post, '/people/new/register.xml', @ryan)
+ assert_equal expected_request.body, ActiveResource::HttpMock.requests.first.body
+
+ # Test POST against a nested collection URL
+ addy = StreetAddress.new(:street => '123 Test Dr.', :person_id => 1)
+ assert_equal ActiveResource::Response.new({ :street => '12345 Street' }.to_xml(:root => 'address'),
+ 201, {'Location' => '/people/1/addresses/2.xml'}),
+ addy.post(:link)
+
+ matz = Person.new(:id => 1, :name => 'Matz')
+ assert_equal ActiveResource::Response.new(@matz, 201), matz.post(:register)
+ end
+
+ def test_find_custom_resources
+ assert_equal 'Matz', Person.find(:all, :from => :managers).first.name
+ end
+end
diff --git a/activeresource/test/cases/base/equality_test.rb b/activeresource/test/cases/base/equality_test.rb
new file mode 100644
index 0000000000..84f1a7b998
--- /dev/null
+++ b/activeresource/test/cases/base/equality_test.rb
@@ -0,0 +1,52 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/street_address"
+
+class BaseEqualityTest < Test::Unit::TestCase
+ def setup
+ @new = Person.new
+ @one = Person.new(:id => 1)
+ @two = Person.new(:id => 2)
+ @street = StreetAddress.new(:id => 2)
+ end
+
+ def test_should_equal_self
+ assert @new == @new, '@new == @new'
+ assert @one == @one, '@one == @one'
+ end
+
+ def test_shouldnt_equal_new_resource
+ assert @new != @one, '@new != @one'
+ assert @one != @new, '@one != @new'
+ end
+
+ def test_shouldnt_equal_different_class
+ assert @two != @street, 'person != street_address with same id'
+ assert @street != @two, 'street_address != person with same id'
+ end
+
+ def test_eql_should_alias_equals_operator
+ assert_equal @new == @new, @new.eql?(@new)
+ assert_equal @new == @one, @new.eql?(@one)
+
+ assert_equal @one == @one, @one.eql?(@one)
+ assert_equal @one == @new, @one.eql?(@new)
+
+ assert_equal @one == @street, @one.eql?(@street)
+ end
+
+ def test_hash_should_be_id_hash
+ [@new, @one, @two, @street].each do |resource|
+ assert_equal resource.id.hash, resource.hash
+ end
+ end
+
+ def test_with_prefix_options
+ assert_equal @one == @one, @one.eql?(@one)
+ assert_equal @one == @one.dup, @one.eql?(@one.dup)
+ new_one = @one.dup
+ new_one.prefix_options = {:foo => 'bar'}
+ assert_not_equal @one, new_one
+ end
+
+end
diff --git a/activeresource/test/cases/base/load_test.rb b/activeresource/test/cases/base/load_test.rb
new file mode 100644
index 0000000000..1952f5b5f0
--- /dev/null
+++ b/activeresource/test/cases/base/load_test.rb
@@ -0,0 +1,163 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/street_address"
+require 'active_support/core_ext/symbol'
+require 'active_support/core_ext/hash/conversions'
+
+module Highrise
+ class Note < ActiveResource::Base
+ self.site = "http://37s.sunrise.i:3000"
+ end
+
+ class Comment < ActiveResource::Base
+ self.site = "http://37s.sunrise.i:3000"
+ end
+
+ module Deeply
+ module Nested
+
+ class Note < ActiveResource::Base
+ self.site = "http://37s.sunrise.i:3000"
+ end
+
+ class Comment < ActiveResource::Base
+ self.site = "http://37s.sunrise.i:3000"
+ end
+
+ module TestDifferentLevels
+
+ class Note < ActiveResource::Base
+ self.site = "http://37s.sunrise.i:3000"
+ end
+
+ end
+
+ end
+ end
+
+end
+
+
+class BaseLoadTest < Test::Unit::TestCase
+ def setup
+ @matz = { :id => 1, :name => 'Matz' }
+
+ @first_address = { :id => 1, :street => '12345 Street' }
+ @addresses = [@first_address, { :id => 2, :street => '67890 Street' }]
+ @addresses_from_xml = { :street_addresses => @addresses }
+ @addresses_from_xml_single = { :street_addresses => [ @first_address ] }
+
+ @deep = { :id => 1, :street => {
+ :id => 1, :state => { :id => 1, :name => 'Oregon',
+ :notable_rivers => [
+ { :id => 1, :name => 'Willamette' },
+ { :id => 2, :name => 'Columbia', :rafted_by => @matz }],
+ :postal_codes => [ 97018, 1234567890 ],
+ :places => [ "Columbia City", "Unknown" ]}}}
+
+ @person = Person.new
+ end
+
+ def test_load_expects_hash
+ assert_raise(ArgumentError) { @person.load nil }
+ assert_raise(ArgumentError) { @person.load '<person id="1"/>' }
+ end
+
+ def test_load_simple_hash
+ assert_equal Hash.new, @person.attributes
+ assert_equal @matz.stringify_keys, @person.load(@matz).attributes
+ end
+
+ def test_load_one_with_existing_resource
+ address = @person.load(:street_address => @first_address).street_address
+ assert_kind_of StreetAddress, address
+ assert_equal @first_address.stringify_keys, address.attributes
+ end
+
+ def test_load_one_with_unknown_resource
+ address = silence_warnings { @person.load(:address => @first_address).address }
+ assert_kind_of Person::Address, address
+ assert_equal @first_address.stringify_keys, address.attributes
+ end
+
+ def test_load_collection_with_existing_resource
+ addresses = @person.load(@addresses_from_xml).street_addresses
+ assert_kind_of Array, addresses
+ addresses.each { |address| assert_kind_of StreetAddress, address }
+ assert_equal @addresses.map(&:stringify_keys), addresses.map(&:attributes)
+ end
+
+ def test_load_collection_with_unknown_resource
+ Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
+ assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
+ addresses = silence_warnings { @person.load(:addresses => @addresses).addresses }
+ assert Person.const_defined?(:Address), "Address should have been autocreated"
+ addresses.each { |address| assert_kind_of Person::Address, address }
+ assert_equal @addresses.map(&:stringify_keys), addresses.map(&:attributes)
+ end
+
+ def test_load_collection_with_single_existing_resource
+ addresses = @person.load(@addresses_from_xml_single).street_addresses
+ assert_kind_of Array, addresses
+ addresses.each { |address| assert_kind_of StreetAddress, address }
+ assert_equal [ @first_address ].map(&:stringify_keys), addresses.map(&:attributes)
+ end
+
+ def test_load_collection_with_single_unknown_resource
+ Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
+ assert !Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
+ addresses = silence_warnings { @person.load(:addresses => [ @first_address ]).addresses }
+ assert Person.const_defined?(:Address), "Address should have been autocreated"
+ addresses.each { |address| assert_kind_of Person::Address, address }
+ assert_equal [ @first_address ].map(&:stringify_keys), addresses.map(&:attributes)
+ end
+
+ def test_recursively_loaded_collections
+ person = @person.load(@deep)
+ assert_equal @deep[:id], person.id
+
+ street = person.street
+ assert_kind_of Person::Street, street
+ assert_equal @deep[:street][:id], street.id
+
+ state = street.state
+ assert_kind_of Person::Street::State, state
+ assert_equal @deep[:street][:state][:id], state.id
+
+ rivers = state.notable_rivers
+ assert_kind_of Array, rivers
+ assert_kind_of Person::Street::State::NotableRiver, rivers.first
+ assert_equal @deep[:street][:state][:notable_rivers].first[:id], rivers.first.id
+ assert_equal @matz[:id], rivers.last.rafted_by.id
+
+ postal_codes = state.postal_codes
+ assert_kind_of Array, postal_codes
+ assert_equal 2, postal_codes.size
+ assert_kind_of Fixnum, postal_codes.first
+ assert_equal @deep[:street][:state][:postal_codes].first, postal_codes.first
+ assert_kind_of Numeric, postal_codes.last
+ assert_equal @deep[:street][:state][:postal_codes].last, postal_codes.last
+
+ places = state.places
+ assert_kind_of Array, places
+ assert_kind_of String, places.first
+ assert_equal @deep[:street][:state][:places].first, places.first
+ end
+
+ def test_nested_collections_within_the_same_namespace
+ n = Highrise::Note.new(:comments => [{ :name => "1" }])
+ assert_kind_of Highrise::Comment, n.comments.first
+ end
+
+ def test_nested_collections_within_deeply_nested_namespace
+ n = Highrise::Deeply::Nested::Note.new(:comments => [{ :name => "1" }])
+ assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
+ end
+
+ def test_nested_collections_in_different_levels_of_namespaces
+ n = Highrise::Deeply::Nested::TestDifferentLevels::Note.new(:comments => [{ :name => "1" }])
+ assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
+ end
+
+
+end
diff --git a/activeresource/test/cases/base_errors_test.rb b/activeresource/test/cases/base_errors_test.rb
new file mode 100644
index 0000000000..eca00e9ca8
--- /dev/null
+++ b/activeresource/test/cases/base_errors_test.rb
@@ -0,0 +1,83 @@
+require 'abstract_unit'
+require "fixtures/person"
+
+class BaseErrorsTest < Test::Unit::TestCase
+ def setup
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.post "/people.xml", {}, %q(<?xml version="1.0" encoding="UTF-8"?><errors><error>Age can't be blank</error><error>Name can't be blank</error><error>Name must start with a letter</error><error>Person quota full for today.</error></errors>), 422, {'Content-Type' => 'application/xml'}
+ mock.post "/people.json", {}, %q({"errors":["Age can't be blank","Name can't be blank","Name must start with a letter","Person quota full for today."]}), 422, {'Content-Type' => 'application/json'}
+ end
+ end
+
+ def test_should_mark_as_invalid
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ assert !@person.valid?
+ end
+ end
+ end
+
+ def test_should_parse_xml_errors
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ assert_kind_of ActiveResource::Errors, @person.errors
+ assert_equal 4, @person.errors.size
+ end
+ end
+ end
+
+ def test_should_parse_errors_to_individual_attributes
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ assert @person.errors[:name].any?
+ assert_equal ["can't be blank"], @person.errors[:age]
+ assert_equal ["can't be blank", "must start with a letter"], @person.errors[:name]
+ assert_equal ["Person quota full for today."], @person.errors[:base]
+ end
+ end
+ end
+
+ def test_should_iterate_over_errors
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ errors = []
+ @person.errors.each { |attribute, message| errors << [attribute, message] }
+ assert errors.include?([:name, "can't be blank"])
+ end
+ end
+ end
+
+ def test_should_iterate_over_full_errors
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ errors = []
+ @person.errors.to_a.each { |message| errors << message }
+ assert errors.include?("Name can't be blank")
+ end
+ end
+ end
+
+ def test_should_format_full_errors
+ [ :json, :xml ].each do |format|
+ invalid_user_using_format(format) do
+ full = @person.errors.full_messages
+ assert full.include?("Age can't be blank")
+ assert full.include?("Name can't be blank")
+ assert full.include?("Name must start with a letter")
+ assert full.include?("Person quota full for today.")
+ end
+ end
+ end
+
+ private
+ def invalid_user_using_format(mime_type_reference)
+ previous_format = Person.format
+ Person.format = mime_type_reference
+ @person = Person.new(:name => '', :age => '')
+ assert_equal false, @person.save
+
+ yield
+ ensure
+ Person.format = previous_format
+ end
+end
diff --git a/activeresource/test/cases/base_test.rb b/activeresource/test/cases/base_test.rb
new file mode 100644
index 0000000000..8c0217aad6
--- /dev/null
+++ b/activeresource/test/cases/base_test.rb
@@ -0,0 +1,969 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/customer"
+require "fixtures/street_address"
+require "fixtures/beast"
+require "fixtures/proxy"
+require 'active_support/core_ext/hash/conversions'
+
+class BaseTest < Test::Unit::TestCase
+ def setup
+ @matz = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+ @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+ @greg = { :id => 3, :name => 'Greg' }.to_xml(:root => 'person')
+ @addy = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
+ @default_request_headers = { 'Content-Type' => 'application/xml' }
+ @rick = { :name => "Rick", :age => 25 }.to_xml(:root => "person")
+ @people = [{ :id => 1, :name => 'Matz' }, { :id => 2, :name => 'David' }].to_xml(:root => 'people')
+ @people_david = [{ :id => 2, :name => 'David' }].to_xml(:root => 'people')
+ @addresses = [{ :id => 1, :street => '12345 Street' }].to_xml(:root => 'addresses')
+
+ # - deep nested resource -
+ # - Luis (Customer)
+ # - JK (Customer::Friend)
+ # - Mateo (Customer::Friend::Brother)
+ # - Edith (Customer::Friend::Brother::Child)
+ # - Martha (Customer::Friend::Brother::Child)
+ # - Felipe (Customer::Friend::Brother)
+ # - Bryan (Customer::Friend::Brother::Child)
+ # - Luke (Customer::Friend::Brother::Child)
+ # - Eduardo (Customer::Friend)
+ # - Sebas (Customer::Friend::Brother)
+ # - Andres (Customer::Friend::Brother::Child)
+ # - Jorge (Customer::Friend::Brother::Child)
+ # - Elsa (Customer::Friend::Brother)
+ # - Natacha (Customer::Friend::Brother::Child)
+ # - Milena (Customer::Friend::Brother)
+ #
+ @luis = {:id => 1, :name => 'Luis',
+ :friends => [{:name => 'JK',
+ :brothers => [{:name => 'Mateo',
+ :children => [{:name => 'Edith'},{:name => 'Martha'}]},
+ {:name => 'Felipe',
+ :children => [{:name => 'Bryan'},{:name => 'Luke'}]}]},
+ {:name => 'Eduardo',
+ :brothers => [{:name => 'Sebas',
+ :children => [{:name => 'Andres'},{:name => 'Jorge'}]},
+ {:name => 'Elsa',
+ :children => [{:name => 'Natacha'}]},
+ {:name => 'Milena',
+ :children => []}]}]}.to_xml(:root => 'customer')
+ # - resource with yaml array of strings; for ActiveRecords using serialize :bar, Array
+ @marty = <<-eof.strip
+ <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+ <person>
+ <id type=\"integer\">5</id>
+ <name>Marty</name>
+ <colors type=\"yaml\">---
+ - \"red\"
+ - \"green\"
+ - \"blue\"
+ </colors>
+ </person>
+ eof
+
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, @matz
+ mock.get "/people/2.xml", {}, @david
+ mock.get "/people/5.xml", {}, @marty
+ mock.get "/people/Greg.xml", {}, @greg
+ mock.get "/people/4.xml", {'key' => 'value'}, nil, 404
+ mock.put "/people/1.xml", {}, nil, 204
+ mock.delete "/people/1.xml", {}, nil, 200
+ mock.delete "/people/2.xml", {}, nil, 400
+ mock.get "/people/99.xml", {}, nil, 404
+ mock.post "/people.xml", {}, @rick, 201, 'Location' => '/people/5.xml'
+ mock.get "/people.xml", {}, @people
+ mock.get "/people/1/addresses.xml", {}, @addresses
+ mock.get "/people/1/addresses/1.xml", {}, @addy
+ mock.get "/people/1/addresses/2.xml", {}, nil, 404
+ mock.get "/people/2/addresses/1.xml", {}, nil, 404
+ mock.get "/people/Greg/addresses/1.xml", {}, @addy
+ mock.put "/people/1/addresses/1.xml", {}, nil, 204
+ mock.delete "/people/1/addresses/1.xml", {}, nil, 200
+ mock.post "/people/1/addresses.xml", {}, nil, 201, 'Location' => '/people/1/addresses/5'
+ mock.get "/people//addresses.xml", {}, nil, 404
+ mock.get "/people//addresses/1.xml", {}, nil, 404
+ mock.put "/people//addresses/1.xml", {}, nil, 404
+ mock.delete "/people//addresses/1.xml", {}, nil, 404
+ mock.post "/people//addresses.xml", {}, nil, 404
+ mock.head "/people/1.xml", {}, nil, 200
+ mock.head "/people/Greg.xml", {}, nil, 200
+ mock.head "/people/99.xml", {}, nil, 404
+ mock.head "/people/1/addresses/1.xml", {}, nil, 200
+ mock.head "/people/1/addresses/2.xml", {}, nil, 404
+ mock.head "/people/2/addresses/1.xml", {}, nil, 404
+ mock.head "/people/Greg/addresses/1.xml", {}, nil, 200
+ # customer
+ mock.get "/customers/1.xml", {}, @luis
+ end
+
+ Person.user = nil
+ Person.password = nil
+ end
+
+
+ def test_site_accessor_accepts_uri_or_string_argument
+ site = URI.parse('http://localhost')
+
+ assert_nothing_raised { Person.site = 'http://localhost' }
+ assert_equal site, Person.site
+
+ assert_nothing_raised { Person.site = site }
+ assert_equal site, Person.site
+ end
+
+ def test_should_use_site_prefix_and_credentials
+ assert_equal 'http://foo:bar@beast.caboo.se', Forum.site.to_s
+ assert_equal 'http://foo:bar@beast.caboo.se/forums/:forum_id', Topic.site.to_s
+ end
+
+ def test_site_variable_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ assert_nil actor.site
+ actor.site = 'http://localhost:31337'
+ actor.site = nil
+ assert_nil actor.site
+ end
+
+ def test_proxy_accessor_accepts_uri_or_string_argument
+ proxy = URI.parse('http://localhost')
+
+ assert_nothing_raised { Person.proxy = 'http://localhost' }
+ assert_equal proxy, Person.proxy
+
+ assert_nothing_raised { Person.proxy = proxy }
+ assert_equal proxy, Person.proxy
+ end
+
+ def test_should_use_proxy_prefix_and_credentials
+ assert_equal 'http://user:password@proxy.local:3000', ProxyResource.proxy.to_s
+ end
+
+ def test_proxy_variable_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ assert_nil actor.site
+ actor.proxy = 'http://localhost:31337'
+ actor.proxy = nil
+ assert_nil actor.site
+ end
+
+ def test_should_accept_setting_user
+ Forum.user = 'david'
+ assert_equal('david', Forum.user)
+ assert_equal('david', Forum.connection.user)
+ end
+
+ def test_should_accept_setting_password
+ Forum.password = 'test123'
+ assert_equal('test123', Forum.password)
+ assert_equal('test123', Forum.connection.password)
+ end
+
+ def test_should_accept_setting_timeout
+ Forum.timeout = 5
+ assert_equal(5, Forum.timeout)
+ assert_equal(5, Forum.connection.timeout)
+ end
+
+ def test_should_accept_setting_ssl_options
+ expected = {:verify => 1}
+ Forum.ssl_options= expected
+ assert_equal(expected, Forum.ssl_options)
+ assert_equal(expected, Forum.connection.ssl_options)
+ end
+
+ def test_user_variable_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ actor.site = 'http://cinema'
+ assert_nil actor.user
+ actor.user = 'username'
+ actor.user = nil
+ assert_nil actor.user
+ assert_nil actor.connection.user
+ end
+
+ def test_password_variable_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ actor.site = 'http://cinema'
+ assert_nil actor.password
+ actor.password = 'username'
+ actor.password = nil
+ assert_nil actor.password
+ assert_nil actor.connection.password
+ end
+
+ def test_timeout_variable_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ actor.site = 'http://cinema'
+ assert_nil actor.timeout
+ actor.timeout = 5
+ actor.timeout = nil
+ assert_nil actor.timeout
+ assert_nil actor.connection.timeout
+ end
+
+ def test_ssl_options_hash_can_be_reset
+ actor = Class.new(ActiveResource::Base)
+ actor.site = 'https://cinema'
+ assert_nil actor.ssl_options
+ actor.ssl_options = {:foo => 5}
+ actor.ssl_options = nil
+ assert_nil actor.ssl_options
+ assert_nil actor.connection.ssl_options
+ end
+
+ def test_credentials_from_site_are_decoded
+ actor = Class.new(ActiveResource::Base)
+ actor.site = 'http://my%40email.com:%31%32%33@cinema'
+ assert_equal("my@email.com", actor.user)
+ assert_equal("123", actor.password)
+ end
+
+ def test_site_reader_uses_superclass_site_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.site
+ assert_nil Class.new(ActiveResource::Base).site
+
+ # Subclass uses superclass site.
+ actor = Class.new(Person)
+ assert_equal Person.site, actor.site
+
+ # Subclass returns frozen superclass copy.
+ assert !Person.site.frozen?
+ assert actor.site.frozen?
+
+ # Changing subclass site doesn't change superclass site.
+ actor.site = 'http://localhost:31337'
+ assert_not_equal Person.site, actor.site
+
+ # Changed subclass site is not frozen.
+ assert !actor.site.frozen?
+
+ # Changing superclass site doesn't overwrite subclass site.
+ Person.site = 'http://somewhere.else'
+ assert_not_equal Person.site, actor.site
+
+ # Changing superclass site after subclassing changes subclass site.
+ jester = Class.new(actor)
+ actor.site = 'http://nomad'
+ assert_equal actor.site, jester.site
+ assert jester.site.frozen?
+
+ # Subclasses are always equal to superclass site when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.site = 'http://market'
+ assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
+
+ fruit.site = 'http://supermarket'
+ assert_equal fruit.site, apple.site, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_proxy_reader_uses_superclass_site_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.proxy
+ assert_nil Class.new(ActiveResource::Base).proxy
+
+ # Subclass uses superclass proxy.
+ actor = Class.new(Person)
+ assert_equal Person.proxy, actor.proxy
+
+ # Subclass returns frozen superclass copy.
+ assert !Person.proxy.frozen?
+ assert actor.proxy.frozen?
+
+ # Changing subclass proxy doesn't change superclass site.
+ actor.proxy = 'http://localhost:31337'
+ assert_not_equal Person.proxy, actor.proxy
+
+ # Changed subclass proxy is not frozen.
+ assert !actor.proxy.frozen?
+
+ # Changing superclass proxy doesn't overwrite subclass site.
+ Person.proxy = 'http://somewhere.else'
+ assert_not_equal Person.proxy, actor.proxy
+
+ # Changing superclass proxy after subclassing changes subclass site.
+ jester = Class.new(actor)
+ actor.proxy = 'http://nomad'
+ assert_equal actor.proxy, jester.proxy
+ assert jester.proxy.frozen?
+
+ # Subclasses are always equal to superclass proxy when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.proxy = 'http://market'
+ assert_equal fruit.proxy, apple.proxy, 'subclass did not adopt changes from parent class'
+
+ fruit.proxy = 'http://supermarket'
+ assert_equal fruit.proxy, apple.proxy, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_user_reader_uses_superclass_user_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.user
+ assert_nil Class.new(ActiveResource::Base).user
+ Person.user = 'anonymous'
+
+ # Subclass uses superclass user.
+ actor = Class.new(Person)
+ assert_equal Person.user, actor.user
+
+ # Subclass returns frozen superclass copy.
+ assert !Person.user.frozen?
+ assert actor.user.frozen?
+
+ # Changing subclass user doesn't change superclass user.
+ actor.user = 'david'
+ assert_not_equal Person.user, actor.user
+
+ # Changing superclass user doesn't overwrite subclass user.
+ Person.user = 'john'
+ assert_not_equal Person.user, actor.user
+
+ # Changing superclass user after subclassing changes subclass user.
+ jester = Class.new(actor)
+ actor.user = 'john.doe'
+ assert_equal actor.user, jester.user
+
+ # Subclasses are always equal to superclass user when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.user = 'manager'
+ assert_equal fruit.user, apple.user, 'subclass did not adopt changes from parent class'
+
+ fruit.user = 'client'
+ assert_equal fruit.user, apple.user, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_password_reader_uses_superclass_password_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.password
+ assert_nil Class.new(ActiveResource::Base).password
+ Person.password = 'my-password'
+
+ # Subclass uses superclass password.
+ actor = Class.new(Person)
+ assert_equal Person.password, actor.password
+
+ # Subclass returns frozen superclass copy.
+ assert !Person.password.frozen?
+ assert actor.password.frozen?
+
+ # Changing subclass password doesn't change superclass password.
+ actor.password = 'secret'
+ assert_not_equal Person.password, actor.password
+
+ # Changing superclass password doesn't overwrite subclass password.
+ Person.password = 'super-secret'
+ assert_not_equal Person.password, actor.password
+
+ # Changing superclass password after subclassing changes subclass password.
+ jester = Class.new(actor)
+ actor.password = 'even-more-secret'
+ assert_equal actor.password, jester.password
+
+ # Subclasses are always equal to superclass password when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.password = 'mega-secret'
+ assert_equal fruit.password, apple.password, 'subclass did not adopt changes from parent class'
+
+ fruit.password = 'ok-password'
+ assert_equal fruit.password, apple.password, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_timeout_reader_uses_superclass_timeout_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.timeout
+ assert_nil Class.new(ActiveResource::Base).timeout
+ Person.timeout = 5
+
+ # Subclass uses superclass timeout.
+ actor = Class.new(Person)
+ assert_equal Person.timeout, actor.timeout
+
+ # Changing subclass timeout doesn't change superclass timeout.
+ actor.timeout = 10
+ assert_not_equal Person.timeout, actor.timeout
+
+ # Changing superclass timeout doesn't overwrite subclass timeout.
+ Person.timeout = 15
+ assert_not_equal Person.timeout, actor.timeout
+
+ # Changing superclass timeout after subclassing changes subclass timeout.
+ jester = Class.new(actor)
+ actor.timeout = 20
+ assert_equal actor.timeout, jester.timeout
+
+ # Subclasses are always equal to superclass timeout when not overridden.
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.timeout = 25
+ assert_equal fruit.timeout, apple.timeout, 'subclass did not adopt changes from parent class'
+
+ fruit.timeout = 30
+ assert_equal fruit.timeout, apple.timeout, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_ssl_options_reader_uses_superclass_ssl_options_until_written
+ # Superclass is Object so returns nil.
+ assert_nil ActiveResource::Base.ssl_options
+ assert_nil Class.new(ActiveResource::Base).ssl_options
+ Person.ssl_options = {:foo => 'bar'}
+
+ # Subclass uses superclass ssl_options.
+ actor = Class.new(Person)
+ assert_equal Person.ssl_options, actor.ssl_options
+
+ # Changing subclass ssl_options doesn't change superclass ssl_options.
+ actor.ssl_options = {:baz => ''}
+ assert_not_equal Person.ssl_options, actor.ssl_options
+
+ # Changing superclass ssl_options doesn't overwrite subclass ssl_options.
+ Person.ssl_options = {:color => 'blue'}
+ assert_not_equal Person.ssl_options, actor.ssl_options
+
+ # Changing superclass ssl_options after subclassing changes subclass ssl_options.
+ jester = Class.new(actor)
+ actor.ssl_options = {:color => 'red'}
+ assert_equal actor.ssl_options, jester.ssl_options
+
+ # Subclasses are always equal to superclass ssl_options when not overridden.
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.ssl_options = {:alpha => 'betas'}
+ assert_equal fruit.ssl_options, apple.ssl_options, 'subclass did not adopt changes from parent class'
+
+ fruit.ssl_options = {:omega => 'moos'}
+ assert_equal fruit.ssl_options, apple.ssl_options, 'subclass did not adopt changes from parent class'
+ end
+
+ def test_updating_baseclass_site_object_wipes_descendent_cached_connection_objects
+ # Subclasses are always equal to superclass site when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+
+ fruit.site = 'http://market'
+ assert_equal fruit.connection.site, apple.connection.site
+ first_connection = apple.connection.object_id
+
+ fruit.site = 'http://supermarket'
+ assert_equal fruit.connection.site, apple.connection.site
+ second_connection = apple.connection.object_id
+ assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+ end
+
+ def test_updating_baseclass_user_wipes_descendent_cached_connection_objects
+ # Subclasses are always equal to superclass user when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+ fruit.site = 'http://market'
+
+ fruit.user = 'david'
+ assert_equal fruit.connection.user, apple.connection.user
+ first_connection = apple.connection.object_id
+
+ fruit.user = 'john'
+ assert_equal fruit.connection.user, apple.connection.user
+ second_connection = apple.connection.object_id
+ assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+ end
+
+ def test_updating_baseclass_password_wipes_descendent_cached_connection_objects
+ # Subclasses are always equal to superclass password when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+ fruit.site = 'http://market'
+
+ fruit.password = 'secret'
+ assert_equal fruit.connection.password, apple.connection.password
+ first_connection = apple.connection.object_id
+
+ fruit.password = 'supersecret'
+ assert_equal fruit.connection.password, apple.connection.password
+ second_connection = apple.connection.object_id
+ assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+ end
+
+ def test_updating_baseclass_timeout_wipes_descendent_cached_connection_objects
+ # Subclasses are always equal to superclass timeout when not overridden
+ fruit = Class.new(ActiveResource::Base)
+ apple = Class.new(fruit)
+ fruit.site = 'http://market'
+
+ fruit.timeout = 5
+ assert_equal fruit.connection.timeout, apple.connection.timeout
+ first_connection = apple.connection.object_id
+
+ fruit.timeout = 10
+ assert_equal fruit.connection.timeout, apple.connection.timeout
+ second_connection = apple.connection.object_id
+ assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
+ end
+
+ def test_collection_name
+ assert_equal "people", Person.collection_name
+ end
+
+ def test_collection_path
+ assert_equal '/people.xml', Person.collection_path
+ end
+
+ def test_collection_path_with_parameters
+ assert_equal '/people.xml?gender=male', Person.collection_path(:gender => 'male')
+ assert_equal '/people.xml?gender=false', Person.collection_path(:gender => false)
+ assert_equal '/people.xml?gender=', Person.collection_path(:gender => nil)
+
+ assert_equal '/people.xml?gender=male', Person.collection_path('gender' => 'male')
+
+ # Use includes? because ordering of param hash is not guaranteed
+ assert Person.collection_path(:gender => 'male', :student => true).include?('/people.xml?')
+ assert Person.collection_path(:gender => 'male', :student => true).include?('gender=male')
+ assert Person.collection_path(:gender => 'male', :student => true).include?('student=true')
+
+ assert_equal '/people.xml?name%5B%5D=bob&name%5B%5D=your+uncle%2Bme&name%5B%5D=&name%5B%5D=false', Person.collection_path(:name => ['bob', 'your uncle+me', nil, false])
+
+ assert_equal '/people.xml?struct%5Ba%5D%5B%5D=2&struct%5Ba%5D%5B%5D=1&struct%5Bb%5D=fred', Person.collection_path(:struct => {:a => [2,1], 'b' => 'fred'})
+ end
+
+ def test_custom_element_path
+ assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, :person_id => 1)
+ assert_equal '/people/1/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 1)
+ assert_equal '/people/Greg/addresses/1.xml', StreetAddress.element_path(1, 'person_id' => 'Greg')
+ end
+
+ def test_custom_element_path_with_redefined_to_param
+ Person.module_eval do
+ alias_method :original_to_param_element_path, :to_param
+ def to_param
+ name
+ end
+ end
+
+ # Class method.
+ assert_equal '/people/Greg.xml', Person.element_path('Greg')
+
+ # Protected Instance method.
+ assert_equal '/people/Greg.xml', Person.find('Greg').send(:element_path)
+
+ ensure
+ # revert back to original
+ Person.module_eval do
+ # save the 'new' to_param so we don't get a warning about discarding the method
+ alias_method :element_path_to_param, :to_param
+ alias_method :to_param, :original_to_param_element_path
+ end
+ end
+
+ def test_custom_element_path_with_parameters
+ assert_equal '/people/1/addresses/1.xml?type=work', StreetAddress.element_path(1, :person_id => 1, :type => 'work')
+ assert_equal '/people/1/addresses/1.xml?type=work', StreetAddress.element_path(1, 'person_id' => 1, :type => 'work')
+ assert_equal '/people/1/addresses/1.xml?type=work', StreetAddress.element_path(1, :type => 'work', :person_id => 1)
+ assert_equal '/people/1/addresses/1.xml?type%5B%5D=work&type%5B%5D=play+time', StreetAddress.element_path(1, :person_id => 1, :type => ['work', 'play time'])
+ end
+
+ def test_custom_element_path_with_prefix_and_parameters
+ assert_equal '/people/1/addresses/1.xml?type=work', StreetAddress.element_path(1, {:person_id => 1}, {:type => 'work'})
+ end
+
+ def test_custom_collection_path
+ assert_equal '/people/1/addresses.xml', StreetAddress.collection_path(:person_id => 1)
+ assert_equal '/people/1/addresses.xml', StreetAddress.collection_path('person_id' => 1)
+ end
+
+ def test_custom_collection_path_with_parameters
+ assert_equal '/people/1/addresses.xml?type=work', StreetAddress.collection_path(:person_id => 1, :type => 'work')
+ assert_equal '/people/1/addresses.xml?type=work', StreetAddress.collection_path('person_id' => 1, :type => 'work')
+ end
+
+ def test_custom_collection_path_with_prefix_and_parameters
+ assert_equal '/people/1/addresses.xml?type=work', StreetAddress.collection_path({:person_id => 1}, {:type => 'work'})
+ end
+
+ def test_custom_element_name
+ assert_equal 'address', StreetAddress.element_name
+ end
+
+ def test_custom_collection_name
+ assert_equal 'addresses', StreetAddress.collection_name
+ end
+
+ def test_prefix
+ assert_equal "/", Person.prefix
+ assert_equal Set.new, Person.__send__(:prefix_parameters)
+ end
+
+ def test_set_prefix
+ SetterTrap.rollback_sets(Person) do |person_class|
+ person_class.prefix = "the_prefix"
+ assert_equal "the_prefix", person_class.prefix
+ end
+ end
+
+ def test_set_prefix_with_inline_keys
+ SetterTrap.rollback_sets(Person) do |person_class|
+ person_class.prefix = "the_prefix:the_param"
+ assert_equal "the_prefixthe_param_value", person_class.prefix(:the_param => "the_param_value")
+ end
+ end
+
+ def test_set_prefix_twice_should_clear_params
+ SetterTrap.rollback_sets(Person) do |person_class|
+ person_class.prefix = "the_prefix/:the_param1"
+ assert_equal Set.new([:the_param1]), person_class.prefix_parameters
+ person_class.prefix = "the_prefix/:the_param2"
+ assert_equal Set.new([:the_param2]), person_class.prefix_parameters
+ end
+ end
+
+ def test_set_prefix_with_default_value
+ SetterTrap.rollback_sets(Person) do |person_class|
+ person_class.set_prefix
+ assert_equal "/", person_class.prefix
+ end
+ end
+
+ def test_custom_prefix
+ assert_equal '/people//', StreetAddress.prefix
+ assert_equal '/people/1/', StreetAddress.prefix(:person_id => 1)
+ assert_equal [:person_id].to_set, StreetAddress.__send__(:prefix_parameters)
+ end
+
+ def test_respond_to
+ matz = Person.find(1)
+ assert matz.respond_to?(:name)
+ assert matz.respond_to?(:name=)
+ assert matz.respond_to?(:name?)
+ assert !matz.respond_to?(:super_scalable_stuff)
+ end
+
+ def test_custom_header
+ Person.headers['key'] = 'value'
+ assert_raise(ActiveResource::ResourceNotFound) { Person.find(4) }
+ ensure
+ Person.headers.delete('key')
+ end
+
+ def test_save
+ rick = Person.new
+ assert rick.save
+ assert_equal '5', rick.id
+ end
+
+ def test_save!
+ rick = Person.new
+ assert rick.save!
+ assert_equal '5', rick.id
+ end
+
+ def test_id_from_response
+ p = Person.new
+ resp = {'Location' => '/foo/bar/1'}
+ assert_equal '1', p.__send__(:id_from_response, resp)
+
+ resp['Location'] << '.xml'
+ assert_equal '1', p.__send__(:id_from_response, resp)
+ end
+
+ def test_id_from_response_without_location
+ p = Person.new
+ resp = {}
+ assert_equal nil, p.__send__(:id_from_response, resp)
+ end
+
+ def test_create_with_custom_prefix
+ matzs_house = StreetAddress.new(:person_id => 1)
+ matzs_house.save
+ assert_equal '5', matzs_house.id
+ end
+
+ # Test that loading a resource preserves its prefix_options.
+ def test_load_preserves_prefix_options
+ address = StreetAddress.find(1, :params => { :person_id => 1 })
+ ryan = Person.new(:id => 1, :name => 'Ryan', :address => address)
+ assert_equal address.prefix_options, ryan.address.prefix_options
+ end
+
+ def test_reload_works_with_prefix_options
+ address = StreetAddress.find(1, :params => { :person_id => 1 })
+ assert_equal address, address.reload
+ end
+
+ def test_reload_with_redefined_to_param
+ Person.module_eval do
+ alias_method :original_to_param_reload, :to_param
+ def to_param
+ name
+ end
+ end
+
+ person = Person.find('Greg')
+ assert_equal person, person.reload
+
+ ensure
+ # revert back to original
+ Person.module_eval do
+ # save the 'new' to_param so we don't get a warning about discarding the method
+ alias_method :reload_to_param, :to_param
+ alias_method :to_param, :original_to_param_reload
+ end
+ end
+
+ def test_reload_works_without_prefix_options
+ person = Person.find(:first)
+ assert_equal person, person.reload
+ end
+
+ def test_create
+ rick = Person.create(:name => 'Rick')
+ assert rick.valid?
+ assert !rick.new?
+ assert_equal '5', rick.id
+
+ # test additional attribute returned on create
+ assert_equal 25, rick.age
+
+ # Test that save exceptions get bubbled up too
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.post "/people.xml", {}, nil, 409
+ end
+ assert_raise(ActiveResource::ResourceConflict) { Person.create(:name => 'Rick') }
+ end
+
+ def test_create_without_location
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.post "/people.xml", {}, nil, 201
+ end
+ person = Person.create(:name => 'Rick')
+ assert_equal nil, person.id
+ end
+
+ def test_clone
+ matz = Person.find(1)
+ matz_c = matz.clone
+ assert matz_c.new?
+ matz.attributes.each do |k, v|
+ assert_equal v, matz_c.send(k) if k != Person.primary_key
+ end
+ end
+
+ def test_nested_clone
+ addy = StreetAddress.find(1, :params => {:person_id => 1})
+ addy_c = addy.clone
+ assert addy_c.new?
+ addy.attributes.each do |k, v|
+ assert_equal v, addy_c.send(k) if k != StreetAddress.primary_key
+ end
+ assert_equal addy.prefix_options, addy_c.prefix_options
+ end
+
+ def test_complex_clone
+ matz = Person.find(1)
+ matz.address = StreetAddress.find(1, :params => {:person_id => matz.id})
+ matz.non_ar_hash = {:not => "an ARes instance"}
+ matz.non_ar_arr = ["not", "ARes"]
+ matz_c = matz.clone
+ assert matz_c.new?
+ assert_raise(NoMethodError) {matz_c.address}
+ assert_equal matz.non_ar_hash, matz_c.non_ar_hash
+ assert_equal matz.non_ar_arr, matz_c.non_ar_arr
+
+ # Test that actual copy, not just reference copy
+ matz.non_ar_hash[:not] = "changed"
+ assert_not_equal matz.non_ar_hash, matz_c.non_ar_hash
+ end
+
+ def test_update
+ matz = Person.find(:first)
+ matz.name = "David"
+ assert_kind_of Person, matz
+ assert_equal "David", matz.name
+ assert_equal true, matz.save
+ end
+
+ def test_update_with_custom_prefix_with_specific_id
+ addy = StreetAddress.find(1, :params => { :person_id => 1 })
+ addy.street = "54321 Street"
+ assert_kind_of StreetAddress, addy
+ assert_equal "54321 Street", addy.street
+ addy.save
+ end
+
+ def test_update_with_custom_prefix_without_specific_id
+ addy = StreetAddress.find(:first, :params => { :person_id => 1 })
+ addy.street = "54321 Lane"
+ assert_kind_of StreetAddress, addy
+ assert_equal "54321 Lane", addy.street
+ addy.save
+ end
+
+ def test_update_conflict
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/2.xml", {}, @david
+ mock.put "/people/2.xml", @default_request_headers, nil, 409
+ end
+ assert_raise(ActiveResource::ResourceConflict) { Person.find(2).save }
+ end
+
+ def test_destroy
+ assert Person.find(1).destroy
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, nil, 404
+ end
+ assert_raise(ActiveResource::ResourceNotFound) { Person.find(1).destroy }
+ end
+
+ def test_destroy_with_custom_prefix
+ assert StreetAddress.find(1, :params => { :person_id => 1 }).destroy
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1/addresses/1.xml", {}, nil, 404
+ end
+ assert_raise(ActiveResource::ResourceNotFound) { StreetAddress.find(1, :params => { :person_id => 1 }) }
+ end
+
+ def test_destroy_with_410_gone
+ assert Person.find(1).destroy
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, nil, 410
+ end
+ assert_raise(ActiveResource::ResourceGone) { Person.find(1).destroy }
+ end
+
+ def test_delete
+ assert Person.delete(1)
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, nil, 404
+ end
+ assert_raise(ActiveResource::ResourceNotFound) { Person.find(1) }
+ end
+
+ def test_delete_with_custom_prefix
+ assert StreetAddress.delete(1, :person_id => 1)
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1/addresses/1.xml", {}, nil, 404
+ end
+ assert_raise(ActiveResource::ResourceNotFound) { StreetAddress.find(1, :params => { :person_id => 1 }) }
+ end
+
+ def test_delete_with_410_gone
+ assert Person.delete(1)
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, nil, 410
+ end
+ assert_raise(ActiveResource::ResourceGone) { Person.find(1) }
+ end
+
+ def test_exists
+ # Class method.
+ assert !Person.exists?(nil)
+ assert Person.exists?(1)
+ assert !Person.exists?(99)
+
+ # Instance method.
+ assert !Person.new.exists?
+ assert Person.find(1).exists?
+ assert !Person.new(:id => 99).exists?
+
+ # Nested class method.
+ assert StreetAddress.exists?(1, :params => { :person_id => 1 })
+ assert !StreetAddress.exists?(1, :params => { :person_id => 2 })
+ assert !StreetAddress.exists?(2, :params => { :person_id => 1 })
+
+ # Nested instance method.
+ assert StreetAddress.find(1, :params => { :person_id => 1 }).exists?
+ assert !StreetAddress.new({:id => 1, :person_id => 2}).exists?
+ assert !StreetAddress.new({:id => 2, :person_id => 1}).exists?
+ end
+
+ def test_exists_with_redefined_to_param
+ Person.module_eval do
+ alias_method :original_to_param_exists, :to_param
+ def to_param
+ name
+ end
+ end
+
+ # Class method.
+ assert Person.exists?('Greg')
+
+ # Instance method.
+ assert Person.find('Greg').exists?
+
+ # Nested class method.
+ assert StreetAddress.exists?(1, :params => { :person_id => Person.find('Greg').to_param })
+
+ # Nested instance method.
+ assert StreetAddress.find(1, :params => { :person_id => Person.find('Greg').to_param }).exists?
+
+ ensure
+ # revert back to original
+ Person.module_eval do
+ # save the 'new' to_param so we don't get a warning about discarding the method
+ alias_method :exists_to_param, :to_param
+ alias_method :to_param, :original_to_param_exists
+ end
+ end
+
+ def test_exists_without_http_mock
+ http = Net::HTTP.new(Person.site.host, Person.site.port)
+ ActiveResource::Connection.any_instance.expects(:http).returns(http)
+ http.expects(:request).returns(ActiveResource::Response.new(""))
+
+ assert Person.exists?('not-mocked')
+ end
+
+ def test_exists_with_410_gone
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.head "/people/1.xml", {}, nil, 410
+ end
+
+ assert !Person.exists?(1)
+ end
+
+ def test_to_xml
+ matz = Person.find(1)
+ xml = matz.encode
+ assert xml.include?('<?xml version="1.0" encoding="UTF-8"?>')
+ assert xml.include?('<name>Matz</name>')
+ assert xml.include?('<id type="integer">1</id>')
+ end
+
+ def test_to_param_quacks_like_active_record
+ new_person = Person.new
+ assert_nil new_person.to_param
+ matz = Person.find(1)
+ assert_equal '1', matz.to_param
+ end
+
+ def test_parse_deep_nested_resources
+ luis = Customer.find(1)
+ assert_kind_of Customer, luis
+ luis.friends.each do |friend|
+ assert_kind_of Customer::Friend, friend
+ friend.brothers.each do |brother|
+ assert_kind_of Customer::Friend::Brother, brother
+ brother.children.each do |child|
+ assert_kind_of Customer::Friend::Brother::Child, child
+ end
+ end
+ end
+ end
+
+ def test_load_yaml_array
+ assert_nothing_raised do
+ marty = Person.find(5)
+ assert_equal 3, marty.colors.size
+ marty.colors.each do |color|
+ assert_kind_of String, color
+ end
+ end
+ end
+end
diff --git a/activeresource/test/cases/finder_test.rb b/activeresource/test/cases/finder_test.rb
new file mode 100644
index 0000000000..38f7de96ac
--- /dev/null
+++ b/activeresource/test/cases/finder_test.rb
@@ -0,0 +1,195 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/customer"
+require "fixtures/street_address"
+require "fixtures/beast"
+require "fixtures/proxy"
+require 'active_support/core_ext/hash/conversions'
+
+class FinderTest < Test::Unit::TestCase
+ def setup
+ # TODO: refactor/DRY this setup - it's a copy of the BaseTest setup.
+ # We can probably put this into abstract_unit
+ @matz = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+ @david = { :id => 2, :name => 'David' }.to_xml(:root => 'person')
+ @greg = { :id => 3, :name => 'Greg' }.to_xml(:root => 'person')
+ @addy = { :id => 1, :street => '12345 Street' }.to_xml(:root => 'address')
+ @default_request_headers = { 'Content-Type' => 'application/xml' }
+ @rick = { :name => "Rick", :age => 25 }.to_xml(:root => "person")
+ @people = [{ :id => 1, :name => 'Matz' }, { :id => 2, :name => 'David' }].to_xml(:root => 'people')
+ @people_david = [{ :id => 2, :name => 'David' }].to_xml(:root => 'people')
+ @addresses = [{ :id => 1, :street => '12345 Street' }].to_xml(:root => 'addresses')
+
+ # - deep nested resource -
+ # - Luis (Customer)
+ # - JK (Customer::Friend)
+ # - Mateo (Customer::Friend::Brother)
+ # - Edith (Customer::Friend::Brother::Child)
+ # - Martha (Customer::Friend::Brother::Child)
+ # - Felipe (Customer::Friend::Brother)
+ # - Bryan (Customer::Friend::Brother::Child)
+ # - Luke (Customer::Friend::Brother::Child)
+ # - Eduardo (Customer::Friend)
+ # - Sebas (Customer::Friend::Brother)
+ # - Andres (Customer::Friend::Brother::Child)
+ # - Jorge (Customer::Friend::Brother::Child)
+ # - Elsa (Customer::Friend::Brother)
+ # - Natacha (Customer::Friend::Brother::Child)
+ # - Milena (Customer::Friend::Brother)
+ #
+ @luis = {:id => 1, :name => 'Luis',
+ :friends => [{:name => 'JK',
+ :brothers => [{:name => 'Mateo',
+ :children => [{:name => 'Edith'},{:name => 'Martha'}]},
+ {:name => 'Felipe',
+ :children => [{:name => 'Bryan'},{:name => 'Luke'}]}]},
+ {:name => 'Eduardo',
+ :brothers => [{:name => 'Sebas',
+ :children => [{:name => 'Andres'},{:name => 'Jorge'}]},
+ {:name => 'Elsa',
+ :children => [{:name => 'Natacha'}]},
+ {:name => 'Milena',
+ :children => []}]}]}.to_xml(:root => 'customer')
+ # - resource with yaml array of strings; for ActiveRecords using serialize :bar, Array
+ @marty = <<-eof.strip
+ <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+ <person>
+ <id type=\"integer\">5</id>
+ <name>Marty</name>
+ <colors type=\"yaml\">---
+ - \"red\"
+ - \"green\"
+ - \"blue\"
+ </colors>
+ </person>
+ eof
+
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, @matz
+ mock.get "/people/2.xml", {}, @david
+ mock.get "/people/5.xml", {}, @marty
+ mock.get "/people/Greg.xml", {}, @greg
+ mock.get "/people/4.xml", {'key' => 'value'}, nil, 404
+ mock.put "/people/1.xml", {}, nil, 204
+ mock.delete "/people/1.xml", {}, nil, 200
+ mock.delete "/people/2.xml", {}, nil, 400
+ mock.get "/people/99.xml", {}, nil, 404
+ mock.post "/people.xml", {}, @rick, 201, 'Location' => '/people/5.xml'
+ mock.get "/people.xml", {}, @people
+ mock.get "/people/1/addresses.xml", {}, @addresses
+ mock.get "/people/1/addresses/1.xml", {}, @addy
+ mock.get "/people/1/addresses/2.xml", {}, nil, 404
+ mock.get "/people/2/addresses.xml", {}, nil, 404
+ mock.get "/people/2/addresses/1.xml", {}, nil, 404
+ mock.get "/people/Greg/addresses/1.xml", {}, @addy
+ mock.put "/people/1/addresses/1.xml", {}, nil, 204
+ mock.delete "/people/1/addresses/1.xml", {}, nil, 200
+ mock.post "/people/1/addresses.xml", {}, nil, 201, 'Location' => '/people/1/addresses/5'
+ mock.get "/people//addresses.xml", {}, nil, 404
+ mock.get "/people//addresses/1.xml", {}, nil, 404
+ mock.put "/people//addresses/1.xml", {}, nil, 404
+ mock.delete "/people//addresses/1.xml", {}, nil, 404
+ mock.post "/people//addresses.xml", {}, nil, 404
+ mock.head "/people/1.xml", {}, nil, 200
+ mock.head "/people/Greg.xml", {}, nil, 200
+ mock.head "/people/99.xml", {}, nil, 404
+ mock.head "/people/1/addresses/1.xml", {}, nil, 200
+ mock.head "/people/1/addresses/2.xml", {}, nil, 404
+ mock.head "/people/2/addresses/1.xml", {}, nil, 404
+ mock.head "/people/Greg/addresses/1.xml", {}, nil, 200
+ # customer
+ mock.get "/customers/1.xml", {}, @luis
+ end
+
+ Person.user = nil
+ Person.password = nil
+ end
+
+ def test_find_by_id
+ matz = Person.find(1)
+ assert_kind_of Person, matz
+ assert_equal "Matz", matz.name
+ assert matz.name?
+ end
+
+ def test_find_by_id_with_custom_prefix
+ addy = StreetAddress.find(1, :params => { :person_id => 1 })
+ assert_kind_of StreetAddress, addy
+ assert_equal '12345 Street', addy.street
+ end
+
+ def test_find_all
+ all = Person.find(:all)
+ assert_equal 2, all.size
+ assert_kind_of Person, all.first
+ assert_equal "Matz", all.first.name
+ assert_equal "David", all.last.name
+ end
+
+ def test_find_first
+ matz = Person.find(:first)
+ assert_kind_of Person, matz
+ assert_equal "Matz", matz.name
+ end
+
+ def test_find_last
+ david = Person.find(:last)
+ assert_kind_of Person, david
+ assert_equal 'David', david.name
+ end
+
+ def test_find_by_id_not_found
+ assert_raise(ActiveResource::ResourceNotFound) { Person.find(99) }
+ assert_raise(ActiveResource::ResourceNotFound) { StreetAddress.find(1) }
+ end
+
+ def test_find_all_sub_objects
+ all = StreetAddress.find(:all, :params => { :person_id => 1 })
+ assert_equal 1, all.size
+ assert_kind_of StreetAddress, all.first
+ end
+
+ def test_find_all_sub_objects_not_found
+ assert_nothing_raised do
+ addys = StreetAddress.find(:all, :params => { :person_id => 2 })
+ end
+ end
+
+ def test_find_all_by_from
+ ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.xml", {}, @people_david }
+
+ people = Person.find(:all, :from => "/companies/1/people.xml")
+ assert_equal 1, people.size
+ assert_equal "David", people.first.name
+ end
+
+ def test_find_all_by_from_with_options
+ ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/people.xml", {}, @people_david }
+
+ people = Person.find(:all, :from => "/companies/1/people.xml")
+ assert_equal 1, people.size
+ assert_equal "David", people.first.name
+ end
+
+ def test_find_all_by_symbol_from
+ ActiveResource::HttpMock.respond_to { |m| m.get "/people/managers.xml", {}, @people_david }
+
+ people = Person.find(:all, :from => :managers)
+ assert_equal 1, people.size
+ assert_equal "David", people.first.name
+ end
+
+ def test_find_single_by_from
+ ActiveResource::HttpMock.respond_to { |m| m.get "/companies/1/manager.xml", {}, @david }
+
+ david = Person.find(:one, :from => "/companies/1/manager.xml")
+ assert_equal "David", david.name
+ end
+
+ def test_find_single_by_symbol_from
+ ActiveResource::HttpMock.respond_to { |m| m.get "/people/leader.xml", {}, @david }
+
+ david = Person.find(:one, :from => :leader)
+ assert_equal "David", david.name
+ end
+end
diff --git a/activeresource/test/cases/format_test.rb b/activeresource/test/cases/format_test.rb
new file mode 100644
index 0000000000..c3733e13d8
--- /dev/null
+++ b/activeresource/test/cases/format_test.rb
@@ -0,0 +1,112 @@
+require 'abstract_unit'
+require "fixtures/person"
+require "fixtures/street_address"
+
+class FormatTest < Test::Unit::TestCase
+ def setup
+ @matz = { :id => 1, :name => 'Matz' }
+ @david = { :id => 2, :name => 'David' }
+
+ @programmers = [ @matz, @david ]
+ end
+
+ def test_http_format_header_name
+ header_name = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[:get]
+ assert_equal 'Accept', header_name
+
+ headers_names = [ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[:put], ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[:post]]
+ headers_names.each{ |name| assert_equal 'Content-Type', name }
+ end
+
+ def test_formats_on_single_element
+ for format in [ :json, :xml ]
+ using_format(Person, format) do
+ ActiveResource::HttpMock.respond_to.get "/people/1.#{format}", {'Accept' => ActiveResource::Formats[format].mime_type}, ActiveResource::Formats[format].encode(@david)
+ assert_equal @david[:name], Person.find(1).name
+ end
+ end
+ end
+
+ def test_formats_on_collection
+ for format in [ :json, :xml ]
+ using_format(Person, format) do
+ ActiveResource::HttpMock.respond_to.get "/people.#{format}", {'Accept' => ActiveResource::Formats[format].mime_type}, ActiveResource::Formats[format].encode(@programmers)
+ remote_programmers = Person.find(:all)
+ assert_equal 2, remote_programmers.size
+ assert remote_programmers.select { |p| p.name == 'David' }
+ end
+ end
+ end
+
+ def test_formats_on_custom_collection_method
+ for format in [ :json, :xml ]
+ using_format(Person, format) do
+ ActiveResource::HttpMock.respond_to.get "/people/retrieve.#{format}?name=David", {'Accept' => ActiveResource::Formats[format].mime_type}, ActiveResource::Formats[format].encode([@david])
+ remote_programmers = Person.get(:retrieve, :name => 'David')
+ assert_equal 1, remote_programmers.size
+ assert_equal @david[:id], remote_programmers[0]['id']
+ assert_equal @david[:name], remote_programmers[0]['name']
+ end
+ end
+ end
+
+ def test_formats_on_custom_element_method
+ for format in [ :json, :xml ]
+ using_format(Person, format) do
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/2.#{format}", {'Accept' => ActiveResource::Formats[format].mime_type}, ActiveResource::Formats[format].encode(@david)
+ mock.get "/people/2/shallow.#{format}", {'Accept' => ActiveResource::Formats[format].mime_type}, ActiveResource::Formats[format].encode(@david)
+ end
+ remote_programmer = Person.find(2).get(:shallow)
+ assert_equal @david[:id], remote_programmer['id']
+ assert_equal @david[:name], remote_programmer['name']
+ end
+ end
+
+ for format in [ :json, :xml ]
+ ryan = ActiveResource::Formats[format].encode({ :name => 'Ryan' })
+ using_format(Person, format) do
+ remote_ryan = Person.new(:name => 'Ryan')
+ ActiveResource::HttpMock.respond_to.post "/people.#{format}", {'Content-Type' => ActiveResource::Formats[format].mime_type}, ryan, 201, {'Location' => "/people/5.#{format}"}
+ remote_ryan.save
+
+ remote_ryan = Person.new(:name => 'Ryan')
+ ActiveResource::HttpMock.respond_to.post "/people/new/register.#{format}", {'Content-Type' => ActiveResource::Formats[format].mime_type}, ryan, 201, {'Location' => "/people/5.#{format}"}
+ assert_equal ActiveResource::Response.new(ryan, 201, {'Location' => "/people/5.#{format}"}), remote_ryan.post(:register)
+ end
+ end
+ end
+
+ def test_setting_format_before_site
+ resource = Class.new(ActiveResource::Base)
+ resource.format = :json
+ resource.site = 'http://37s.sunrise.i:3000'
+ assert_equal ActiveResource::Formats[:json], resource.connection.format
+ end
+
+ def test_serialization_of_nested_resource
+ address = { :street => '12345 Street' }
+ person = { :name=> 'Rus', :address => address}
+
+ [:json, :xml].each do |format|
+ encoded_person = ActiveResource::Formats[format].encode(person)
+ assert_match(/12345 Street/, encoded_person)
+ remote_person = Person.new(person.update({:address => StreetAddress.new(address)}))
+ assert_kind_of StreetAddress, remote_person.address
+ using_format(Person, format) do
+ ActiveResource::HttpMock.respond_to.post "/people.#{format}", {'Content-Type' => ActiveResource::Formats[format].mime_type}, encoded_person, 201, {'Location' => "/people/5.#{format}"}
+ remote_person.save
+ end
+ end
+ end
+
+ private
+ def using_format(klass, mime_type_reference)
+ previous_format = klass.format
+ klass.format = mime_type_reference
+
+ yield
+ ensure
+ klass.format = previous_format
+ end
+end
diff --git a/activeresource/test/cases/observing_test.rb b/activeresource/test/cases/observing_test.rb
new file mode 100644
index 0000000000..334b256772
--- /dev/null
+++ b/activeresource/test/cases/observing_test.rb
@@ -0,0 +1,53 @@
+require 'abstract_unit'
+
+class ObservingTest < Test::Unit::TestCase
+ cattr_accessor :history
+
+ class PersonObserver < ActiveModel::Observer
+ observe :person
+
+ %w( after_create after_destroy after_save after_update
+ before_create before_destroy before_save before_update).each do |method|
+ define_method(method) { log method }
+ end
+
+ private
+ def log(method)
+ (ObservingTest.history ||= []) << method.to_sym
+ end
+ end
+
+ def setup
+ @matz = { :id => 1, :name => 'Matz' }.to_xml(:root => 'person')
+
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.get "/people/1.xml", {}, @matz
+ mock.post "/people.xml", {}, @matz, 201, 'Location' => '/people/1.xml'
+ mock.put "/people/1.xml", {}, nil, 204
+ mock.delete "/people/1.xml", {}, nil, 200
+ end
+
+ PersonObserver.instance
+ end
+
+ def teardown
+ self.history = nil
+ end
+
+ def test_create_fires_save_and_create_notifications
+ rick = Person.create(:name => 'Rick')
+ assert_equal [:before_save, :before_create, :after_create, :after_save], self.history
+ end
+
+ def test_update_fires_save_and_update_notifications
+ person = Person.find(1)
+ person.save
+ assert_equal [:before_save, :before_update, :after_update, :after_save], self.history
+ end
+
+ def test_destroy_fires_destroy_notifications
+ person = Person.find(1)
+ person.destroy
+ assert_equal [:before_destroy, :after_destroy], self.history
+ end
+end
diff --git a/activeresource/test/cases/validations_test.rb b/activeresource/test/cases/validations_test.rb
new file mode 100644
index 0000000000..a8ab7d64e7
--- /dev/null
+++ b/activeresource/test/cases/validations_test.rb
@@ -0,0 +1,55 @@
+require 'abstract_unit'
+require "fixtures/project"
+
+# The validations are tested thoroughly under ActiveModel::Validations
+# This test case simply makes sur that they are all accessible by
+# Active Resource objects.
+class ValidationsTest < ActiveModel::TestCase
+ VALID_PROJECT_HASH = { :name => "My Project", :description => "A project" }
+ def setup
+ @my_proj = VALID_PROJECT_HASH.to_xml(:root => "person")
+ ActiveResource::HttpMock.respond_to do |mock|
+ mock.post "/projects.xml", {}, @my_proj, 201, 'Location' => '/projects/5.xml'
+ end
+ end
+
+ def test_validates_presence_of
+ p = new_project(:name => nil)
+ assert !p.valid?, "should not be a valid record without name"
+ assert !p.save, "should not have saved an invalid record"
+ assert_equal ["can't be blank"], p.errors[:name], "should have an error on name"
+
+ p.name = "something"
+
+ assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
+ end
+
+ def test_fails_save!
+ p = new_project(:name => nil)
+ assert_raise(ActiveResource::ResourceInvalid) { p.save! }
+ end
+
+
+ def test_validate_callback
+ # we have a callback ensuring the description is longer than three letters
+ p = new_project(:description => 'a')
+ assert !p.valid?, "should not be a valid record when it fails a validation callback"
+ assert !p.save, "should not have saved an invalid record"
+ assert_equal ["must be greater than three letters long"], p.errors[:description], "should be an error on description"
+
+ # should now allow this description
+ p.description = 'abcd'
+ assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
+ end
+
+ protected
+
+ # quickie helper to create a new project with all the required
+ # attributes.
+ # Pass in any params you specifically want to override
+ def new_project(opts = {})
+ Project.new(VALID_PROJECT_HASH.merge(opts))
+ end
+
+end
+