Ticket #233: THE.diff

old-openid/openid/consumer/consumer.py

@@ -1471 +1461 @@
-        self.assoc = assoc
-        self.endpoint = endpoint
-        self.return_to_args = {}
-
-
+
-        self._anonymous = False
-
-    def setAnonymous(self, is_anonymous):

old-openid/openid/message.py

@@ -26 +26 @@
-
-# The OpenID 1.X namespace URI
-OPENID1_NS = 'http://openid.net/signon/1.0'
+THE_OTHER_OPENID1_NS = 'http://openid.net/signon/1.1'
+
+OPENID1_NAMESPACES = OPENID1_NS, THE_OTHER_OPENID1_NS
-
-# The OpenID 2.0 namespace URI
-OPENID2_NS = 'http://specs.openid.net/auth/2.0'
@@ -109 +124 @@
-        URI.
-    """
-
-
+THE_OTHER_OPENID1_NS, 
-
-    def __init__(self, openid_namespace=None):
-        """Create an empty Message.
-
-
-        @raises InvalidOpenIDNamespace: if openid_namespace is not in
-            L{Message.allowed_openid_namespaces}
-        """
-        self.args = {}
-        self.namespaces = NamespaceMap()
-        if openid_namespace is None:
-            self._openid_ns_uri = None
-        else:
-
+
+
-
-    def fromPostArgs(cls, args):
-        """Construct a Message containing a set of POST arguments. """
-        self = cls()
-
-        # Partition into "openid." args and bare args
@@ -157 +184 @@
-    fromOpenIDArgs = classmethod(fromOpenIDArgs)
-
-    def _fromOpenIDArgs(self, openid_args):
-        global registered_aliases
-
-        ns_args = []
-
-        # Resolve namespaces
@@ -173 +198 @@
-                self.namespaces.addAlias(value, ns_key)
-            elif ns_alias == NULL_NAMESPACE and ns_key == 'ns':
-                # null namespace
-namespaces.addAlias(value, NULL_NAMESPACE
+setOpenIDNamespace(value, False
-            else:
-                ns_args.append((ns_alias, ns_key, value))
-
-
-
-
-
-
-
+
+
+
-
-        # Actually put the pairs into the appropriate namespaces
-        for (ns_alias, ns_key, value) in ns_args:
-            ns_uri = self.namespaces.getNamespaceURI(ns_alias)
-            if ns_uri is None:
-                # we found a namespaced arg without a namespace URI defined
-                ns_uri = self._getDefaultNamespace(ns_alias)
-                if ns_uri is None:
-                    ns_uri = self.getOpenIDNamespace()
-                    ns_key = '%s.%s' % (ns_alias, ns_key)
-                else:
-                    self.namespaces.addAlias(ns_uri, ns_alias, implicit=True)
-
-            self.setArg(ns_uri, ns_key, value)
-
-
+
+
+
+
+
+
-        if openid_ns_uri not in self.allowed_openid_namespaces:
-ValueError('Invalid null namespace: %r' % (openid_ns_uri,)
+InvalidOpenIDNamespace(openid_ns_uri
-
-
+, implicit
-        self._openid_ns_uri = openid_ns_uri
-
-    def getOpenIDNamespace(self):
-        return self._openid_ns_uri
-
-    def isOpenID1(self):
-== OPENID1_N
+in OPENID1_NAMESPACE
-
-    def isOpenID2(self):
-        return self.getOpenIDNamespace() == OPENID2_NS

old-openid/openid/test/test_consumer.py

@@ -1176 +1176 @@
-        assert args == {
-            'openid.mode':'check_authentication',
-            'openid.signed':'foo',
+            'openid.ns':OPENID1_NS
-            }, args
-        return None
-
@@ -1218 +1219 @@
-    def test_signedList(self):
-        query = Message.fromOpenIDArgs({
-            'mode': 'id_res',
-            'ns': OPENID2_NS,
-            'sig': 'rabbits',
-            'identity': '=example',
-            'assoc_handle': 'munchkins',
@@ -1227 +1227 @@
-            'signed': 'identity,mode,ns.sreg,sreg.email',
-            'foo': 'bar',
-            })
-        expected = Message.fromOpenIDArgs({
-            'mode': 'check_authentication',
-            'sig': 'rabbits',
-            'assoc_handle': 'munchkins',
-            'identity': '=example',
-            'signed': 'identity,mode,ns.sreg,sreg.email',
-            'ns.sreg': 'urn:sreg',
-            'sreg.email': 'bogus@example.com',
-            })
-        args = self.consumer._createCheckAuthRequest(query)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-

old-openid/openid/test/test_message.py

@@ -1 +1 @@
-from openid import message
-from openid import oidutil
+from openid.extensions import sreg
-
-import urllib
-import cgi
@@ -400 +401 @@
-    def test_isOpenID2(self):
-        self.failIf(self.msg.isOpenID2())
-
-OpenID1MessageTest
+unittest.TestCase
-    def setUp(self):
-        self.msg = message.Message.fromPostArgs({'openid.mode':'error',
-                                                 'openid.error':'unit test',
-                                                 'openid.ns':message.OPENID1_NS
-                                                 })
-
+    def test_toPostArgs(self):
+        self.failUnlessEqual(self.msg.toPostArgs(),
+                             {'openid.mode':'error',
+                              'openid.error':'unit test',
+                              'openid.ns':message.OPENID1_NS
+                              })
+
+    def test_toArgs(self):
+        self.failUnlessEqual(self.msg.toArgs(), {'mode':'error',
+                                                 'error':'unit test',
+                                                 'ns':message.OPENID1_NS})
+
+    def test_toKVForm(self):
+        self.failUnlessEqual(self.msg.toKVForm(),
+                             'error:unit test\nmode:error\nns:%s\n'
+                              %message.OPENID1_NS)
+
+    def test_toURLEncoded(self):
+        self.failUnlessEqual(self.msg.toURLEncoded(),
+                             'openid.error=unit+test&openid.mode=error&openid.ns=http%3A%2F%2Fopenid.net%2Fsignon%2F1.0')
+
+    def test_toURL(self):
+        base_url = 'http://base.url/'
+        actual = self.msg.toURL(base_url)
+        actual_base = actual[:len(base_url)]
+        self.failUnlessEqual(actual_base, base_url)
+        self.failUnlessEqual(actual[len(base_url)], '?')
+        query = actual[len(base_url) + 1:]
+        parsed = cgi.parse_qs(query)
+        self.failUnlessEqual(parsed, {'openid.mode':['error'],
+                                      'openid.error':['unit test'],
+                                      'openid.ns':[message.OPENID1_NS]
+                                      })
+
+    def test_isOpenID1(self):
+        self.failUnless(self.msg.isOpenID1())
+
-
-class OpenID2MessageTest(unittest.TestCase):
-    def setUp(self):
@@ -769 +769 @@
-        self._checkForm(html, m, self.action_url,
-                        tag_attrs, self.submit_text)
-
+
+    def test_setOpenIDNamespace_invalid(self):
+        m = message.Message()
+        invalid_things = [
+            # Empty string is not okay here.
+            '',
+            # Good guess!  But wrong.
+            'http://openid.net/signon/2.0',
+            # What?
+            u'http://specs%\\\r2Eopenid.net/auth/2.0',
+            # Too much escapings!
+            'http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0',
+            # This is a Type URI, not a openid.ns value.
+            'http://specs.openid.net/auth/2.0/signon',
+            ]
+
+        for x in invalid_things:
+            self.failUnlessRaises(message.InvalidOpenIDNamespace,
+                                  m.setOpenIDNamespace, x, False)
+
+
+    def test_isOpenID1(self):
+        v1_namespaces = [
+            # Yes, there are two of them.
+            'http://openid.net/signon/1.1',
+            'http://openid.net/signon/1.0',
+            ]
+
+        for ns in v1_namespaces:
+            m = message.Message(ns)
+            self.failUnless(m.isOpenID1(), "%r not recognized as OpenID 1" %
+                            (ns,))
+            self.failUnlessEqual(ns, m.getOpenIDNamespace())
+            self.failUnless(m.namespaces.isImplicit(ns),
+                            m.namespaces.getNamespaceURI(message.NULL_NAMESPACE))
+
+    def test_isOpenID2(self):
+        ns = 'http://specs.openid.net/auth/2.0'
+        m = message.Message(ns)
+        self.failUnless(m.isOpenID2())
+        self.failIf(m.namespaces.isImplicit(message.NULL_NAMESPACE))
+        self.failUnlessEqual(ns, m.getOpenIDNamespace())
+
+    def test_setOpenIDNamespace_explicit(self):
+        m = message.Message()
+        m.setOpenIDNamespace(message.THE_OTHER_OPENID1_NS, False)
+        self.failIf(m.namespaces.isImplicit(message.THE_OTHER_OPENID1_NS))
+
+    def test_setOpenIDNamespace_implicit(self):
+        m = message.Message()
+        m.setOpenIDNamespace(message.THE_OTHER_OPENID1_NS, True)
+        self.failUnless(m.namespaces.isImplicit(message.THE_OTHER_OPENID1_NS))
+
+
+    def test_explicitOpenID11NSSerialzation(self):
+        m = message.Message()
+        m.setOpenIDNamespace(message.THE_OTHER_OPENID1_NS, implicit=False)
+
+        post_args = m.toPostArgs()
+        self.failUnlessEqual(post_args,
+                             {'openid.ns':message.THE_OTHER_OPENID1_NS})
+
+    def test_fromPostArgs_ns11(self):
+        # An example of the stuff that some Drupal installations send us,
+        # which includes openid.ns but is 1.1.
+        query = {
+            u'openid.assoc_handle': u'',
+            u'openid.claimed_id': u'http://foobar.invalid/',
+            u'openid.identity': u'http://foobar.myopenid.com',
+            u'openid.mode': u'checkid_setup',
+            u'openid.ns': u'http://openid.net/signon/1.1',
+            u'openid.ns.sreg': u'http://openid.net/extensions/sreg/1.1',
+            u'openid.return_to': u'http://drupal.invalid/return_to',
+            u'openid.sreg.required': u'nickname,email',
+            u'openid.trust_root': u'http://drupal.invalid',
+            }
+        m = message.Message.fromPostArgs(query)
+        self.failUnless(m.isOpenID1())
+
+
+
-class NamespaceMapTest(unittest.TestCase):
-    def test_onealias(self):
-        nsm = message.NamespaceMap()

old-openid/openid/test/test_server.py

@@ -945 +970 @@
-                             len(expected_list) + 2,
-                             answer.fields.toPostArgs())
-
-    def _expectAnswerv1(self, answer, identity=None):
-        expected_list = [
-            ('mode', 'id_res'),
-            ('return_to', self.request.return_to),
-            ('identity', identity),
-            ]
-
-        for k, expected in expected_list:
-            actual = answer.fields.getArg(OPENID_NS, k)
-            self.failUnlessEqual(actual, expected, "%s: expected %s, got %s" % (k, expected, actual))
-
-        self.failUnless(answer.fields.hasKey(OPENID_NS, 'response_nonce'))
-        self.failUnlessEqual(answer.fields.getOpenIDNamespace(), OPENID1_NS)
-
-        # One for nonce
-        self.failUnlessEqual(len(answer.fields.toPostArgs()),
-                             len(expected_list) + 1,
-                             answer.fields.toPostArgs())
-
-
-    def test_answerAllow(self):
-        """Check the fields specified by "Positive Assertions"
-
@@ -1110 +1154 @@
-        """Test .allow() with an OpenID 1.x Message on a CheckIDRequest
-        built without an op_endpoint parameter.
-        """
+        identity = 'http://bambam.unittest/'
-        reqmessage = Message.fromOpenIDArgs({
-'http://bambam.unittest/'
+identity
-            'trust_root': 'http://bar.unittest/',
-            'return_to': 'http://bar.unittest/999',
-            })
-        self.request = server.CheckIDRequest.fromMessage(reqmessage, None)
-        answer = self.request.answer(True)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def test_answerImmediateDenyOpenID2(self):
-        """Look for mode=setup_needed in checkid_immediate negative
@@ -1150 +1215 @@
-        self.failUnlessEqual(answer.request, self.request)
-        self.failUnlessEqual(len(answer.fields.toPostArgs()), 2, answer.fields)
-        self.failUnlessEqual(answer.fields.getOpenIDNamespace(), OPENID1_NS)
+        self.failUnless(answer.fields.namespaces.isImplicit(OPENID1_NS))
-        self.failUnlessEqual(answer.fields.getArg(OPENID_NS, 'mode'), 'id_res')
-        self.failUnless(answer.fields.getArg(
-            OPENID_NS, 'user_setup_url', '').startswith(server_url))
@@ -1202 +1268 @@
-            immediate = False,
-            op_endpoint = self.server.op_endpoint,
-            )
+        self.request.message = Message(OPENID2_NS)
-        self.response = server.OpenIDResponse(self.request)
-        self.response.fields.setArg(OPENID_NS, 'mode', 'id_res')
-        self.response.fields.setArg(OPENID_NS, 'blue', 'star')