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