entp-ruby-openid 2.2

data/test/test_ax.rb

@@ -0,0 +1,690 @@
+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_from_openid_request_wrong_ax_mode
+        uri = 'http://under.the.sea/'
+        name = 'ext0'
+        value = 'snarfblat'
+        
+        message = 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' => 'store_request',
+                                               'ax.type.' + name => uri,
+                                               'ax.count.' + name => '1',
+                                               'ax.value.' + name + '.1' => value
+                                             })
+        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_from_openid_request_wrong_ax_mode
+        uri = 'http://under.the.sea/'
+        name = 'ext0'
+        value = 'snarfblat'
+        
+        message = 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_request',
+                                               'ax.type.' + name => uri,
+                                               'ax.count.' + name => '1',
+                                               'ax.value.' + name + '.1' => value
+                                             })
+        openid_req = Server::OpenIDRequest.new
+        openid_req.message = message
+        ax_req = StoreRequest.from_openid_request(openid_req)
+        assert(ax_req.nil?)
+      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