def test_endpointWithoutLocalID(self):
# An endpoint like this with no local_id is generated as a result of
# e.g. Yadis discovery with no LocalID tag.
endpoint = discover.OpenIDServiceEndpoint()
endpoint.server_url = "http://localhost:8000/openidserver"
endpoint.claimed_id = "http://localhost:8000/id/id-jo"
to_match = discover.OpenIDServiceEndpoint()
to_match.server_url = "http://localhost:8000/openidserver"
to_match.claimed_id = "http://localhost:8000/id/id-jo"
to_match.local_id = "http://localhost:8000/id/id-jo"
result = self.consumer._verifyDiscoverySingle(endpoint, to_match)
# result should always be None, raises exception on failure.
self.failUnlessEqual(result, None)
self.failUnlessLogEmpty()
def test_endpointWithoutLocalID(self):
# An endpoint like this with no local_id is generated as a result of
# e.g. Yadis discovery with no LocalID tag.
endpoint = discover.OpenIDServiceEndpoint()
endpoint.server_url = "http://localhost:8000/openidserver"
endpoint.claimed_id = "http://localhost:8000/id/id-jo"
to_match = discover.OpenIDServiceEndpoint()
to_match.server_url = "http://localhost:8000/openidserver"
to_match.claimed_id = "http://localhost:8000/id/id-jo"
to_match.local_id = "http://localhost:8000/id/id-jo"
with LogCapture() as logbook:
result = self.consumer._verifyDiscoverySingle(endpoint, to_match)
# result should always be None, raises exception on failure.
self.assertIsNone(result)
self.assertEqual(logbook.records, [])
def test_openid1Fallback1_0(self):
claimed_id = 'http://claimed.id/'
endpoint = None
resp_mesg = message.Message.fromOpenIDArgs({
'ns': message.OPENID1_NS,
'identity': claimed_id
})
# Pass the OpenID 1 claimed_id this way since we're passing
# None for the endpoint.
resp_mesg.setArg(message.BARE_NS, 'openid1_claimed_id', claimed_id)
# We expect the OpenID 1 discovery verification to try
# matching the discovered endpoint against the 1.1 type and
# fall back to 1.0.
expected_endpoint = discover.OpenIDServiceEndpoint()
expected_endpoint.type_uris = [discover.OPENID_1_0_TYPE]
expected_endpoint.local_id = None
expected_endpoint.claimed_id = claimed_id
discovered_services = [expected_endpoint]
self.consumer._discover = lambda *args: ('unused', discovered_services)
actual_endpoint = self.consumer._verifyDiscoveryResults(
resp_mesg, endpoint)
self.failUnless(actual_endpoint is expected_endpoint)
def test_openid2UsePreDiscoveredWrongType(self):
text = "verify failed"
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_1_1_TYPE]
def discoverAndVerify(claimed_id, to_match_endpoints):
self.failUnlessEqual(claimed_id, endpoint.claimed_id)
for to_match in to_match_endpoints:
self.failUnlessEqual(claimed_id, to_match.claimed_id)
raise consumer.ProtocolError(text)
self.consumer._discoverAndVerify = discoverAndVerify
msg = message.Message.fromOpenIDArgs({
'ns': message.OPENID2_NS,
'identity': endpoint.local_id,
'claimed_id': endpoint.claimed_id,
'op_endpoint': endpoint.server_url
})
try:
r = self.consumer._verifyDiscoveryResults(msg, endpoint)
except consumer.ProtocolError, e:
# Should we make more ProtocolError subclasses?
self.failUnless(str(e), text)
def test_openid1UsePreDiscoveredWrongType(self):
class VerifiedError(Exception):
pass
def discoverAndVerify(claimed_id, _to_match):
raise VerifiedError
self.consumer._discoverAndVerify = discoverAndVerify
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_2_0_TYPE]
msg = message.Message.fromOpenIDArgs({
'ns': message.OPENID1_NS,
'identity': endpoint.local_id
})
self.failUnlessRaises(VerifiedError,
self.consumer._verifyDiscoveryResults, msg,
endpoint)
self.failUnlessLogMatches('Error attempting to use stored',
'Attempting discovery')
def test_openid1UsePreDiscoveredWrongType(self):
class VerifiedError(Exception):
pass
def discoverAndVerify(claimed_id, _to_match):
raise VerifiedError
self.consumer._discoverAndVerify = discoverAndVerify
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_2_0_TYPE]
msg = message.Message.fromOpenIDArgs({
'ns': message.OPENID1_NS,
'identity': endpoint.local_id
})
with LogCapture() as logbook:
self.assertRaises(VerifiedError,
self.consumer._verifyDiscoveryResults, msg,
endpoint)
logbook.check(('openid.consumer.consumer', 'ERROR',
StringComparison('Error attempting to use .*')),
('openid.consumer.consumer', 'INFO',
'Attempting discovery to verify endpoint'))
def test_useCanonicalID(self):
"""When there is no delegate, the CanonicalID should be used with XRI.
"""
endpoint = discover.OpenIDServiceEndpoint()
endpoint.claimed_id = XRI("=!1000")
endpoint.canonicalID = XRI("=!1000")
self.assertEqual(endpoint.getLocalID(), XRI("=!1000"))
def test_openid2UsePreDiscoveredWrongType(self):
text = "verify failed"
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_1_1_TYPE]
def discoverAndVerify(claimed_id, to_match_endpoints):
self.assertEqual(claimed_id, endpoint.claimed_id)
for to_match in to_match_endpoints:
self.assertEqual(claimed_id, to_match.claimed_id)
raise consumer.ProtocolError(text)
self.consumer._discoverAndVerify = discoverAndVerify
msg = message.Message.fromOpenIDArgs(
{'ns': message.OPENID2_NS,
'identity': endpoint.local_id,
'claimed_id': endpoint.claimed_id,
'op_endpoint': endpoint.server_url})
with LogCapture() as logbook:
with six.assertRaisesRegex(self, consumer.ProtocolError, text):
self.consumer._verifyDiscoveryResults(msg, endpoint)
logbook.check(('openid.consumer.consumer', 'ERROR', StringComparison('Error attempting to use .*')),
('openid.consumer.consumer', 'INFO', 'Attempting discovery to verify endpoint'))
def test_openID1NoLocalID(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.claimed_id = 'bogus'
msg = message.Message.fromOpenIDArgs({})
self.failUnlessProtocolError('Missing required field openid.identity',
self.consumer._verifyDiscoveryResults,
msg, endpoint)
self.failUnlessLogEmpty()
def test_openID2MismatchedDoesDisco(self):
mismatched = discover.OpenIDServiceEndpoint()
mismatched.identity = 'nothing special, but different'
mismatched.local_id = 'green cheese'
op_endpoint = 'Phone Home'
sentinel = discover.OpenIDServiceEndpoint()
sentinel.claimed_id = 'monkeysoft'
self.consumer._discoverAndVerify = const(sentinel)
msg = message.Message.fromOpenIDArgs(
{'ns':message.OPENID2_NS,
'identity':'sour grapes',
'claimed_id':'monkeysoft',
'op_endpoint':op_endpoint})
result = self.consumer._verifyDiscoveryResults(msg, mismatched)
self.failUnlessEqual(sentinel, result)
self.failUnlessLogMatches('Error attempting to use stored',
'Attempting discovery')
def test_openID1NoLocalID(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.claimed_id = 'bogus'
msg = message.Message.fromOpenIDArgs({})
with LogCapture() as logbook:
with six.assertRaisesRegex(self, consumer.ProtocolError, 'Missing required field openid.identity'):
self.consumer._verifyDiscoveryResults(msg, endpoint)
self.assertEqual(logbook.records, [])
def test_openID2MismatchedDoesDisco(self):
mismatched = discover.OpenIDServiceEndpoint()
mismatched.identity = 'nothing special, but different'
mismatched.local_id = 'green cheese'
op_endpoint = 'Phone Home'
sentinel = discover.OpenIDServiceEndpoint()
sentinel.claimed_id = 'monkeysoft'
self.consumer._discoverAndVerify = const(sentinel)
msg = message.Message.fromOpenIDArgs(
{'ns': message.OPENID2_NS,
'identity': 'sour grapes',
'claimed_id': 'monkeysoft',
'op_endpoint': op_endpoint})
with LogCapture() as logbook:
result = self.consumer._verifyDiscoveryResults(msg, mismatched)
self.assertEqual(result, sentinel)
logbook.check(('openid.consumer.consumer', 'ERROR', StringComparison('Error attempting to use .*')),
('openid.consumer.consumer', 'INFO', 'Attempting discovery to verify endpoint'))
def test_openID2NoEndpointDoesDisco(self):
op_endpoint = 'Phone Home'
sentinel = discover.OpenIDServiceEndpoint()
sentinel.claimed_id = 'monkeysoft'
self.consumer._discoverAndVerify = const(sentinel)
msg = message.Message.fromOpenIDArgs(
{'ns':message.OPENID2_NS,
'identity':'sour grapes',
'claimed_id':'monkeysoft',
'op_endpoint':op_endpoint})
result = self.consumer._verifyDiscoveryResults(msg)
self.failUnlessEqual(sentinel, result)
self.failUnlessLogMatches('No pre-discovered')
def test_openid1UsePreDiscovered(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_1_1_TYPE]
msg = message.Message.fromOpenIDArgs(
{'ns':message.OPENID1_NS,
'identity':endpoint.local_id})
result = self.consumer._verifyDiscoveryResults(msg, endpoint)
self.failUnless(result is endpoint)
self.failUnlessLogEmpty()
def test_openid1UsePreDiscovered(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = 'i am sam'
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_1_1_TYPE]
msg = message.Message.fromOpenIDArgs(
{'ns': message.OPENID1_NS,
'identity': endpoint.local_id})
with LogCapture() as logbook:
result = self.consumer._verifyDiscoveryResults(msg, endpoint)
self.assertEqual(result, endpoint)
self.assertEqual(logbook.records, [])
def test_openID2NoEndpointDoesDisco(self):
op_endpoint = 'Phone Home'
sentinel = discover.OpenIDServiceEndpoint()
sentinel.claimed_id = 'monkeysoft'
self.consumer._discoverAndVerify = const(sentinel)
msg = message.Message.fromOpenIDArgs(
{'ns': message.OPENID2_NS,
'identity': 'sour grapes',
'claimed_id': 'monkeysoft',
'op_endpoint': op_endpoint})
with LogCapture() as logbook:
result = self.consumer._verifyDiscoveryResults(msg)
self.assertEqual(result, sentinel)
logbook.check(('openid.consumer.consumer', 'INFO', 'No pre-discovered information supplied.'))
def test_openid2Fragment(self):
claimed_id = "http://unittest.invalid/"
claimed_id_frag = claimed_id + "#fragment"
endpoint = discover.OpenIDServiceEndpoint()
endpoint.local_id = 'my identity'
endpoint.claimed_id = claimed_id
endpoint.server_url = 'Phone Home'
endpoint.type_uris = [discover.OPENID_2_0_TYPE]
msg = message.Message.fromOpenIDArgs(
{'ns': message.OPENID2_NS,
'identity': endpoint.local_id,
'claimed_id': claimed_id_frag,
'op_endpoint': endpoint.server_url})
with LogCapture() as logbook:
result = self.consumer._verifyDiscoveryResults(msg, endpoint)
self.assertEqual(result.local_id, endpoint.local_id)
self.assertEqual(result.server_url, endpoint.server_url)
self.assertEqual(result.type_uris, endpoint.type_uris)
self.assertEqual(result.claimed_id, claimed_id_frag)
self.assertEqual(logbook.records, [])
def test_strip_fragment(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.claimed_id = 'http://recycled.invalid/#123'
self.assertEqual('http://recycled.invalid/',
endpoint.getDisplayIdentifier())
def setUp(self):
self.endpoint = discover.OpenIDServiceEndpoint()
def runOneTest(self):
endpoint = discover.OpenIDServiceEndpoint()
endpoint.type_uris = self.type_uris
actual_ns = endpoint.preferredNamespace()
self.assertEqual(actual_ns, self.expected_ns)
def test(self):
for expected_ns, type_uris in self.cases:
endpoint = discover.OpenIDServiceEndpoint()
endpoint.type_uris = type_uris
actual_ns = endpoint.preferredNamespace()
self.assertEqual(actual_ns, expected_ns)
