test_ax.rb

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