##// END OF EJS Templates
jro_apps » redmine
RSS
Link to watched issues list on my page....
Link to watched issues list on my page. git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@2457 e93f8b46-1217-0410-a6f0-8f06a7374b81
Eric Davis - - Load All Authors

File last commit:

r2376:f70be197e0ae
r2396:5bdd4291624c
Show More
test_ax.rb
648 lines | 19.9 KiB | text/x-ruby | RubyLexer
/ vendor / gems / ruby-openid-2.1.4 / test / test_ax.rb
History | Source | Raw |Copy content |Copy permalink
Eric Davis
Unpacked OpenID gem. #699...
 r2376 require 'openid/extensions/ax'
require 'openid/message'
require 'openid/consumer/responses'
require 'openid/consumer/discovery'
require 'openid/consumer/checkid_request'
module OpenID
module AX
class BogusAXMessage < AXMessage
@mode = 'bogus'
def get_extension_args
new_args
end
def do_check_mode(args)
check_mode(args)
end
def do_check_mode_new_args
check_mode(new_args)
end
end
class AXMessageTest < Test::Unit::TestCase
def setup
@bax = BogusAXMessage.new
end
def test_check_mode
assert_raises(Error) { @bax.do_check_mode({'mode' => 'fetch_request'})}
@bax.do_check_mode({'mode' => @bax.mode})
end
def test_check_mode_new_args
@bax.do_check_mode_new_args
end
end
class AttrInfoTest < Test::Unit::TestCase
def test_construct
assert_raises(ArgumentError) { AttrInfo.new }
type_uri = 'uri geller'
ainfo = AttrInfo.new(type_uri)
assert_equal(type_uri, ainfo.type_uri)
assert_equal(1, ainfo.count)
assert_equal(false, ainfo.required)
assert_equal(nil, ainfo.ns_alias)
end
end
class ToTypeURIsTest < Test::Unit::TestCase
def setup
@aliases = NamespaceMap.new
end
def test_empty
[nil, ''].each{|empty|
uris = AX.to_type_uris(@aliases, empty)
assert_equal([], uris)
}
end
def test_undefined
assert_raises(IndexError) {
AX.to_type_uris(@aliases, 'http://janrain.com/')
}
end
def test_one
uri = 'http://janrain.com/'
name = 'openid_hackers'
@aliases.add_alias(uri, name)
uris = AX::to_type_uris(@aliases, name)
assert_equal([uri], uris)
end
def test_two
uri1 = 'http://janrain.com/'
name1 = 'openid_hackers'
@aliases.add_alias(uri1, name1)
uri2 = 'http://jyte.com/'
name2 = 'openid_hack'
@aliases.add_alias(uri2, name2)
uris = AX.to_type_uris(@aliases, [name1, name2].join(','))
assert_equal([uri1, uri2], uris)
end
end
class ParseAXValuesTest < Test::Unit::TestCase
def ax_values(ax_args, expected_args)
msg = KeyValueMessage.new
msg.parse_extension_args(ax_args)
assert_equal(expected_args, msg.data)
end
def ax_error(ax_args, error)
msg = KeyValueMessage.new
assert_raises(error) {
msg.parse_extension_args(ax_args)
}
end
def test_empty_is_valid
ax_values({}, {})
end
def test_missing_value_for_alias_explodes
ax_error({'type.foo'=>'urn:foo'}, IndexError)
end
def test_count_present_but_not_value
ax_error({'type.foo'=>'urn:foo', 'count.foo' => '1'}, IndexError)
end
def test_invalid_count_value
msg = FetchRequest.new
assert_raises(Error) {
msg.parse_extension_args({'type.foo'=>'urn:foo',
'count.foo' => 'bogus'})
}
end
def test_request_unlimited_values
msg = FetchRequest.new
args = {'mode' => 'fetch_request',
'required' => 'foo',
'type.foo' => 'urn:foo',
'count.foo' => UNLIMITED_VALUES
}
msg.parse_extension_args(args)
foo = msg.attributes[0]
assert_equal(UNLIMITED_VALUES, foo.count)
assert(foo.wants_unlimited_values?)
end
def test_long_alias
# spec says we must support at least 32 character-long aliases
name = 'x' * MINIMUM_SUPPORTED_ALIAS_LENGTH
msg = KeyValueMessage.new
args = {
"type.#{name}" => 'urn:foo',
"count.#{name}" => '1',
"value.#{name}.1" => 'first',
}
msg.parse_extension_args(args)
assert_equal(['first'],msg['urn:foo'])
end
def test_invalid_alias
types = [
KeyValueMessage,
FetchRequest
]
inputs = [
{'type.a.b'=>'urn:foo',
'count.a.b'=>'1'},
{'type.a,b'=>'urn:foo',
'count.a,b'=>'1'},
]
types.each{|t|
inputs.each{|input|
msg = t.new
assert_raises(Error) {msg.parse_extension_args(input)}
}
}
end
def test_count_present_and_is_zero
ax_values(
{'type.foo'=>'urn:foo',
'count.foo'=>'0',
},
{'urn:foo'=>[]}
)
end
def test_singleton_empty
ax_values(
{'type.foo'=>'urn:foo',
'value.foo'=>'',
},
{'urn:foo'=>[]}
)
end
def test_double_alias
ax_error(
{'type.foo'=>'urn:foo',
'value.foo'=>'',
'type.bar'=>'urn:foo',
'value.bar'=>'',
},
IndexError
)
end
def test_double_singleton
ax_values(
{'type.foo'=>'urn:foo',
'value.foo'=>'',
'type.bar'=>'urn:bar',
'value.bar'=>'',
},
{'urn:foo'=>[],'urn:bar'=>[]}
)
end
def singleton_value
ax_values(
{'type.foo'=>'urn:foo',
'value.foo'=>'something',
},
{'urn:foo'=>['something']}
)
end
end
class FetchRequestTest < Test::Unit::TestCase
def setup
@msg = FetchRequest.new
@type_a = 'http://janrain.example.com/a'
@name_a = 'a'
end
def test_mode
assert_equal('fetch_request', @msg.mode)
end
def test_construct
assert_equal({}, @msg.requested_attributes)
assert_equal(nil, @msg.update_url)
msg = FetchRequest.new('hailstorm')
assert_equal({}, msg.requested_attributes)
assert_equal('hailstorm', msg.update_url)
end
def test_add
uri = 'mud://puddle'
assert(! @msg.member?(uri))
a = AttrInfo.new(uri)
@msg.add(a)
assert(@msg.member?(uri))
end
def test_add_twice
uri = 'its://raining'
a = AttrInfo.new(uri)
@msg.add(a)
assert_raises(IndexError) {@msg.add(a)}
end
def do_extension_args(expected_args)
expected_args['mode'] = @msg.mode
assert_equal(expected_args, @msg.get_extension_args)
end
def test_get_extension_args_empty
do_extension_args({})
end
def test_get_extension_args_no_alias
a = AttrInfo.new('foo://bar')
@msg.add(a)
ax_args = @msg.get_extension_args
ax_args.each{|k,v|
if v == a.type_uri and k.index('type.') == 0
@name = k[5..-1]
break
end
}
do_extension_args({'type.'+@name => a.type_uri,
'if_available' => @name})
end
def test_get_extension_args_alias_if_available
a = AttrInfo.new('type://of.transportation',
'transport')
@msg.add(a)
do_extension_args({'type.'+a.ns_alias => a.type_uri,
'if_available' => a.ns_alias})
end
def test_get_extension_args_alias_req
a = AttrInfo.new('type://of.transportation',
'transport',
true)
@msg.add(a)
do_extension_args({'type.'+a.ns_alias => a.type_uri,
'required' => a.ns_alias})
end
def test_get_required_attrs_empty
assert_equal([], @msg.get_required_attrs)
end
def test_parse_extension_args_extra_type
args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a
}
assert_raises(Error) {@msg.parse_extension_args(args)}
end
def test_parse_extension_args
args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a,
'if_available' => @name_a
}
@msg.parse_extension_args(args)
assert(@msg.member?(@type_a) )
assert_equal([@type_a], @msg.requested_types)
ai = @msg.requested_attributes[@type_a]
assert(ai.is_a?(AttrInfo))
assert(!ai.required)
assert_equal(@type_a, ai.type_uri)
assert_equal(@name_a, ai.ns_alias)
assert_equal([ai], @msg.attributes)
end
def test_extension_args_idempotent
args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a,
'if_available' => @name_a
}
@msg.parse_extension_args(args)
assert_equal(args, @msg.get_extension_args)
assert(!@msg.requested_attributes[@type_a].required)
end
def test_extension_args_idempotent_count_required
args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a,
'count.' + @name_a => '2',
'required' => @name_a
}
@msg.parse_extension_args(args)
assert_equal(args, @msg.get_extension_args)
assert(@msg.requested_attributes[@type_a].required)
end
def test_extension_args_count1
args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a,
'count.' + @name_a => '1',
'if_available' => @name_a
}
norm_args = {
'mode' => 'fetch_request',
'type.' + @name_a => @type_a,
'if_available' => @name_a
}
@msg.parse_extension_args(args)
assert_equal(norm_args, @msg.get_extension_args)
end
def test_from_openid_request_no_ax
message = Message.new
openid_req = Server::OpenIDRequest.new
openid_req.message = message
ax_req = FetchRequest.from_openid_request(openid_req)
assert(ax_req.nil?)
end
def test_openid_update_url_verification_error
openid_req_msg = Message.from_openid_args({
'mode' => 'checkid_setup',
'ns' => OPENID2_NS,
'realm' => 'http://example.com/realm',
'ns.ax' => AXMessage::NS_URI,
'ax.update_url' => 'http://different.site/path',
'ax.mode' => 'fetch_request',
})
openid_req = Server::OpenIDRequest.new
openid_req.message = openid_req_msg
assert_raises(Error) {
FetchRequest.from_openid_request(openid_req)
}
end
def test_openid_no_realm
openid_req_msg = Message.from_openid_args({
'mode' => 'checkid_setup',
'ns' => OPENID2_NS,
'ns.ax' => AXMessage::NS_URI,
'ax.update_url' => 'http://different.site/path',
'ax.mode' => 'fetch_request',
})
openid_req = Server::OpenIDRequest.new
openid_req.message = openid_req_msg
assert_raises(Error) {
FetchRequest.from_openid_request(openid_req)
}
end
def test_openid_update_url_verification_success
openid_req_msg = Message.from_openid_args({
'mode' => 'checkid_setup',
'ns' => OPENID2_NS,
'realm' => 'http://example.com/realm',
'ns.ax' => AXMessage::NS_URI,
'ax.update_url' => 'http://example.com/realm/update_path',
'ax.mode' => 'fetch_request',
})
openid_req = Server::OpenIDRequest.new
openid_req.message = openid_req_msg
fr = FetchRequest.from_openid_request(openid_req)
assert(fr.is_a?(FetchRequest))
end
def test_openid_update_url_verification_success_return_to
openid_req_msg = Message.from_openid_args({
'mode' => 'checkid_setup',
'ns' => OPENID2_NS,
'return_to' => 'http://example.com/realm',
'ns.ax' => AXMessage::NS_URI,
'ax.update_url' => 'http://example.com/realm/update_path',
'ax.mode' => 'fetch_request',
})
openid_req = Server::OpenIDRequest.new
openid_req.message = openid_req_msg
fr = FetchRequest.from_openid_request(openid_req)
assert(fr.is_a?(FetchRequest))
end
def test_add_extension
openid_req_msg = Message.from_openid_args({
'mode' => 'checkid_setup',
'ns' => OPENID2_NS,
'return_to' => 'http://example.com/realm',
})
e = OpenID::OpenIDServiceEndpoint.new
openid_req = Consumer::CheckIDRequest.new(nil, e)
openid_req.message = openid_req_msg
fr = FetchRequest.new
fr.add(AttrInfo.new("urn:bogus"))
openid_req.add_extension(fr)
expected = {
'mode' => 'fetch_request',
'if_available' => 'ext0',
'type.ext0' => 'urn:bogus',
}
expected.each { |k,v|
assert(openid_req.message.get_arg(AXMessage::NS_URI, k) == v)
}
end
end
class FetchResponseTest < Test::Unit::TestCase
def setup
@msg = FetchResponse.new
@value_a = 'commodity'
@type_a = 'http://blood.transfusion/'
@name_a = 'george'
@request_update_url = 'http://some.url.that.is.awesome/'
end
def test_construct
assert_equal(nil, @msg.update_url)
assert_equal({}, @msg.data)
end
def test_get_extension_args_empty
eargs = {
'mode' => 'fetch_response'
}
assert_equal(eargs, @msg.get_extension_args)
end
def test_get_extension_args_empty_request
eargs = {
'mode' => 'fetch_response'
}
req = FetchRequest.new
assert_equal(eargs, @msg.get_extension_args(req))
end
def test_get_extension_args_empty_request_some
uri = 'http://not.found/'
name = 'ext0'
eargs = {
'mode' => 'fetch_response',
'type.' + name => uri,
'count.' + name => '0'
}
req = FetchRequest.new
req.add(AttrInfo.new(uri))
assert_equal(eargs, @msg.get_extension_args(req))
end
def test_update_url_in_response
uri = 'http://not.found/'
name = 'ext0'
eargs = {
'mode' => 'fetch_response',
'update_url' => @request_update_url,
'type.' + name => uri,
'count.' + name => '0'
}
req = FetchRequest.new(@request_update_url)
req.add(AttrInfo.new(uri))
assert_equal(eargs, @msg.get_extension_args(req))
end
def test_get_extension_args_some_request
eargs = {
'mode' => 'fetch_response',
'type.' + @name_a => @type_a,
'value.' + @name_a + '.1' => @value_a,
'count.' + @name_a => '1'
}
req = FetchRequest.new
req.add(AttrInfo.new(@type_a, @name_a))
@msg.add_value(@type_a, @value_a)
assert_equal(eargs, @msg.get_extension_args(req))
end
def test_get_extension_args_some_not_request
req = FetchRequest.new
@msg.add_value(@type_a, @value_a)
assert_raises(IndexError) {@msg.get_extension_args(req)}
end
def test_get_single_success
req = FetchRequest.new
@msg.add_value(@type_a, @value_a)
assert_equal(@value_a, @msg.get_single(@type_a))
end
def test_get_single_none
assert_equal(nil, @msg.get_single(@type_a))
end
def test_get_single_extra
@msg.set_values(@type_a, ['x', 'y'])
assert_raises(Error) { @msg.get_single(@type_a) }
end
def test_from_success_response
uri = 'http://under.the.sea/'
name = 'ext0'
value = 'snarfblat'
m = OpenID::Message.from_openid_args({
'mode' => 'id_res',
'ns' => OPENID2_NS,
'ns.ax' => AXMessage::NS_URI,
'ax.update_url' => 'http://example.com/realm/update_path',
'ax.mode' => 'fetch_response',
'ax.type.' + name => uri,
'ax.count.' + name => '1',
'ax.value.' + name + '.1' => value,
})
e = OpenID::OpenIDServiceEndpoint.new()
resp = OpenID::Consumer::SuccessResponse.new(e, m, [])
ax_resp = FetchResponse.from_success_response(resp, false)
values = ax_resp[uri]
assert_equal(values, [value])
end
def test_from_success_response_empty
e = OpenID::OpenIDServiceEndpoint.new()
m = OpenID::Message.from_openid_args({'mode' => 'id_res'})
resp = OpenID::Consumer::SuccessResponse.new(e, m, [])
ax_resp = FetchResponse.from_success_response(resp)
assert(ax_resp.nil?)
end
end
class StoreRequestTest < Test::Unit::TestCase
def setup
@msg = StoreRequest.new
@type_a = 'http://oranges.are.for/'
@name_a = 'juggling'
end
def test_construct
assert_equal({}, @msg.data)
end
def test_get_extension_args_empty
eargs = {
'mode' => 'store_request'
}
assert_equal(eargs, @msg.get_extension_args)
end
def test_get_extension_args_nonempty
@msg.set_values(@type_a, ['foo','bar'])
aliases = NamespaceMap.new
aliases.add_alias(@type_a, @name_a)
eargs = {
'mode' => 'store_request',
'type.' + @name_a => @type_a,
'value.' + @name_a + '.1' => 'foo',
'value.' + @name_a + '.2' => 'bar',
'count.' + @name_a => '2'
}
assert_equal(eargs, @msg.get_extension_args(aliases))
end
end
class StoreResponseTest < Test::Unit::TestCase
def test_success
msg = StoreResponse.new
assert(msg.succeeded?)
assert(!msg.error_message)
assert_equal({'mode' => 'store_response_success'},
msg.get_extension_args)
end
def test_fail_nomsg
msg = StoreResponse.new(false)
assert(! msg.succeeded? )
assert(! msg.error_message )
assert_equal({'mode' => 'store_response_failure'},
msg.get_extension_args)
end
def test_fail_msg
reason = "because I said so"
msg = StoreResponse.new(false, reason)
assert(! msg.succeeded? )
assert_equal(reason, msg.error_message)
assert_equal({'mode' => 'store_response_failure', 'error' => reason},
msg.get_extension_args)
end
end
end
end