ruby-openid 2.0.4 → 2.1.2

data/test/test_kvform.rb

@@ -54,10 +54,10 @@ class KVFormTests < Test::Unit::TestCase
       # Convert KVForm to dict
       d = Util.kv_to_dict(kv)
 
-      # Strict mode should raise ArgumentError instead of logging
+      # Strict mode should raise KVFormError instead of logging
       # messages
       if warnings > 0
-        assert_raise(ArgumentError) do
+        assert_raise(KVFormError) do
           Util.kv_to_seq(kv, true)
         end
       end
@@ -117,10 +117,10 @@ class KVFormTests < Test::Unit::TestCase
       assert_equal(kvform, actual)
       assert actual.is_a?(String)
 
-      # Strict mode should raise ArgumentError instead of logging
+      # Strict mode should raise KVFormError instead of logging
       # messages
       if warnings > 0
-        assert_raise(ArgumentError) do
+        assert_raise(KVFormError) do
           Util.seq_to_kv(seq, true)
         end
       end
@@ -151,7 +151,7 @@ class KVFormTests < Test::Unit::TestCase
   def _run_kvexcTest(case_)
     seq = case_
 
-    assert_raise(ArgumentError) do
+    assert_raise(KVFormError) do
       Util.seq_to_kv(seq)
     end
   end

data/test/test_message.rb

@@ -255,8 +255,8 @@ module OpenID
     end
 
     def test_set_openid_namespace
-      assert_raise(ArgumentError) {
-        @m.set_openid_namespace('http://invalid/')
+      assert_raise(InvalidOpenIDNamespace) {
+        @m.set_openid_namespace('http://invalid/', false)
       }
     end
   end
@@ -317,6 +317,7 @@ module OpenID
                      'openid.error' => 'unit test',
                      'openid.foos.ball' => 'awesome',
                      'xey' => 'value',
+                     'openid.ns.foos' => 'http://invalid/'
                    }, @m.to_post_args)
     end
 
@@ -522,7 +523,7 @@ module OpenID
     end
   end
 
-  class OpenID1ExplicitMessageTest < OpenID1MessageTest
+  class OpenID1ExplicitMessageTest < Test::Unit::TestCase
     # XXX - check to make sure the test suite will get built the way this
     # expects.
     def setup
@@ -530,6 +531,62 @@ module OpenID
                                           '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
@@ -1041,6 +1098,7 @@ module OpenID
 
       # 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

data/test/test_pape.rb

@@ -1,6 +1,7 @@
 require 'openid/extensions/pape'
 require 'openid/message'
 require 'openid/server'
+require 'openid/consumer/responses'
 
 module OpenID
   module PAPETest
@@ -108,13 +109,13 @@ module OpenID
 
       def test_construct
         assert_equal([], @req.auth_policies)
-        assert_equal(nil, @req.auth_age)
+        assert_equal(nil, @req.auth_time)
         assert_equal('pape', @req.ns_alias)
         assert_equal(nil, @req.nist_auth_level)
 
-        req2 = PAPE::Response.new([PAPE::AUTH_MULTI_FACTOR], 1000, 3)
+        req2 = PAPE::Response.new([PAPE::AUTH_MULTI_FACTOR], "1983-11-05T12:30:24Z", 3)
         assert_equal([PAPE::AUTH_MULTI_FACTOR], req2.auth_policies)
-        assert_equal(1000, req2.auth_age)
+        assert_equal("1983-11-05T12:30:24Z", req2.auth_time)
         assert_equal(3, req2.nist_auth_level)
       end
 
@@ -131,21 +132,19 @@ module OpenID
       end
 
       def test_get_extension_args
-        assert_equal({'auth_policies' => ''}, @req.get_extension_args)
+        assert_equal({'auth_policies' => 'none'}, @req.get_extension_args)
         @req.add_policy_uri('http://uri')
         assert_equal({'auth_policies' => 'http://uri'}, @req.get_extension_args)
         @req.add_policy_uri('http://zig')
         assert_equal({'auth_policies' => 'http://uri http://zig'}, @req.get_extension_args)
-        @req.auth_age = 789
-        assert_equal({'auth_policies' => 'http://uri http://zig', 'auth_age' => '789'}, @req.get_extension_args)
+        @req.auth_time =  "1983-11-05T12:30:24Z"
+        assert_equal({'auth_policies' => 'http://uri http://zig', 'auth_time' => "1983-11-05T12:30:24Z"}, @req.get_extension_args)
         @req.nist_auth_level = 3
-        assert_equal({'auth_policies' => 'http://uri http://zig', 'auth_age' => '789', 'nist_auth_level' => '3'}, @req.get_extension_args)
+        assert_equal({'auth_policies' => 'http://uri http://zig', 'auth_time' => "1983-11-05T12:30:24Z", 'nist_auth_level' => '3'}, @req.get_extension_args)
       end
 
       def test_get_extension_args_error_auth_age
-        @req.auth_age = "older than the sun"
-        assert_raises(ArgumentError) { @req.get_extension_args }
-        @req.auth_age = -10
+        @req.auth_time = "the beginning of time"
         assert_raises(ArgumentError) { @req.get_extension_args }
       end
 
@@ -160,21 +159,21 @@ module OpenID
 
       def test_parse_extension_args
         args = {'auth_policies' => 'http://foo http://bar',
-                'auth_age' => '9'}
+                'auth_time' => '1983-11-05T12:30:24Z'}
         @req.parse_extension_args(args)
-        assert_equal(9, @req.auth_age)
+        assert_equal('1983-11-05T12:30:24Z', @req.auth_time)
         assert_equal(['http://foo','http://bar'], @req.auth_policies)
       end
 
       def test_parse_extension_args_empty
         @req.parse_extension_args({})
-        assert_equal(nil, @req.auth_age)
+        assert_equal(nil, @req.auth_time)
         assert_equal([], @req.auth_policies)
       end
       
       def test_parse_extension_args_strict_bogus1
         args = {'auth_policies' => 'http://foo http://bar',
-                'auth_age' => 'not too old'}
+                'auth_time' => 'this one time'}
         assert_raises(ArgumentError) { 
           @req.parse_extension_args(args, true)
         }
@@ -182,7 +181,7 @@ module OpenID
 
       def test_parse_extension_args_strict_bogus2
         args = {'auth_policies' => 'http://foo http://bar',
-                'auth_age' => '63',
+                'auth_time' => '1983-11-05T12:30:24Z',
                 'nist_auth_level' => 'some'}
         assert_raises(ArgumentError) { 
           @req.parse_extension_args(args, true)
@@ -191,21 +190,21 @@ module OpenID
       
       def test_parse_extension_args_strict_good
         args = {'auth_policies' => 'http://foo http://bar',
-                'auth_age' => '0',
+                'auth_time' => '2007-10-11T05:25:18Z',
                 'nist_auth_level' => '0'}
         @req.parse_extension_args(args, true)
         assert_equal(['http://foo','http://bar'], @req.auth_policies)
-        assert_equal(0, @req.auth_age)
+        assert_equal('2007-10-11T05:25:18Z', @req.auth_time)
         assert_equal(0, @req.nist_auth_level)
       end
 
       def test_parse_extension_args_nostrict_bogus
         args = {'auth_policies' => 'http://foo http://bar',
-                'auth_age' => 'old',
+                'auth_time' => 'some time ago',
                 'nist_auth_level' => 'some'}
         @req.parse_extension_args(args)
         assert_equal(['http://foo','http://bar'], @req.auth_policies)
-        assert_equal(nil, @req.auth_age)
+        assert_equal(nil, @req.auth_time)
         assert_equal(nil, @req.nist_auth_level)
       end
 
@@ -217,16 +216,31 @@ module OpenID
           'ns' => OPENID2_NS,
           'ns.pape' => PAPE::NS_URI,
           'pape.auth_policies' => [PAPE::AUTH_MULTI_FACTOR, PAPE::AUTH_PHISHING_RESISTANT].join(' '),
-          'pape.auth_age' => '5476'
+          'pape.auth_time' => '1983-11-05T12:30:24Z'
           })
         signed_stuff = {
           'auth_policies' => [PAPE::AUTH_MULTI_FACTOR, PAPE::AUTH_PHISHING_RESISTANT].join(' '),
-          'auth_age' => '5476'
+          'auth_time' => '1983-11-05T12:30:24Z'
         }
         oid_req = DummySuccessResponse.new(openid_req_msg, signed_stuff)
         req = PAPE::Response.from_success_response(oid_req)
         assert_equal([PAPE::AUTH_MULTI_FACTOR, PAPE::AUTH_PHISHING_RESISTANT], req.auth_policies)
-        assert_equal(5476, req.auth_age)
+        assert_equal('1983-11-05T12:30:24Z', req.auth_time)
+      end
+
+      def test_from_success_response_unsigned
+        openid_req_msg = Message.from_openid_args({
+          'mode' => 'id_res',
+          'ns' => OPENID2_NS,
+          'ns.pape' => PAPE::NS_URI,
+          'pape.auth_policies' => [PAPE::AUTH_MULTI_FACTOR, PAPE::AUTH_PHISHING_RESISTANT].join(' '),
+          'pape.auth_time' => '1983-11-05T12:30:24Z'
+          })
+        signed_stuff = {}
+        endpoint = OpenIDServiceEndpoint.new
+        oid_req = Consumer::SuccessResponse.new(endpoint, openid_req_msg, signed_stuff)
+        req = PAPE::Response.from_success_response(oid_req)
+        assert(req.nil?, req.inspect)
       end
     end
   end

data/test/test_server.rb

@@ -149,6 +149,7 @@ module OpenID
     def test_no_message
       e = Server::ProtocolError.new(nil, "no message")
       assert(e.get_return_to.nil?)
+      assert_equal(e.which_encoding, nil)
     end
 
     def test_which_encoding_no_message
@@ -656,6 +657,17 @@ module OpenID
         @decode.call(args)
       }
     end
+
+    def test_invalidns
+      args = {'openid.ns' => 'Vegetables',
+              'openid.mode' => 'associate'}
+      begin
+        r = @decode.call(args)
+      rescue Server::ProtocolError => err
+        assert(err.openid_message)
+        assert(err.to_s.index('Vegetables'))
+      end
+    end
   end
 
   class BogusEncoder < Server::Encoder
@@ -689,6 +701,7 @@ module OpenID
                                    'http://burr.unittest/',
                                    false,
                                    nil)
+      request.message = Message.new(OPENID2_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
                                                    'ns' => OPENID2_NS,
@@ -714,6 +727,7 @@ module OpenID
                                    'http://burr.unittest/',
                                    false,
                                    nil)
+      request.message = Message.new(OPENID2_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
                                                    'ns' => OPENID2_NS,
@@ -730,6 +744,48 @@ module OpenID
       assert_equal(webresponse.body, response.to_form_markup)
     end
 
+    def test_to_form_markup
+       request = Server::CheckIDRequest.new(
+                                   'http://bombom.unittest/',
+                                   'http://burr.unittest/999',
+                                   @server.op_endpoint,
+                                   'http://burr.unittest/',
+                                   false,
+                                   nil)
+      request.message = Message.new(OPENID2_NS)
+      response = Server::OpenIDResponse.new(request)
+      response.fields = Message.from_openid_args({
+                                                   'ns' => OPENID2_NS,
+                                                   'mode' => 'id_res',
+                                                   'identity' => request.identity,
+                                                   'claimed_id' => request.identity,
+                                                   'return_to' => 'x' * OPENID1_URL_LIMIT,
+                                                 })
+      form_markup = response.to_form_markup({'foo'=>'bar'})
+      assert(/ foo="bar"/ =~ form_markup, form_markup)
+    end
+
+    def test_to_html
+       request = Server::CheckIDRequest.new(
+                                   'http://bombom.unittest/',
+                                   'http://burr.unittest/999',
+                                   @server.op_endpoint,
+                                   'http://burr.unittest/',
+                                   false,
+                                   nil)
+      request.message = Message.new(OPENID2_NS)
+      response = Server::OpenIDResponse.new(request)
+      response.fields = Message.from_openid_args({
+                                                   'ns' => OPENID2_NS,
+                                                   'mode' => 'id_res',
+                                                   'identity' => request.identity,
+                                                   'claimed_id' => request.identity,
+                                                   'return_to' => 'x' * OPENID1_URL_LIMIT,
+                                                 })
+      html = response.to_html
+      assert(html)
+    end
+
     def test_id_res_OpenID1_exceeds_limit
       # Check that when an OpenID 1 response exceeds the OpenID 1
       # message size, a GET response is issued.  Technically, this
@@ -742,6 +798,7 @@ module OpenID
                                    'http://burr.unittest/',
                                    false,
                                    nil)
+      request.message = Message.new(OPENID1_NS)
 
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
@@ -764,6 +821,7 @@ module OpenID
                                    @server.op_endpoint,
                                    'http://burr.unittest/',
                                    false, nil)
+      request.message = Message.new(OPENID1_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
                                                    'mode' => 'id_res',
@@ -791,6 +849,7 @@ module OpenID
                                    @server.op_endpoint,
                                    'http://burr.unittest/',
                                    false, nil)
+      request.message = Message.new(OPENID2_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
                                                    'mode' => 'cancel',
@@ -800,6 +859,22 @@ module OpenID
       assert(webresponse.headers.member?('location'))
     end
 
+    def test_cancel_to_form
+      request = Server::CheckIDRequest.new(
+                                   'http://bombom.unittest/',
+                                   'http://burr.unittest/999',
+                                   @server.op_endpoint,
+                                   'http://burr.unittest/',
+                                   false, nil)
+      request.message = Message.new(OPENID2_NS)
+      response = Server::OpenIDResponse.new(request)
+      response.fields = Message.from_openid_args({
+                                                   'mode' => 'cancel',
+                                                 })
+      form = response.to_form_markup
+      assert(form.index(request.return_to))
+    end
+
     def test_assocReply
       msg = Message.new(OPENID2_NS)
       msg.set_arg(OPENID2_NS, 'session_type', 'no-encryption')
@@ -819,6 +894,7 @@ module OpenID
       request = Server::CheckAuthRequest.new('a_sock_monkey',
                                      'siggggg',
                                      [])
+      request.message = Message.new(OPENID2_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields = Message.from_openid_args({
                                                    'is_valid' => 'true',
@@ -867,6 +943,7 @@ module OpenID
                                     @server.op_endpoint,
                                     'http://burr.unittest/',
                                     false, nil)
+      @request.message = Message.new(OPENID2_NS)
 
       @response = Server::OpenIDResponse.new(@request)
       @response.fields = Message.from_openid_args({
@@ -923,6 +1000,7 @@ module OpenID
                                    @server.op_endpoint,
                                    'http://burr.unittest/',
                                    false, nil)
+      request.message = Message.new(OPENID2_NS)
       response = Server::OpenIDResponse.new(request)
       response.fields.set_arg(OPENID_NS, 'mode', 'cancel')
       webresponse = @encode.call(response)
@@ -965,6 +1043,7 @@ module OpenID
                                     @server.op_endpoint,
                                     'http://bar.unittest/',
                                     false)
+      @request.message = Message.new(OPENID2_NS)
     end
 
     def test_trustRootInvalid
@@ -1133,7 +1212,7 @@ module OpenID
     end
 
     def test_immediate_openid1_no_identity
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.immediate = true
       @request.mode = 'checkid_immediate'
       resp = @request.answer(false)
@@ -1141,7 +1220,7 @@ module OpenID
     end
 
     def test_checkid_setup_openid1_no_identity
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.immediate = false
       @request.mode = 'checkid_setup'
       resp = @request.answer(false)
@@ -1149,7 +1228,7 @@ module OpenID
     end
 
     def test_immediate_openid1_no_server_url
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.immediate = true
       @request.mode = 'checkid_immediate'
       @request.op_endpoint = nil
@@ -1160,7 +1239,7 @@ module OpenID
     end
 
     def test_immediate_encode_to_url
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.immediate = true
       @request.mode = 'checkid_immediate'
       @request.trust_root = "BOGUS"
@@ -1196,7 +1275,7 @@ module OpenID
 
     def test_answerAllowWithDelegatedIdentityOpenID1
       # claimed_id parameter doesn't exist in OpenID 1.
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       # claimed_id delegates to selected_id here.
       @request.identity = IDENTIFIER_SELECT
       selected_id = 'http://anon.unittest/9861'
@@ -1215,7 +1294,7 @@ module OpenID
     end
 
     def test_answerAllowNoIdentityOpenID1
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.identity = nil
       assert_raise(ArgumentError) {
         @request.answer(true, nil, nil)
@@ -1241,6 +1320,43 @@ module OpenID
       }
     end
 
+    def test_fromMessageClaimedIDWithoutIdentityOpenID2
+      msg = Message.new(OPENID2_NS)
+      msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
+      msg.set_arg(OPENID_NS, 'return_to', 'http://invalid:8000/rt')
+      msg.set_arg(OPENID_NS, 'claimed_id', 'https://example.myopenid.com')
+
+      assert_raise(Server::ProtocolError) {
+        Server::CheckIDRequest.from_message(msg, @server)
+      }
+    end
+
+    def test_fromMessageIdentityWithoutClaimedIDOpenID2
+      msg = Message.new(OPENID2_NS)
+      msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
+      msg.set_arg(OPENID_NS, 'return_to', 'http://invalid:8000/rt')
+      msg.set_arg(OPENID_NS, 'identity', 'https://example.myopenid.com')
+
+      assert_raise(Server::ProtocolError) {
+        Server::CheckIDRequest.from_message(msg, @server)
+      }
+    end
+
+    def test_fromMessageWithEmptyTrustRoot
+      return_to = 'http://some.url/foo?bar=baz'
+      msg = Message.from_post_args({
+              'openid.assoc_handle' => '{blah}{blah}{OZivdQ==}',
+              'openid.claimed_id' => 'http://delegated.invalid/',
+              'openid.identity' => 'http://op-local.example.com/',
+              'openid.mode' => 'checkid_setup',
+              'openid.ns' => 'http://openid.net/signon/1.0',
+              'openid.return_to' => return_to,
+              'openid.trust_root' => ''
+              });
+      result = Server::CheckIDRequest.from_message(msg, @server)
+      assert_equal(return_to, result.trust_root)
+    end
+
     def test_trustRootOpenID1
       # Ignore openid.realm in OpenID 1
       msg = Message.new(OPENID1_NS)
@@ -1302,16 +1418,16 @@ module OpenID
     def test_answerImmediateDenyOpenID1
       # Look for user_setup_url in checkid_immediate negative response
       # in OpenID 1 case.
-      @request.namespace = OPENID1_NS
+      @request.message = Message.new(OPENID1_NS)
       @request.mode = 'checkid_immediate'
       @request.immediate = true
       server_url = "http://setup-url.unittest/"
       # crappiting setup_url, you dirty my interface with your presence!
       answer = @request.answer(false, server_url)
       assert_equal(answer.request, @request)
-      assert_equal(answer.fields.to_post_args.length, 2, answer.fields)
-      assert_equal(answer.fields.get_openid_namespace, OPENID1_NS)
-      assert_equal(answer.fields.get_arg(OPENID_NS, 'mode'), 'id_res')
+      assert_equal(2, answer.fields.to_post_args.length, answer.fields)
+      assert_equal(OPENID1_NS, answer.fields.get_openid_namespace)
+      assert_equal('id_res', answer.fields.get_arg(OPENID_NS, 'mode'))
       assert(answer.fields.get_arg(
                                    OPENID_NS, 'user_setup_url', '').starts_with?(server_url))
     end
@@ -1358,6 +1474,31 @@ module OpenID
         @request.cancel_url
       }
     end
+
+    def test_fromMessageWithoutTrustRoot
+        msg = Message.new(OPENID2_NS)
+        msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
+        msg.set_arg(OPENID_NS, 'return_to', 'http://real.trust.root/foo')
+        msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
+        msg.set_arg(OPENID_NS, 'identity', 'george')
+        msg.set_arg(OPENID_NS, 'claimed_id', 'george')
+
+        result = Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
+
+        assert_equal(result.trust_root, 'http://real.trust.root/foo')
+    end
+
+    def test_fromMessageWithoutTrustRootOrReturnTo
+        msg = Message.new(OPENID2_NS)
+        msg.set_arg(OPENID_NS, 'mode', 'checkid_setup')
+        msg.set_arg(OPENID_NS, 'assoc_handle', 'bogus')
+        msg.set_arg(OPENID_NS, 'identity', 'george')
+        msg.set_arg(OPENID_NS, 'claimed_id', 'george')
+
+        assert_raises(Server::ProtocolError) {
+          Server::CheckIDRequest.from_message(msg, @server.op_endpoint)
+        }
+    end
   end
 
   class TestCheckIDExtension < Test::Unit::TestCase
@@ -1372,6 +1513,7 @@ module OpenID
                                     @server.op_endpoint,
                                     'http://bar.unittest/',
                                     false)
+      @request.message = Message.new(OPENID2_NS)
       @response = Server::OpenIDResponse.new(@request)
       @response.fields.set_arg(OPENID_NS, 'mode', 'id_res')
       @response.fields.set_arg(OPENID_NS, 'blue', 'star')
@@ -1446,6 +1588,7 @@ module OpenID
                                         })
       @request = Server::CheckAuthRequest.new(
                                       @assoc_handle, @message)
+      @request.message = Message.new(OPENID2_NS)
 
       @signatory = MockSignatory.new([true, @assoc_handle])
     end
@@ -1522,6 +1665,7 @@ module OpenID
       server_dh = DiffieHellman.from_defaults()
       session = Server::DiffieHellmanSHA1ServerSession.new(server_dh, cpub)
       @request = Server::AssociateRequest.new(session, 'HMAC-SHA1')
+      @request.message = Message.new(OPENID2_NS)
       response = @request.answer(@assoc)
       rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
       assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
@@ -1545,6 +1689,7 @@ module OpenID
       server_dh = DiffieHellman.from_defaults()
       session = Server::DiffieHellmanSHA256ServerSession.new(server_dh, cpub)
       @request = Server::AssociateRequest.new(session, 'HMAC-SHA256')
+      @request.message = Message.new(OPENID2_NS)
       response = @request.answer(@assoc)
       rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
       assert_equal(rfg.call("assoc_type"), "HMAC-SHA256")
@@ -1676,6 +1821,38 @@ module OpenID
       assert(!rfg.call("dh_server_public"))
     end
 
+    def test_plaintext_v2
+        # The main difference between this and the v1 test is that
+        # session_type is always returned in v2.
+        args = {
+            'openid.ns' => OPENID2_NS,
+            'openid.mode' => 'associate',
+            'openid.assoc_type' => 'HMAC-SHA1',
+            'openid.session_type' => 'no-encryption',
+            }
+        @request = Server::AssociateRequest.from_message(
+          Message.from_post_args(args))
+
+        assert(!@request.message.is_openid1())
+
+        @assoc = @signatory.create_association(false, 'HMAC-SHA1')
+        response = @request.answer(@assoc)
+        rfg = lambda { |f| response.fields.get_arg(OPENID_NS, f) }
+
+        assert_equal(rfg.call("assoc_type"), "HMAC-SHA1")
+        assert_equal(rfg.call("assoc_handle"), @assoc.handle)
+
+        failUnlessExpiresInMatches(
+            response.fields, @signatory.secret_lifetime)
+
+        assert_equal(
+            rfg.call("mac_key"), Util.to_base64(@assoc.secret))
+
+        assert_equal(rfg.call("session_type"), "no-encryption")
+        assert(!rfg.call("enc_mac_key"))
+        assert(!rfg.call("dh_server_public"))
+    end
+
     def test_plaintext256
       @assoc = @signatory.create_association(false, 'HMAC-SHA256')
       response = @request.answer(@assoc)
@@ -1764,7 +1941,7 @@ module OpenID
     def test_failed_dispatch
       request = Server::OpenIDRequest.new()
       request.mode = "monkeymode"
-      request.namespace = OPENID1_NS
+      request.message = Message.new(OPENID1_NS)
       assert_raise(RuntimeError) {
         webresult = @server.handle_request(request)
       }
@@ -1790,7 +1967,7 @@ module OpenID
 
       request = Server::OpenIDRequest.new()
       request.mode = "monkeymode"
-      request.namespace = OPENID1_NS
+      request.message = Message.new(OPENID1_NS)
       assert_raise(UnhandledError) {
         webresult = @server.handle_request(request)
       }
@@ -1897,6 +2074,7 @@ module OpenID
 
     def test_checkAuth
       request = Server::CheckAuthRequest.new('arrrrrf', '0x3999', [])
+      request.message = Message.new(OPENID2_NS)
       response = nil
       silence_logging {
         response = @server.openid_check_authentication(request)