diff options
Diffstat (limited to 'vendor/gems/ruby-openid-2.1.4/test/test_ax.rb')
| -rw-r--r-- | vendor/gems/ruby-openid-2.1.4/test/test_ax.rb | 648 |
1 files changed, 648 insertions, 0 deletions
diff --git a/vendor/gems/ruby-openid-2.1.4/test/test_ax.rb b/vendor/gems/ruby-openid-2.1.4/test/test_ax.rb new file mode 100644 index 000000000..c1dcfb1f5 --- /dev/null +++ b/vendor/gems/ruby-openid-2.1.4/test/test_ax.rb @@ -0,0 +1,648 @@ +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 |