require 'rubygems'
require 'flickr'
require 'test/unit'
require 'mocha'
class TestFlickr < Test::Unit::TestCase
# Flickr client tests
#
# instantiation tests
def test_should_instantiate_new_flickr_client
Flickr.any_instance.stubs(:login)
flickr = Flickr.new('some_api_key', 'email@test.com', 'some_password', 'some_shared_secret')
assert_equal 'some_api_key', flickr.api_key
assert_equal 'some_shared_secret', flickr.instance_variable_get(:@shared_secret)
end
def test_should_try_to_login_using_old_api_if_email_and_password_passed
Flickr.any_instance.expects(:login).with('email@test.com', 'some_password') # checks email and password have been set
flickr = Flickr.new('some_api_key', 'email@test.com', 'some_password', 'some_shared_secret')
end
def test_should_instantiate_new_flickr_client_on_new_api
flickr = Flickr.new('api_key' => 'some_api_key', 'email' => 'email@test.com', 'password' => 'some_password', 'shared_secret' => 'some_shared_secret', 'foo' => 'bar')
assert_equal 'some_api_key', flickr.api_key
assert_equal 'some_shared_secret', flickr.instance_variable_get(:@shared_secret)
assert_nil flickr.instance_variable_get(:@foo) # should ignore other params
end
def test_should_not_try_to_login_using_old_api_when_instantiate_new_flickr_client_on_new_api
Flickr.any_instance.expects(:login).never # doesn't bother trying to login with new api -- it'll fail in any case
flickr = Flickr.new('api_key' => 'some_api_key', 'email' => 'email@test.com', 'password' => 'some_password', 'shared_secret' => 'some_shared_secret', 'foo' => 'bar')
end
# signature_from method tests
def test_should_return_signature_from_given_params
assert_equal Digest::MD5.hexdigest('shared_secret_codea_param1234xb_param5678yc_param97531t'),
authenticated_flickr_client.send(:signature_from, {:b_param => '5678y', 'c_param' => '97531t', :a_param => '1234x', :d_param => nil})
end
def test_should_return_nil_for_signature_when_no_shared_secret
assert_nil flickr_client.send(:signature_from, {:b_param => '5678y', :c_param => '97531t', :a_param => '1234x'})
end
# request_url method tests
def test_should_get_signature_for_params_when_building_url
f = authenticated_flickr_client
f.expects(:signature_from).with( 'method' => 'flickr.someMethod',
'api_key' => 'some_api_key',
'foo' => 'value which/needs&escaping',
'auth_token' => 'some_auth_token').returns("foo123bar456")
url = f.send(:request_url, 'someMethod', 'foo' => 'value which/needs&escaping')
end
def test_should_build_url_from_params_with_signature
f = authenticated_flickr_client
f.stubs(:signature_from).returns("foo123bar456")
url = f.send(:request_url, 'someMethod', 'foo' => 'value which/needs&escaping')
[ "#{Flickr::HOST_URL}#{Flickr::API_PATH}",
'api_key=some_api_key',
'method=flickr.someMethod',
'foo=value+which%2Fneeds%26escaping',
'auth_token=some_auth_token',
'api_sig=foo123bar456'].each do |kv_pair|
assert_match Regexp.new(Regexp.escape(kv_pair)), url
end
end
def test_should_build_url_from_params_when_signature_returns_nil
flickr = flickr_client
flickr.stubs(:signature_from)
assert_equal "#{Flickr::HOST_URL}#{Flickr::API_PATH}/?api_key=some_api_key&method=flickr.someMethod", flickr.send(:request_url, 'someMethod')
assert_equal "#{Flickr::HOST_URL}#{Flickr::API_PATH}/?api_key=some_api_key&method=flickr.someMethod&foo=bar", flickr.send(:request_url, 'someMethod', 'foo' => 'bar', 'foobar' => nil)
assert_equal "#{Flickr::HOST_URL}#{Flickr::API_PATH}/?api_key=some_api_key&method=flickr.someMethod&foo=101", flickr.send(:request_url, 'someMethod', 'foo' => 101)
assert_equal "#{Flickr::HOST_URL}#{Flickr::API_PATH}/?api_key=some_api_key&method=flickr.someMethod&foo=value+which%2Fneeds%26escaping", flickr.send(:request_url, 'someMethod', 'foo' => 'value which/needs&escaping')
end
# method_missing tests
def test_should_generate_flickr_method_from_unkown_method_on_flickr_client
f = flickr_client
f.expects(:request).with('some.unknown.methodForFlickr', {})
f.some_unknown_methodForFlickr
end
# request method tests
def test_should_make_successful_request
f = flickr_client
f.expects(:http_get).with('some.url').returns(successful_xml_response)
f.expects(:request_url).with('some_method', 'foo' => 'bar').returns("some.url")
f.send(:request, 'some_method', 'foo' => 'bar') # request is protected
end
def test_should_raise_exception_on_unsuccessful_request
f = flickr_client
f.expects(:http_get).returns(unsuccessful_xml_response)
assert_raise(RuntimeError) { f.send(:request, 'some_method', 'foo' => 'bar') }
end
def test_should_parse_returned_xml_in_successful_request
f = flickr_client
f.stubs(:http_get).returns(successful_xml_response)
expected_response = { "contacts" => { "perpage" => "1000",
"contact" => [{ "nsid"=>"12037949629@N01",
"username"=>"Eric",
"ignored"=>"1",
"family"=>"0",
"friend"=>"1",
"realname"=>"Eric Costello",
"iconserver"=>"1"},
{ "nsid"=>"12037949631@N01",
"username"=>"neb",
"ignored"=>"0",
"family"=>"0",
"friend"=>"0",
"realname"=>"Ben Cerveny",
"iconserver"=>"1"}],
"total" => "2",
"pages"=> "1",
"page"=>"1" },
"stat"=>"ok" }
assert_equal expected_response, f.send(:request, 'some_method', 'foo' => 'bar')
end
def test_should_generate_login_url
f = flickr_client
f.expects(:signature_from).with('api_key' => 'some_api_key', 'perms' => 'write').returns('validsignature')
assert_equal 'http://flickr.com/services/auth/?api_key=some_api_key&perms=write&api_sig=validsignature', f.login_url('write')
end
def test_should_get_token_from_frob
f = flickr_client
f.expects(:request).with('auth.getToken',:frob => 'some_frob').returns({'auth' => {'token' => 'some_auth_token', 'user' => {}}})
auth_token = f.get_token_from('some_frob')
assert_equal 'some_auth_token', auth_token
end
def test_should_store_auth_token_in_client
f = flickr_client
f.expects(:request).returns({'auth' => {'token' => 'some_auth_token','user' => {}}})
f.get_token_from('some_frob')
assert_equal 'some_auth_token', f.auth_token
end
def test_should_store_authenticated_user_details_in_client
f = flickr_client
f.expects(:request).returns({ 'auth' => { 'token' => 'some_auth_token',
'user' => { 'nsid' => 'foo123',
'username' => 'some_user', 'fullname' => 'Some User'}}})
f.get_token_from('some_frob')
assert_kind_of Flickr::User, user = f.user
assert_equal 'foo123', user.id
assert_equal 'some_user', user.username
assert_equal 'Some User', user.name
assert_equal f, user.client
end
# photos method tests
def test_should_get_recent_photos_if_no_params_for_photos
f = flickr_client
f.expects(:photos_getRecent).returns({"photos" => {"photo" => []}})
f.photos
end
def test_should_instantiate_recent_photos_with_id_and_all_params_returned_by_flickr
f = flickr_client
f.expects(:photos_getRecent).returns(dummy_photos_response)
Flickr::Photo.expects(:new).with("foo123",
"some_api_key", { "key1" => "value1",
"key2" => "value2"})
Flickr::Photo.expects(:new).with("bar456",
"some_api_key", { "key3" => "value3"})
f.photos
end
# photos_search method tests
def test_should_search_photos
f = authenticated_flickr_client
f.expects(:request).with('photos.search', anything).returns(dummy_photos_response)
photos = f.photos_search
assert_kind_of Flickr::Photo, photos.first
end
# users method tests
def test_should_find_user_from_email
f = flickr_client
f.expects(:request).with('people.findByEmail', anything).returns(dummy_user_response)
assert_kind_of Flickr::User, user = f.users("email@test.com")
assert_equal "12037949632@N01", user.id
assert_equal "Stewart", user.username
end
def test_should_find_user_from_username_if_fails_to_get_from_email
f = flickr_client
f.expects(:request).with('people.findByEmail', anything).raises
f.expects(:request).with('people.findByUsername', anything).returns(dummy_user_response)
assert_kind_of Flickr::User, f.users("email@test.com")
end
def test_should_pass_on_flickr_client_when_finding_user
f = flickr_client
f.stubs(:request).returns(dummy_user_response)
user = f.users("email@test.com")
assert_equal f, user.client
end
# groups method tests
def test_should_search_for_given_group
f = flickr_client
f.expects(:request).with("groups.search", {"text" => "foo"}).returns(dummy_groups_response)
f.groups("foo")
end
def test_should_search_for_given_group_with_additional_params
f = flickr_client
f.expects(:request).with("groups.search", {"text" => "foo", "per_page" => "1"}).returns(dummy_groups_response)
f.groups("foo", "per_page" => "1")
end
def test_should_instantiate_groups_from_search_response
f = flickr_client
f.stubs(:request).returns(dummy_groups_response)
assert_kind_of Array, groups = f.groups("foo")
assert_kind_of Flickr::Group, group = groups.first
assert_equal "group1", group.id
assert_equal "Group One", group.name
assert_equal "0", group.eighteenplus
assert_equal f, group.client
end
def test_should_instantiate_groups_from_search_response_with_single_group_returned
f = flickr_client
f.stubs(:request).returns(dummy_single_group_response)
assert_kind_of Array, groups = f.groups("foo")
assert_equal 1, groups.size
assert_equal "group1", groups.first.id
end
# ##### DIRECT MODE
#
# def test_test_echo
# assert_equal @f.test_echo['stat'], 'ok'
# end
# def test_test_login
# assert_equal @f.test_login['stat'], 'ok'
# end
#
#
# ##### BASICS
#
# def test_login
# assert_equal @username, @f.user.getInfo.username
# end
#
# def test_find_by_url
# assert_equal @group_id, @f.find_by_url(@group_url).getInfo.id # find group by URL
# assert_equal @user_id, @f.find_by_url(@user_url).getInfo.id # find user by URL
# end
#
# def test_licenses
# assert_kind_of Array, @f.licenses # find all licenses
# end
#
#
# Flickr#photos tests
#
# ##### Flickr::User tests
#
def test_should_instantiate_user
user = new_user
assert_equal 'foo123', user.id
assert_equal 'some_user', user.username
assert_equal 'bar', user.instance_variable_get(:@foo) # should collect all other params up and store as instance variables
end
def test_should_instantiate_new_user_with_old_api
Flickr.any_instance.stubs(:login) # stub logging in
user = Flickr::User.new('foo123',
'some_user',
'email@test.com', # email irrelevant since Flickr API no longer supports authentication in this way
'password', # password irrelevant since Flickr API no longer supports authentication in this way
'bar456')
assert_equal 'foo123', user.id
assert_equal 'some_user', user.username
assert_equal 'email@test.com', user.instance_variable_get(:@email)
assert_equal 'password', user.instance_variable_get(:@password)
assert_equal 'bar456', user.client.api_key
end
def test_should_instantiate_new_client_when_instantiating_user_if_no_client_passed_in_params
f = flickr_client
Flickr.expects(:new).returns(f)
user = new_user( 'api_key' => 'an_api_key' )
assert_equal f, user.client
end
def test_should_not_instantiate_new_client_when_instantiating_user_if_client_passed_in_params
f = flickr_client
Flickr.expects(:new).never
user = new_user( 'client' => f )
assert_equal f, user.client
end
def test_should_not_instantiate_client_if_no_api_key_passed
Flickr.expects(:new).never
user = new_user
assert_nil user.client
end
def test_should_get_users_public_groups
f = flickr_client
f.expects(:request).with("people.getPublicGroups", anything).returns(dummy_groups_response)
new_user( 'client' => f ).groups
end
def test_should_instantiate_users_public_groups
f = flickr_client
f.stubs(:request).returns(dummy_groups_response)
user = new_user( 'client' => f )
groups = user.groups
assert_equal 2, groups.size
assert_kind_of Flickr::Group, group = groups.first
assert_equal "group1", group.id
assert_equal "Group One", group.name
assert_equal "0", group.eighteenplus
assert_equal f, group.client
end
def test_should_instantiate_users_public_groups_when_only_one_returned
f = flickr_client
f.stubs(:request).returns(dummy_single_group_response)
user = new_user( 'client' => f )
groups = user.groups
assert_equal 1, groups.size
end
# def test_getInfo
# @u.getInfo
# assert_equal @username, @u.username
# end
#
# def test_groups
# assert_kind_of Flickr::Group, @u.groups.first # public groups
# end
#
#
# def test_contacts
# assert_kind_of Flickr::User, @u.contacts.first # public contacts
# end
#
# def test_favorites
# assert_kind_of Flickr::Photo, @u.favorites.first # public favorites
# end
#
# def test_photosets
# assert_kind_of Flickr::Photoset, @u.photosets.first # public photosets
# end
#
# def test_tags
# assert_kind_of Array, @u.tags # tags
# end
#
# def test_contactsPhotos
# assert_kind_of Flickr::Photo, @u.contactsPhotos.first # contacts' favorites
# end
# User#photos tests
def test_should_get_users_public_photos
Flickr.expects(:new).at_least_once.returns(photos_response_stubber(:people_getPublicPhotos))
user = Flickr::User.new(nil, "some_user", nil, nil, "some_api_key")
photos = user.photos
assert_equal 2, photos.size
assert_kind_of Flickr::Photo, photos.first
end
def test_should_get_users_public_photos_when_only_one_returned
Flickr.expects(:new).at_least_once.returns(photos_response_stubber(:people_getPublicPhotos, dummy_single_photo_response))
user = Flickr::User.new(nil, "some_user", nil, nil, "some_api_key")
photos = user.photos
assert_equal 1, photos.size
assert_kind_of Flickr::Photo, photos.first
end
def test_should_instantiate_photos_with_id_and_all_params_returned_by_query_and_username
Flickr.stubs(:new).returns(photos_response_stubber(:people_getPublicPhotos))
user = Flickr::User.new(nil, "some_user", nil, nil, "some_api_key")
Flickr::Photo.expects(:new).with("foo123",
"some_api_key", { "key1" => "value1",
&n
) is private.
