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.rb254
-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.rb199
-rw-r--r--activeresource/test/cases/base/schema_test.rb411
-rw-r--r--activeresource/test/cases/base_errors_test.rb107
-rw-r--r--activeresource/test/cases/base_test.rb1144
-rw-r--r--activeresource/test/cases/connection_test.rb276
-rw-r--r--activeresource/test/cases/finder_test.rb139
-rw-r--r--activeresource/test/cases/format_test.rb114
-rw-r--r--activeresource/test/cases/http_mock_test.rb202
-rw-r--r--activeresource/test/cases/log_subscriber_test.rb32
-rw-r--r--activeresource/test/cases/observing_test.rb55
-rw-r--r--activeresource/test/cases/validations_test.rb67
14 files changed, 0 insertions, 3153 deletions
diff --git a/activeresource/test/cases/authorization_test.rb b/activeresource/test/cases/authorization_test.rb
deleted file mode 100644
index 0185e5432d..0000000000
--- a/activeresource/test/cases/authorization_test.rb
+++ /dev/null
@@ -1,254 +0,0 @@
-require 'abstract_unit'
-
-class AuthorizationTest < ActiveSupport::TestCase
- Response = Struct.new(:code)
-
- def setup
- @conn = ActiveResource::Connection.new('http://localhost')
- @matz = { :person => { :id => 1, :name => 'Matz' } }.to_json
- @david = { :person => { :id => 2, :name => 'David' } }.to_json
- @authenticated_conn = ActiveResource::Connection.new("http://david:test123@localhost")
- @basic_authorization_request_header = { 'Authorization' => 'Basic ZGF2aWQ6dGVzdDEyMw==' }
-
- @nonce = "MTI0OTUxMzc4NzpjYWI3NDM3NDNmY2JmODU4ZjQ2ZjcwNGZkMTJiMjE0NA=="
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/2.json", @basic_authorization_request_header, @david
- mock.get "/people/1.json", @basic_authorization_request_header, nil, 401, { 'WWW-Authenticate' => 'i_should_be_ignored' }
- mock.put "/people/2.json", @basic_authorization_request_header, nil, 204
- mock.delete "/people/2.json", @basic_authorization_request_header, nil, 200
- mock.post "/people/2/addresses.json", @basic_authorization_request_header, nil, 201, 'Location' => '/people/1/addresses/5'
- mock.head "/people/2.json", @basic_authorization_request_header, nil, 200
-
- mock.get "/people/2.json", { 'Authorization' => blank_digest_auth_header("/people/2.json", "fad396f6a34aeba28e28b9b96ddbb671") }, nil, 401, { 'WWW-Authenticate' => response_digest_auth_header }
- mock.get "/people/2.json", { 'Authorization' => request_digest_auth_header("/people/2.json", "c064d5ba8891a25290c76c8c7d31fb7b") }, @david, 200
- mock.get "/people/1.json", { 'Authorization' => request_digest_auth_header("/people/1.json", "f9c0b594257bb8422af4abd429c5bb70") }, @matz, 200
-
- mock.put "/people/2.json", { 'Authorization' => blank_digest_auth_header("/people/2.json", "50a685d814f94665b9d160fbbaa3958a") }, nil, 401, { 'WWW-Authenticate' => response_digest_auth_header }
- mock.put "/people/2.json", { 'Authorization' => request_digest_auth_header("/people/2.json", "5a75cde841122d8e0f20f8fd1f98a743") }, nil, 204
-
- mock.delete "/people/2.json", { 'Authorization' => blank_digest_auth_header("/people/2.json", "846f799107eab5ca4285b909ee299a33") }, nil, 401, { 'WWW-Authenticate' => response_digest_auth_header }
- mock.delete "/people/2.json", { 'Authorization' => request_digest_auth_header("/people/2.json", "9f5b155224edbbb69fd99d8ce094681e") }, nil, 200
-
- mock.post "/people/2/addresses.json", { 'Authorization' => blank_digest_auth_header("/people/2/addresses.json", "6984d405ff3d9ed07bbf747dcf16afb0") }, nil, 401, { 'WWW-Authenticate' => response_digest_auth_header }
- mock.post "/people/2/addresses.json", { 'Authorization' => request_digest_auth_header("/people/2/addresses.json", "4bda6a28dbf930b5af9244073623bd04") }, nil, 201, 'Location' => '/people/1/addresses/5'
-
- mock.head "/people/2.json", { 'Authorization' => blank_digest_auth_header("/people/2.json", "15e5ed84ba5c4cfcd5c98a36c2e4f421") }, nil, 401, { 'WWW-Authenticate' => response_digest_auth_header }
- mock.head "/people/2.json", { 'Authorization' => request_digest_auth_header("/people/2.json", "d4c6d2bcc8717abb2e2ccb8c49ee6a91") }, nil, 200
- end
-
- # Make client nonce deterministic
- class << @authenticated_conn
- private
-
- def client_nonce
- 'i-am-a-client-nonce'
- end
- end
- end
-
- def test_authorization_header
- authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse('/people/2.json'))
- assert_equal @basic_authorization_request_header['Authorization'], authorization_header['Authorization']
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["david", "test123"], ::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, :get, URI.parse('/people/2.json'))
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["david"], ::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, :get, URI.parse('/people/2.json'))
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["", "test123"], ::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, :get, URI.parse('/people/2.json'))
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["my@email.com", "123"], ::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, :get, URI.parse('/people/2.json'))
- assert_equal @basic_authorization_request_header['Authorization'], authorization_header['Authorization']
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["david", "test123"], ::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, :get, URI.parse('/people/2.json'))
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["david"], ::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, :get, URI.parse('/people/2.json'))
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
- end
-
- def test_authorization_header_if_credentials_supplied_and_auth_type_is_basic
- @authenticated_conn.auth_type = :basic
- authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse('/people/2.json'))
- assert_equal @basic_authorization_request_header['Authorization'], authorization_header['Authorization']
- authorization = authorization_header["Authorization"].to_s.split
-
- assert_equal "Basic", authorization[0]
- assert_equal ["david", "test123"], ::Base64.decode64(authorization[1]).split(":")[0..1]
- end
-
- def test_authorization_header_if_credentials_supplied_and_auth_type_is_digest
- @authenticated_conn.auth_type = :digest
- authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse('/people/2.json'))
- assert_equal blank_digest_auth_header("/people/2.json", "fad396f6a34aeba28e28b9b96ddbb671"), authorization_header['Authorization']
- end
-
- def test_authorization_header_with_query_string_if_auth_type_is_digest
- @authenticated_conn.auth_type = :digest
- authorization_header = @authenticated_conn.__send__(:authorization_header, :get, URI.parse('/people/2.json?only=name'))
- assert_equal blank_digest_auth_header("/people/2.json?only=name", "f8457b0b5d21b6b80737a386217afb24"), authorization_header['Authorization']
- end
-
- def test_get
- david = decode(@authenticated_conn.get("/people/2.json"))
- assert_equal "David", david["name"]
- end
-
- def test_post
- response = @authenticated_conn.post("/people/2/addresses.json")
- assert_equal "/people/1/addresses/5", response["Location"]
- end
-
- def test_put
- response = @authenticated_conn.put("/people/2.json")
- assert_equal 204, response.code
- end
-
- def test_delete
- response = @authenticated_conn.delete("/people/2.json")
- assert_equal 200, response.code
- end
-
- def test_head
- response = @authenticated_conn.head("/people/2.json")
- assert_equal 200, response.code
- end
-
- def test_get_with_digest_auth_handles_initial_401_response_and_retries
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.get("/people/2.json")
- assert_equal "David", decode(response)["name"]
- end
-
- def test_post_with_digest_auth_handles_initial_401_response_and_retries
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.post("/people/2/addresses.json")
- assert_equal "/people/1/addresses/5", response["Location"]
- assert_equal 201, response.code
- end
-
- def test_put_with_digest_auth_handles_initial_401_response_and_retries
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.put("/people/2.json")
- assert_equal 204, response.code
- end
-
- def test_delete_with_digest_auth_handles_initial_401_response_and_retries
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.delete("/people/2.json")
- assert_equal 200, response.code
- end
-
- def test_head_with_digest_auth_handles_initial_401_response_and_retries
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.head("/people/2.json")
- assert_equal 200, response.code
- end
-
- def test_get_with_digest_auth_caches_nonce
- @authenticated_conn.auth_type = :digest
- response = @authenticated_conn.get("/people/2.json")
- assert_equal "David", decode(response)["name"]
-
- # There is no mock for this request with a non-cached nonce.
- response = @authenticated_conn.get("/people/1.json")
- assert_equal "Matz", decode(response)["name"]
- end
-
- def test_retry_on_401_only_happens_with_digest_auth
- assert_raise(ActiveResource::UnauthorizedAccess) { @authenticated_conn.get("/people/1.json") }
- assert_equal "", @authenticated_conn.send(:response_auth_header)
- end
-
- def test_raises_invalid_request_on_unauthorized_requests
- assert_raise(ActiveResource::InvalidRequestError) { @conn.get("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.head("/people/2.json") }
- end
-
- def test_raises_invalid_request_on_unauthorized_requests_with_digest_auth
- @conn.auth_type = :digest
- assert_raise(ActiveResource::InvalidRequestError) { @conn.get("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.post("/people/2/addresses.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.put("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.delete("/people/2.json") }
- assert_raise(ActiveResource::InvalidRequestError) { @conn.head("/people/2.json") }
- end
-
- def test_client_nonce_is_not_nil
- assert_not_nil ActiveResource::Connection.new("http://david:test123@localhost").send(:client_nonce)
- 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
-
- def blank_digest_auth_header(uri, response)
- %Q(Digest username="david", realm="", qop="", uri="#{uri}", nonce="", nc="0", cnonce="i-am-a-client-nonce", opaque="", response="#{response}")
- end
-
- def request_digest_auth_header(uri, response)
- %Q(Digest username="david", realm="RailsTestApp", qop="auth", uri="#{uri}", nonce="#{@nonce}", nc="0", cnonce="i-am-a-client-nonce", opaque="ef6dfb078ba22298d366f99567814ffb", response="#{response}")
- end
-
- def response_digest_auth_header
- %Q(Digest realm="RailsTestApp", qop="auth", algorithm=MD5, nonce="#{@nonce}", opaque="ef6dfb078ba22298d366f99567814ffb")
- end
-
- def decode(response)
- @authenticated_conn.format.decode(response.body)
- end
-end
diff --git a/activeresource/test/cases/base/custom_methods_test.rb b/activeresource/test/cases/base/custom_methods_test.rb
deleted file mode 100644
index f7aa7a4a09..0000000000
--- a/activeresource/test/cases/base/custom_methods_test.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/person'
-require 'fixtures/street_address'
-require 'active_support/core_ext/hash/conversions'
-
-class CustomMethodsTest < ActiveSupport::TestCase
- def setup
- @matz = { :person => { :id => 1, :name => 'Matz' } }.to_json
- @matz_deep = { :person => { :id => 1, :name => 'Matz', :other => 'other' } }.to_json
- @matz_array = { :people => [{ :person => { :id => 1, :name => 'Matz' } }] }.to_json
- @ryan = { :person => { :name => 'Ryan' } }.to_json
- @addy = { :address => { :id => 1, :street => '12345 Street' } }.to_json
- @addy_deep = { :address => { :id => 1, :street => '12345 Street', :zip => "27519" } }.to_json
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/1.json", {}, @matz
- mock.get "/people/1/shallow.json", {}, @matz
- mock.get "/people/1/deep.json", {}, @matz_deep
- mock.get "/people/retrieve.json?name=Matz", {}, @matz_array
- mock.get "/people/managers.json", {}, @matz_array
- mock.post "/people/hire.json?name=Matz", {}, nil, 201
- mock.put "/people/1/promote.json?position=Manager", {}, nil, 204
- mock.put "/people/promote.json?name=Matz", {}, nil, 204, {}
- mock.put "/people/sort.json?by=name", {}, nil, 204
- mock.delete "/people/deactivate.json?name=Matz", {}, nil, 200
- mock.delete "/people/1/deactivate.json", {}, nil, 200
- mock.post "/people/new/register.json", {}, @ryan, 201, 'Location' => '/people/5.json'
- mock.post "/people/1/register.json", {}, @matz, 201
- mock.get "/people/1/addresses/1.json", {}, @addy
- mock.get "/people/1/addresses/1/deep.json", {}, @addy_deep
- mock.put "/people/1/addresses/1/normalize_phone.json?locale=US", {}, nil, 204
- mock.put "/people/1/addresses/sort.json?by=name", {}, nil, 204
- mock.post "/people/1/addresses/new/link.json", {}, { :address => { :street => '12345 Street' } }.to_json, 201, 'Location' => '/people/1/addresses/2.json'
- 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.json' }), ryan.post(:register)
- expected_request = ActiveResource::Request.new(:post, '/people/new/register.json', @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({ :address => { :street => '12345 Street' } }.to_json,
- 201, { 'Location' => '/people/1/addresses/2.json' }),
- addy.post(:link)
-
- matz = Person.find(1)
- 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
deleted file mode 100644
index fffd8b75c3..0000000000
--- a/activeresource/test/cases/base/equality_test.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require 'abstract_unit'
-require "fixtures/person"
-require "fixtures/street_address"
-
-class BaseEqualityTest < ActiveSupport::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
deleted file mode 100644
index f07e1ea16b..0000000000
--- a/activeresource/test/cases/base/load_test.rb
+++ /dev/null
@@ -1,199 +0,0 @@
-require 'abstract_unit'
-require "fixtures/person"
-require "fixtures/street_address"
-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 < ActiveSupport::TestCase
- def setup
- @matz = { :id => 1, :name => 'Matz' }
-
- @first_address = { :address => { :id => 1, :street => '12345 Street' } }
- @addresses = [@first_address, { :address => { :id => 2, :street => '67890 Street' } }]
- @addresses_from_json = { :street_addresses => @addresses }
- @addresses_from_json_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 ],
- :dates => [ Time.now ],
- :votes => [ true, false, true ],
- :places => [ "Columbia City", "Unknown" ]}}}
-
-
- # List of books formated as [{timestamp_of_publication => name}, ...]
- @books = {:books => [
- {1009839600 => "Ruby in a Nutshell"},
- {1199142000 => "The Ruby Programming Language"}
- ]}
-
- @books_date = {:books => [
- {Time.at(1009839600) => "Ruby in a Nutshell"},
- {Time.at(1199142000) => "The Ruby Programming Language"}
- ]}
- @person = Person.new
- end
-
- def test_load_hash_with_integers_as_keys
- assert_nothing_raised{@person.load(@books)}
- end
-
- def test_load_hash_with_dates_as_keys
- assert_nothing_raised{@person.load(@books_date)}
- 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_after_load_attributes_are_accessible
- assert_equal Hash.new, @person.attributes
- assert_equal @matz.stringify_keys, @person.load(@matz).attributes
- assert_equal @matz[:name], @person.attributes['name']
- end
-
- def test_after_load_attributes_are_accessible_via_indifferent_access
- assert_equal Hash.new, @person.attributes
- assert_equal @matz.stringify_keys, @person.load(@matz).attributes
- assert_equal @matz[:name], @person.attributes['name']
- assert_equal @matz[:name], @person.attributes[:name]
- end
-
- def test_load_one_with_existing_resource
- address = @person.load(:street_address => @first_address.values.first).street_address
- assert_kind_of StreetAddress, address
- assert_equal @first_address.values.first.stringify_keys, address.attributes
- end
-
- def test_load_one_with_unknown_resource
- address = silence_warnings { @person.load(@first_address).address }
- assert_kind_of Person::Address, address
- assert_equal @first_address.values.first.stringify_keys, address.attributes
- end
-
- def test_load_collection_with_existing_resource
- addresses = @person.load(@addresses_from_json).street_addresses
- assert_kind_of Array, addresses
- addresses.each { |address| assert_kind_of StreetAddress, address }
- assert_equal @addresses.map { |a| a[:address].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 { |a| a[:address].stringify_keys }, addresses.map(&:attributes)
- end
-
- def test_load_collection_with_single_existing_resource
- addresses = @person.load(@addresses_from_json_single).street_addresses
- assert_kind_of Array, addresses
- addresses.each { |address| assert_kind_of StreetAddress, address }
- assert_equal [ @first_address.values.first ].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.values.first ].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
-
- dates = state.dates
- assert_kind_of Array, dates
- assert_kind_of Time, dates.first
- assert_equal @deep[:street][:state][:dates].first, dates.first
-
- votes = state.votes
- assert_kind_of Array, votes
- assert_kind_of TrueClass, votes.first
- assert_equal @deep[:street][:state][:votes].first, votes.first
- end
-
- def test_nested_collections_within_the_same_namespace
- n = Highrise::Note.new(:comments => [{ :comment => { :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/schema_test.rb b/activeresource/test/cases/base/schema_test.rb
deleted file mode 100644
index d29eaf5fb6..0000000000
--- a/activeresource/test/cases/base/schema_test.rb
+++ /dev/null
@@ -1,411 +0,0 @@
-require 'abstract_unit'
-require 'active_support/core_ext/hash/conversions'
-require "fixtures/person"
-require "fixtures/street_address"
-
-########################################################################
-# Testing the schema of your Active Resource models
-########################################################################
-class SchemaTest < ActiveModel::TestCase
- def setup
- setup_response # find me in abstract_unit
- end
-
- def teardown
- Person.schema = nil # hack to stop test bleedthrough...
- end
-
- #####################################################
- # Passing in a schema directly and returning it
- ####
-
- test "schema on a new model should be empty" do
- assert Person.schema.blank?, "should have a blank class schema"
- assert Person.new.schema.blank?, "should have a blank instance schema"
- end
-
- test "schema should only accept a hash" do
- ["blahblah", ['one','two'], [:age, :name], Person.new].each do |bad_schema|
- assert_raises(ArgumentError,"should only accept a hash (or nil), but accepted: #{bad_schema.inspect}") do
- Person.schema = bad_schema
- end
- end
- end
-
- test "schema should accept a simple hash" do
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
-
- assert_nothing_raised { Person.schema = new_schema }
- assert_equal new_schema, Person.schema
- end
-
- test "schema should accept a hash with simple values" do
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- assert_nothing_raised { Person.schema = new_schema }
- assert_equal new_schema, Person.schema
- end
-
- test "schema should accept all known attribute types as values" do
- # I'd prefer to use here...
- ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
- assert_nothing_raised("should have accepted #{the_type.inspect}"){ Person.schema = {'my_key' => the_type }}
- end
- end
-
- test "schema should not accept unknown values" do
- bad_values = [ :oogle, :blob, 'thing']
-
- bad_values.each do |bad_value|
- assert_raises(ArgumentError,"should only accept a known attribute type, but accepted: #{bad_value.inspect}") do
- Person.schema = {'key' => bad_value}
- end
- end
- end
-
- test "schema should accept nil and remove the schema" do
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- assert_nothing_raised { Person.schema = new_schema }
- assert_equal new_schema, Person.schema # sanity check
-
-
- assert_nothing_raised { Person.schema = nil }
- assert_nil Person.schema, "should have nulled out the schema, but still had: #{Person.schema.inspect}"
- end
-
-
- test "schema should be with indifferent access" do
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- new_schema_syms = new_schema.keys
-
- assert_nothing_raised { Person.schema = new_schema }
- new_schema_syms.each do |col|
- assert Person.new.respond_to?(col.to_s), "should respond to the schema's string key, but failed on: #{col.to_s}"
- assert Person.new.respond_to?(col.to_sym), "should respond to the schema's symbol key, but failed on: #{col.to_sym}"
- end
- end
-
-
- test "schema on a fetched resource should return all the attributes of that model instance" do
- p = Person.find(1)
- s = p.schema
-
- assert s.present?, "should have found a non-empty schema!"
-
- p.attributes.each do |the_attr, val|
- assert s.has_key?(the_attr), "should have found attr: #{the_attr} in schema, but only had: #{s.inspect}"
- end
- end
-
- test "with two instances, default schema should match the attributes of the individual instances - even if they differ" do
- matz = Person.find(1)
- rick = Person.find(6)
-
- m_attrs = matz.attributes.keys.sort
- r_attrs = rick.attributes.keys.sort
-
- assert_not_equal m_attrs, r_attrs, "should have different attributes on each model"
-
- assert_not_equal matz.schema, rick.schema, "should have had different schemas too"
- end
-
- test "defining a schema should return it when asked" do
- assert Person.schema.blank?, "should have a blank class schema"
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- assert_nothing_raised {
- Person.schema = new_schema
- assert_equal new_schema, Person.schema, "should have saved the schema on the class"
- assert_equal new_schema, Person.new.schema, "should have made the schema available to every instance"
- }
- end
-
- test "defining a schema, then fetching a model should still match the defined schema" do
- # sanity checks
- assert Person.schema.blank?, "should have a blank class schema"
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- matz = Person.find(1)
- assert !matz.schema.blank?, "should have some sort of schema on an instance variable"
- assert_not_equal new_schema, matz.schema, "should not have the class-level schema until it's been added to the class!"
-
- assert_nothing_raised {
- Person.schema = new_schema
- assert_equal new_schema, matz.schema, "class-level schema should override instance-level schema"
- }
- end
-
-
- #####################################################
- # Using the schema syntax
- ####
-
- test "should be able to use schema" do
- assert_respond_to Person, :schema, "should at least respond to the schema method"
-
- assert_nothing_raised("Should allow the schema to take a block") do
- Person.schema { }
- end
- end
-
- test "schema definition should store and return attribute set" do
- assert_nothing_raised do
- s = nil
- Person.schema do
- s = self
- attribute :foo, :string
- end
- assert_respond_to s, :attrs, "should return attributes in theory"
- assert_equal({'foo' => 'string' }, s.attrs, "should return attributes in practice")
- end
- end
-
- test "should be able to add attributes through schema" do
- assert_nothing_raised do
- s = nil
- Person.schema do
- s = self
- attribute('foo', 'string')
- end
- assert s.attrs.has_key?('foo'), "should have saved the attribute name"
- assert_equal 'string', s.attrs['foo'], "should have saved the attribute type"
- end
- end
-
- test "should convert symbol attributes to strings" do
- assert_nothing_raised do
- s = nil
- Person.schema do
- attribute(:foo, :integer)
- s = self
- end
-
- assert s.attrs.has_key?('foo'), "should have saved the attribute name as a string"
- assert_equal 'integer', s.attrs['foo'], "should have saved the attribute type as a string"
- end
- end
-
- test "should be able to add all known attribute types" do
- assert_nothing_raised do
- ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
- s = nil
- Person.schema do
- s = self
- attribute('foo', the_type)
- end
- assert s.attrs.has_key?('foo'), "should have saved the attribute name"
- assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
- end
- end
- end
-
- test "attributes should not accept unknown values" do
- bad_values = [ :oogle, :blob, 'thing']
-
- bad_values.each do |bad_value|
- s = nil
- assert_raises(ArgumentError,"should only accept a known attribute type, but accepted: #{bad_value.inspect}") do
- Person.schema do
- s = self
- attribute 'key', bad_value
- end
- end
- assert !self.respond_to?(bad_value), "should only respond to a known attribute type, but accepted: #{bad_value.inspect}"
- assert_raises(NoMethodError,"should only have methods for known attribute types, but accepted: #{bad_value.inspect}") do
- Person.schema do
- send bad_value, 'key'
- end
- end
- end
- end
-
-
- test "should accept attribute types as the type's name as the method" do
- ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
- s = nil
- Person.schema do
- s = self
- send(the_type,'foo')
- end
- assert s.attrs.has_key?('foo'), "should now have saved the attribute name"
- assert_equal the_type.to_s, s.attrs['foo'], "should have saved the attribute type of: #{the_type}"
- end
- end
-
- test "should accept multiple attribute names for an attribute method" do
- names = ['foo','bar','baz']
- s = nil
- Person.schema do
- s = self
- string(*names)
- end
- names.each do |the_name|
- assert s.attrs.has_key?(the_name), "should now have saved the attribute name: #{the_name}"
- assert_equal 'string', s.attrs[the_name], "should have saved the attribute as a string"
- end
- end
-
- #####################################################
- # What a schema does for us
- ####
-
- # respond_to?
-
- test "should respond positively to attributes that are only in the schema" do
- new_attr_name = :my_new_schema_attribute
- new_attr_name_two = :another_new_schema_attribute
- assert Person.schema.blank?, "sanity check - should have a blank class schema"
-
- assert !Person.new.respond_to?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
- assert !Person.new.respond_to?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
-
- assert_nothing_raised do
- Person.schema = {new_attr_name.to_s => 'string'}
- Person.schema { string new_attr_name_two }
- end
-
- assert_respond_to Person.new, new_attr_name, "should respond to the attribute in a passed-in schema, but failed on: #{new_attr_name}"
- assert_respond_to Person.new, new_attr_name_two, "should respond to the attribute from the schema, but failed on: #{new_attr_name_two}"
- end
-
- test "should not care about ordering of schema definitions" do
- new_attr_name = :my_new_schema_attribute
- new_attr_name_two = :another_new_schema_attribute
-
- assert Person.schema.blank?, "sanity check - should have a blank class schema"
-
- assert !Person.new.respond_to?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
- assert !Person.new.respond_to?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
-
- assert_nothing_raised do
- Person.schema { string new_attr_name_two }
- Person.schema = {new_attr_name.to_s => 'string'}
- end
-
- assert_respond_to Person.new, new_attr_name, "should respond to the attribute in a passed-in schema, but failed on: #{new_attr_name}"
- assert_respond_to Person.new, new_attr_name_two, "should respond to the attribute from the schema, but failed on: #{new_attr_name_two}"
- end
-
- # method_missing effects
-
- test "should not give method_missing for attribute only in schema" do
- new_attr_name = :another_new_schema_attribute
- new_attr_name_two = :another_new_schema_attribute
-
- assert Person.schema.blank?, "sanity check - should have a blank class schema"
-
- assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name} as a method") do
- Person.new.send(new_attr_name)
- end
- assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name_two} as a method") do
- Person.new.send(new_attr_name_two)
- end
-
- Person.schema = {new_attr_name.to_s => :float}
- Person.schema { string new_attr_name_two }
-
- assert_nothing_raised do
- Person.new.send(new_attr_name)
- Person.new.send(new_attr_name_two)
- end
- end
-
-
- ########
- # Known attributes
- #
- # Attributes can be known to be attributes even if they aren't actually
- # 'set' on a particular instance.
- # This will only differ from 'attributes' if a schema has been set.
-
- test "new model should have no known attributes" do
- assert Person.known_attributes.blank?, "should have no known attributes"
- assert Person.new.known_attributes.blank?, "should have no known attributes on a new instance"
- end
-
- test "setting schema should set known attributes on class and instance" do
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- assert_nothing_raised { Person.schema = new_schema }
-
- assert_equal new_schema.keys.sort, Person.known_attributes.sort
- assert_equal new_schema.keys.sort, Person.new.known_attributes.sort
- end
-
- test "known attributes on a fetched resource should return all the attributes of the instance" do
- p = Person.find(1)
- attrs = p.known_attributes
-
- assert attrs.present?, "should have found some attributes!"
-
- p.attributes.each do |the_attr, val|
- assert attrs.include?(the_attr), "should have found attr: #{the_attr} in known attributes, but only had: #{attrs.inspect}"
- end
- end
-
- test "with two instances, known attributes should match the attributes of the individual instances - even if they differ" do
- matz = Person.find(1)
- rick = Person.find(6)
-
- m_attrs = matz.attributes.keys.sort
- r_attrs = rick.attributes.keys.sort
-
- assert_not_equal m_attrs, r_attrs, "should have different attributes on each model"
-
- assert_not_equal matz.known_attributes, rick.known_attributes, "should have had different known attributes too"
- end
-
- test "setting schema then fetching should add schema attributes to the instance attributes" do
- # an attribute in common with fetched instance and one that isn't
- new_schema = {'age' => 'integer', 'name' => 'string',
- 'height' => 'float', 'bio' => 'text',
- 'weight' => 'decimal', 'photo' => 'binary',
- 'alive' => 'boolean', 'created_at' => 'timestamp',
- 'thetime' => 'time', 'thedate' => 'date', 'mydatetime' => 'datetime'}
-
- assert_nothing_raised { Person.schema = new_schema }
-
- matz = Person.find(1)
- known_attrs = matz.known_attributes
-
- matz.attributes.keys.each do |the_attr|
- assert known_attrs.include?(the_attr), "should have found instance attr: #{the_attr} in known attributes, but only had: #{known_attrs.inspect}"
- end
- new_schema.keys.each do |the_attr|
- assert known_attrs.include?(the_attr), "should have found schema attr: #{the_attr} in known attributes, but only had: #{known_attrs.inspect}"
- end
- end
-
-
-end
diff --git a/activeresource/test/cases/base_errors_test.rb b/activeresource/test/cases/base_errors_test.rb
deleted file mode 100644
index aacbeeb83c..0000000000
--- a/activeresource/test/cases/base_errors_test.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-require 'abstract_unit'
-require "fixtures/person"
-
-class BaseErrorsTest < ActiveSupport::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; charset=utf-8'}
- 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; charset=utf-8'}
- 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_json_and_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_json_errors_when_no_errors_key
- ActiveResource::HttpMock.respond_to do |mock|
- mock.post "/people.json", {}, '{}', 422, {'Content-Type' => 'application/json; charset=utf-8'}
- end
-
- invalid_user_using_format(:json) do
- assert_kind_of ActiveResource::Errors, @person.errors
- assert_equal 0, @person.errors.size
- 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
-
- def test_should_mark_as_invalid_when_content_type_is_unavailable_in_response_header
- 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, {}
- 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, {}
- end
-
- [ :json, :xml ].each do |format|
- invalid_user_using_format(format) do
- assert !@person.valid?
- 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
deleted file mode 100644
index c3b963844c..0000000000
--- a/activeresource/test/cases/base_test.rb
+++ /dev/null
@@ -1,1144 +0,0 @@
-require 'abstract_unit'
-require "fixtures/person"
-require "fixtures/customer"
-require "fixtures/street_address"
-require "fixtures/sound"
-require "fixtures/beast"
-require "fixtures/proxy"
-require "fixtures/address"
-require "fixtures/subscription_plan"
-require 'active_support/json'
-require 'active_support/ordered_hash'
-require 'active_support/core_ext/hash/conversions'
-require 'mocha'
-
-class BaseTest < ActiveSupport::TestCase
- def setup
- setup_response # find me in abstract_unit
- @original_person_site = Person.site
- end
-
- def teardown
- Person.site = @original_person_site
- end
-
- ########################################################################
- # Tests relating to setting up the API-connection configuration
- ########################################################################
-
- 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_auth_type
- Forum.auth_type = :digest
- assert_equal(:digest, Forum.auth_type)
- assert_equal(:digest, Forum.connection.auth_type)
- 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
-
-
- ########################################################################
- # Tests for setting up remote URLs for a given model (including adding
- # parameters appropriately)
- ########################################################################
- def test_collection_name
- assert_equal "people", Person.collection_name
- end
-
- def test_collection_path
- assert_equal '/people.json', Person.collection_path
- end
-
- def test_collection_path_with_parameters
- assert_equal '/people.json?gender=male', Person.collection_path(:gender => 'male')
- assert_equal '/people.json?gender=false', Person.collection_path(:gender => false)
- assert_equal '/people.json?gender=', Person.collection_path(:gender => nil)
-
- assert_equal '/people.json?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.json?')
- 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.json?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.json?struct%5Ba%5D%5B%5D=2&struct%5Ba%5D%5B%5D=1&struct%5Bb%5D=fred', Person.collection_path(:struct => ActiveSupport::OrderedHash[:a, [2,1], 'b', 'fred'])
- end
-
- def test_custom_element_path
- assert_equal '/people/1/addresses/1.json', StreetAddress.element_path(1, :person_id => 1)
- assert_equal '/people/1/addresses/1.json', StreetAddress.element_path(1, 'person_id' => 1)
- assert_equal '/people/Greg/addresses/1.json', StreetAddress.element_path(1, 'person_id' => 'Greg')
- assert_equal '/people/ann%20mary/addresses/ann%20mary.json', StreetAddress.element_path(:'ann mary', 'person_id' => 'ann mary')
- end
-
- def test_custom_element_path_without_required_prefix_param
- assert_raise ActiveResource::MissingPrefixParam do
- StreetAddress.element_path(1)
- end
- end
-
- def test_module_element_path
- assert_equal '/sounds/1.json', Asset::Sound.element_path(1)
- 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.json', Person.element_path('Greg')
-
- # Protected Instance method.
- assert_equal '/people/Greg.json', 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.json?type=work', StreetAddress.element_path(1, :person_id => 1, :type => 'work')
- assert_equal '/people/1/addresses/1.json?type=work', StreetAddress.element_path(1, 'person_id' => 1, :type => 'work')
- assert_equal '/people/1/addresses/1.json?type=work', StreetAddress.element_path(1, :type => 'work', :person_id => 1)
- assert_equal '/people/1/addresses/1.json?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.json?type=work', StreetAddress.element_path(1, {:person_id => 1}, {:type => 'work'})
- end
-
- def test_custom_collection_path_without_required_prefix_param
- assert_raise ActiveResource::MissingPrefixParam do
- StreetAddress.collection_path
- end
- end
-
- def test_custom_collection_path
- assert_equal '/people/1/addresses.json', StreetAddress.collection_path(:person_id => 1)
- assert_equal '/people/1/addresses.json', StreetAddress.collection_path('person_id' => 1)
- end
-
- def test_custom_collection_path_with_parameters
- assert_equal '/people/1/addresses.json?type=work', StreetAddress.collection_path(:person_id => 1, :type => 'work')
- assert_equal '/people/1/addresses.json?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.json?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
- person_class.prefix = "the_prefix/:the_param1/other_prefix/:the_param2"
- assert_equal Set.new([:the_param2, :the_param1]), 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
-
-
- ########################################################################
- # Tests basic CRUD functions (find/save/create etc)
- ########################################################################
- def test_respond_to
- matz = Person.find(1)
- assert_respond_to matz, :name
- assert_respond_to matz, :name=
- assert_respond_to matz, :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'] << '.json'
- assert_equal '1', p.__send__(:id_from_response, resp)
- end
-
- def test_id_from_response_without_location
- p = Person.new
- resp = {}
- assert_nil p.__send__(:id_from_response, resp)
- end
-
- def test_not_persisted_with_no_body_and_positive_content_length
- resp = ActiveResource::Response.new(nil)
- resp['Content-Length'] = "100"
- Person.connection.expects(:post).returns(resp)
- assert !Person.create.persisted?
- end
-
- def test_not_persisted_with_body_and_zero_content_length
- resp = ActiveResource::Response.new(@rick)
- resp['Content-Length'] = "0"
- Person.connection.expects(:post).returns(resp)
- assert !Person.create.persisted?
- end
-
- # These response codes aren't allowed to have bodies per HTTP spec
- def test_not_persisted_with_empty_response_codes
- [100,101,204,304].each do |status_code|
- resp = ActiveResource::Response.new(@rick, status_code)
- Person.connection.expects(:post).returns(resp)
- assert !Person.create.persisted?
- end
- end
-
- # Content-Length is not required by HTTP 1.1, so we should read
- # the body anyway in its absence.
- def test_persisted_with_no_content_length
- resp = ActiveResource::Response.new(@rick)
- resp['Content-Length'] = nil
- Person.connection.expects(:post).returns(resp)
- assert Person.create.persisted?
- 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.json", {}, 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.json", {}, nil, 201
- end
- person = Person.create(:name => 'Rick')
- assert_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.json", {}, @david
- mock.put "/people/2.json", @default_request_headers, nil, 409
- end
- assert_raise(ActiveResource::ResourceConflict) { Person.find(2).save }
- end
-
-
- ######
- # update_attribute(s)(!)
-
- def test_update_attribute_as_symbol
- matz = Person.first
- matz.expects(:save).returns(true)
-
- assert_equal "Matz", matz.name
- assert matz.update_attribute(:name, "David")
- assert_equal "David", matz.name
- end
-
- def test_update_attribute_as_string
- matz = Person.first
- matz.expects(:save).returns(true)
-
- assert_equal "Matz", matz.name
- assert matz.update_attribute('name', "David")
- assert_equal "David", matz.name
- end
-
-
- def test_update_attributes_as_symbols
- addy = StreetAddress.first(:params => {:person_id => 1})
- addy.expects(:save).returns(true)
-
- assert_equal "12345 Street", addy.street
- assert_equal "Australia", addy.country
- assert addy.update_attributes(:street => '54321 Street', :country => 'USA')
- assert_equal "54321 Street", addy.street
- assert_equal "USA", addy.country
- end
-
- def test_update_attributes_as_strings
- addy = StreetAddress.first(:params => {:person_id => 1})
- addy.expects(:save).returns(true)
-
- assert_equal "12345 Street", addy.street
- assert_equal "Australia", addy.country
- assert addy.update_attributes('street' => '54321 Street', 'country' => 'USA')
- assert_equal "54321 Street", addy.street
- assert_equal "USA", addy.country
- end
-
-
- #####
- # Mayhem and destruction
-
- def test_destroy
- assert Person.find(1).destroy
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/1.json", {}, 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.json", {}, 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.json", {}, 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.json", {}, 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.json", {}, 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.json", {}, nil, 410
- end
- assert_raise(ActiveResource::ResourceGone) { Person.find(1) }
- end
-
- ########################################################################
- # Tests the more miscellaneous helper methods
- ########################################################################
- 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.json", {}, nil, 410
- end
-
- assert !Person.exists?(1)
- end
-
- def test_to_xml
- Person.format = :xml
- matz = Person.find(1)
- encode = matz.encode
- xml = matz.to_xml
-
- assert_equal encode, xml
- assert xml.include?('<?xml version="1.0" encoding="UTF-8"?>')
- assert xml.include?('<name>Matz</name>')
- assert xml.include?('<id type="integer">1</id>')
- ensure
- Person.format = :json
- end
-
- def test_to_xml_with_element_name
- Person.format = :xml
- old_elem_name = Person.element_name
- matz = Person.find(1)
- Person.element_name = 'ruby_creator'
- encode = matz.encode
- xml = matz.to_xml
-
- assert_equal encode, xml
- assert xml.include?('<?xml version="1.0" encoding="UTF-8"?>')
- assert xml.include?('<ruby-creator>')
- assert xml.include?('<name>Matz</name>')
- assert xml.include?('<id type="integer">1</id>')
- assert xml.include?('</ruby-creator>')
- ensure
- Person.format = :json
- Person.element_name = old_elem_name
- end
-
- def test_to_xml_with_private_method_name_as_attribute
- Person.format = :xml
-
- customer = Customer.new(:foo => "foo")
- customer.singleton_class.class_eval do
- def foo
- "bar"
- end
- private :foo
- end
-
- assert !customer.to_xml.include?("<foo>bar</foo>")
- assert customer.to_xml.include?("<foo>foo</foo>")
- ensure
- Person.format = :json
- end
-
- def test_to_json
- Person.include_root_in_json = true
- joe = Person.find(6)
- encode = joe.encode
- json = joe.to_json
-
- assert_equal encode, json
- assert_match %r{^\{"person":\{}, json
- assert_match %r{"id":6}, json
- assert_match %r{"name":"Joe"}, json
- assert_match %r{\}\}$}, json
- end
-
- def test_to_json_with_element_name
- old_elem_name = Person.element_name
- Person.include_root_in_json = true
- joe = Person.find(6)
- Person.element_name = 'ruby_creator'
- encode = joe.encode
- json = joe.to_json
-
- assert_equal encode, json
- assert_match %r{^\{"ruby_creator":\{}, json
- assert_match %r{"id":6}, json
- assert_match %r{"name":"Joe"}, json
- assert_match %r{\}\}$}, json
- ensure
- Person.element_name = old_elem_name
- 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_to_key_quacks_like_active_record
- new_person = Person.new
- assert_nil new_person.to_key
- matz = Person.find(1)
- assert_equal [1], matz.to_key
- 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
- Person.format = :xml
- marty = Person.find(5)
- assert_equal 3, marty.colors.size
- marty.colors.each do |color|
- assert_kind_of String, color
- end
- end
- ensure
- Person.format = :json
- end
-
- def test_with_custom_formatter
- addresses = [{ :id => "1", :street => "1 Infinite Loop", :city => "Cupertino", :state => "CA" }].to_xml(:root => :addresses)
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/addresses.xml", {}, addresses, 200
- end
-
- # late bind the site
- AddressResource.site = "http://localhost"
- addresses = AddressResource.find(:all)
-
- assert_equal "Cupertino, CA", addresses.first.city_state
- end
-
- def test_create_with_custom_primary_key
- silver_plan = { :plan => { :code => "silver", :price => 5.00 } }.to_json
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.post "/plans.json", {}, silver_plan, 201, 'Location' => '/plans/silver.json'
- end
-
- plan = SubscriptionPlan.new(:code => "silver", :price => 5.00)
- assert plan.new?
-
- plan.save!
- assert !plan.new?
- end
-
- def test_update_with_custom_primary_key
- silver_plan = { :plan => { :code => "silver", :price => 5.00 } }.to_json
- silver_plan_updated = { :plan => { :code => "silver", :price => 10.00 } }.to_json
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/plans/silver.json", {}, silver_plan
- mock.put "/plans/silver.json", {}, silver_plan_updated, 201, 'Location' => '/plans/silver.json'
- end
-
- plan = SubscriptionPlan.find("silver")
- assert !plan.new?
- assert_equal 5.00, plan.price
-
- # update price
- plan.price = 10.00
- plan.save!
- assert_equal 10.00, plan.price
- end
-
- def test_namespacing
- sound = Asset::Sound.find(1)
- assert_equal "Asset::Sound::Author", sound.author.class.to_s
- end
-end
diff --git a/activeresource/test/cases/connection_test.rb b/activeresource/test/cases/connection_test.rb
deleted file mode 100644
index 653912f000..0000000000
--- a/activeresource/test/cases/connection_test.rb
+++ /dev/null
@@ -1,276 +0,0 @@
-require 'abstract_unit'
-
-class ConnectionTest < ActiveSupport::TestCase
- ResponseCodeStub = Struct.new(:code)
- RedirectResponseStub = Struct.new(:code, :Location)
-
- def setup
- @conn = ActiveResource::Connection.new('http://localhost')
- matz = { :person => { :id => 1, :name => 'Matz' } }
- david = { :person => { :id => 2, :name => 'David' } }
- @people = { :people => [ matz, david ] }.to_json
- @people_single = { 'people-single-elements' => [ matz ] }.to_json
- @people_empty = { 'people-empty-elements' => [ ] }.to_json
- @matz = matz.to_json
- @david = david.to_json
- @header = { 'key' => 'value' }.freeze
-
- @default_request_headers = { 'Content-Type' => 'application/json' }
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/2.json", @header, @david
- mock.get "/people.json", {}, @people
- mock.get "/people_single_elements.json", {}, @people_single
- mock.get "/people_empty_elements.json", {}, @people_empty
- mock.get "/people/1.json", {}, @matz
- mock.put "/people/1.json", {}, nil, 204
- mock.put "/people/2.json", {}, @header, 204
- mock.delete "/people/1.json", {}, nil, 200
- mock.delete "/people/2.json", @header, nil, 200
- mock.post "/people.json", {}, nil, 201, 'Location' => '/people/5.json'
- mock.post "/members.json", {}, @header, 201, 'Location' => '/people/6.json'
- mock.head "/people/1.json", {}, nil, 200
- end
- end
-
- def test_handle_response
- # 2xx and 3xx are valid responses.
- [200, 299, 300, 399].each do |code|
- expected = ResponseCodeStub.new(code)
- assert_equal expected, handle_response(expected)
- end
-
- # 301 is moved permanently (redirect)
- assert_redirect_raises 301
-
- # 302 is found (redirect)
- assert_redirect_raises 302
-
- # 303 is see other (redirect)
- assert_redirect_raises 303
-
- # 307 is temporary redirect
- assert_redirect_raises 307
-
- # 400 is a bad request (e.g. malformed URI or missing request parameter)
- assert_response_raises ActiveResource::BadRequest, 400
-
- # 401 is an unauthorized request
- assert_response_raises ActiveResource::UnauthorizedAccess, 401
-
- # 403 is a forbidden request (and authorizing will not help)
- assert_response_raises ActiveResource::ForbiddenAccess, 403
-
- # 404 is a missing resource.
- assert_response_raises ActiveResource::ResourceNotFound, 404
-
- # 405 is a method not allowed error
- assert_response_raises ActiveResource::MethodNotAllowed, 405
-
- # 409 is an optimistic locking error
- assert_response_raises ActiveResource::ResourceConflict, 409
-
- # 410 is a removed resource
- assert_response_raises ActiveResource::ResourceGone, 410
-
- # 422 is a validation error
- assert_response_raises ActiveResource::ResourceInvalid, 422
-
- # 4xx are client errors.
- [402, 499].each do |code|
- assert_response_raises ActiveResource::ClientError, code
- end
-
- # 5xx are server errors.
- [500, 599].each do |code|
- assert_response_raises ActiveResource::ServerError, code
- end
-
- # Others are unknown.
- [199, 600].each do |code|
- assert_response_raises ActiveResource::ConnectionError, code
- end
- end
-
- ResponseHeaderStub = Struct.new(:code, :message, 'Allow')
- def test_should_return_allowed_methods_for_method_no_allowed_exception
- begin
- handle_response ResponseHeaderStub.new(405, "HTTP Failed...", "GET, POST")
- rescue ActiveResource::MethodNotAllowed => e
- assert_equal "Failed. Response code = 405. Response message = HTTP Failed....", e.message
- assert_equal [:get, :post], e.allowed_methods
- end
- end
-
- def test_initialize_raises_argument_error_on_missing_site
- assert_raise(ArgumentError) { ActiveResource::Connection.new(nil) }
- end
-
- def test_site_accessor_accepts_uri_or_string_argument
- site = URI.parse("http://localhost")
-
- assert_raise(URI::InvalidURIError) { @conn.site = nil }
-
- assert_nothing_raised { @conn.site = "http://localhost" }
- assert_equal site, @conn.site
-
- assert_nothing_raised { @conn.site = site }
- assert_equal site, @conn.site
- end
-
- def test_proxy_accessor_accepts_uri_or_string_argument
- proxy = URI.parse("http://proxy_user:proxy_password@proxy.local:4242")
-
- assert_nothing_raised { @conn.proxy = "http://proxy_user:proxy_password@proxy.local:4242" }
- assert_equal proxy, @conn.proxy
-
- assert_nothing_raised { @conn.proxy = proxy }
- assert_equal proxy, @conn.proxy
- end
-
- def test_timeout_accessor
- @conn.timeout = 5
- assert_equal 5, @conn.timeout
- end
-
- def test_get
- matz = decode(@conn.get("/people/1.json"))
- assert_equal "Matz", matz["name"]
- end
-
- def test_head
- response = @conn.head("/people/1.json")
- assert response.body.blank?
- assert_equal 200, response.code
- end
-
- def test_get_with_header
- david = decode(@conn.get("/people/2.json", @header))
- assert_equal "David", david["name"]
- end
-
- def test_get_collection
- people = decode(@conn.get("/people.json"))
- assert_equal "Matz", people[0]["person"]["name"]
- assert_equal "David", people[1]["person"]["name"]
- end
-
- def test_get_collection_single
- people = decode(@conn.get("/people_single_elements.json"))
- assert_equal "Matz", people[0]["person"]["name"]
- end
-
- def test_get_collection_empty
- people = decode(@conn.get("/people_empty_elements.json"))
- assert_equal [], people
- end
-
- def test_post
- response = @conn.post("/people.json")
- assert_equal "/people/5.json", response["Location"]
- end
-
- def test_post_with_header
- response = @conn.post("/members.json", @header)
- assert_equal "/people/6.json", response["Location"]
- end
-
- def test_put
- response = @conn.put("/people/1.json")
- assert_equal 204, response.code
- end
-
- def test_put_with_header
- response = @conn.put("/people/2.json", @header)
- assert_equal 204, response.code
- end
-
- def test_delete
- response = @conn.delete("/people/1.json")
- assert_equal 200, response.code
- end
-
- def test_delete_with_header
- response = @conn.delete("/people/2.json", @header)
- assert_equal 200, response.code
- end
-
- def test_timeout
- @http = mock('new Net::HTTP')
- @conn.expects(:http).returns(@http)
- @http.expects(:get).raises(Timeout::Error, 'execution expired')
- assert_raise(ActiveResource::TimeoutError) { @conn.get('/people_timeout.json') }
- end
-
- def test_setting_timeout
- http = Net::HTTP.new('')
-
- [10, 20].each do |timeout|
- @conn.timeout = timeout
- @conn.send(:configure_http, http)
- assert_equal timeout, http.open_timeout
- assert_equal timeout, http.read_timeout
- end
- end
-
- def test_accept_http_header
- @http = mock('new Net::HTTP')
- @conn.expects(:http).returns(@http)
- path = '/people/1.xml'
- @http.expects(:get).with(path, { 'Accept' => 'application/xhtml+xml' }).returns(ActiveResource::Response.new(@matz, 200, { 'Content-Type' => 'text/xhtml' }))
- assert_nothing_raised(Mocha::ExpectationError) { @conn.get(path, { 'Accept' => 'application/xhtml+xml' }) }
- end
-
- def test_ssl_options_get_applied_to_http
- http = Net::HTTP.new('')
- @conn.site="https://secure"
- @conn.ssl_options={:verify_mode => OpenSSL::SSL::VERIFY_PEER}
- @conn.timeout = 10 # prevent warning about uninitialized.
- @conn.send(:configure_http, http)
-
- assert http.use_ssl?
- assert_equal http.verify_mode, OpenSSL::SSL::VERIFY_PEER
- end
-
- def test_ssl_error
- http = Net::HTTP.new('')
- @conn.expects(:http).returns(http)
- http.expects(:get).raises(OpenSSL::SSL::SSLError, 'Expired certificate')
- assert_raise(ActiveResource::SSLError) { @conn.get('/people/1.json') }
- end
-
- def test_auth_type_can_be_string
- @conn.auth_type = 'digest'
- assert_equal(:digest, @conn.auth_type)
- end
-
- def test_auth_type_defaults_to_basic
- @conn.auth_type = nil
- assert_equal(:basic, @conn.auth_type)
- end
-
- def test_auth_type_ignores_nonsensical_values
- @conn.auth_type = :wibble
- assert_equal(:basic, @conn.auth_type)
- end
-
- protected
- def assert_response_raises(klass, code)
- assert_raise(klass, "Expected response code #{code} to raise #{klass}") do
- handle_response ResponseCodeStub.new(code)
- end
- end
-
- def assert_redirect_raises(code)
- assert_raise(ActiveResource::Redirection, "Expected response code #{code} to raise ActiveResource::Redirection") do
- handle_response RedirectResponseStub.new(code, 'http://example.com/')
- end
- end
-
- def handle_response(response)
- @conn.__send__(:handle_response, response)
- end
-
- def decode(response)
- @conn.format.decode(response.body)
- end
-end
diff --git a/activeresource/test/cases/finder_test.rb b/activeresource/test/cases/finder_test.rb
deleted file mode 100644
index 3e8550d356..0000000000
--- a/activeresource/test/cases/finder_test.rb
+++ /dev/null
@@ -1,139 +0,0 @@
-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 < ActiveSupport::TestCase
- def setup
- setup_response # find me in abstract_unit
- 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_all
- all = Person.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_all_with_params
- all = StreetAddress.all(:params => { :person_id => 1 })
- assert_equal 1, all.size
- assert_kind_of StreetAddress, all.first
- end
-
- def test_find_first
- matz = Person.find(:first)
- assert_kind_of Person, matz
- assert_equal "Matz", matz.name
- end
-
- def test_first
- matz = Person.first
- assert_kind_of Person, matz
- assert_equal "Matz", matz.name
- end
-
- def test_first_with_params
- addy = StreetAddress.first(:params => { :person_id => 1 })
- assert_kind_of StreetAddress, addy
- assert_equal '12345 Street', addy.street
- end
-
- def test_find_last
- david = Person.find(:last)
- assert_kind_of Person, david
- assert_equal 'David', david.name
- end
-
- def test_last
- david = Person.last
- assert_kind_of Person, david
- assert_equal 'David', david.name
- end
-
- def test_last_with_params
- addy = StreetAddress.last(:params => { :person_id => 1 })
- assert_kind_of StreetAddress, addy
- assert_equal '12345 Street', addy.street
- end
-
- def test_find_by_id_not_found
- assert_raise(ActiveResource::ResourceNotFound) { Person.find(99) }
- assert_raise(ActiveResource::ResourceNotFound) { StreetAddress.find(99, :params => {:person_id => 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
- 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.json", {}, @people_david }
-
- people = Person.find(:all, :from => "/companies/1/people.json")
- 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.json", {}, @people_david }
-
- people = Person.find(:all, :from => "/companies/1/people.json")
- 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.json", {}, @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.json", {}, @david }
-
- david = Person.find(:one, :from => "/companies/1/manager.json")
- assert_equal "David", david.name
- end
-
- def test_find_single_by_symbol_from
- ActiveResource::HttpMock.respond_to { |m| m.get "/people/leader.json", {}, @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
deleted file mode 100644
index 21fdc24832..0000000000
--- a/activeresource/test/cases/format_test.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-require 'abstract_unit'
-require "fixtures/person"
-require "fixtures/street_address"
-
-class FormatTest < ActiveSupport::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.find { |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
- [:json, :xml].each do |format|
- using_format(Person, format) do
- david = (format == :json ? { :person => @david } : @david)
- 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
-
- ryan_hash = { :name => 'Ryan' }
- ryan_hash = (format == :json ? { :person => ryan_hash } : ryan_hash)
- ryan = ActiveResource::Formats[format].encode(ryan_hash)
- 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/http_mock_test.rb b/activeresource/test/cases/http_mock_test.rb
deleted file mode 100644
index d2fd911314..0000000000
--- a/activeresource/test/cases/http_mock_test.rb
+++ /dev/null
@@ -1,202 +0,0 @@
-require 'abstract_unit'
-require 'active_support/core_ext/object/inclusion'
-
-class HttpMockTest < ActiveSupport::TestCase
- setup do
- @http = ActiveResource::HttpMock.new("http://example.com")
- end
-
- FORMAT_HEADER = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES
-
- [:post, :put, :get, :delete, :head].each do |method|
- test "responds to simple #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "Response")
- end
-
- assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
- end
-
- test "adds format header by default to #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", {}, "Response")
- end
-
- assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
- end
-
- test "respond only when headers match header by default to #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", {"X-Header" => "X"}, "Response")
- end
-
- assert_equal "Response", request(method, "/people/1", "X-Header" => "X").body
- assert_raise(ActiveResource::InvalidRequestError) { request(method, "/people/1") }
- end
-
- test "does not overwrite format header to #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", {FORMAT_HEADER[method] => "application/json"}, "Response")
- end
-
- assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
- end
-
- test "ignores format header when there is only one response to same url in a #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", {}, "Response")
- end
-
- assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
- assert_equal "Response", request(method, "/people/1", FORMAT_HEADER[method] => "application/xml").body
- end
-
- test "responds correctly when format header is given to #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/xml" }, "XML")
- mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "Json")
- end
-
- assert_equal "XML", request(method, "/people/1", FORMAT_HEADER[method] => "application/xml").body
- assert_equal "Json", request(method, "/people/1", FORMAT_HEADER[method] => "application/json").body
- end
-
- test "raises InvalidRequestError if no response found for the #{method} request" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(method, "/people/1", { FORMAT_HEADER[method] => "application/json" }, "json")
- end
-
- assert_raise(::ActiveResource::InvalidRequestError) do
- request(method, "/people/1", FORMAT_HEADER[method] => "application/xml")
- end
- end
-
- end
-
- test "allows you to send in pairs directly to the respond_to method" do
- matz = { :person => { :id => 1, :name => "Matz" } }.to_json
-
- create_matz = ActiveResource::Request.new(:post, '/people.json', matz, {})
- created_response = ActiveResource::Response.new("", 201, { "Location" => "/people/1.json" })
- get_matz = ActiveResource::Request.new(:get, '/people/1.json', nil)
- ok_response = ActiveResource::Response.new(matz, 200, {})
-
- pairs = {create_matz => created_response, get_matz => ok_response}
-
- ActiveResource::HttpMock.respond_to(pairs)
- assert_equal 2, ActiveResource::HttpMock.responses.length
- assert_equal "", ActiveResource::HttpMock.responses.assoc(create_matz)[1].body
- assert_equal matz, ActiveResource::HttpMock.responses.assoc(get_matz)[1].body
- end
-
- test "resets all mocked responses on each call to respond_to with a block by default" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/2", {}, "JSON2")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
- end
-
- test "resets all mocked responses on each call to respond_to by passing pairs by default" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- matz = { :person => { :id => 1, :name => "Matz" } }.to_json
- get_matz = ActiveResource::Request.new(:get, '/people/1.json', nil)
- ok_response = ActiveResource::Response.new(matz, 200, {})
- ActiveResource::HttpMock.respond_to({get_matz => ok_response})
-
- assert_equal 1, ActiveResource::HttpMock.responses.length
- end
-
- test "allows you to add new responses to the existing responses by calling a block" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- ActiveResource::HttpMock.respond_to(false) do |mock|
- mock.send(:get, "/people/2", {}, "JSON2")
- end
- assert_equal 2, ActiveResource::HttpMock.responses.length
- end
-
- test "allows you to add new responses to the existing responses by passing pairs" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- matz = { :person => { :id => 1, :name => "Matz" } }.to_json
- get_matz = ActiveResource::Request.new(:get, '/people/1.json', nil)
- ok_response = ActiveResource::Response.new(matz, 200, {})
- ActiveResource::HttpMock.respond_to({get_matz => ok_response}, false)
-
- assert_equal 2, ActiveResource::HttpMock.responses.length
- end
-
- test "allows you to replace the existing reponse with the same request by calling a block" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- ActiveResource::HttpMock.respond_to(false) do |mock|
- mock.send(:get, "/people/1", {}, "JSON2")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
- end
-
- test "allows you to replace the existing reponse with the same request by passing pairs" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- matz = { :person => { :id => 1, :name => "Matz" } }.to_json
- get_matz = ActiveResource::Request.new(:get, '/people/1', nil)
- ok_response = ActiveResource::Response.new(matz, 200, {})
-
- ActiveResource::HttpMock.respond_to({get_matz => ok_response}, false)
- assert_equal 1, ActiveResource::HttpMock.responses.length
- end
-
- test "do not replace the response with the same path but different method by calling a block" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- ActiveResource::HttpMock.respond_to(false) do |mock|
- mock.send(:put, "/people/1", {}, "JSON2")
- end
- assert_equal 2, ActiveResource::HttpMock.responses.length
- end
-
- test "do not replace the response with the same path but different method by passing pairs" do
- ActiveResource::HttpMock.respond_to do |mock|
- mock.send(:get, "/people/1", {}, "JSON1")
- end
- assert_equal 1, ActiveResource::HttpMock.responses.length
-
- put_matz = ActiveResource::Request.new(:put, '/people/1', nil)
- ok_response = ActiveResource::Response.new("", 200, {})
-
- ActiveResource::HttpMock.respond_to({put_matz => ok_response}, false)
- assert_equal 2, ActiveResource::HttpMock.responses.length
- end
-
- def request(method, path, headers = {}, body = nil)
- if method.in?([:put, :post])
- @http.send(method, path, body, headers)
- else
- @http.send(method, path, headers)
- end
- end
-end
diff --git a/activeresource/test/cases/log_subscriber_test.rb b/activeresource/test/cases/log_subscriber_test.rb
deleted file mode 100644
index ab5c22a783..0000000000
--- a/activeresource/test/cases/log_subscriber_test.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-require "abstract_unit"
-require "fixtures/person"
-require "active_support/log_subscriber/test_helper"
-require "active_resource/log_subscriber"
-require "active_support/core_ext/hash/conversions"
-
-class LogSubscriberTest < ActiveSupport::TestCase
- include ActiveSupport::LogSubscriber::TestHelper
-
- def setup
- super
-
- @matz = { :person => { :id => 1, :name => 'Matz' } }.to_json
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/1.json", {}, @matz
- end
-
- ActiveResource::LogSubscriber.attach_to :active_resource
- end
-
- def set_logger(logger)
- ActiveResource::Base.logger = logger
- end
-
- def test_request_notification
- Person.find(1)
- wait
- assert_equal 2, @logger.logged(:info).size
- assert_equal "GET http://37s.sunrise.i:3000/people/1.json", @logger.logged(:info)[0]
- assert_match(/\-\-\> 200 200 33/, @logger.logged(:info)[1])
- end
-end
diff --git a/activeresource/test/cases/observing_test.rb b/activeresource/test/cases/observing_test.rb
deleted file mode 100644
index b2371a1bdf..0000000000
--- a/activeresource/test/cases/observing_test.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/person'
-require 'active_support/core_ext/hash/conversions'
-
-class ObservingTest < ActiveSupport::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 = { 'person' => { :id => 1, :name => 'Matz' } }.to_json
-
- ActiveResource::HttpMock.respond_to do |mock|
- mock.get "/people/1.json", {}, @matz
- mock.post "/people.json", {}, @matz, 201, 'Location' => '/people/1.json'
- mock.put "/people/1.json", {}, nil, 204
- mock.delete "/people/1.json", {}, nil, 200
- end
-
- PersonObserver.instance
- end
-
- def teardown
- self.history = nil
- end
-
- def test_create_fires_save_and_create_notifications
- 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
deleted file mode 100644
index c6c6e1d786..0000000000
--- a/activeresource/test/cases/validations_test.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/project'
-require 'active_support/core_ext/hash/conversions'
-
-# The validations are tested thoroughly under ActiveModel::Validations
-# This test case simply makes sure 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 = { "person" => VALID_PROJECT_HASH }.to_json
- ActiveResource::HttpMock.respond_to do |mock|
- mock.post "/projects.json", {}, @my_proj, 201, 'Location' => '/projects/5.json'
- 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_save_without_validation
- p = new_project(:name => nil)
- assert !p.save
- assert p.save(:validate => false)
- 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
-
- def test_client_side_validation_maximum
- project = Project.new(:description => '123456789012345')
- assert ! project.valid?
- assert_equal ['is too long (maximum is 10 characters)'], project.errors[:description]
- 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
-