Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
1512 lines (1237 sloc) 49.4 KB
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 "fixtures/post"
require "fixtures/comment"
require "fixtures/product"
require "fixtures/inventory"
require 'active_support/json'
require 'active_support/core_ext/hash/conversions'
require 'mocha/setup'
class BaseTest < ActiveSupport::TestCase
def setup
setup_response # find me in abstract_unit
@original_person_site = Person.site
@original_person_proxy = Person.proxy
end
def teardown
Person.site = @original_person_site
Person.proxy = @original_person_proxy
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_open_timeout
Forum.open_timeout = 5
assert_equal(5, Forum.open_timeout)
assert_equal(5, Forum.connection.open_timeout)
end
def test_should_accept_setting_read_timeout
Forum.read_timeout = 5
assert_equal(5, Forum.read_timeout)
assert_equal(5, Forum.connection.read_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_open_timeout_variable_can_be_reset
actor = Class.new(ActiveResource::Base)
actor.site = 'http://cinema'
assert_nil actor.open_timeout
actor.open_timeout = 5
actor.open_timeout = nil
assert_nil actor.open_timeout
assert_nil actor.connection.open_timeout
end
def test_read_timeout_variable_can_be_reset
actor = Class.new(ActiveResource::Base)
actor.site = 'http://cinema'
assert_nil actor.read_timeout
actor.read_timeout = 5
actor.read_timeout = nil
assert_nil actor.read_timeout
assert_nil actor.connection.read_timeout
end
def test_ssl_options_hash_can_be_reset
# SSL options are nil, resulting in an empty hash on the connection.
actor = Class.new(ActiveResource::Base)
actor.site = 'https://cinema'
assert_nil actor.ssl_options
connection = actor.connection
assert_equal Hash.new, connection.ssl_options
# Setting SSL options wipes the connection.
actor.ssl_options = { :foo => 5 }
assert_not_equal connection, actor.connection
connection = actor.connection
assert_equal 5, connection.ssl_options[:foo]
# Setting SSL options to nil also wipes the connection.
actor.ssl_options = nil
assert_not_equal connection, actor.connection
assert_equal Hash.new, 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
Person.proxy = 'http://proxy.local'
# 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_open_and_read_timeout_readers_uses_superclass_timeout_until_written
# Superclass is Object so returns nil.
assert_nil ActiveResource::Base.open_timeout
assert_nil Class.new(ActiveResource::Base).open_timeout
assert_nil ActiveResource::Base.read_timeout
assert_nil Class.new(ActiveResource::Base).read_timeout
Person.open_timeout = 5
Person.read_timeout = 5
# Subclass uses superclass open and read timeouts.
actor = Class.new(Person)
assert_equal Person.open_timeout, actor.open_timeout
assert_equal Person.read_timeout, actor.read_timeout
# Changing subclass open and read timeouts doesn't change superclass timeouts.
actor.open_timeout = 10
actor.read_timeout = 10
assert_not_equal Person.open_timeout, actor.open_timeout
assert_not_equal Person.read_timeout, actor.read_timeout
# Changing superclass open and read timeouts doesn't overwrite subclass timeouts.
Person.open_timeout = 15
Person.read_timeout = 15
assert_not_equal Person.open_timeout, actor.open_timeout
assert_not_equal Person.read_timeout, actor.read_timeout
# Changing superclass open and read timeouts after subclassing changes subclass timeouts.
jester = Class.new(actor)
actor.open_timeout = 20
actor.read_timeout = 20
assert_equal actor.open_timeout, jester.open_timeout
assert_equal actor.read_timeout, jester.read_timeout
# Subclasses are always equal to superclass open and read timeouts when not overridden.
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.open_timeout = 25
fruit.read_timeout = 25
assert_equal fruit.open_timeout, apple.open_timeout, 'subclass did not adopt changes from parent class'
assert_equal fruit.read_timeout, apple.read_timeout, 'subclass did not adopt changes from parent class'
fruit.open_timeout = 30
fruit.read_timeout = 30
assert_equal fruit.open_timeout, apple.open_timeout, 'subclass did not adopt changes from parent class'
assert_equal fruit.read_timeout, apple.read_timeout, 'subclass did not adopt changes from parent class'
end
def test_primary_key_uses_superclass_primary_key_until_written
# Superclass is Object so defaults to 'id'
assert_equal 'id', ActiveResource::Base.primary_key
assert_equal 'id', Class.new(ActiveResource::Base).primary_key
Person.primary_key = :first
# Subclass uses superclass primary_key
actor = Class.new(Person)
assert_equal Person.primary_key, actor.primary_key
# Changing subclass primary_key doesn't change superclass primary_key
actor.primary_key = :second
assert_not_equal Person.primary_key, actor.primary_key
# Changing superclass primary_key doesn't overwrite subclass primary_key
Person.primary_key = :third
assert_not_equal Person.primary_key, actor.primary_key
# Changing superclass primary_key after subclassing changes subclass primary_key
jester = Class.new(actor)
actor.primary_key = :fourth
assert_equal actor.primary_key, jester.primary_key
# Subclass primary_keys are always equal to superclass primary_key when not overridden
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.primary_key = :fifth
assert_equal fruit.primary_key, apple.primary_key, 'subclass did not adopt changes from parent class'
fruit.primary_key = :sixth
assert_equal fruit.primary_key, apple.primary_key, 'subclass did not adopt changes from parent class'
# Reset the primary key for subsequent tests
Person.primary_key = 'id'
end
def test_ssl_options_reader_uses_superclass_ssl_options_until_written
# Superclass is Object so returns nil.
assert_nil ActiveResource::Base.ssl_options
assert_nil Class.new(ActiveResource::Base).ssl_options
Person.ssl_options = {:foo => 'bar'}
# Subclass uses superclass ssl_options.
actor = Class.new(Person)
assert_equal Person.ssl_options, actor.ssl_options
# Changing subclass ssl_options doesn't change superclass ssl_options.
actor.ssl_options = {:baz => ''}
assert_not_equal Person.ssl_options, actor.ssl_options
# Changing superclass ssl_options doesn't overwrite subclass ssl_options.
Person.ssl_options = {:color => 'blue'}
assert_not_equal Person.ssl_options, actor.ssl_options
# Changing superclass ssl_options after subclassing changes subclass ssl_options.
jester = Class.new(actor)
actor.ssl_options = {:color => 'red'}
assert_equal actor.ssl_options, jester.ssl_options
# Subclasses are always equal to superclass ssl_options when not overridden.
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.ssl_options = {:alpha => 'betas'}
assert_equal fruit.ssl_options, apple.ssl_options, 'subclass did not adopt changes from parent class'
fruit.ssl_options = {:omega => 'moos'}
assert_equal fruit.ssl_options, apple.ssl_options, 'subclass did not adopt changes from parent class'
end
def test_updating_baseclass_site_object_wipes_descendent_cached_connection_objects
# Subclasses are always equal to superclass site when not overridden
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
assert_equal fruit.connection.site, apple.connection.site
first_connection = apple.connection.object_id
fruit.site = 'http://supermarket'
assert_equal fruit.connection.site, apple.connection.site
second_connection = apple.connection.object_id
assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
end
def test_updating_baseclass_user_wipes_descendent_cached_connection_objects
# Subclasses are always equal to superclass user when not overridden
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.user = 'david'
assert_equal fruit.connection.user, apple.connection.user
first_connection = apple.connection.object_id
fruit.user = 'john'
assert_equal fruit.connection.user, apple.connection.user
second_connection = apple.connection.object_id
assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
end
def test_updating_baseclass_password_wipes_descendent_cached_connection_objects
# Subclasses are always equal to superclass password when not overridden
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.password = 'secret'
assert_equal fruit.connection.password, apple.connection.password
first_connection = apple.connection.object_id
fruit.password = 'supersecret'
assert_equal fruit.connection.password, apple.connection.password
second_connection = apple.connection.object_id
assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
end
def test_updating_baseclass_timeout_wipes_descendent_cached_connection_objects
# Subclasses are always equal to superclass timeout when not overridden
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.timeout = 5
assert_equal fruit.connection.timeout, apple.connection.timeout
first_connection = apple.connection.object_id
fruit.timeout = 10
assert_equal fruit.connection.timeout, apple.connection.timeout
second_connection = apple.connection.object_id
assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
end
def test_updating_baseclass_read_and_open_timeouts_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.open_timeout = 1
fruit.read_timeout = 5
assert_equal fruit.connection.open_timeout, apple.connection.open_timeout
assert_equal fruit.connection.read_timeout, apple.connection.read_timeout
first_connection = apple.connection.object_id
fruit.open_timeout = 2
fruit.read_timeout = 10
assert_equal fruit.connection.open_timeout, apple.connection.open_timeout
assert_equal fruit.connection.read_timeout, apple.connection.read_timeout
second_connection = apple.connection.object_id
assert_not_equal(first_connection, second_connection, 'Connection should be re-created')
end
def test_header_inheritance
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.headers['key'] = 'value'
assert_equal 'value', apple.headers['key']
end
def test_header_inheritance_set_at_multiple_points
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.headers['key'] = 'value'
assert_equal 'value', apple.headers['key']
apple.headers['key2'] = 'value2'
fruit.headers['key3'] = 'value3'
assert_equal 'value', apple.headers['key']
assert_equal 'value2', apple.headers['key2']
assert_equal 'value3', apple.headers['key3']
end
def test_header_inheritance_should_not_leak_upstream
fruit = Class.new(ActiveResource::Base)
apple = Class.new(fruit)
fruit.site = 'http://market'
fruit.headers['key'] = 'value'
apple.headers['key2'] = 'value2'
assert_equal nil, fruit.headers['key2']
end
def test_header_should_be_copied_to_main_thread_if_not_defined
fruit = Class.new(ActiveResource::Base)
Thread.new do
fruit.site = 'http://market'
assert_equal 'http://market', fruit.site.to_s
fruit.headers['key'] = 'value'
assert_equal 'value', fruit.headers['key']
end.join
assert_equal 'http://market', fruit.site.to_s
assert_equal 'value', fruit.headers['key']
end
def test_connection_should_use_connection_class
apple = Class.new(ActiveResource::Base)
orange = Class.new(ActiveResource::Base)
telephone = Class.new(ActiveResource::Connection)
orange.connection_class = telephone
apple.site = orange.site = "https://some-site.com/api"
assert_equal ActiveResource::Connection, apple.connection.class
assert_equal telephone, orange.connection.class
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 => {: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_build_with_custom_header
Person.headers['key'] = 'value'
ActiveResource::HttpMock.respond_to do |mock|
mock.get "/people/new.json", {}, Person.new.to_json
mock.get "/people/new.json", { 'key' => 'value' }, Person.new.to_json, 404
end
assert_raise(ActiveResource::ResourceNotFound) { Person.build }
ensure
Person.headers.delete('key')
end
def test_build_without_attributes_for_prefix_call
ActiveResource::HttpMock.respond_to do |mock|
mock.get "/people/1/addresses/new.json", {}, StreetAddress.new.to_json
end
assert_raise(ActiveResource::InvalidRequestError) { StreetAddress.build }
end
def test_build_with_attributes_for_prefix_call
ActiveResource::HttpMock.respond_to do |mock|
mock.get "/people/1/addresses/new.json", {}, StreetAddress.new.to_json
end
assert_nothing_raised { StreetAddress.build(person_id: 1) }
end
def test_build_with_non_prefix_attributes
ActiveResource::HttpMock.respond_to do |mock|
mock.get "/people/1/addresses/new.json", {}, StreetAddress.new.to_json
end
assert_nothing_raised do
address = StreetAddress.build(person_id: 1, city: "Toronto")
assert_equal "Toronto", address.city
end
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_create!
rick = Person.create(:name => 'Rick')
rick_bang = Person.create!(:name => 'Rick')
assert_equal rick.id, rick_bang.id
assert_equal rick.age, rick_bang.age
ActiveResource::HttpMock.respond_to do |mock|
mock.post "/people.json", {}, nil, 422
end
assert_raise(ActiveResource::ResourceInvalid) { Person.create!(:name => 'Rick') }
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
def test_delete_with_custom_header
Person.headers['key'] = 'value'
ActiveResource::HttpMock.respond_to do |mock|
mock.delete "/people/1.json", {}, nil, 200
mock.delete "/people/1.json", { 'key' => 'value' }, nil, 404
end
assert_raise(ActiveResource::ResourceNotFound) { Person.delete(1) }
ensure
Person.headers.delete('key')
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_exists_with_204_no_content
ActiveResource::HttpMock.respond_to do |mock|
mock.head "/people/1.json", {}, nil, 204
end
assert Person.exists?(1)
end
def test_read_attribute_for_serialization
joe = Person.find(6)
joe.singleton_class.class_eval do
def non_attribute_field
'foo'
end
def id
'bar'
end
end
assert_equal joe.read_attribute_for_serialization(:id), 6
assert_equal joe.read_attribute_for_serialization(:name), 'Joe'
assert_equal joe.read_attribute_for_serialization(:likes_hats), true
assert_equal joe.read_attribute_for_serialization(:non_attribute_field), 'foo'
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
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_without_root
ActiveResource::Base.include_root_in_json = false
joe = Person.find(6)
encode = joe.encode
json = joe.to_json
assert_equal encode, json
assert_match %r{^\{"id":6}, json
assert_match %r{"name":"Joe"}, json
assert_match %r{\}$}, json
ensure
ActiveResource::Base.include_root_in_json = true
end
def test_to_json_with_element_name
old_elem_name = Person.element_name
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_persisted_nested_resources_from_response
luis = Customer.find(1)
luis.friends.each do |friend|
assert !friend.new?
friend.brothers.each do |brother|
assert !brother.new?
brother.children.each do |child|
assert !child.new?
end
end
end
end
def test_parse_resource_with_given_has_one_resources
Customer.send(:has_one, :mother, :class_name => "external/person")
luis = Customer.find(1)
assert_kind_of External::Person, luis.mother
end
def test_parse_resources_with_given_has_many_resources
Customer.send(:has_many, :enemies, :class_name => "external/person")
luis = Customer.find(1)
luis.enemies.each do |enemy|
assert_kind_of External::Person, enemy
end
end
def test_parse_resources_with_has_many_makes_get_request_on_nested_route
Post.send(:has_many, :comments)
post = Post.find(1)
post.comments.each do |comment|
assert_kind_of Comment, comment
end
end
def test_parse_resource_with_has_one_makes_get_request_on_child_route
Product.send(:has_one, :inventory)
product = Product.find(1)
assert product.inventory.status == ActiveSupport::JSON.decode(@inventory)['status']
end
def test_parse_non_singleton_resource_with_has_one_makes_get_request_on_child_route
accepts = { 'Accept' => 'application/json' }
ActiveResource::HttpMock.respond_to do |mock|
mock.get '/posts/1.json', accepts, @post
mock.get '/posts/1/author.json', accepts, @matz
end
Post.send(:has_one, :author, class_name: 'Person')
post = Post.find(1)
assert post.author.name == ActiveSupport::JSON.decode(@matz)['person']['name']
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
def test_paths_with_format
assert_equal "/customers.json", Customer.collection_path
assert_equal "/customers/1.json", Customer.element_path(1)
assert_equal "/customers/new.json", Customer.new_element_path
end
def test_paths_without_format
ActiveResource::Base.include_format_in_path = false
assert_equal "/customers", Customer.collection_path
assert_equal "/customers/1", Customer.element_path(1)
assert_equal "/customers/new", Customer.new_element_path
ensure
ActiveResource::Base.include_format_in_path = true
end
end