/vendor/gems/ruby-openid-2.1.4/test/test_message.rb
Ruby | 1116 lines | 911 code | 176 blank | 29 comment | 18 complexity | 687b13345a31513084ae68a9c5550e18 MD5 | raw file
Possible License(s): GPL-2.0, Apache-2.0, MIT
- # 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