Class BaseTest < ActiveSupport::TestCase

# File activeresource/test/cases/base_test.rb, line 1010
def foo
  "bar"
end

# File activeresource/test/cases/base_test.rb, line 16
def setup
  setup_response # find me in abstract_unit
  @original_person_site = Person.site
end

# File actionmailer/test/base_test.rb, line 9
def teardown
  ActionMailer::Base.asset_host = nil
  ActionMailer::Base.assets_dir = nil
end

# File activeresource/test/cases/base_test.rb, line 738
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

# File activeresource/test/cases/base_test.rb, line 446
def test_collection_name
  assert_equal "people", Person.collection_name
end

# File activeresource/test/cases/base_test.rb, line 450
def test_collection_path
  assert_equal '/people.json', Person.collection_path
end

# File activeresource/test/cases/base_test.rb, line 454
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

# File activeresource/test/cases/base_test.rb, line 757
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

# File activeresource/test/cases/base_test.rb, line 714
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

# File activeresource/test/cases/base_test.rb, line 671
def test_create_with_custom_prefix
  matzs_house = StreetAddress.new(:person_id => 1)
  matzs_house.save
  assert_equal '5', matzs_house.id
end

# File activeresource/test/cases/base_test.rb, line 1108
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

# File activeresource/test/cases/base_test.rb, line 730
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

# File activeresource/test/cases/base_test.rb, line 145
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

# File activeresource/test/cases/base_test.rb, line 546
def test_custom_collection_name
  assert_equal 'addresses', StreetAddress.collection_name
end

# File activeresource/test/cases/base_test.rb, line 528
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

# File activeresource/test/cases/base_test.rb, line 533
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

# File activeresource/test/cases/base_test.rb, line 538
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

# File activeresource/test/cases/base_test.rb, line 522
def test_custom_collection_path_without_required_prefix_param
  assert_raise ActiveResource::MissingPrefixParam do
    StreetAddress.collection_path
  end
end

# File activeresource/test/cases/base_test.rb, line 542
def test_custom_element_name
  assert_equal 'address', StreetAddress.element_name
end

# File activeresource/test/cases/base_test.rb, line 471
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

# File activeresource/test/cases/base_test.rb, line 511
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

# File activeresource/test/cases/base_test.rb, line 518
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

# File activeresource/test/cases/base_test.rb, line 488
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

# File activeresource/test/cases/base_test.rb, line 478
def test_custom_element_path_without_required_prefix_param
  assert_raise ActiveResource::MissingPrefixParam do
    StreetAddress.element_path(1)
  end
end

# File activeresource/test/cases/base_test.rb, line 605
def test_custom_header
  Person.headers['key'] = 'value'
  assert_raise(ActiveResource::ResourceNotFound) { Person.find(4) }
ensure
  Person.headers.delete('key')
end

# File activeresource/test/cases/base_test.rb, line 587
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

# File activeresource/test/cases/base_test.rb, line 878
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

# File activeresource/test/cases/base_test.rb, line 894
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

# File activeresource/test/cases/base_test.rb, line 886
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

# File activeresource/test/cases/base_test.rb, line 854
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

# File activeresource/test/cases/base_test.rb, line 870
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

# File activeresource/test/cases/base_test.rb, line 862
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

# File activeresource/test/cases/base_test.rb, line 905
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

# File activeresource/test/cases/base_test.rb, line 964
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

# File activeresource/test/cases/base_test.rb, line 927
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

# File activeresource/test/cases/base_test.rb, line 956
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

# File activeresource/test/cases/base_test.rb, line 624
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

# File activeresource/test/cases/base_test.rb, line 633
def test_id_from_response_without_location
  p = Person.new
  resp = {}
  assert_nil p.__send__(:id_from_response, resp)
end

# File activeresource/test/cases/base_test.rb, line 678
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

# File activeresource/test/cases/base_test.rb, line 484
def test_module_element_path
  assert_equal '/sounds/1.json', Asset::Sound.element_path(1)
end

# File activeresource/test/cases/base_test.rb, line 1141
def test_namespacing
  sound = Asset::Sound.find(1)
  assert_equal "Asset::Sound::Author", sound.author.class.to_s
end

# File activeresource/test/cases/base_test.rb, line 747
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

# File activeresource/test/cases/base_test.rb, line 646
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

# File activeresource/test/cases/base_test.rb, line 654
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

# File activeresource/test/cases/base_test.rb, line 639
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

# File activeresource/test/cases/base_test.rb, line 1080
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

# File activeresource/test/cases/base_test.rb, line 272
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

# File activeresource/test/cases/base_test.rb, line 115
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

# File activeresource/test/cases/base_test.rb, line 664
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

# File activeresource/test/cases/base_test.rb, line 550
def test_prefix
  assert_equal "/", Person.prefix
  assert_equal Set.new, Person.__send__(:prefix_parameters)
end

# File activeresource/test/cases/base_test.rb, line 52
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

# File activeresource/test/cases/base_test.rb, line 193
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

# File activeresource/test/cases/base_test.rb, line 66
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

# File activeresource/test/cases/base_test.rb, line 689
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

# File activeresource/test/cases/base_test.rb, line 684
def test_reload_works_with_prefix_options
  address = StreetAddress.find(1, :params => { :person_id => 1 })
  assert_equal address, address.reload
end

# File activeresource/test/cases/base_test.rb, line 709
def test_reload_works_without_prefix_options
  person = Person.find(:first)
  assert_equal person, person.reload
end

# File activeresource/test/cases/base_test.rb, line 597
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

# File activeresource/test/cases/base_test.rb, line 612
def test_save
  rick = Person.new
  assert rick.save
  assert_equal '5', rick.id
end

# File activeresource/test/cases/base_test.rb, line 618
def test_save!
  rick = Person.new
  assert rick.save!
  assert_equal '5', rick.id
end

# File activeresource/test/cases/base_test.rb, line 555
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

# File activeresource/test/cases/base_test.rb, line 569
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

# File activeresource/test/cases/base_test.rb, line 580
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

# File activeresource/test/cases/base_test.rb, line 562
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

# File activeresource/test/cases/base_test.rb, line 86
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

# File activeresource/test/cases/base_test.rb, line 80
def test_should_accept_setting_password
  Forum.password = 'test123'
  assert_equal('test123', Forum.password)
  assert_equal('test123', Forum.connection.password)
end

# File activeresource/test/cases/base_test.rb, line 98
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

# File activeresource/test/cases/base_test.rb, line 92
def test_should_accept_setting_timeout
  Forum.timeout = 5
  assert_equal(5, Forum.timeout)
  assert_equal(5, Forum.connection.timeout)
end

# File activeresource/test/cases/base_test.rb, line 74
def test_should_accept_setting_user
  Forum.user = 'david'
  assert_equal('david', Forum.user)
  assert_equal('david', Forum.connection.user)
end

# File activeresource/test/cases/base_test.rb, line 62
def test_should_use_proxy_prefix_and_credentials
  assert_equal 'http://user:password@proxy.local:3000', ProxyResource.proxy.to_s
end

# File activeresource/test/cases/base_test.rb, line 39
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

# File activeresource/test/cases/base_test.rb, line 29
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

# File activeresource/test/cases/base_test.rb, line 152
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

# File activeresource/test/cases/base_test.rb, line 44
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

# File activeresource/test/cases/base_test.rb, line 135
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

# File activeresource/test/cases/base_test.rb, line 344
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

# File activeresource/test/cases/base_test.rb, line 310
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

# File activeresource/test/cases/base_test.rb, line 125
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

# File activeresource/test/cases/base_test.rb, line 1022
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

# File activeresource/test/cases/base_test.rb, line 1049
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

# File activeresource/test/cases/base_test.rb, line 1034
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_no_match %r{^\{"person":\}}, 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

# File activeresource/test/cases/base_test.rb, line 1073
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

# File activeresource/test/cases/base_test.rb, line 1066
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

# File activeresource/test/cases/base_test.rb, line 972
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

# File activeresource/test/cases/base_test.rb, line 986
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

# File activeresource/test/cases/base_test.rb, line 1005
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

# File activeresource/test/cases/base_test.rb, line 773
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

# File activeresource/test/cases/base_test.rb, line 818
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

# File activeresource/test/cases/base_test.rb, line 809
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

# File activeresource/test/cases/base_test.rb, line 839
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

# File activeresource/test/cases/base_test.rb, line 828
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

# File activeresource/test/cases/base_test.rb, line 797
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

# File activeresource/test/cases/base_test.rb, line 781
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

# File activeresource/test/cases/base_test.rb, line 789
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

# File activeresource/test/cases/base_test.rb, line 1122
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

# File activeresource/test/cases/base_test.rb, line 409
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

# File activeresource/test/cases/base_test.rb, line 378
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

# File activeresource/test/cases/base_test.rb, line 425
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

# File activeresource/test/cases/base_test.rb, line 393
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

# File activeresource/test/cases/base_test.rb, line 234
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

# File activeresource/test/cases/base_test.rb, line 105
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

# File activeresource/test/cases/base_test.rb, line 1094
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

# File activeresource/test/cases/base_test.rb, line 491
def to_param
  name
end

# File actionmailer/test/base_test.rb, line 578
def welcome
  mail
end

# File actionmailer/test/base_test.rb, line 593
def swap(klass, new_values)
  old_values = {}
  new_values.each do |key, value|
    old_values[key] = klass.send key
    klass.send :"#{key}=", value
  end
  yield
ensure
  old_values.each do |key, value|
    klass.send :"#{key}=", value
  end
end

# File actionmailer/test/base_test.rb, line 606
def with_default(klass, new_values)
  old = klass.default_params
  klass.default(new_values)
  yield
ensure
  klass.default_params = old
end