258 lines
8.2 KiB
Ruby
258 lines
8.2 KiB
Ruby
require "openid/consumer"
|
|
require "test/unit"
|
|
require "testutil"
|
|
|
|
module OpenID
|
|
class Consumer
|
|
module TestConsumer
|
|
class TestLastEndpoint < Test::Unit::TestCase
|
|
def test_set_get
|
|
session = {}
|
|
consumer = Consumer.new(session, nil)
|
|
consumer.send(:last_requested_endpoint=, :endpoint)
|
|
ep = consumer.send(:last_requested_endpoint)
|
|
assert_equal(:endpoint, ep)
|
|
ep = consumer.send(:last_requested_endpoint)
|
|
assert_equal(:endpoint, ep)
|
|
consumer.send(:cleanup_last_requested_endpoint)
|
|
ep = consumer.send(:last_requested_endpoint)
|
|
assert_equal(nil, ep)
|
|
end
|
|
end
|
|
|
|
class TestBegin < Test::Unit::TestCase
|
|
attr_accessor :user_input, :anonymous, :services,
|
|
:discovered_identifier, :checkid_request, :service
|
|
|
|
def setup
|
|
@discovered_identifier = 'http://discovered/'
|
|
@user_input = 'user.input'
|
|
@service = :service
|
|
@services = [@service]
|
|
@session = {}
|
|
@anonymous = false
|
|
@checkid_request = :checkid_request
|
|
end
|
|
|
|
def consumer
|
|
test = self
|
|
consumer = Consumer.new(@session, nil)
|
|
consumer.extend(InstanceDefExtension)
|
|
consumer.instance_def(:discover) do |identifier|
|
|
test.assert_equal(test.user_input, identifier)
|
|
[test.discovered_identifier, test.services]
|
|
end
|
|
consumer.instance_def(:begin_without_discovery) do
|
|
|service, sent_anonymous|
|
|
test.assert_equal(test.service, service)
|
|
test.assert_equal(test.anonymous, sent_anonymous)
|
|
test.checkid_request
|
|
end
|
|
consumer
|
|
end
|
|
|
|
def test_begin
|
|
checkid_request = consumer.begin(@user_input, @anonymous)
|
|
assert_equal(:checkid_request, checkid_request)
|
|
assert_equal(['OpenID::Consumer::DiscoveredServices::'\
|
|
'OpenID::Consumer::'], @session.keys.sort!)
|
|
end
|
|
|
|
def test_begin_failure
|
|
@services = []
|
|
assert_raises(DiscoveryFailure) {
|
|
consumer.begin(@user_input, @anonymous)
|
|
}
|
|
end
|
|
|
|
def test_begin_fallback
|
|
@services = [:service1, :service2]
|
|
consumer = self.consumer
|
|
@service = :service1
|
|
consumer.begin(@user_input, @anonymous)
|
|
@service = :service2
|
|
consumer.begin(@user_input, @anonymous)
|
|
@service = :service1
|
|
consumer.begin(@user_input, @anonymous)
|
|
@service = :service2
|
|
consumer.begin(@user_input, @anonymous)
|
|
end
|
|
end
|
|
|
|
class TestBeginWithoutDiscovery < Test::Unit::TestCase
|
|
attr_reader :assoc
|
|
def setup
|
|
@session = {}
|
|
@assoc = :assoc
|
|
@service = OpenIDServiceEndpoint.new
|
|
@claimed_id = 'http://claimed.id/'
|
|
@service.claimed_id = @claimed_id
|
|
@anonymous = false
|
|
end
|
|
|
|
def consumer
|
|
test = self
|
|
assoc_manager = Object.new
|
|
assoc_manager.extend(InstanceDefExtension)
|
|
assoc_manager.instance_def(:get_association) do
|
|
test.assoc
|
|
end
|
|
|
|
consumer = Consumer.new(@session, nil)
|
|
consumer.extend(InstanceDefExtension)
|
|
consumer.instance_def(:association_manager) do |service|
|
|
assoc_manager
|
|
end
|
|
consumer
|
|
end
|
|
|
|
def call_begin_without_discovery
|
|
result = consumer.begin_without_discovery(@service, @anonymous)
|
|
assert(result.instance_of?(CheckIDRequest))
|
|
assert_equal(@anonymous, result.anonymous)
|
|
assert_equal(@service, consumer.send(:last_requested_endpoint))
|
|
assert_equal(result.instance_variable_get(:@assoc), @assoc)
|
|
return result
|
|
end
|
|
|
|
def cid_name
|
|
Consumer.openid1_return_to_claimed_id_name
|
|
end
|
|
|
|
def nonce_name
|
|
Consumer.openid1_return_to_nonce_name
|
|
end
|
|
|
|
def test_begin_without_openid1
|
|
result = call_begin_without_discovery
|
|
|
|
assert_equal(@claimed_id, result.return_to_args[cid_name])
|
|
assert_equal([cid_name, nonce_name].sort!,
|
|
result.return_to_args.keys.sort!)
|
|
end
|
|
|
|
def test_begin_without_openid1_anonymous
|
|
@anonymous = true
|
|
assert_raises(ArgumentError) {
|
|
call_begin_without_discovery
|
|
}
|
|
end
|
|
|
|
def test_begin_without_openid2
|
|
@service.type_uris = [OPENID_2_0_TYPE]
|
|
result = call_begin_without_discovery
|
|
|
|
assert(result.return_to_args.empty?)
|
|
end
|
|
|
|
def test_begin_without_openid2_anonymous
|
|
@anonymous = true
|
|
@service.type_uris = [OPENID_2_0_TYPE]
|
|
result = call_begin_without_discovery
|
|
|
|
assert(result.return_to_args.empty?)
|
|
end
|
|
end
|
|
|
|
class TestComplete < Test::Unit::TestCase
|
|
def setup
|
|
@session = {}
|
|
@consumer = Consumer.new(@session, nil)
|
|
end
|
|
|
|
def test_bad_mode
|
|
response = @consumer.complete({'openid.ns' => OPENID2_NS,
|
|
'openid.mode' => 'bad'}, nil)
|
|
assert_equal(FAILURE, response.status)
|
|
end
|
|
|
|
def test_missing_mode
|
|
response = @consumer.complete({'openid.ns' => OPENID2_NS}, nil)
|
|
assert_equal(FAILURE, response.status)
|
|
end
|
|
|
|
def test_cancel
|
|
response = @consumer.complete({'openid.mode' => 'cancel'}, nil)
|
|
assert_equal(CANCEL, response.status)
|
|
end
|
|
|
|
def test_setup_needed_openid1
|
|
response = @consumer.complete({'openid.mode' => 'setup_needed'}, nil)
|
|
assert_equal(FAILURE, response.status)
|
|
end
|
|
|
|
def test_setup_needed_openid2
|
|
args = {'openid.ns' => OPENID2_NS, 'openid.mode' => 'setup_needed'}
|
|
response = @consumer.complete(args, nil)
|
|
assert_equal(SETUP_NEEDED, response.status)
|
|
end
|
|
|
|
def test_idres_setup_needed_openid1
|
|
setup_url = 'http://setup.url/'
|
|
args = {
|
|
'openid.user_setup_url' => setup_url,
|
|
'openid.mode' => 'id_res',
|
|
}
|
|
response = @consumer.complete(args, nil)
|
|
assert_equal(SETUP_NEEDED, response.status)
|
|
end
|
|
|
|
def test_error
|
|
contact = 'me'
|
|
reference = 'thing thing'
|
|
args = {
|
|
'openid.mode' => 'error',
|
|
'openid.contact' => contact,
|
|
'openid.reference' => reference,
|
|
}
|
|
response = @consumer.complete(args, nil)
|
|
assert_equal(FAILURE, response.status)
|
|
assert_equal(contact, response.contact)
|
|
assert_equal(reference, response.reference)
|
|
|
|
args['openid.ns'] = OPENID2_NS
|
|
response = @consumer.complete(args, nil)
|
|
assert_equal(FAILURE, response.status)
|
|
assert_equal(contact, response.contact)
|
|
assert_equal(reference, response.reference)
|
|
end
|
|
|
|
def test_idres_openid1
|
|
args = {
|
|
'openid.mode' => 'id_res',
|
|
}
|
|
|
|
endpoint = OpenIDServiceEndpoint.new
|
|
endpoint.claimed_id = :test_claimed_id
|
|
|
|
idres = Object.new
|
|
idres.extend(InstanceDefExtension)
|
|
idres.instance_def(:endpoint){endpoint}
|
|
idres.instance_def(:signed_fields){:test_signed_fields}
|
|
|
|
test = self
|
|
@consumer.extend(InstanceDefExtension)
|
|
@consumer.instance_def(:handle_idres) {|message, return_to|
|
|
test.assert_equal(args, message.to_post_args)
|
|
test.assert_equal(:test_return_to, return_to)
|
|
idres
|
|
}
|
|
|
|
response = @consumer.complete(args, :test_return_to)
|
|
assert_equal(SUCCESS, response.status, response.message)
|
|
assert_equal(:test_claimed_id, response.identity_url)
|
|
assert_equal(endpoint, response.endpoint)
|
|
|
|
error_message = "In Soviet Russia, id_res handles you!"
|
|
@consumer.instance_def(:handle_idres) {|message, return_to|
|
|
raise ProtocolError, error_message
|
|
}
|
|
response = @consumer.complete(args, :test_return_to)
|
|
assert_equal(FAILURE, response.status)
|
|
assert_equal(error_message, response.message)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|