def test_notWrapped(self):
"""Make sure that if we set a non-wrapped fetcher as default,
it will not wrap exceptions."""
# A fetcher that will raise an exception when it encounters a
# host that will not resolve
fetcher = fetchers.Urllib2Fetcher()
fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
self.failIf(isinstance(fetchers.getDefaultFetcher(),
fetchers.ExceptionWrappingFetcher))
try:
fetchers.fetch('http://invalid.janrain.com/')
except fetchers.HTTPFetchingError:
self.fail('Should not be wrapping exception')
except:
exc = sys.exc_info()[1]
self.failUnless(isinstance(exc, urllib2.URLError), exc)
pass
else:
self.fail('Should have raised an exception')
def discoverNoYadis(uri):
http_resp = fetchers.fetch(uri)
if http_resp.status != 200:
raise DiscoveryFailure(
'HTTP Response status from identity URL host is not 200. '
'Got status %r' % (http_resp.status,), http_resp)
identity_url = http_resp.final_url
# Try to parse the response as HTML to get OpenID 1.0/1.1
# <link rel="...">
try:
service = OpenIDServiceEndpoint.fromHTML(identity_url, http_resp.body)
except ParseError:
openid_services = []
else:
openid_services = [service]
return identity_url, openid_services
def query(self, xri, service_types):
"""Resolve some services for an XRI.
Note: I don't implement any service endpoint selection beyond what
the resolver I'm querying does, so the Services I return may well
include Services that were not of the types you asked for.
May raise fetchers.HTTPFetchingError or L{etxrd.XRDError} if
the fetching or parsing don't go so well.
@param xri: An XRI to resolve.
@type xri: unicode
@param service_types: A list of services types to query for. Service
types are URIs.
@type service_types: list of str
@returns: tuple of (CanonicalID, Service elements)
@returntype: (unicode, list of C{ElementTree.Element}s)
"""
# FIXME: No test coverage!
services = []
# Make a seperate request to the proxy resolver for each service
# type, as, if it is following Refs, it could return a different
# XRDS for each.
for service_type in service_types:
url = self.queryURL(xri, service_type)
response = fetchers.fetch(url)
if response.status != 200:
# XXX: sucks to fail silently.
# print "response not OK:", response
continue
et = etxrd.parseXRDS(response.body)
canonicalID = etxrd.getCanonicalID(xri, et)
some_services = list(iterServices(et))
services.extend(some_services)
# TODO:
# * If we do get hits for multiple service_types, we're almost
# certainly going to have duplicated service entries and
# broken priority ordering.
return canonicalID, services
def query(self, xri, service_types):
"""Resolve some services for an XRI.
Note: I don't implement any service endpoint selection beyond what
the resolver I'm querying does, so the Services I return may well
include Services that were not of the types you asked for.
May raise fetchers.HTTPFetchingError or L{etxrd.XRDError} if
the fetching or parsing don't go so well.
@param xri: An XRI to resolve.
@type xri: unicode
@param service_types: A list of services types to query for. Service
types are URIs.
@type service_types: list of str
@returns: tuple of (CanonicalID, Service elements)
@returntype: (unicode, list of C{ElementTree.Element}s)
"""
# FIXME: No test coverage!
services = []
# Make a seperate request to the proxy resolver for each service
# type, as, if it is following Refs, it could return a different
# XRDS for each.
for service_type in service_types:
url = self.queryURL(xri, service_type)
response = fetchers.fetch(url)
if response.status != 200:
# XXX: sucks to fail silently.
# print "response not OK:", response
continue
et = etxrd.parseXRDS(response.body)
canonicalID = etxrd.getCanonicalID(xri, et)
some_services = list(iterServices(et))
services.extend(some_services)
# TODO:
# * If we do get hits for multiple service_types, we're almost
# certainly going to have duplicated service entries and
# broken priority ordering.
return canonicalID, services
def _makeKVPost(self, args, server_url):
mode = args['openid.mode']
body = urllib.urlencode(args)
resp = fetchers.fetch(server_url, body=body)
if resp is None:
fmt = 'openid.mode=%s: failed to fetch URL: %s'
oidutil.log(fmt % (mode, server_url))
return None
response = kvform.kvToDict(resp.body)
if resp.status == 400:
server_error = response.get('error', '<no message from server>')
fmt = 'openid.mode=%s: error returned from server %s: %s'
oidutil.log(fmt % (mode, server_url, server_error))
return None
elif resp.status != 200:
fmt = 'openid.mode=%s: bad status code from server %s: %s'
oidutil.log(fmt % (mode, server_url, resp.status))
return None
return response
def test_callFetch(self):
"""Make sure that fetchers.fetch() uses the default fetcher
instance that was set."""
fetchers.setDefaultFetcher(FakeFetcher())
actual = fetchers.fetch('bad://url')
self.failUnless(actual is FakeFetcher.sentinel)
def discover(uri):
"""Discover services for a given URI.
@param uri: The identity URI as a well-formed http or https
URI. The well-formedness and the protocol are not checked, but
the results of this function are undefined if those properties
do not hold.
@return: DiscoveryResult object
@raises Exception: Any exception that can be raised by fetching a URL with
the given fetcher.
"""
result = DiscoveryResult(uri)
resp = fetchers.fetch(uri, headers={'Accept': YADIS_ACCEPT_HEADER})
if resp.status != 200:
raise DiscoveryFailure(
'HTTP Response status from identity URL host is not 200. '
'Got status %r' % (resp.status,), resp)
# Note the URL after following redirects
result.normalized_uri = resp.final_url
# Attempt to find out where to go to discover the document
# or if we already have it
result.content_type = resp.headers.get('content-type')
# According to the spec, the content-type header must be an exact
# match, or else we have to look for an indirection.
if (result.content_type and
result.content_type.split(';', 1)[0].lower() == YADIS_CONTENT_TYPE):
result.xrds_uri = result.normalized_uri
else:
# Try the header
yadis_loc = resp.headers.get(YADIS_HEADER_NAME.lower())
if not yadis_loc:
# Parse as HTML if the header is missing.
#
# XXX: do we want to do something with content-type, like
# have a whitelist or a blacklist (for detecting that it's
# HTML)?
try:
yadis_loc = findHTMLMeta(StringIO(resp.body))
except MetaNotFound:
pass
# At this point, we have not found a YADIS Location URL. We
# will return the content that we scanned so that the caller
# can try to treat it as an XRDS if it wishes.
if yadis_loc:
result.xrds_uri = yadis_loc
resp = fetchers.fetch(yadis_loc)
if resp.status != 200:
exc = DiscoveryFailure(
'HTTP Response status from Yadis host is not 200. '
'Got status %r' % (resp.status,), resp)
exc.identity_url = result.normalized_uri
raise exc
result.content_type = resp.headers.get('content-type')
result.response_text = resp.body
return result
def discover(uri):
"""Discover services for a given URI.
@param uri: The identity URI as a well-formed http or https
URI. The well-formedness and the protocol are not checked, but
the results of this function are undefined if those properties
do not hold.
@return: DiscoveryResult object
@raises Exception: Any exception that can be raised by fetching a URL with
the given fetcher.
"""
result = DiscoveryResult(uri)
resp = fetchers.fetch(uri, headers={'Accept': YADIS_ACCEPT_HEADER})
if resp.status != 200:
raise DiscoveryFailure(
'HTTP Response status from identity URL host is not 200. '
'Got status %r' % (resp.status, ), resp)
# Note the URL after following redirects
result.normalized_uri = resp.final_url
# Attempt to find out where to go to discover the document
# or if we already have it
result.content_type = resp.headers.get('content-type')
# According to the spec, the content-type header must be an exact
# match, or else we have to look for an indirection.
if (result.content_type and result.content_type.split(';', 1)[0].lower()
== YADIS_CONTENT_TYPE):
result.xrds_uri = result.normalized_uri
else:
# Try the header
yadis_loc = resp.headers.get(YADIS_HEADER_NAME.lower())
if not yadis_loc:
# Parse as HTML if the header is missing.
#
# XXX: do we want to do something with content-type, like
# have a whitelist or a blacklist (for detecting that it's
# HTML)?
try:
yadis_loc = findHTMLMeta(StringIO(resp.body))
except MetaNotFound:
pass
# At this point, we have not found a YADIS Location URL. We
# will return the content that we scanned so that the caller
# can try to treat it as an XRDS if it wishes.
if yadis_loc:
result.xrds_uri = yadis_loc
resp = fetchers.fetch(yadis_loc)
if resp.status != 200:
exc = DiscoveryFailure(
'HTTP Response status from Yadis host is not 200. '
'Got status %r' % (resp.status, ), resp)
exc.identity_url = result.normalized_uri
raise exc
result.content_type = resp.headers.get('content-type')
result.response_text = resp.body
return result
