async def test_baas():
async def handler(client, request):
if request.path == "/1.0.0/application/token":
assert request.encode().decode() == ACCESS_REQUEST
response = http.HTTPResponse(200)
response.json = {
"accessToken": "access.token"
}
return response
else:
assert request.encode().decode() == LOGIN_REQUEST
response = http.HTTPResponse(200)
response.json = {
"idToken": "id token"
}
return response
async with http.serve(handler, "127.0.0.1", 12345):
client = baas.BAASClient()
client.set_url("127.0.0.1:12345")
client.set_system_version(1200)
client.set_context(None)
response = await client.authenticate("device.token")
token = response["accessToken"]
response = await client.login(
0x1234567890abcdef, "a" * 40, token, "app.token"
)
assert response["idToken"] == "id token"
async def test_dauth_1200():
async def handler(client, request):
if request.path == "/v6/challenge":
assert request.encode().decode() == CHALLENGE_REQUEST_1200
response = http.HTTPResponse(200)
response.json = {
"challenge": "vaNgVZZH7gUse0y3t8Cksuln-TAVtvBmcD-ow59qp0E=",
"data": "dlL7ZBNSLmYo1hUlKYZiUA=="
}
return response
else:
assert request.encode().decode() == TOKEN_REQUEST_1200
response = http.HTTPResponse(200)
response.json = {"device_auth_token": "device token"}
return response
async with http.serve(handler, "127.0.0.1", 12345):
keys = switch.KeySet()
keys["aes_kek_generation_source"] = bytes.fromhex(
"485d45ad27c07c7e538c0183f90ee845")
keys["master_key_0a"] = bytes.fromhex(
"37eed242e0f2ce6f8371e783c1a6a0ae")
client = dauth.DAuthClient(keys)
client.set_url("127.0.0.1:12345")
client.set_system_version(1200)
client.set_context(None)
response = await client.device_token(client.BAAS)
token = response["device_auth_token"]
assert token == "device token"
async def test_dauth_1300():
async def handler(client, request):
if request.path == "/v7/challenge":
assert request.encode().decode() == CHALLENGE_REQUEST_1300
response = http.HTTPResponse(200)
response.json = {
"challenge": "TzJ0EB3EvsWvQI5aPj15uaNVH9paGdsWB4l-eI5uzW0=",
"data": "4SxW91vqVg6pz4CXMH2Ouw=="
}
return response
else:
assert request.encode().decode() == TOKEN_REQUEST_1300
response = http.HTTPResponse(200)
response.json = {"device_auth_token": "device token"}
return response
async with http.serve(handler, "127.0.0.1", 12345):
keys = switch.KeySet()
keys["aes_kek_generation_source"] = bytes.fromhex(
"cae2728f56af642d5d59dfc23bd314a2")
keys["master_key_0c"] = bytes.fromhex(
"f1642c98bddb5850eb23d0cebab7dc05")
client = dauth.DAuthClient(keys)
client.set_url("127.0.0.1:12345")
client.set_system_version(1300)
client.set_context(None)
response = await client.device_token(client.BAAS)
token = response["device_auth_token"]
assert token == "device token"
async def test_exception(self):
async def handler(client, request):
raise ValueError("Oops")
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345")
assert response.status_code == 500
assert response.status_name == "Internal Server Error"
async def test_json(self):
async def handler(client, request):
response = http.HTTPResponse(200)
response.json = {"result": request.json["value"]}
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345", json={"value": True})
assert response.json["result"] is True
async def test_ok(self):
async def handler(client, request):
assert request.method == "GET"
assert request.path == "/test/ok"
response = http.HTTPResponse(200)
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345/test/ok")
assert response.success()
async def test_text(self):
async def handler(client, request):
assert request.body == b"Hello"
response = http.HTTPResponse(200)
response.text = request.text.upper()
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345", text="Hello")
assert response.text == "HELLO"
async def test_rawform(self):
async def handler(client, request):
response = http.HTTPResponse(200)
response.rawform = {"$<result>": request.rawform["value+!"]}
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345",
rawform={"value+!": "???"})
assert response.rawform["$<result>"] == "???"
async def test_files(self):
async def handler(client, request):
response = http.HTTPResponse(200)
response.files = {"response": request.files["filename"]}
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345",
boundary="TEST",
files={"filename": b"content"})
assert response.files == {"response": b"content"}
async def test_body(self):
async def handler(client, request):
assert request.body == b"abcdef"
response = http.HTTPResponse(200)
response.body = request.body[::-1]
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345", body=b"abcdef")
assert response.success()
assert response.body == b"fedcba"
async def test_headers(self):
async def handler(client, request):
assert request.headers["X-Header-1"] == "test1"
assert request.headers["X-Header-2"] == "test2"
return http.HTTPResponse(200)
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345",
headers={
"X-Header-1": "test1",
"X-Header-2": "test2"
})
assert response.success()
async def test_continue(self):
async def handler(client, request):
response = http.HTTPResponse(200)
response.body = request.body
return response
async with http.serve(handler, "localhost", 12345):
request = http.HTTPRequest()
request.continue_threshold = 64
request.body = b"a" * 80
response = await http.request("localhost:12345", request)
assert response.body == b"a" * 80
async def test_request(self):
async def handler(client, request):
assert request.path == "/path"
response = http.HTTPResponse(200)
response.body = request.body
return response
async with http.serve(handler, "localhost", 12345):
request = http.HTTPRequest()
request.body = b"test"
request.path = "/path"
response = await http.request("localhost:12345", request)
assert response.body == b"test"
async def test_xml(self):
async def handler(client, request):
assert request.xml.name == "value"
tree = xml.XMLTree("result")
tree.text = request.xml.text
response = http.HTTPResponse(200)
response.xml = tree
return response
async with http.serve(handler, "localhost", 12345):
tree = xml.XMLTree("value")
tree.text = "12345"
response = await http.get("localhost:12345", xml=tree)
assert response.xml.name == "result"
assert response.xml.text == "12345"
async def test_aauth():
async def handler(client, request):
text = request.encode().decode()
assert text.startswith(EXPECTED_REQUEST)
assert text[1378:1388] == "&cert_key="
response = http.HTTPResponse(200)
response.json = {"application_auth_token": "application token"}
return response
async with http.serve(handler, "127.0.0.1", 12345):
client = aauth.AAuthClient()
client.set_url("127.0.0.1:12345")
client.set_context(None)
response = await client.auth_digital(0x0100123001234000, 0x70000,
"device.token", CERT)
assert response["application_auth_token"] == "application token"
async def test_status(self):
async def handler(client, request):
status = int(request.headers["X-Status-Code"])
return http.HTTPResponse(status)
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345",
headers={"X-Status-Code": 404})
assert response.status_code == 404
assert response.status_name == "Not Found"
assert response.error()
response = await http.get("localhost:12345",
headers={"X-Status-Code": 678})
assert response.status_code == 678
assert response.status_name == "Unknown"
assert response.error()
async def test_methods(self):
async def handler(client, request):
response = http.HTTPResponse(200)
response.text = request.method
return response
async with http.serve(handler, "localhost", 12345):
response = await http.get("localhost:12345")
assert response.text == "GET"
response = await http.post("localhost:12345")
assert response.text == "POST"
response = await http.put("localhost:12345")
assert response.text == "PUT"
response = await http.patch("localhost:12345")
assert response.text == "PATCH"
response = await http.delete("localhost:12345")
assert response.text == "DELETE"
async def test_certificate(self):
# Create a self signed server certificate
serverkey = tls.TLSPrivateKey.generate()
servercert = tls.TLSCertificate.generate(serverkey)
servercert.subject["CN"] = "localhost"
servercert.issuer["CN"] = "localhost"
servercert.sign(serverkey)
# Create a certificate authority for the client certificate
authoritykey = tls.TLSPrivateKey.generate()
authoritycert = tls.TLSCertificate.generate(authoritykey)
authoritycert.subject["CN"] = "authority"
authoritycert.issuer["CN"] = "authority"
authoritycert.sign(authoritykey)
# Create a client certificate and sign it
clientkey = tls.TLSPrivateKey.generate()
clientcert = tls.TLSCertificate.generate(clientkey)
clientcert.subject["CN"] = "testclient"
clientcert.issuer["CN"] = "authority"
clientcert.sign(authoritykey)
# Create TLS context for the server
servercontext = tls.TLSContext()
servercontext.set_certificate(servercert, serverkey)
servercontext.set_authority(authoritycert)
clientcontext = tls.TLSContext()
clientcontext.set_certificate(clientcert, clientkey)
clientcontext.set_authority(servercert)
async def handler(client, request):
cert = client.remote_certificate()
assert cert.subject["CN"] == "testclient"
return http.HTTPResponse(200)
async with http.serve(handler, "localhost", 12345, servercontext):
response = await http.get("localhost:12345", context=clientcontext)
assert response.success()
async def serve(host, port, context, clients, matchmaker):
dashboard = Dashboard(clients, matchmaker)
async with http.serve(dashboard.handle, host, port, context):
yield
