def testAddingProtocol(self):
f = ErrorRaisingFetcher(RuntimeError())
fetchers.setDefaultFetcher(f, wrap_exceptions=False)
try:
discover.discover('users.stompy.janrain.com:8000/x')
except DiscoveryFailure, why:
self.fail('failed to parse url with port correctly')
def testAddingProtocol(self):
f = ErrorRaisingFetcher(RuntimeError())
fetchers.setDefaultFetcher(f, wrap_exceptions=False)
try:
discover.discover('users.stompy.janrain.com:8000/x')
except DiscoveryFailure, why:
self.fail('failed to parse url with port correctly')
def runOneTest(self):
expected_status = self.responses[-1].status
try:
discover.discover(self.url)
except DiscoveryFailure as why:
self.assertEqual(why.http_response.status, expected_status)
else:
self.fail('Did not raise DiscoveryFailure')
def runOneTest(self):
expected_status = self.responses[-1].status
try:
discover.discover(self.url)
except DiscoveryFailure as why:
self.assertEqual(why.http_response.status, expected_status)
else:
self.fail('Did not raise DiscoveryFailure')
def runOneTest(self):
try:
discover.discover('http://doesnt.matter/')
except:
exc = sys.exc_info()[1]
if exc is None:
# str exception
self.assertTrue(self.exc is sys.exc_info()[0])
else:
self.assertTrue(self.exc is exc, exc)
else:
self.fail('Expected %r', self.exc)
def runOneTest(self):
try:
discover.discover('http://doesnt.matter/')
except:
exc = sys.exc_info()[1]
if exc is None:
# str exception
self.assertTrue(self.exc is sys.exc_info()[0])
else:
self.assertTrue(self.exc is exc, exc)
else:
self.fail('Expected %r', self.exc)
def test_emptyList(self):
self.fetcher.documents = {
self.id_url: ('application/xrds+xml', yadis_0entries),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failIf(services)
def test_noOpenID(self):
self.fetcher.documents = {
self.id_url: ('text/plain', "junk"),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failIf(len(services))
def __init__(self, request, domain):
GAEMultiAuthMixin.__init__(self, request)
self.domain = domain
xrds_url = "https://www.google.com/accounts/o8/site-xrds?hd=%s" % domain
try:
from openid.consumer import discover
d = discover.discover(xrds_url)
self.set_endpoint(d[1][0].server_url)
except Exception:
self.set_endpoint("https://www.google.com/a/%s/o8/ud?be=o8" % domain)
def _discover(self, content_type, data,
expected_services, expected_id=None):
if expected_id is None:
expected_id = self.id_url
self.documents[self.id_url] = (content_type, data)
id_url, services = discover.discover(self.id_url)
self.assertEqual(expected_services, len(services))
self.assertEqual(expected_id, id_url)
return services
def discover_extensions(openid_url):
service = discover(openid_url)
use_ax = False
use_sreg = False
for endpoint in service[1]:
if not use_sreg:
use_sreg = sreg.supportsSReg(endpoint)
if not use_ax:
use_ax = endpoint.usesExtension("http://openid.net/srv/ax/1.0")
if use_ax and use_sreg: break
return use_ax, use_sreg
def discover_extensions(openid_url):
service = discover(openid_url)
use_ax = False
use_sreg = False
for endpoint in service[1]:
if not use_sreg:
use_sreg = sreg.supportsSReg(endpoint)
if not use_ax:
use_ax = endpoint.usesExtension("http://openid.net/srv/ax/1.0")
if use_ax and use_sreg: break
return use_ax, use_sreg
def __init__(self, request, domain):
GAEMultiAuthMixin.__init__(self, request)
self.domain = domain
xrds_url = "https://www.google.com/accounts/o8/site-xrds?hd=%s" % domain
try:
from openid.consumer import discover
d = discover.discover(xrds_url)
self.set_endpoint(d[1][0].server_url)
except Exception:
self.set_endpoint("https://www.google.com/a/%s/o8/ud?be=o8" % domain)
def test_noYadis(self):
self.documents[self.id_url] = ('text/html', openid_html)
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failUnlessEqual(len(services), 1,
"More than one service in %r" % (services,))
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self.failUnlessEqual(services[0].delegate,
"http://smoker.myopenid.com/")
self.failUnlessEqual(services[0].identity_url, self.id_url)
self._notUsedYadis(services[0])
def test_emptyListWithLegacy(self):
self.fetcher.documents = {
self.id_url: ('text/html', openid_and_yadis_html),
self.id_url + 'xrds': ('application/xrds+xml', yadis_0entries),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failUnlessEqual(len(services), 1,
"Not one service in %r" % (services,))
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self.failUnlessEqual(services[0].identity_url, self.id_url)
self._notUsedYadis(services[0])
def _discover(self,
content_type,
data,
expected_service_count,
expected_id=None):
if expected_id is None:
expected_id = self.id_url
self.documents[self.id_url] = (content_type, data)
id_url, services = discover.discover(self.id_url)
self.assertEqual(expected_service_count, len(services))
self.assertEqual(expected_id, id_url)
return services
def test_yadisNoDelegate(self):
self.fetcher.documents = {
self.id_url: ('application/xrds+xml', yadis_no_delegate),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failUnlessEqual(len(services), 1,
"Not 1 service in %r" % (services,))
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self.failUnless(services[0].delegate is None,
'Delegate should be None. Got %r' %
(services[0].delegate,))
self._usedYadis(services[0])
def test_openidNoDelegate(self):
self.fetcher.documents = {
self.id_url: ('text/html', openid_html_no_delegate),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self.failUnlessEqual(services[0].identity_url, self.id_url)
self.failUnless(services[0].delegate is None,
'Delegate should be None. Got %r' %
(services[0].delegate,))
self._notUsedYadis(services[0])
def test_yadis(self):
self.fetcher.documents = {
BaseTestDiscovery.id_url: ('application/xrds+xml', yadis_2entries),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(self.id_url, id_url)
self.failUnlessEqual(len(services), 2,
"Not 2 services in %r" % (services,))
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self._usedYadis(services[0])
self.failUnlessEqual(services[1].server_url,
"http://www.livejournal.com/openid/server.bml")
self._usedYadis(services[1])
def test_redirect(self):
expected_final_url = "http://elsewhere.unittest/"
self.fetcher.redirect = expected_final_url
self.fetcher.documents = {
self.id_url: ('text/html', openid_html),
}
id_url, services = discover.discover(self.id_url)
self.failUnlessEqual(expected_final_url, id_url)
self.failUnlessEqual(len(services), 1,
"More than one service in %r" % (services,))
self.failUnlessEqual(services[0].server_url,
"http://www.myopenid.com/server")
self.failUnlessEqual(services[0].delegate,
"http://smoker.myopenid.com/")
self.failUnlessEqual(services[0].identity_url, expected_final_url)
self._notUsedYadis(services[0])
def print_endpoints(url, yadis=True):
"""Print the OpenID services found through YADIS discovery."""
if not yadis:
claimed_id, services = discoverNoYadis(url)
else:
claimed_id, services = discover(url)
print 'Claimed ID:', claimed_id
print '----'
if not services:
print 'No services discovered'
for service in services:
print 'Local ID:', service.getLocalID()
print 'Server URL:', service.server_url
print 'Supports:'
for type_uri in service.type_uris:
print ' ' + type_uri
print '----'
def get_endpoints(self, url='/', yadis=True):
"""Print the OpenID services found through YADIS discovery."""
if not url.startswith('http'):
url = self.base_url + url
if not yadis:
claimed_id, services = discoverNoYadis(url)
else:
claimed_id, services = discover(url)
endpoints = []
for s in services:
endpoints.append({
'local_id': s.getLocalID(),
'server_url': s.server_url,
'supports': [t for t in s.type_uris]
})
return {
'claimed_id': claimed_id,
'endpoints': endpoints,
}
def test_html1Fragment(self):
"""Ensure that the Claimed Identifier does not have a fragment
if one is supplied in the User Input."""
content_type = 'text/html'
data = readDataFile('openid.html')
expected_service_count = 1
self.documents[self.id_url] = (content_type, data)
expected_id = self.id_url
self.id_url = self.id_url + '#fragment'
id_url, services = discover.discover(self.id_url)
self.assertEqual(expected_service_count, len(services))
self.assertEqual(expected_id, id_url)
self._checkService(
services[0],
used_yadis=False,
types=['1.1'],
server_url="http://www.myopenid.com/server",
claimed_id=expected_id,
local_id='http://smoker.myopenid.com/',
display_identifier=expected_id, )
def test_html1Fragment(self):
"""Ensure that the Claimed Identifier does not have a fragment
if one is supplied in the User Input."""
content_type = 'text/html'
data = readDataFile('openid.html')
expected_service_count = 1
self.documents[self.id_url] = (content_type, data)
expected_id = self.id_url
self.id_url = self.id_url + '#fragment'
id_url, services = discover.discover(self.id_url)
self.assertEqual(expected_service_count, len(services))
self.assertEqual(expected_id, id_url)
self._checkService(
services[0],
used_yadis=False,
types=['1.1'],
server_url="http://www.myopenid.com/server",
claimed_id=expected_id,
local_id='http://smoker.myopenid.com/',
display_identifier=expected_id,
)
def runOneTest(self, url, expected_status):
with self.assertRaises(DiscoveryFailure) as catch:
discover.discover(url)
self.assertEqual(catch.exception.http_response.status, expected_status)
def test_xriChar(self):
self.failUnlessEqual('XRI', discover.discover('=something'))
def test_xri(self):
self.failUnlessEqual('XRI', discover.discover('xri://=something'))
def test_xri(self):
self.failUnlessEqual('XRI', discover.discover('xri://=something'))
def test_xriChar(self):
self.assertEqual('XRI', discover.discover('=something'))
def test_uriForBogus(self):
self.assertEqual('URI', discover.discover('not a URL or XRI'))
val = getattr(service, attr, None)
if val is not None:
print " %s: %s" % (name, val)
print " Type URIs:"
for type_uri in service.type_uris:
print " *", type_uri
print
else:
print " No OpenID services found"
print
if __name__ == "__main__":
import sys
for user_input in sys.argv[1:]:
print "=" * 50
print "Running discovery on", user_input
try:
normalized, services = discover(user_input)
except DiscoveryFailure, why:
print "Discovery failed:", why
print
except HTTPFetchingError, why:
print "HTTP request failed:", why
print
else:
show_services(user_input, normalized, services)
def runOneTest(self):
expected_status = self.responses[-1].status
try:
discover.discover(self.url)
except DiscoveryFailure, why:
self.failUnlessEqual(why.http_response.status, expected_status)
def test_uri(self):
self.failUnlessEqual('URI', discover.discover('http://woo!'))
def runOneTest(self, url, expected_status):
with self.assertRaises(DiscoveryFailure) as catch:
discover.discover(url)
self.assertEqual(catch.exception.http_response.status, expected_status)
def test_xri(self):
self.assertEqual('XRI', discover.discover('xri://=something'))
def test_uriForBogus(self):
self.assertEqual('URI', discover.discover('not a URL or XRI'))
def test_uri(self):
self.assertEqual('URI', discover.discover('http://woo!'))
def test_uriForBogus(self):
self.failUnlessEqual('URI', discover.discover('not a URL or XRI'))
def runOneTest(self, exc):
with self.assertRaises(Exception) as catch:
discover.discover('http://doesnt.matter/')
self.assertEqual(catch.exception, exc)
def runOneTest(self, exc):
with self.assertRaises(Exception) as catch:
discover.discover('http://doesnt.matter/')
self.assertEqual(catch.exception, exc)
def runOneTest(self):
expected_status = self.responses[-1].status
try:
discover.discover(self.url)
except DiscoveryFailure, why:
self.failUnlessEqual(why.http_response.status, expected_status)
def test_uri(self):
self.assertEqual('URI', discover.discover('http://woo!'))
def test_uri(self):
self.failUnlessEqual('URI', discover.discover('http://woo!'))
def test_xri(self):
self.assertEqual('XRI', discover.discover('xri://=something'))
def test_uriForBogus(self):
self.failUnlessEqual('URI', discover.discover('not a URL or XRI'))
def test_xriChar(self):
self.assertEqual('XRI', discover.discover('=something'))
def test_xriChar(self):
self.failUnlessEqual('XRI', discover.discover('=something'))