##// END OF EJS Templates
jro_apps » redmine
RSS
Adds ability to filter watched issues (#846)....
Adds ability to filter watched issues (#846). git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@2456 e93f8b46-1217-0410-a6f0-8f06a7374b81
Eric Davis - - Load All Authors

File last commit:

r2376:f70be197e0ae
r2395:e1b828de95ec
Show More
test_message.rb
1116 lines | 30.3 KiB | text/x-ruby | RubyLexer
/ vendor / gems / ruby-openid-2.1.4 / test / test_message.rb
History | Source | Raw |Copy content |Copy permalink
Eric Davis
Unpacked OpenID gem. #699...
 r2376 # last synced with Python openid.test.test_message on 6/29/2007.
require 'test/unit'
require 'util'
require 'openid/message'
require 'rexml/document'
module OpenID
module GetArgsMixin
# Tests a standard set of behaviors of Message.get_arg with
# variations on handling defaults.
def get_arg_tests(ns, key, expected=nil)
assert_equal(expected, @m.get_arg(ns, key))
if expected.nil?
assert_equal(@m.get_arg(ns, key, :a_default), :a_default)
assert_raise(Message::KeyNotFound) { @m.get_arg(ns, key, NO_DEFAULT) }
else
assert_equal(@m.get_arg(ns, key, :a_default), expected)
assert_equal(@m.get_arg(ns, key, NO_DEFAULT), expected)
end
end
end
class EmptyMessageTestCase < Test::Unit::TestCase
include GetArgsMixin
def setup
@m = Message.new
end
def test_get_aliased_arg_no_default
assert_raises(Message::KeyNotFound) do
@m.get_aliased_arg('ns.pork', NO_DEFAULT)
end
ns_uri = "urn:pork"
@m.namespaces.add_alias(ns_uri, 'pork_alias')
# Should return ns_uri.
assert_equal(ns_uri, @m.get_aliased_arg('ns.pork_alias', NO_DEFAULT))
end
def test_to_post_args
assert_equal({}, @m.to_post_args)
end
def test_to_args
assert_equal({}, @m.to_args)
end
def test_to_kvform
assert_equal('', @m.to_kvform)
end
def test_from_kvform
kvform = "foo:bar\none:two\n"
args = {'foo' => 'bar', 'one' => 'two'}
expected_result = Message.from_openid_args(args)
assert_equal(expected_result, Message.from_kvform(kvform))
end
def test_to_url_encoded
assert_equal('', @m.to_url_encoded)
end
def test_to_url
base_url = 'http://base.url/'
assert_equal(base_url, @m.to_url(base_url))
end
def test_get_openid
assert_equal(nil, @m.get_openid_namespace)
end
def test_get_key_openid
assert_raise(UndefinedOpenIDNamespace) {
@m.get_key(OPENID_NS, nil)
}
end
def test_get_key_bare
assert_equal('foo', @m.get_key(BARE_NS, 'foo'))
end
def test_get_key_ns1
assert_equal(nil, @m.get_key(OPENID1_NS, 'foo'))
end
def test_get_key_ns2
assert_equal(nil, @m.get_key(OPENID2_NS, 'foo'))
end
def test_get_key_ns3
assert_equal(nil, @m.get_key('urn:something-special', 'foo'))
end
def test_has_key
assert_raise(UndefinedOpenIDNamespace) {
@m.has_key?(OPENID_NS, 'foo')
}
end
def test_has_key_bare
assert_equal(false, @m.has_key?(BARE_NS, 'foo'))
end
def test_has_key_ns1
assert_equal(false, @m.has_key?(OPENID1_NS, 'foo'))
end
def test_has_key_ns2
assert_equal(false, @m.has_key?(OPENID2_NS, 'foo'))
end
def test_has_key_ns3
assert_equal(false, @m.has_key?('urn:xxx', 'foo'))
end
def test_get_arg
assert_raise(UndefinedOpenIDNamespace) {
@m.get_args(OPENID_NS)
}
end
def test_get_arg_bare
get_arg_tests(ns=BARE_NS, key='foo')
end
def test_get_arg_ns1
get_arg_tests(ns=OPENID1_NS, key='foo')
end
def test_get_arg_ns2
get_arg_tests(ns=OPENID2_NS, key='foo')
end
def test_get_arg_ns3
get_arg_tests(ns='urn:nothing-significant', key='foo')
end
def test_get_args
assert_raise(UndefinedOpenIDNamespace) {
@m.get_args(OPENID_NS)
}
end
def test_get_args_bare
assert_equal({}, @m.get_args(BARE_NS))
end
def test_get_args_ns1
assert_equal({}, @m.get_args(OPENID1_NS))
end
def test_get_args_ns2
assert_equal({}, @m.get_args(OPENID2_NS))
end
def test_get_args_ns3
assert_equal({}, @m.get_args('urn:xxx'))
end
def test_update_args
assert_raise(UndefinedOpenIDNamespace) {
@m.update_args(OPENID_NS, {'does not'=>'matter'})
}
end
def _test_update_args_ns(ns)
updates = {
'camper van beethoven' => 'david l',
'magnolia electric, co' => 'jason m'
}
assert_equal({}, @m.get_args(ns))
@m.update_args(ns, updates)
assert_equal(updates, @m.get_args(ns))
end
def test_update_args_bare
_test_update_args_ns(BARE_NS)
end
def test_update_args_ns1
_test_update_args_ns(OPENID1_NS)
end
def test_update_args_ns2
_test_update_args_ns(OPENID2_NS)
end
def test_update_args_ns3
_test_update_args_ns('urn:xxx')
end
def test_set_arg
assert_raise(UndefinedOpenIDNamespace) {
@m.set_arg(OPENID_NS,'does not','matter')
}
end
def _test_set_arg_ns(ns)
key = 'Camper Van Beethoven'
value = 'David Lowery'
assert_equal(nil, @m.get_arg(ns, key))
@m.set_arg(ns, key, value)
assert_equal(value, @m.get_arg(ns, key))
end
def test_set_arg_bare
_test_set_arg_ns(BARE_NS)
end
def test_set_arg_ns1
_test_set_arg_ns(OPENID1_NS)
end
def test_set_arg_ns2
_test_set_arg_ns(OPENID2_NS)
end
def test_set_arg_ns3
_test_set_arg_ns('urn:xxx')
end
def test_del_arg
assert_raise(UndefinedOpenIDNamespace) {
@m.set_arg(OPENID_NS, 'does not', 'matter')
}
end
def _test_del_arg_ns(ns)
key = 'Fleeting Joys'
assert_equal(nil, @m.del_arg(ns, key))
end
def test_del_arg_bare
_test_del_arg_ns(BARE_NS)
end
def test_del_arg_ns1
_test_del_arg_ns(OPENID1_NS)
end
def test_del_arg_ns2
_test_del_arg_ns(OPENID2_NS)
end
def test_del_arg_ns3
_test_del_arg_ns('urn:xxx')
end
def test_isOpenID1
assert_equal(false, @m.is_openid1)
end
def test_isOpenID2
assert_equal(false, @m.is_openid2)
end
def test_set_openid_namespace
assert_raise(InvalidOpenIDNamespace) {
@m.set_openid_namespace('http://invalid/', false)
}
end
end
class OpenID1MessageTest < Test::Unit::TestCase
include GetArgsMixin
def setup
@m = Message.from_post_args({'openid.mode' => 'error',
'openid.error' => 'unit test'})
end
def test_has_openid_ns
assert_equal(OPENID1_NS, @m.get_openid_namespace)
assert_equal(OPENID1_NS,
@m.namespaces.get_namespace_uri(NULL_NAMESPACE))
end
def test_get_aliased_arg
assert_equal('error', @m.get_aliased_arg('mode'))
end
def test_get_aliased_arg_ns
assert_equal(OPENID1_NS, @m.get_aliased_arg('ns'))
end
def test_get_aliased_arg_with_ns
@m = Message.from_post_args(
{'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.ns.invalid' => 'http://invalid/',
'openid.invalid.stuff' => 'things',
'openid.invalid.stuff.blinky' => 'powerplant',
})
assert_equal('http://invalid/', @m.get_aliased_arg('ns.invalid'))
assert_equal('things', @m.get_aliased_arg('invalid.stuff'))
assert_equal('powerplant', @m.get_aliased_arg('invalid.stuff.blinky'))
end
def test_get_aliased_arg_with_ns_default
@m = Message.from_post_args({})
assert_equal('monkeys!', @m.get_aliased_arg('ns.invalid',
default="monkeys!"))
end
def test_to_post_args
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test'},
@m.to_post_args)
end
def test_to_post_args_ns
invalid_ns = 'http://invalid/'
@m.namespaces.add_alias(invalid_ns, 'foos')
@m.set_arg(invalid_ns, 'ball', 'awesome')
@m.set_arg(BARE_NS, 'xey', 'value')
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.foos.ball' => 'awesome',
'xey' => 'value',
'openid.ns.foos' => 'http://invalid/'
}, @m.to_post_args)
end
def test_to_args
assert_equal({'mode' => 'error',
'error' => 'unit test'},
@m.to_args)
end
def test_to_kvform
assert_equal("error:unit test\nmode:error\n",
@m.to_kvform)
end
def test_to_url_encoded
assert_equal('openid.error=unit+test&openid.mode=error',
@m.to_url_encoded)
end
def test_to_url
base_url = 'http://base.url/'
actual = @m.to_url(base_url)
actual_base = actual[0...base_url.length]
assert_equal(base_url, actual_base)
assert_equal('?', actual[base_url.length].chr)
query = actual[base_url.length+1..-1]
assert_equal({'openid.mode'=>['error'],'openid.error'=>['unit test']},
CGI.parse(query))
end
def test_get_openid
assert_equal(OPENID1_NS, @m.get_openid_namespace)
end
def test_get_key_openid
assert_equal('openid.mode', @m.get_key(OPENID_NS, 'mode'))
end
def test_get_key_bare
assert_equal('mode', @m.get_key(BARE_NS, 'mode'))
end
def test_get_key_ns1
assert_equal('openid.mode', @m.get_key(OPENID1_NS, 'mode'))
end
def test_get_key_ns2
assert_equal(nil, @m.get_key(OPENID2_NS, 'mode'))
end
def test_get_key_ns3
assert_equal(nil, @m.get_key('urn:xxx', 'mode'))
end
def test_has_key
assert_equal(true, @m.has_key?(OPENID_NS, 'mode'))
end
def test_has_key_bare
assert_equal(false, @m.has_key?(BARE_NS, 'mode'))
end
def test_has_key_ns1
assert_equal(true, @m.has_key?(OPENID1_NS, 'mode'))
end
def test_has_key_ns2
assert_equal(false, @m.has_key?(OPENID2_NS, 'mode'))
end
def test_has_key_ns3
assert_equal(false, @m.has_key?('urn:xxx', 'mode'))
end
def test_get_arg
assert_equal('error', @m.get_arg(OPENID_NS, 'mode'))
end
def test_get_arg_bare
get_arg_tests(ns=BARE_NS, key='mode')
end
def test_get_arg_ns
get_arg_tests(ns=OPENID_NS, key='mode', expected='error')
end
def test_get_arg_ns1
get_arg_tests(ns=OPENID1_NS, key='mode', expected='error')
end
def test_get_arg_ns2
get_arg_tests(ns=OPENID2_NS, key='mode')
end
def test_get_arg_ns3
get_arg_tests(ns='urn:nothing-significant', key='mode')
end
def test_get_args
assert_equal({'mode'=>'error','error'=>'unit test'},
@m.get_args(OPENID_NS))
end
def test_get_args_bare
assert_equal({}, @m.get_args(BARE_NS))
end
def test_get_args_ns1
assert_equal({'mode'=>'error','error'=>'unit test'},
@m.get_args(OPENID1_NS))
end
def test_get_args_ns2
assert_equal({}, @m.get_args(OPENID2_NS))
end
def test_get_args_ns3
assert_equal({}, @m.get_args('urn:xxx'))
end
def _test_update_args_ns(ns, before=nil)
if before.nil?
before = {}
end
update_args = {
'Camper van Beethoven'=>'David Lowery',
'Magnolia Electric Co.'=>'Jason Molina'
}
assert_equal(before, @m.get_args(ns))
@m.update_args(ns, update_args)
after = before.dup
after.update(update_args)
assert_equal(after, @m.get_args(ns))
end
def test_update_args
_test_update_args_ns(OPENID_NS, {'mode'=>'error','error'=>'unit test'})
end
def test_update_args_bare
_test_update_args_ns(BARE_NS)
end
def test_update_args_ns1
_test_update_args_ns(OPENID1_NS, {'mode'=>'error','error'=>'unit test'})
end
def test_update_args_ns2
_test_update_args_ns(OPENID2_NS)
end
def test_update_args_ns3
_test_update_args_ns('urn:xxx')
end
def _test_set_arg_ns(ns)
key = 'awesometown'
value = 'funny'
assert_equal(nil, @m.get_arg(ns,key))
@m.set_arg(ns, key, value)
assert_equal(value, @m.get_arg(ns,key))
end
def test_set_arg; _test_set_arg_ns(OPENID_NS); end
def test_set_arg_bare; _test_set_arg_ns(BARE_NS); end
def test_set_arg_ns1; _test_set_arg_ns(OPENID1_NS); end
def test_set_arg_ns2; _test_set_arg_ns(OPENID2_NS); end
def test_set_arg_ns3; _test_set_arg_ns('urn:xxx'); end
def _test_del_arg_ns(ns)
key = 'marry an'
value = 'ice cream sandwich'
@m.set_arg(ns, key, value)
assert_equal(value, @m.get_arg(ns,key))
@m.del_arg(ns,key)
assert_equal(nil, @m.get_arg(ns,key))
end
def test_del_arg; _test_del_arg_ns(OPENID_NS); end
def test_del_arg_bare; _test_del_arg_ns(BARE_NS); end
def test_del_arg_ns1; _test_del_arg_ns(OPENID1_NS); end
def test_del_arg_ns2; _test_del_arg_ns(OPENID2_NS); end
def test_del_arg_ns3; _test_del_arg_ns('urn:yyy'); end
def test_isOpenID1
assert_equal(true, @m.is_openid1)
end
def test_isOpenID2
assert_equal(false, @m.is_openid2)
end
def test_equal
assert_equal(Message.new, Message.new)
assert_not_equal(Message.new, nil)
end
def test_from_openid_args_undefined_ns
expected = 'almost.complete'
msg = Message.from_openid_args({'coverage.is' => expected})
actual = msg.get_arg(OPENID1_NS, 'coverage.is')
assert_equal(expected, actual)
end
# XXX: we need to implement the KVForm module before we can fix this
def TODOtest_from_kvform
kv = 'foos:ball\n'
msg = Message.from_kvform(kv)
assert_equal(msg.get(OPENID1_NS, 'foos'), 'ball')
end
def test_initialize_sets_namespace
msg = Message.new(OPENID1_NS)
assert_equal(OPENID1_NS, msg.get_openid_namespace)
end
end
class OpenID1ExplicitMessageTest < Test::Unit::TestCase
# XXX - check to make sure the test suite will get built the way this
# expects.
def setup
@m = Message.from_post_args({'openid.mode'=>'error',
'openid.error'=>'unit test',
'openid.ns'=>OPENID1_NS})
end
def test_to_post_args
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.ns'=>OPENID1_NS,
},
@m.to_post_args)
end
def test_to_post_args_ns
invalid_ns = 'http://invalid/'
@m.namespaces.add_alias(invalid_ns, 'foos')
@m.set_arg(invalid_ns, 'ball', 'awesome')
@m.set_arg(BARE_NS, 'xey', 'value')
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.foos.ball' => 'awesome',
'xey' => 'value',
'openid.ns'=>OPENID1_NS,
'openid.ns.foos' => 'http://invalid/'
}, @m.to_post_args)
end
def test_to_args
assert_equal({'mode' => 'error',
'error' => 'unit test',
'ns'=>OPENID1_NS
},
@m.to_args)
end
def test_to_kvform
assert_equal("error:unit test\nmode:error\nns:#{OPENID1_NS}\n",
@m.to_kvform)
end
def test_to_url_encoded
assert_equal('openid.error=unit+test&openid.mode=error&openid.ns=http%3A%2F%2Fopenid.net%2Fsignon%2F1.0',
@m.to_url_encoded)
end
def test_to_url
base_url = 'http://base.url/'
actual = @m.to_url(base_url)
actual_base = actual[0...base_url.length]
assert_equal(base_url, actual_base)
assert_equal('?', actual[base_url.length].chr)
query = actual[base_url.length+1..-1]
assert_equal({'openid.mode'=>['error'],
'openid.error'=>['unit test'],
'openid.ns'=>[OPENID1_NS],
},
CGI.parse(query))
end
end
class OpenID2MessageTest < Test::Unit::TestCase
include TestUtil
def setup
@m = Message.from_post_args({'openid.mode'=>'error',
'openid.error'=>'unit test',
'openid.ns'=>OPENID2_NS})
@m.set_arg(BARE_NS, 'xey', 'value')
end
def test_to_args_fails
assert_raises(ArgumentError) {
@m.to_args
}
end
def test_fix_ns_non_string
# Using has_key to invoke _fix_ns since _fix_ns should be private
assert_raises(ArgumentError) {
@m.has_key?(:non_string_namespace, "key")
}
end
def test_fix_ns_non_uri
# Using has_key to invoke _fix_ns since _fix_ns should be private
assert_log_matches(/identifiers SHOULD be URIs/) {
@m.has_key?("foo", "key")
}
end
def test_fix_ns_sreg_literal
# Using has_key to invoke _fix_ns since _fix_ns should be private
assert_log_matches(/identifiers SHOULD be URIs/, /instead of "sreg"/) {
@m.has_key?("sreg", "key")
}
end
def test_copy
n = @m.copy
assert_equal(@m, n)
end
def test_to_post_args
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.ns' => OPENID2_NS,
'xey' => 'value',
}, @m.to_post_args)
end
def test_to_post_args_ns
invalid_ns = 'http://invalid/'
@m.namespaces.add_alias(invalid_ns, 'foos')
@m.set_arg(invalid_ns, 'ball', 'awesome')
assert_equal({'openid.mode' => 'error',
'openid.error' => 'unit test',
'openid.ns' => OPENID2_NS,
'openid.ns.foos' => invalid_ns,
'openid.foos.ball' => 'awesome',
'xey' => 'value',
}, @m.to_post_args)
end
def test_to_args
@m.del_arg(BARE_NS, 'xey')
assert_equal({'mode' => 'error',
'error' => 'unit test',
'ns' => OPENID2_NS},
@m.to_args)
end
def test_to_kvform
@m.del_arg(BARE_NS, 'xey')
assert_equal("error:unit test\nmode:error\nns:#{OPENID2_NS}\n",
@m.to_kvform)
end
def _test_urlencoded(s)
expected_list = ["openid.error=unit+test",
"openid.mode=error",
"openid.ns=#{CGI.escape(OPENID2_NS)}",
"xey=value"]
# Hard to do this with string comparison since the mapping doesn't
# preserve order.
encoded_list = s.split('&')
encoded_list.sort!
assert_equal(expected_list, encoded_list)
end
def test_to_urlencoded
_test_urlencoded(@m.to_url_encoded)
end
def test_to_url
base_url = 'http://base.url/'
actual = @m.to_url(base_url)
actual_base = actual[0...base_url.length]
assert_equal(base_url, actual_base)
assert_equal('?', actual[base_url.length].chr)
query = actual[base_url.length+1..-1]
_test_urlencoded(query)
end
def test_get_openid
assert_equal(OPENID2_NS, @m.get_openid_namespace)
end
def test_get_key_openid
assert_equal('openid.mode', @m.get_key(OPENID2_NS, 'mode'))
end
def test_get_key_bare
assert_equal('mode', @m.get_key(BARE_NS, 'mode'))
end
def test_get_key_ns1
assert_equal(nil, @m.get_key(OPENID1_NS, 'mode'))
end
def test_get_key_ns2
assert_equal('openid.mode', @m.get_key(OPENID2_NS, 'mode'))
end
def test_get_key_ns3
assert_equal(nil, @m.get_key('urn:xxx', 'mode'))
end
def test_has_key_openid
assert_equal(true, @m.has_key?(OPENID_NS,'mode'))
end
def test_has_key_bare
assert_equal(false, @m.has_key?(BARE_NS,'mode'))
end
def test_has_key_ns1
assert_equal(false, @m.has_key?(OPENID1_NS,'mode'))
end
def test_has_key_ns2
assert_equal(true, @m.has_key?(OPENID2_NS,'mode'))
end
def test_has_key_ns3
assert_equal(false, @m.has_key?('urn:xxx','mode'))
end
# XXX - getArgTest
def test_get_arg_openid
assert_equal('error', @m.get_arg(OPENID_NS,'mode'))
end
def test_get_arg_bare
assert_equal(nil, @m.get_arg(BARE_NS,'mode'))
end
def test_get_arg_ns1
assert_equal(nil, @m.get_arg(OPENID1_NS,'mode'))
end
def test_get_arg_ns2
assert_equal('error', @m.get_arg(OPENID2_NS,'mode'))
end
def test_get_arg_ns3
assert_equal(nil, @m.get_arg('urn:bananastand','mode'))
end
def test_get_args_openid
assert_equal({'mode'=>'error','error'=>'unit test'},
@m.get_args(OPENID_NS))
end
def test_get_args_bare
assert_equal({'xey'=>'value'},
@m.get_args(BARE_NS))
end
def test_get_args_ns1
assert_equal({},
@m.get_args(OPENID1_NS))
end
def test_get_args_ns2
assert_equal({'mode'=>'error','error'=>'unit test'},
@m.get_args(OPENID2_NS))
end
def test_get_args_ns3
assert_equal({},
@m.get_args('urn:loose seal'))
end
def _test_update_args_ns(ns, before=nil)
before = {} unless before
update_args = {'aa'=>'bb','cc'=>'dd'}
assert_equal(before, @m.get_args(ns))
@m.update_args(ns, update_args)
after = before.dup
after.update(update_args)
assert_equal(after, @m.get_args(ns))
end
def test_update_args_openid
_test_update_args_ns(OPENID_NS, {'mode'=>'error','error'=>'unit test'})
end
def test_update_args_bare
_test_update_args_ns(BARE_NS, {'xey'=>'value'})
end
def test_update_args_ns1
_test_update_args_ns(OPENID1_NS)
end
def test_update_args_ns2
_test_update_args_ns(OPENID2_NS, {'mode'=>'error','error'=>'unit test'})
end
def test_update_args_ns3
_test_update_args_ns('urn:sven')
end
def _test_set_arg_ns(ns)
key = "logan's"
value = "run"
assert_equal(nil, @m.get_arg(ns,key))
@m.set_arg(ns, key, value)
assert_equal(value, @m.get_arg(ns,key))
end
def test_set_arg_openid; _test_set_arg_ns(OPENID_NS); end
def test_set_arg_bare; _test_set_arg_ns(BARE_NS); end
def test_set_arg_ns1; _test_set_arg_ns(OPENID1_NS); end
def test_set_arg_ns2; _test_set_arg_ns(OPENID2_NS); end
def test_set_arg_ns3; _test_set_arg_ns('urn:g'); end
def test_bad_alias
# Make sure dotted aliases and OpenID protocol fields are not allowed
# as namespace aliases.
fields = OPENID_PROTOCOL_FIELDS + ['dotted.alias']
fields.each { |f|
args = {"openid.ns.#{f}" => "blah#{f}",
"openid.#{f}.foo" => "test#{f}"}
# .fromPostArgs covers .fromPostArgs, .fromOpenIDArgs,
# ._fromOpenIDArgs, and .fromOpenIDArgs (since it calls
# .fromPostArgs).
assert_raise(AssertionError) {
Message.from_post_args(args)
}
}
end
def test_from_post_args
msg = Message.from_post_args({'foos' => 'ball'})
assert_equal('ball', msg.get_arg(BARE_NS, 'foos'))
end
def _test_del_arg_ns(ns)
key = 'no'
value = 'socks'
assert_equal(nil, @m.get_arg(ns, key))
@m.set_arg(ns, key, value)
assert_equal(value, @m.get_arg(ns, key))
@m.del_arg(ns, key)
assert_equal(nil, @m.get_arg(ns, key))
end
def test_del_arg_openid; _test_del_arg_ns(OPENID_NS); end
def test_del_arg_bare; _test_del_arg_ns(BARE_NS); end
def test_del_arg_ns1; _test_del_arg_ns(OPENID1_NS); end
def test_del_arg_ns2; _test_del_arg_ns(OPENID2_NS); end
def test_del_arg_ns3; _test_del_arg_ns('urn:tofu'); end
def test_overwrite_extension_arg
ns = 'urn:unittest_extension'
key = 'mykey'
value_1 = 'value_1'
value_2 = 'value_2'
@m.set_arg(ns, key, value_1)
assert_equal(value_1, @m.get_arg(ns, key))
@m.set_arg(ns, key, value_2)
assert_equal(value_2, @m.get_arg(ns, key))
end
def test_argList
assert_raise(ArgumentError) {
Message.from_post_args({'arg' => [1, 2, 3]})
}
end
def test_isOpenID1
assert_equal(false, @m.is_openid1)
end
def test_isOpenID2
assert_equal(true, @m.is_openid2)
end
end
class MessageTest < Test::Unit::TestCase
def setup
@postargs = {
'openid.ns' => OPENID2_NS,
'openid.mode' => 'checkid_setup',
'openid.identity' => 'http://bogus.example.invalid:port/',
'openid.assoc_handle' => 'FLUB',
'openid.return_to' => 'Neverland',
}
@action_url = 'scheme://host:port/path?query'
@form_tag_attrs = {
'company' => 'janrain',
'class' => 'fancyCSS',
}
@submit_text = 'GO!'
### Expected data regardless of input
@required_form_attrs = {
'accept-charset' => 'UTF-8',
'enctype' => 'application/x-www-form-urlencoded',
'method' => 'post',
}
end
def _checkForm(html, message_, action_url,
form_tag_attrs, submit_text)
@xml = REXML::Document.new(html)
# Get root element
form = @xml.root
# Check required form attributes
@required_form_attrs.each { |k, v|
assert(form.attributes[k] == v,
"Expected '#{v}' for required form attribute '#{k}', got '#{form.attributes[k]}'")
}
# Check extra form attributes
@form_tag_attrs.each { |k, v|
# Skip attributes that already passed the required attribute
# check, since they should be ignored by the form generation
# code.
if @required_form_attrs.include?(k)
continue
end
assert(form.attributes[k] == v,
"Form attribute '#{k}' should be '#{v}', found '#{form.attributes[k]}'")
# Check hidden fields against post args
hiddens = []
form.each { |e|
if (e.is_a?(REXML::Element)) and
(e.name.upcase() == 'INPUT') and
(e.attributes['type'].upcase() == 'HIDDEN')
# For each post arg, make sure there is a hidden with that
# value. Make sure there are no other hiddens.
hiddens += [e]
end
}
message_.to_post_args().each { |name, value|
success = false
hiddens.each { |e|
if e.attributes['name'] == name
assert(e.attributes['value'] == value,
"Expected value of hidden input '#{e.attributes['name']}' " +
"to be '#{value}', got '#{e.attributes['value']}'")
success = true
break
end
}
if !success
flunk "Post arg '#{name}' not found in form"
end
}
hiddens.each { |e|
assert(message_.to_post_args().keys().include?(e.attributes['name']),
"Form element for '#{e.attributes['name']}' not in " +
"original message")
}
# Check action URL
assert(form.attributes['action'] == action_url,
"Expected form 'action' to be '#{action_url}', got '#{form.attributes['action']}'")
# Check submit text
submits = []
form.each { |e|
if (e.is_a?(REXML::Element)) and
(e.name.upcase() == 'INPUT') and
e.attributes['type'].upcase() == 'SUBMIT'
submits += [e]
end
}
assert(submits.length == 1,
"Expected only one 'input' with type = 'submit', got #{submits.length}")
assert(submits[0].attributes['value'] == submit_text,
"Expected submit value to be '#{submit_text}', " +
"got '#{submits[0].attributes['value']}'")
}
end
def test_toFormMarkup
m = Message.from_post_args(@postargs)
html = m.to_form_markup(@action_url, @form_tag_attrs,
@submit_text)
_checkForm(html, m, @action_url,
@form_tag_attrs, @submit_text)
end
def test_overrideMethod
# Be sure that caller cannot change form method to GET.
m = Message.from_post_args(@postargs)
tag_attrs = @form_tag_attrs.clone
tag_attrs['method'] = 'GET'
html = m.to_form_markup(@action_url, @form_tag_attrs,
@submit_text)
_checkForm(html, m, @action_url,
@form_tag_attrs, @submit_text)
end
def test_overrideRequired
# Be sure that caller CANNOT change the form charset for
# encoding type.
m = Message.from_post_args(@postargs)
tag_attrs = @form_tag_attrs.clone
tag_attrs['accept-charset'] = 'UCS4'
tag_attrs['enctype'] = 'invalid/x-broken'
html = m.to_form_markup(@action_url, tag_attrs,
@submit_text)
_checkForm(html, m, @action_url,
tag_attrs, @submit_text)
end
end
class NamespaceMapTestCase < Test::Unit::TestCase
def test_onealias
nsm = NamespaceMap.new
uri = 'http://example.com/foo'
_alias = 'foo'
nsm.add_alias(uri, _alias)
assert_equal(uri, nsm.get_namespace_uri(_alias))
assert_equal(_alias, nsm.get_alias(uri))
end
def test_iteration
nsm = NamespaceMap.new
uripat = "http://example.com/foo%i"
nsm.add(uripat % 0)
(1..23).each { |i|
assert_equal(false, nsm.member?(uripat % i))
nsm.add(uripat % i)
}
nsm.each { |uri, _alias|
assert_equal(uri[22..-1], _alias[3..-1])
}
nsm = NamespaceMap.new
alias_ = 'bogus'
uri = 'urn:bogus'
nsm.add_alias(uri, alias_)
assert_equal(nsm.aliases(), [alias_])
assert_equal(nsm.namespace_uris(), [uri])
end
def test_register_default_alias
invalid_ns = 'http://invalid/'
alias_ = 'invalid'
Message.register_namespace_alias(invalid_ns, alias_)
# Doing it again doesn't raise an exception
Message.register_namespace_alias(invalid_ns, alias_)
# Once it's registered, you can't register it again
assert_raises(NamespaceAliasRegistrationError) {
Message.register_namespace_alias(invalid_ns, 'another_alias')
}
# Once it's registered, you can't register another URL with that alias
assert_raises(NamespaceAliasRegistrationError) {
Message.register_namespace_alias('http://janrain.com/', alias_)
}
# It gets used automatically by the Message class:
msg = Message.from_openid_args({'invalid.stuff' => 'things'})
assert(msg.is_openid1)
assert_equal(alias_, msg.namespaces.get_alias(invalid_ns))
assert_equal(invalid_ns, msg.namespaces.get_namespace_uri(alias_))
end
def test_alias_defined_twice
nsm = NamespaceMap.new
uri = 'urn:bogus'
nsm.add_alias(uri, 'foos')
assert_raises(IndexError) {
nsm.add_alias(uri, 'ball')
}
end
end
end