diff options
Diffstat (limited to 'activeresource/test/cases')
| -rw-r--r-- | activeresource/test/cases/authorization_test.rb | 122 | ||||
| -rw-r--r-- | activeresource/test/cases/base/custom_methods_test.rb | 101 | ||||
| -rw-r--r-- | activeresource/test/cases/base/equality_test.rb | 52 | ||||
| -rw-r--r-- | activeresource/test/cases/base/load_test.rb | 163 | ||||
| -rw-r--r-- | activeresource/test/cases/base_errors_test.rb | 83 | ||||
| -rw-r--r-- | activeresource/test/cases/base_test.rb | 1039 | ||||
| -rw-r--r-- | activeresource/test/cases/format_test.rb | 112 | ||||
| -rw-r--r-- | activeresource/test/cases/observing_test.rb | 53 | ||||
| -rw-r--r-- | activeresource/test/cases/validations_test.rb | 49 |
9 files changed, 1774 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..9c236bc893 --- /dev/null +++ b/activeresource/test/cases/base_test.rb @@ -0,0 +1,1039 @@ +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_find_by_id + matz = Person.find(1) + assert_kind_of Person, matz + assert_equal "Matz", matz.name + assert matz.name? + 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_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_custom_header + Person.headers['key'] = 'value' + assert_raise(ActiveResource::ResourceNotFound) { Person.find(4) } + ensure + Person.headers.delete('key') + 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_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 + + def test_save + rick = Person.new + assert_equal true, 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/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..f5a43b1ac1 --- /dev/null +++ b/activeresource/test/cases/validations_test.rb @@ -0,0 +1,49 @@ +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_validate_callback + # we have a callback ensuring the description is longer thn 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 + |