def make_response_ax(self,
schema="http://axschema.org/",
fullname="Some User",
nickname="someuser",
email="*****@*****.**",
first=None,
last=None,
verified=False):
endpoint = OpenIDServiceEndpoint()
message = Message(OPENID2_NS)
attributes = [("nickname", schema + "namePerson/friendly", nickname),
("fullname", schema + "namePerson", fullname),
("email", schema + "contact/email", email),
("account_verified",
"http://ns.login.ubuntu.com/2013/validation/account",
"token_via_email" if verified else "no")]
if first:
attributes.append(
("first", "http://axschema.org/namePerson/first", first))
if last:
attributes.append(
("last", "http://axschema.org/namePerson/last", last))
message.setArg(AX_NS, "mode", "fetch_response")
for (alias, uri, value) in attributes:
message.setArg(AX_NS, "type.%s" % alias, uri)
message.setArg(AX_NS, "value.%s" % alias, value)
return SuccessResponse(endpoint,
message,
signed_fields=message.toPostArgs().keys())
def __init__(self, status, identity_url):
self.status = status
self.identity_url = identity_url
self.message = message.Message()
sig_ext = SignatureVerification(consumer_key='CKEY',
secret_key='SKEY',
request_token='token',
hmac=None,
timestamp=None)
sig_ext.toMessage(self.message)
sreg_ext = SRegRequest(
required=['nickname', 'email'],
optional=['fullname'],
policy_url=None,
sreg_ns_uri='http://openid.net/extensions/sreg/1.1')
sreg_ext.toMessage(self.message)
self.signed_fields = [
'openid.sreg.nickname', 'openid.sreg.email',
'openid.sreg.required', 'openid.sreg.optional',
'openid.sreg.fullname'
]
self.endpoint = OpenIDServiceEndpoint()
self.endpoint.claimed_id = identity_url
def setUp(self):
CatchLogs.setUp(self)
self.consumer = ErrorRaisingConsumer(store=None)
self.endpoint = OpenIDServiceEndpoint()
self.endpoint.type_uris = [OPENID_2_0_TYPE]
self.endpoint.server_url = 'bogus'
def v1endpoint(self, port):
"""Return an OpenID 1.1 OpenIDServiceEndpoint for the server."""
base = "http://%s:%s" % (socket.getfqdn('127.0.0.1'), port)
ep = OpenIDServiceEndpoint()
ep.claimed_id = base + "/id/bob"
ep.server_url = base + "/openidserver"
ep.type_uris = [OPENID_1_1_TYPE]
return ep
def test_openidserviceendpoint(self):
self.assertEqual(
json.loads(JSONEncoder().encode({'k': OpenIDServiceEndpoint()})),
{"k": {
"type_uris": [], "claimed_id": None, "canonicalID": None,
"__class__": "OpenIDServiceEndpoint", "used_yadis": False,
"server_url": None, "local_id": None, "display_identifier": None,
}}
)
def create_sreg_response(self, fullname='', email='', identifier=''):
message = Message(OPENID2_NS)
message.setArg(SREG_NS, "fullname", fullname)
message.setArg(SREG_NS, "email", email)
endpoint = OpenIDServiceEndpoint()
endpoint.display_identifier = identifier
return SuccessResponse(endpoint,
message,
signed_fields=message.toPostArgs().keys())
def _object_hook(self, d):
cls_name = d.pop('__class__', None)
if cls_name in ('OpenID', 'YadisServiceManager'):
return globals()[cls_name](**d)
elif cls_name == 'OpenIDServiceEndpoint':
endpoint = OpenIDServiceEndpoint()
for k, v in d.items():
setattr(endpoint, k, v)
return endpoint
return d
def test_extract_user_details_sreg(self):
endpoint = OpenIDServiceEndpoint()
message = Message(OPENID2_NS)
message.setArg(SREG_NS, "nickname", "someuser")
message.setArg(SREG_NS, "fullname", "Some User")
message.setArg(SREG_NS, "email", "*****@*****.**")
response = SuccessResponse(
endpoint, message, signed_fields=message.toPostArgs().keys())
data = self.backend._extract_user_details(response)
self.assertEqual(data, {"nickname": "someuser",
"first_name": "Some",
"last_name": "User",
"email": "*****@*****.**"})
def make_openid_response(self, sreg_args=None, teams_args=None):
endpoint = OpenIDServiceEndpoint()
endpoint.claimed_id = 'some-id'
message = Message(OPENID2_NS)
if sreg_args is not None:
for key, value in sreg_args.items():
message.setArg(SREG_NS, key, value)
if teams_args is not None:
for key, value in teams_args.items():
message.setArg(TEAMS_NS, key, value)
response = SuccessResponse(endpoint,
message,
signed_fields=message.toPostArgs().keys())
return response
def test_extract_user_details_ax(self):
endpoint = OpenIDServiceEndpoint()
message = Message(OPENID2_NS)
attributes = [
("nickname", "http://axschema.org/namePerson/friendly", "someuser"),
("fullname", "http://axschema.org/namePerson", "Some User"),
("email", "http://axschema.org/contact/email", "*****@*****.**"),
]
message.setArg(AX_NS, "mode", "fetch_response")
for (alias, uri, value) in attributes:
message.setArg(AX_NS, "type.%s" % alias, uri)
message.setArg(AX_NS, "value.%s" % alias, value)
response = SuccessResponse(
endpoint, message, signed_fields=message.toPostArgs().keys())
data = self.backend._extract_user_details(response)
self.assertEqual(data, {"nickname": "someuser",
"first_name": "Some",
"last_name": "User",
"email": "*****@*****.**"})
def setUp(self):
self.consumer = ErrorRaisingConsumer(store=None)
self.endpoint = OpenIDServiceEndpoint()
self.endpoint.type_uris = [OPENID1_NS]
self.endpoint.server_url = 'bogus'
def setUp(self):
self.store = memstore.MemoryStore()
self.consumer = GenericConsumer(self.store)
self.endpoint = OpenIDServiceEndpoint()
def make_identifier_select_endpoint():
"""Create an endpoint for use in OpenID identifier select mode."""
endpoint = OpenIDServiceEndpoint()
endpoint.server_url = get_server_url()
endpoint.type_uris = [OPENID_IDP_2_0_TYPE]
return endpoint
def test_openidserviceendpoint(self):
endpoint = OpenIDServiceEndpoint()
endpoint2 = JSONSerializer().loads(JSONSerializer().dumps({'k': endpoint}))
self.assertIsInstance(endpoint2['k'], OpenIDServiceEndpoint)
def __init__(self, openid_namespace=OPENID2_NS):
super(TestMessage, self).__init__(openid_namespace=openid_namespace)
endpoint = OpenIDServiceEndpoint()
endpoint.claimed_id = make_claimed_id('some-id')
endpoint.server_url = SERVER_URL
self.endpoint = endpoint
def test_auth_setup_needed_response(self):
response = SetupNeededResponse(OpenIDServiceEndpoint())
self.assertIsNone(self.backend.authenticate(openid_response=response))
self.assert_no_users_created()
def test_auth_failure_response(self):
response = FailureResponse(OpenIDServiceEndpoint())
self.assertIsNone(self.backend.authenticate(openid_response=response))
self.assert_no_users_created()
def test_openid_request_failure_response(self):
openid_response = MockOpenIdFailureResponse(
endpoint=OpenIDServiceEndpoint())
user = self.backend.authenticate(openid_response=openid_response)
self.failUnlessEqual(user, None)
