← Back to branch summary

~gary/python-openid/python-openid-2.2.1-patched

« back to all changes in this revision

Viewing changes to openid/test/test_discover.py

  • Committer: Launchpad Patch Queue Manager
  • Date: 2007-11-30 02:46:28 UTC
  • mfrom: (1.1.1 pyopenid-2.0)
  • Revision ID: launchpad@pqm.canonical.com-20071130024628-qktwsew3383iawmq
[rs=SteveA] upgrade to python-openid-2.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
openid/test/test_discover.py
1
1
import sys
2
2
import unittest
3
3
import datadriven
4
 
from urljr import fetchers
5
 
from urljr.fetchers import HTTPResponse
6
 
from yadis.discover import DiscoveryFailure
 
4
import os.path
 
5
from openid import fetchers
 
6
from openid.fetchers import HTTPResponse
 
7
from openid.yadis.discover import DiscoveryFailure
7
8
from openid.consumer import discover
8
 
from yadis import xrires
9
 
from yadis.xri import XRI
 
9
from openid.yadis import xrires
 
10
from openid.yadis.xri import XRI
10
11
from urlparse import urlsplit
 
12
from openid import message
11
13
 
12
14
### Tests for conditions that trigger DiscoveryFailure
13
15
 
63
65
# string exception is raised.
64
66
import warnings
65
67
warnings.filterwarnings('ignore', 'raising a string.*', DeprecationWarning,
66
 
                        r'^openid\.test\.test_discover$', 74)
 
68
                        r'^openid\.test\.test_discover$', 77)
67
69
 
68
70
class ErrorRaisingFetcher(object):
69
71
    """Just raise an exception when fetch is called"""
116
118
 
117
119
### Tests for openid.consumer.discover.discover
118
120
 
 
121
class TestNormalization(unittest.TestCase):
 
122
    def testAddingProtocol(self):
 
123
        f = ErrorRaisingFetcher(RuntimeError())
 
124
        fetchers.setDefaultFetcher(f, wrap_exceptions=False)
 
125
 
 
126
        try:
 
127
            discover.discover('users.stompy.janrain.com:8000/x')
 
128
        except DiscoveryFailure, why:
 
129
            self.fail('failed to parse url with port correctly')
 
130
        except RuntimeError:
 
131
            pass #expected
 
132
 
 
133
        fetchers.setDefaultFetcher(None)
 
134
 
119
135
 
120
136
class DiscoveryMockFetcher(object):
121
137
    redirect = None
150
166
    documents = {}
151
167
    fetcherClass = DiscoveryMockFetcher
152
168
 
 
169
    def _checkService(self, s,
 
170
                      server_url,
 
171
                      claimed_id=None,
 
172
                      local_id=None,
 
173
                      canonical_id=None,
 
174
                      types=None,
 
175
                      used_yadis=False
 
176
                      ):
 
177
        self.failUnlessEqual(server_url, s.server_url)
 
178
        if types == ['2.0 OP']:
 
179
            self.failIf(claimed_id)
 
180
            self.failIf(local_id)
 
181
            self.failIf(s.claimed_id)
 
182
            self.failIf(s.local_id)
 
183
            self.failIf(s.getLocalID())
 
184
            self.failIf(s.compatibilityMode())
 
185
            self.failUnless(s.isOPIdentifier())
 
186
            self.failUnlessEqual(s.preferredNamespace(),
 
187
                                 discover.OPENID_2_0_MESSAGE_NS)
 
188
        else:
 
189
            self.failUnlessEqual(claimed_id, s.claimed_id)
 
190
            self.failUnlessEqual(local_id, s.getLocalID())
 
191
 
 
192
        if used_yadis:
 
193
            self.failUnless(s.used_yadis, "Expected to use Yadis")
 
194
        else:
 
195
            self.failIf(s.used_yadis,
 
196
                        "Expected to use old-style discovery")
 
197
 
 
198
        openid_types = {
 
199
            '1.1': discover.OPENID_1_1_TYPE,
 
200
            '1.0': discover.OPENID_1_0_TYPE,
 
201
            '2.0': discover.OPENID_2_0_TYPE,
 
202
            '2.0 OP': discover.OPENID_IDP_2_0_TYPE,
 
203
            }
 
204
 
 
205
        type_uris = [openid_types[t] for t in types]
 
206
        self.failUnlessEqual(type_uris, s.type_uris)
 
207
        self.failUnlessEqual(canonical_id, s.canonicalID)
 
208
 
153
209
    def setUp(self):
154
210
        self.documents = self.documents.copy()
155
211
        self.fetcher = self.fetcherClass(self.documents)
158
214
    def tearDown(self):
159
215
        fetchers.setDefaultFetcher(None)
160
216
 
161
 
yadis_2entries = '''<?xml version="1.0" encoding="UTF-8"?>
162
 
<xrds:XRDS xmlns:xrds="xri://$xrds"
163
 
           xmlns="xri://$xrd*($v*2.0)"
164
 
           xmlns:openid="http://openid.net/xmlns/1.0"
165
 
           >
166
 
  <XRD>
167
 
    <CanonicalID>=!1000</CanonicalID>
168
 
 
169
 
    <Service priority="10">
170
 
      <Type>http://openid.net/signon/1.0</Type>
171
 
      <URI>http://www.myopenid.com/server</URI>
172
 
      <openid:Delegate>http://smoker.myopenid.com/</openid:Delegate>
173
 
    </Service>
174
 
 
175
 
    <Service priority="20">
176
 
      <Type>http://openid.net/signon/1.0</Type>
177
 
      <URI>http://www.livejournal.com/openid/server.bml</URI>
178
 
      <openid:Delegate>http://frank.livejournal.com/</openid:Delegate>
179
 
    </Service>
180
 
 
181
 
  </XRD>
182
 
</xrds:XRDS>
183
 
'''
184
 
 
185
 
yadis_another = '''<?xml version="1.0" encoding="UTF-8"?>
186
 
<xrds:XRDS xmlns:xrds="xri://$xrds"
187
 
           xmlns="xri://$xrd*($v*2.0)"
188
 
           xmlns:openid="http://openid.net/xmlns/1.0"
189
 
           >
190
 
  <XRD>
191
 
 
192
 
    <Service priority="10">
193
 
      <Type>http://openid.net/signon/1.0</Type>
194
 
      <URI>http://vroom.unittest/server</URI>
195
 
      <openid:Delegate>http://smoker.myopenid.com/</openid:Delegate>
196
 
    </Service>
197
 
  </XRD>
198
 
</xrds:XRDS>
199
 
'''
200
 
 
201
 
 
202
 
yadis_0entries = '''<?xml version="1.0" encoding="UTF-8"?>
203
 
<xrds:XRDS xmlns:xrds="xri://$xrds"
204
 
           xmlns="xri://$xrd*($v*2.0)"
205
 
           xmlns:openid="http://openid.net/xmlns/1.0"
206
 
           >
207
 
  <XRD>
208
 
    <Service >
209
 
      <Type>http://is-not-openid.unittest/</Type>
210
 
      <URI>http://noffing.unittest./</URI>
211
 
    </Service>
212
 
  </XRD>
213
 
</xrds:XRDS>
214
 
'''
215
 
 
216
 
yadis_no_delegate = '''<?xml version="1.0" encoding="UTF-8"?>
217
 
<xrds:XRDS xmlns:xrds="xri://$xrds"
218
 
           xmlns="xri://$xrd*($v*2.0)"
219
 
           >
220
 
  <XRD>
221
 
    <Service priority="10">
222
 
      <Type>http://openid.net/signon/1.0</Type>
223
 
      <URI>http://www.myopenid.com/server</URI>
224
 
    </Service>
225
 
  </XRD>
226
 
</xrds:XRDS>
227
 
'''
228
 
 
229
 
openid_html = """
230
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
231
 
<html>
232
 
  <head>
233
 
    <title>Identity Page for Smoker</title>
234
 
<link rel="openid.server" href="http://www.myopenid.com/server" />
235
 
<link rel="openid.delegate" href="http://smoker.myopenid.com/" />
236
 
  </head><body><p>foo</p></body></html>
237
 
"""
238
 
 
239
 
openid_html_no_delegate = """
240
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
241
 
<html>
242
 
  <head>
243
 
    <title>Identity Page for Smoker</title>
244
 
<link rel="openid.server" href="http://www.myopenid.com/server" />
245
 
  </head><body><p>foo</p></body></html>
246
 
"""
247
 
 
248
 
openid_and_yadis_html = """
249
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
250
 
<html>
251
 
  <head>
252
 
    <title>Identity Page for Smoker</title>
253
 
<meta http-equiv="X-XRDS-Location" content="http://someuser.unittest/xrds" />
254
 
<link rel="openid.server" href="http://www.myopenid.com/server" />
255
 
<link rel="openid.delegate" href="http://smoker.myopenid.com/" />
256
 
  </head><body><p>foo</p></body></html>
257
 
"""
 
217
def readDataFile(filename):
 
218
    module_directory = os.path.dirname(os.path.abspath(__file__))
 
219
    filename = os.path.join(
 
220
        module_directory, 'data', 'test_discover', filename)
 
221
    return file(filename).read()
258
222
 
259
223
class TestDiscovery(BaseTestDiscovery):
260
 
    def _usedYadis(self, service):
261
 
        self.failUnless(service.used_yadis, "Expected to use Yadis")
 
224
    def _discover(self, content_type, data,
 
225
                  expected_services, expected_id=None):
 
226
        if expected_id is None:
 
227
            expected_id = self.id_url
262
228
 
263
 
    def _notUsedYadis(self, service):
264
 
        self.failIf(service.used_yadis, "Expected to use old-style discovery")
 
229
        self.documents[self.id_url] = (content_type, data)
 
230
        id_url, services = discover.discover(self.id_url)
 
231
        self.failUnlessEqual(expected_services, len(services))
 
232
        self.failUnlessEqual(expected_id, id_url)
 
233
        return services
265
234
 
266
235
    def test_404(self):
267
236
        self.failUnlessRaises(DiscoveryFailure,
268
237
                              discover.discover, self.id_url + '/404')
269
238
 
270
 
    def test_noYadis(self):
271
 
        self.documents[self.id_url] = ('text/html', openid_html)
272
 
        id_url, services = discover.discover(self.id_url)
273
 
        self.failUnlessEqual(self.id_url, id_url)
274
 
        self.failUnlessEqual(len(services), 1,
275
 
                             "More than one service in %r" % (services,))
276
 
        self.failUnlessEqual(services[0].server_url,
277
 
                             "http://www.myopenid.com/server")
278
 
        self.failUnlessEqual(services[0].delegate,
279
 
                             "http://smoker.myopenid.com/")
280
 
        self.failUnlessEqual(services[0].identity_url, self.id_url)
281
 
        self._notUsedYadis(services[0])
282
 
 
283
239
    def test_noOpenID(self):
284
 
        self.fetcher.documents = {
285
 
            self.id_url: ('text/plain', "junk"),
286
 
        }
287
 
        id_url, services = discover.discover(self.id_url)
288
 
        self.failUnlessEqual(self.id_url, id_url)
289
 
        self.failIf(len(services))
290
 
 
291
 
    def test_yadis(self):
292
 
        self.fetcher.documents = {
293
 
            BaseTestDiscovery.id_url: ('application/xrds+xml', yadis_2entries),
294
 
        }
295
 
 
296
 
        id_url, services = discover.discover(self.id_url)
297
 
        self.failUnlessEqual(self.id_url, id_url)
298
 
        self.failUnlessEqual(len(services), 2,
299
 
                             "Not 2 services in %r" % (services,))
300
 
        self.failUnlessEqual(services[0].server_url,
301
 
                             "http://www.myopenid.com/server")
302
 
        self._usedYadis(services[0])
303
 
        self.failUnlessEqual(services[1].server_url,
304
 
                             "http://www.livejournal.com/openid/server.bml")
305
 
        self._usedYadis(services[1])
306
 
 
307
 
    def test_redirect(self):
308
 
        expected_final_url = "http://elsewhere.unittest/"
309
 
        self.fetcher.redirect = expected_final_url
310
 
        self.fetcher.documents = {
311
 
            self.id_url: ('text/html', openid_html),
312
 
        }
313
 
        id_url, services = discover.discover(self.id_url)
314
 
        self.failUnlessEqual(expected_final_url, id_url)
315
 
        self.failUnlessEqual(len(services), 1,
316
 
                             "More than one service in %r" % (services,))
317
 
        self.failUnlessEqual(services[0].server_url,
318
 
                             "http://www.myopenid.com/server")
319
 
        self.failUnlessEqual(services[0].delegate,
320
 
                             "http://smoker.myopenid.com/")
321
 
        self.failUnlessEqual(services[0].identity_url, expected_final_url)
322
 
        self._notUsedYadis(services[0])
323
 
 
324
 
    def test_emptyList(self):
325
 
        self.fetcher.documents = {
326
 
            self.id_url: ('application/xrds+xml', yadis_0entries),
327
 
        }
328
 
        id_url, services = discover.discover(self.id_url)
329
 
        self.failUnlessEqual(self.id_url, id_url)
330
 
        self.failIf(services)
331
 
 
332
 
    def test_emptyListWithLegacy(self):
333
 
        self.fetcher.documents = {
334
 
            self.id_url: ('text/html', openid_and_yadis_html),
335
 
            self.id_url + 'xrds': ('application/xrds+xml', yadis_0entries),
336
 
        }
337
 
        id_url, services = discover.discover(self.id_url)
338
 
        self.failUnlessEqual(self.id_url, id_url)
339
 
        self.failUnlessEqual(len(services), 1,
340
 
                             "Not one service in %r" % (services,))
341
 
        self.failUnlessEqual(services[0].server_url,
342
 
                             "http://www.myopenid.com/server")
343
 
        self.failUnlessEqual(services[0].identity_url, self.id_url)
344
 
        self._notUsedYadis(services[0])
345
 
 
346
 
    def test_yadisNoDelegate(self):
347
 
        self.fetcher.documents = {
348
 
            self.id_url: ('application/xrds+xml', yadis_no_delegate),
349
 
        }
350
 
        id_url, services = discover.discover(self.id_url)
351
 
        self.failUnlessEqual(self.id_url, id_url)
352
 
        self.failUnlessEqual(len(services), 1,
353
 
                             "Not 1 service in %r" % (services,))
354
 
        self.failUnlessEqual(services[0].server_url,
355
 
                             "http://www.myopenid.com/server")
356
 
        self.failUnless(services[0].delegate is None,
357
 
                        'Delegate should be None. Got %r' %
358
 
                        (services[0].delegate,))
359
 
        self._usedYadis(services[0])
360
 
 
361
 
    def test_openidNoDelegate(self):
362
 
        self.fetcher.documents = {
363
 
            self.id_url: ('text/html', openid_html_no_delegate),
364
 
        }
365
 
        id_url, services = discover.discover(self.id_url)
366
 
        self.failUnlessEqual(self.id_url, id_url)
367
 
        self.failUnlessEqual(services[0].server_url,
368
 
                             "http://www.myopenid.com/server")
369
 
        self.failUnlessEqual(services[0].identity_url, self.id_url)
370
 
        self.failUnless(services[0].delegate is None,
371
 
                        'Delegate should be None. Got %r' %
372
 
                        (services[0].delegate,))
373
 
 
374
 
        self._notUsedYadis(services[0])
375
 
 
 
240
        services = self._discover(content_type='text/plain',
 
241
                                  data="junk",
 
242
                                  expected_services=0)
 
243
 
 
244
        services = self._discover(
 
245
            content_type='text/html',
 
246
            data=readDataFile('openid_no_delegate.html'),
 
247
            expected_services=1,
 
248
            )
 
249
 
 
250
        self._checkService(
 
251
            services[0],
 
252
            used_yadis=False,
 
253
            types=['1.1'],
 
254
            server_url="http://www.myopenid.com/server",
 
255
            claimed_id=self.id_url,
 
256
            local_id=self.id_url,
 
257
            )
 
258
 
 
259
    def test_html1(self):
 
260
        services = self._discover(
 
261
            content_type='text/html',
 
262
            data=readDataFile('openid.html'),
 
263
            expected_services=1)
 
264
 
 
265
 
 
266
        self._checkService(
 
267
            services[0],
 
268
            used_yadis=False,
 
269
            types=['1.1'],
 
270
            server_url="http://www.myopenid.com/server",
 
271
            claimed_id=self.id_url,
 
272
            local_id='http://smoker.myopenid.com/',
 
273
            )
 
274
 
 
275
    def test_html2(self):
 
276
        services = self._discover(
 
277
            content_type='text/html',
 
278
            data=readDataFile('openid2.html'),
 
279
            expected_services=1,
 
280
            )
 
281
 
 
282
        self._checkService(
 
283
            services[0],
 
284
            used_yadis=False,
 
285
            types=['2.0'],
 
286
            server_url="http://www.myopenid.com/server",
 
287
            claimed_id=self.id_url,
 
288
            local_id='http://smoker.myopenid.com/',
 
289
            )
 
290
 
 
291
    def test_html1And2(self):
 
292
        services = self._discover(
 
293
            content_type='text/html',
 
294
            data=readDataFile('openid_1_and_2.html'),
 
295
            expected_services=2,
 
296
            )
 
297
 
 
298
        for t, s in zip(['2.0', '1.1'], services):
 
299
            self._checkService(
 
300
                s,
 
301
                used_yadis=False,
 
302
                types=[t],
 
303
                server_url="http://www.myopenid.com/server",
 
304
                claimed_id=self.id_url,
 
305
                local_id='http://smoker.myopenid.com/',
 
306
                )
 
307
 
 
308
    def test_yadisEmpty(self):
 
309
        services = self._discover(content_type='application/xrds+xml',
 
310
                                  data=readDataFile('yadis_0entries.xml'),
 
311
                                  expected_services=0)
 
312
 
 
313
    def test_htmlEmptyYadis(self):
 
314
        """HTML document has discovery information, but points to an
 
315
        empty Yadis document."""
 
316
        # The XRDS document pointed to by "openid_and_yadis.html"
 
317
        self.documents[self.id_url + 'xrds'] = (
 
318
            'application/xrds+xml', readDataFile('yadis_0entries.xml'))
 
319
 
 
320
        services = self._discover(content_type='text/html',
 
321
                                  data=readDataFile('openid_and_yadis.html'),
 
322
                                  expected_services=1)
 
323
 
 
324
        self._checkService(
 
325
            services[0],
 
326
            used_yadis=False,
 
327
            types=['1.1'],
 
328
            server_url="http://www.myopenid.com/server",
 
329
            claimed_id=self.id_url,
 
330
            local_id='http://smoker.myopenid.com/',
 
331
            )
 
332
 
 
333
    def test_yadis1NoDelegate(self):
 
334
        services = self._discover(content_type='application/xrds+xml',
 
335
                                  data=readDataFile('yadis_no_delegate.xml'),
 
336
                                  expected_services=1)
 
337
 
 
338
        self._checkService(
 
339
            services[0],
 
340
            used_yadis=True,
 
341
            types=['1.0'],
 
342
            server_url="http://www.myopenid.com/server",
 
343
            claimed_id=self.id_url,
 
344
            local_id=self.id_url,
 
345
            )
 
346
 
 
347
    def test_yadis2NoLocalID(self):
 
348
        services = self._discover(
 
349
            content_type='application/xrds+xml',
 
350
            data=readDataFile('openid2_xrds_no_local_id.xml'),
 
351
            expected_services=1,
 
352
            )
 
353
 
 
354
        self._checkService(
 
355
            services[0],
 
356
            used_yadis=True,
 
357
            types=['2.0'],
 
358
            server_url="http://www.myopenid.com/server",
 
359
            claimed_id=self.id_url,
 
360
            local_id=self.id_url,
 
361
            )
 
362
 
 
363
    def test_yadis2(self):
 
364
        services = self._discover(
 
365
            content_type='application/xrds+xml',
 
366
            data=readDataFile('openid2_xrds.xml'),
 
367
            expected_services=1,
 
368
            )
 
369
 
 
370
        self._checkService(
 
371
            services[0],
 
372
            used_yadis=True,
 
373
            types=['2.0'],
 
374
            server_url="http://www.myopenid.com/server",
 
375
            claimed_id=self.id_url,
 
376
            local_id='http://smoker.myopenid.com/',
 
377
            )
 
378
 
 
379
    def test_yadis2OP(self):
 
380
        services = self._discover(
 
381
            content_type='application/xrds+xml',
 
382
            data=readDataFile('yadis_idp.xml'),
 
383
            expected_services=1,
 
384
            )
 
385
 
 
386
        self._checkService(
 
387
            services[0],
 
388
            used_yadis=True,
 
389
            types=['2.0 OP'],
 
390
            server_url="http://www.myopenid.com/server",
 
391
            )
 
392
 
 
393
    def test_yadis2OPDelegate(self):
 
394
        """The delegate tag isn't meaningful for OP entries."""
 
395
        services = self._discover(
 
396
            content_type='application/xrds+xml',
 
397
            data=readDataFile('yadis_idp_delegate.xml'),
 
398
            expected_services=1,
 
399
            )
 
400
 
 
401
        self._checkService(
 
402
            services[0],
 
403
            used_yadis=True,
 
404
            types=['2.0 OP'],
 
405
            server_url="http://www.myopenid.com/server",
 
406
            )
 
407
 
 
408
    def test_yadis2BadLocalID(self):
 
409
        self.failUnlessRaises(DiscoveryFailure, self._discover,
 
410
            content_type='application/xrds+xml',
 
411
            data=readDataFile('yadis_2_bad_local_id.xml'),
 
412
            expected_services=1,
 
413
            )
 
414
 
 
415
    def test_yadis1And2(self):
 
416
        services = self._discover(
 
417
            content_type='application/xrds+xml',
 
418
            data=readDataFile('openid_1_and_2_xrds.xml'),
 
419
            expected_services=1,
 
420
            )
 
421
 
 
422
        self._checkService(
 
423
            services[0],
 
424
            used_yadis=True,
 
425
            types=['2.0', '1.1'],
 
426
            server_url="http://www.myopenid.com/server",
 
427
            claimed_id=self.id_url,
 
428
            local_id='http://smoker.myopenid.com/',
 
429
            )
 
430
 
 
431
    def test_yadis1And2BadLocalID(self):
 
432
        self.failUnlessRaises(DiscoveryFailure, self._discover,
 
433
            content_type='application/xrds+xml',
 
434
            data=readDataFile('openid_1_and_2_xrds_bad_delegate.xml'),
 
435
            expected_services=1,
 
436
            )
376
437
 
377
438
class MockFetcherForXRIProxy(object):
378
439
 
412
473
class TestXRIDiscovery(BaseTestDiscovery):
413
474
    fetcherClass = MockFetcherForXRIProxy
414
475
 
415
 
    documents = {'=smoker': ('application/xrds+xml', yadis_2entries) }
 
476
    documents = {'=smoker': ('application/xrds+xml',
 
477
                             readDataFile('yadis_2entries_delegate.xml')),
 
478
                 '=smoker*bad': ('application/xrds+xml',
 
479
                                 readDataFile('yadis_another_delegate.xml')) }
416
480
 
417
481
    def test_xri(self):
418
482
        user_xri, services = discover.discoverXRI('=smoker')
419
 
        self.failUnless(services)
420
 
        self.failUnlessEqual(services[0].server_url,
421
 
                             "http://www.myopenid.com/server")
422
 
        self.failUnlessEqual(services[1].server_url,
423
 
                             "http://www.livejournal.com/openid/server.bml")
424
 
        self.failUnlessEqual(services[0].canonicalID, XRI("=!1000"))
 
483
 
 
484
        self._checkService(
 
485
            services[0],
 
486
            used_yadis=True,
 
487
            types=['1.0'],
 
488
            server_url="http://www.myopenid.com/server",
 
489
            claimed_id=XRI("=!1000"),
 
490
            canonical_id=XRI("=!1000"),
 
491
            local_id='http://smoker.myopenid.com/',
 
492
            )
 
493
 
 
494
        self._checkService(
 
495
            services[1],
 
496
            used_yadis=True,
 
497
            types=['1.0'],
 
498
            server_url="http://www.livejournal.com/openid/server.bml",
 
499
            claimed_id=XRI("=!1000"),
 
500
            canonical_id=XRI("=!1000"),
 
501
            local_id='http://frank.livejournal.com/',
 
502
            )
 
503
 
 
504
    def test_xriNoCanonicalID(self):
 
505
        user_xri, services = discover.discoverXRI('=smoker*bad')
 
506
        self.failIf(services)
425
507
 
426
508
    def test_useCanonicalID(self):
427
509
        """When there is no delegate, the CanonicalID should be used with XRI.
428
510
        """
429
511
        endpoint = discover.OpenIDServiceEndpoint()
430
 
        endpoint.identity_url = "=example"
 
512
        endpoint.claimed_id = XRI("=!1000")
431
513
        endpoint.canonicalID = XRI("=!1000")
432
 
        self.failUnlessEqual(endpoint.getServerID(), XRI("=!1000"))
433
 
 
434
 
 
 
514
        self.failUnlessEqual(endpoint.getLocalID(), XRI("=!1000"))
 
515
 
 
516
 
 
517
class TestXRIDiscoveryIDP(BaseTestDiscovery):
 
518
    fetcherClass = MockFetcherForXRIProxy
 
519
 
 
520
    documents = {'=smoker': ('application/xrds+xml',
 
521
                             readDataFile('yadis_2entries_idp.xml')) }
 
522
 
 
523
    def test_xri(self):
 
524
        user_xri, services = discover.discoverXRI('=smoker')
 
525
        self.failUnless(services, "Expected services, got zero")
 
526
        self.failUnlessEqual(services[0].server_url,
 
527
                             "http://www.livejournal.com/openid/server.bml")
 
528
 
 
529
 
 
530
class TestPreferredNamespace(datadriven.DataDrivenTestCase):
 
531
    def __init__(self, expected_ns, type_uris):
 
532
        datadriven.DataDrivenTestCase.__init__(
 
533
            self, 'Expecting %s from %s' % (expected_ns, type_uris))
 
534
        self.expected_ns = expected_ns
 
535
        self.type_uris = type_uris
 
536
 
 
537
    def runOneTest(self):
 
538
        endpoint = discover.OpenIDServiceEndpoint()
 
539
        endpoint.type_uris = self.type_uris
 
540
        actual_ns = endpoint.preferredNamespace()
 
541
        self.failUnlessEqual(actual_ns, self.expected_ns)
 
542
 
 
543
    cases = [
 
544
        (message.OPENID1_NS, []),
 
545
        (message.OPENID1_NS, ['http://jyte.com/']),
 
546
        (message.OPENID1_NS, [discover.OPENID_1_0_TYPE]),
 
547
        (message.OPENID1_NS, [discover.OPENID_1_1_TYPE]),
 
548
        (message.OPENID2_NS, [discover.OPENID_2_0_TYPE]),
 
549
        (message.OPENID2_NS, [discover.OPENID_IDP_2_0_TYPE]),
 
550
        (message.OPENID2_NS, [discover.OPENID_2_0_TYPE,
 
551
                              discover.OPENID_1_0_TYPE]),
 
552
        (message.OPENID2_NS, [discover.OPENID_1_0_TYPE,
 
553
                              discover.OPENID_2_0_TYPE]),
 
554
        ]
 
555
 
 
556
class TestIsOPIdentifier(unittest.TestCase):
 
557
    def setUp(self):
 
558
        self.endpoint = discover.OpenIDServiceEndpoint()
 
559
 
 
560
    def test_none(self):
 
561
        self.failIf(self.endpoint.isOPIdentifier())
 
562
 
 
563
    def test_openid1_0(self):
 
564
        self.endpoint.type_uris = [discover.OPENID_1_0_TYPE]
 
565
        self.failIf(self.endpoint.isOPIdentifier())
 
566
 
 
567
    def test_openid1_1(self):
 
568
        self.endpoint.type_uris = [discover.OPENID_1_1_TYPE]
 
569
        self.failIf(self.endpoint.isOPIdentifier())
 
570
 
 
571
    def test_openid2(self):
 
572
        self.endpoint.type_uris = [discover.OPENID_2_0_TYPE]
 
573
        self.failIf(self.endpoint.isOPIdentifier())
 
574
 
 
575
    def test_openid2OP(self):
 
576
        self.endpoint.type_uris = [discover.OPENID_IDP_2_0_TYPE]
 
577
        self.failUnless(self.endpoint.isOPIdentifier())
 
578
 
 
579
    def test_multipleMissing(self):
 
580
        self.endpoint.type_uris = [discover.OPENID_2_0_TYPE,
 
581
                                   discover.OPENID_1_0_TYPE]
 
582
        self.failIf(self.endpoint.isOPIdentifier())
 
583
 
 
584
    def test_multiplePresent(self):
 
585
        self.endpoint.type_uris = [discover.OPENID_2_0_TYPE,
 
586
                                   discover.OPENID_1_0_TYPE,
 
587
                                   discover.OPENID_IDP_2_0_TYPE]
 
588
        self.failUnless(self.endpoint.isOPIdentifier())
 
589
 
 
590
class TestFromOPEndpointURL(unittest.TestCase):
 
591
    def setUp(self):
 
592
        self.op_endpoint_url = 'http://example.com/op/endpoint'
 
593
        self.endpoint = discover.OpenIDServiceEndpoint.fromOPEndpointURL(
 
594
            self.op_endpoint_url)
 
595
 
 
596
    def test_isOPEndpoint(self):
 
597
        self.failUnless(self.endpoint.isOPIdentifier())
 
598
 
 
599
    def test_noIdentifiers(self):
 
600
        self.failUnlessEqual(self.endpoint.getLocalID(), None)
 
601
        self.failUnlessEqual(self.endpoint.claimed_id, None)
 
602
 
 
603
    def test_compatibility(self):
 
604
        self.failIf(self.endpoint.compatibilityMode())
 
605
 
 
606
    def test_canonicalID(self):
 
607
        self.failUnlessEqual(self.endpoint.canonicalID, None)
 
608
 
 
609
    def test_serverURL(self):
 
610
        self.failUnlessEqual(self.endpoint.server_url, self.op_endpoint_url)
 
611
 
 
612
class TestDiscoverFunction(unittest.TestCase):
 
613
    def setUp(self):
 
614
        self._old_discoverURI = discover.discoverURI
 
615
        self._old_discoverXRI = discover.discoverXRI
 
616
 
 
617
        discover.discoverXRI = self.discoverXRI
 
618
        discover.discoverURI = self.discoverURI
 
619
 
 
620
    def tearDown(self):
 
621
        discover.discoverURI = self._old_discoverURI
 
622
        discover.discoverXRI = self._old_discoverXRI
 
623
 
 
624
    def discoverXRI(self, identifier):
 
625
        return 'XRI'
 
626
 
 
627
    def discoverURI(self, identifier):
 
628
        return 'URI'
 
629
 
 
630
    def test_uri(self):
 
631
        self.failUnlessEqual('URI', discover.discover('http://woo!'))
 
632
 
 
633
    def test_uriForBogus(self):
 
634
        self.failUnlessEqual('URI', discover.discover('not a URL or XRI'))
 
635
 
 
636
    def test_xri(self):
 
637
        self.failUnlessEqual('XRI', discover.discover('xri://=something'))
 
638
 
 
639
    def test_xriChar(self):
 
640
        self.failUnlessEqual('XRI', discover.discover('=something'))
 
641
 
 
642
class TestEndpointSupportsType(unittest.TestCase):
 
643
    def setUp(self):
 
644
        self.endpoint = discover.OpenIDServiceEndpoint()
 
645
 
 
646
    def failUnlessSupportsOnly(self, *types):
 
647
        for t in [
 
648
            'foo',
 
649
            discover.OPENID_1_1_TYPE,
 
650
            discover.OPENID_1_0_TYPE,
 
651
            discover.OPENID_2_0_TYPE,
 
652
            discover.OPENID_IDP_2_0_TYPE,
 
653
            ]:
 
654
            if t in types:
 
655
                self.failUnless(self.endpoint.supportsType(t),
 
656
                                "Must support %r" % (t,))
 
657
            else:
 
658
                self.failIf(self.endpoint.supportsType(t),
 
659
                            "Shouldn't support %r" % (t,))
 
660
 
 
661
    def test_supportsNothing(self):
 
662
        self.failUnlessSupportsOnly()
 
663
 
 
664
    def test_openid2(self):
 
665
        self.endpoint.type_uris = [discover.OPENID_2_0_TYPE]
 
666
        self.failUnlessSupportsOnly(discover.OPENID_2_0_TYPE)
 
667
 
 
668
    def test_openid2provider(self):
 
669
        self.endpoint.type_uris = [discover.OPENID_IDP_2_0_TYPE]
 
670
        self.failUnlessSupportsOnly(discover.OPENID_IDP_2_0_TYPE,
 
671
                                    discover.OPENID_2_0_TYPE)
 
672
 
 
673
    def test_openid1_0(self):
 
674
        self.endpoint.type_uris = [discover.OPENID_1_0_TYPE]
 
675
        self.failUnlessSupportsOnly(discover.OPENID_1_0_TYPE)
 
676
 
 
677
    def test_openid1_1(self):
 
678
        self.endpoint.type_uris = [discover.OPENID_1_1_TYPE]
 
679
        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE)
 
680
 
 
681
    def test_multiple(self):
 
682
        self.endpoint.type_uris = [discover.OPENID_1_1_TYPE,
 
683
                                   discover.OPENID_2_0_TYPE]
 
684
        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE,
 
685
                                    discover.OPENID_2_0_TYPE)
 
686
 
 
687
    def test_multipleWithProvider(self):
 
688
        self.endpoint.type_uris = [discover.OPENID_1_1_TYPE,
 
689
                                   discover.OPENID_2_0_TYPE,
 
690
                                   discover.OPENID_IDP_2_0_TYPE]
 
691
        self.failUnlessSupportsOnly(discover.OPENID_1_1_TYPE,
 
692
                                    discover.OPENID_2_0_TYPE,
 
693
                                    discover.OPENID_IDP_2_0_TYPE,
 
694
                                    )
435
695
 
436
696
def pyUnitTests():
437
697
    return datadriven.loadTests(__name__)