libs/openid/test/test_auth_request.py

   1 import cgi
   2 import unittest
   3
   4 from openid.consumer import consumer
   5 from openid import message
   6 from openid.test import support
   7
   8 class DummyEndpoint(object):
   9     preferred_namespace = None
  10     local_id = None
  11     server_url = None
  12     is_op_identifier = False
  13
  14     def preferredNamespace(self):
  15         return self.preferred_namespace
  16
  17     def getLocalID(self):
  18         return self.local_id
  19
  20     def isOPIdentifier(self):
  21         return self.is_op_identifier
  22
  23 class DummyAssoc(object):
  24     handle = "assoc-handle"
  25
  26 class TestAuthRequestMixin(support.OpenIDTestMixin):
  27     """Mixin for AuthRequest tests for OpenID 1 and 2; DON'T add
  28     unittest.TestCase as a base class here."""
  29
  30     preferred_namespace = None
  31     immediate = False
  32     expected_mode = 'checkid_setup'
  33
  34     def setUp(self):
  35         self.endpoint = DummyEndpoint()
  36         self.endpoint.local_id = 'http://server.unittest/joe'
  37         self.endpoint.claimed_id = 'http://joe.vanity.example/'
  38         self.endpoint.server_url = 'http://server.unittest/'
  39         self.endpoint.preferred_namespace = self.preferred_namespace
  40         self.realm = 'http://example/'
  41         self.return_to = 'http://example/return/'
  42         self.assoc = DummyAssoc()
  43         self.authreq = consumer.AuthRequest(self.endpoint, self.assoc)
  44
  45     def failUnlessAnonymous(self, msg):
  46         for key in ['claimed_id', 'identity']:
  47             self.failIfOpenIDKeyExists(msg, key)
  48
  49     def failUnlessHasRequiredFields(self, msg):
  50         self.failUnlessEqual(self.preferred_namespace,
  51                              self.authreq.message.getOpenIDNamespace())
  52
  53         self.failUnlessEqual(self.preferred_namespace,
  54                              msg.getOpenIDNamespace())
  55
  56         self.failUnlessOpenIDValueEquals(msg, 'mode',
  57                                          self.expected_mode)
  58
  59         # Implement these in subclasses because they depend on
  60         # protocol differences!
  61         self.failUnlessHasRealm(msg)
  62         self.failUnlessIdentifiersPresent(msg)
  63
  64     # TESTS
  65
  66     def test_checkNoAssocHandle(self):
  67         self.authreq.assoc = None
  68         msg = self.authreq.getMessage(self.realm, self.return_to,
  69                                       self.immediate)
  70
  71         self.failIfOpenIDKeyExists(msg, 'assoc_handle')
  72
  73     def test_checkWithAssocHandle(self):
  74         msg = self.authreq.getMessage(self.realm, self.return_to,
  75                                       self.immediate)
  76
  77         self.failUnlessOpenIDValueEquals(msg, 'assoc_handle',
  78                                          self.assoc.handle)
  79
  80     def test_addExtensionArg(self):
  81         self.authreq.addExtensionArg('bag:', 'color', 'brown')
  82         self.authreq.addExtensionArg('bag:', 'material', 'paper')
  83         self.failUnless('bag:' in self.authreq.message.namespaces)
  84         self.failUnlessEqual(self.authreq.message.getArgs('bag:'),
  85                              {'color': 'brown',
  86                               'material': 'paper'})
  87         msg = self.authreq.getMessage(self.realm, self.return_to,
  88                                       self.immediate)
  89
  90         # XXX: this depends on the way that Message assigns
  91         # namespaces. Really it doesn't care that it has alias "0",
  92         # but that is tested anyway
  93         post_args = msg.toPostArgs()
  94         self.failUnlessEqual('brown', post_args['openid.ext0.color'])
  95         self.failUnlessEqual('paper', post_args['openid.ext0.material'])
  96
  97     def test_standard(self):
  98         msg = self.authreq.getMessage(self.realm, self.return_to,
  99                                       self.immediate)
 100
 101         self.failUnlessHasIdentifiers(
 102             msg, self.endpoint.local_id, self.endpoint.claimed_id)
 103
 104 class TestAuthRequestOpenID2(TestAuthRequestMixin, unittest.TestCase):
 105     preferred_namespace = message.OPENID2_NS
 106
 107     def failUnlessHasRealm(self, msg):
 108         # check presence of proper realm key and absence of the wrong
 109         # one.
 110         self.failUnlessOpenIDValueEquals(msg, 'realm', self.realm)
 111         self.failIfOpenIDKeyExists(msg, 'trust_root')
 112
 113     def failUnlessIdentifiersPresent(self, msg):
 114         identity_present = msg.hasKey(message.OPENID_NS, 'identity')
 115         claimed_present = msg.hasKey(message.OPENID_NS, 'claimed_id')
 116
 117         self.failUnlessEqual(claimed_present, identity_present)
 118
 119     def failUnlessHasIdentifiers(self, msg, op_specific_id, claimed_id):
 120         self.failUnlessOpenIDValueEquals(msg, 'identity', op_specific_id)
 121         self.failUnlessOpenIDValueEquals(msg, 'claimed_id', claimed_id)
 122
 123     # TESTS
 124
 125     def test_setAnonymousWorksForOpenID2(self):
 126         """OpenID AuthRequests should be able to set 'anonymous' to true."""
 127         self.failUnless(self.authreq.message.isOpenID2())
 128         self.authreq.setAnonymous(True)
 129         self.authreq.setAnonymous(False)
 130
 131     def test_userAnonymousIgnoresIdentfier(self):
 132         self.authreq.setAnonymous(True)
 133         msg = self.authreq.getMessage(self.realm, self.return_to,
 134                                       self.immediate)
 135         self.failUnlessHasRequiredFields(msg)
 136         self.failUnlessAnonymous(msg)
 137
 138     def test_opAnonymousIgnoresIdentifier(self):
 139         self.endpoint.is_op_identifier = True
 140         self.authreq.setAnonymous(True)
 141         msg = self.authreq.getMessage(self.realm, self.return_to,
 142                                       self.immediate)
 143         self.failUnlessHasRequiredFields(msg)
 144         self.failUnlessAnonymous(msg)
 145
 146     def test_opIdentifierSendsIdentifierSelect(self):
 147         self.endpoint.is_op_identifier = True
 148         msg = self.authreq.getMessage(self.realm, self.return_to,
 149                                       self.immediate)
 150         self.failUnlessHasRequiredFields(msg)
 151         self.failUnlessHasIdentifiers(
 152             msg, message.IDENTIFIER_SELECT, message.IDENTIFIER_SELECT)
 153
 154 class TestAuthRequestOpenID1(TestAuthRequestMixin, unittest.TestCase):
 155     preferred_namespace = message.OPENID1_NS
 156
 157     def setUpEndpoint(self):
 158         TestAuthRequestBase.setUpEndpoint(self)
 159         self.endpoint.preferred_namespace = message.OPENID1_NS
 160
 161     def failUnlessHasIdentifiers(self, msg, op_specific_id, claimed_id):
 162         """Make sure claimed_is is *absent* in request."""
 163         self.failUnlessOpenIDValueEquals(msg, 'identity', op_specific_id)
 164         self.failIfOpenIDKeyExists(msg, 'claimed_id')
 165
 166     def failUnlessIdentifiersPresent(self, msg):
 167         self.failIfOpenIDKeyExists(msg, 'claimed_id')
 168         self.failUnless(msg.hasKey(message.OPENID_NS, 'identity'))
 169
 170     def failUnlessHasRealm(self, msg):
 171         # check presence of proper realm key and absence of the wrong
 172         # one.
 173         self.failUnlessOpenIDValueEquals(msg, 'trust_root', self.realm)
 174         self.failIfOpenIDKeyExists(msg, 'realm')
 175
 176     # TESTS
 177
 178     def test_setAnonymousFailsForOpenID1(self):
 179         """OpenID 1 requests MUST NOT be able to set anonymous to True"""
 180         self.failUnless(self.authreq.message.isOpenID1())
 181         self.failUnlessRaises(ValueError, self.authreq.setAnonymous, True)
 182         self.authreq.setAnonymous(False)
 183
 184     def test_identifierSelect(self):
 185         """Identfier select SHOULD NOT be sent, but this pathway is in
 186         here in case some special discovery stuff is done to trigger
 187         it with OpenID 1. If it is triggered, it will send
 188         identifier_select just like OpenID 2.
 189         """
 190         self.endpoint.is_op_identifier = True
 191         msg = self.authreq.getMessage(self.realm, self.return_to,
 192                                       self.immediate)
 193         self.failUnlessHasRequiredFields(msg)
 194         self.failUnlessEqual(message.IDENTIFIER_SELECT,
 195                              msg.getArg(message.OPENID1_NS, 'identity'))
 196
 197 class TestAuthRequestOpenID1Immediate(TestAuthRequestOpenID1):
 198     immediate = True
 199     expected_mode = 'checkid_immediate'
 200
 201 class TestAuthRequestOpenID2Immediate(TestAuthRequestOpenID2):
 202     immediate = True
 203     expected_mode = 'checkid_immediate'
 204
 205 if __name__ == '__main__':
 206     unittest.main()