117 lines
4.7 KiB
Python
117 lines
4.7 KiB
Python
import asyncio
|
||
import contextlib
|
||
import json
|
||
import socket
|
||
|
||
import fakeredis.aioredis
|
||
import httpx
|
||
import pytest_asyncio
|
||
import uvicorn
|
||
|
||
from relay.cli import device_request, init_project, issue
|
||
from relay.config import Settings
|
||
from relay.connector import create_app as connector_app
|
||
from relay.router import create_app as router_app
|
||
|
||
|
||
class PlatformStub:
|
||
def __init__(self):
|
||
self.replies = []
|
||
self.exchanges = 0
|
||
self.refreshes = 0
|
||
|
||
async def exchange(self, code):
|
||
self.exchanges += 1
|
||
await asyncio.sleep(0.01)
|
||
return {"user_access_token": "fake-user-token", "refresh_token": "fake-refresh-token",
|
||
"expires_in": 6900, "refresh_expires_in": 2592000, "open_id": "ou_test"}
|
||
|
||
async def refresh(self, token):
|
||
self.refreshes += 1
|
||
await asyncio.sleep(0.01)
|
||
return {"user_access_token": "new-fake-token", "refresh_token": "rotated-fake-token",
|
||
"expires_in": 7200, "open_id": "ou_test"}
|
||
|
||
async def user_info(self, token):
|
||
return {"open_id": "ou_test"}
|
||
|
||
async def reply(self, message, text):
|
||
self.replies.append((message, text))
|
||
|
||
async def close(self):
|
||
pass
|
||
|
||
|
||
async def serve(app):
|
||
sock = socket.socket()
|
||
sock.bind(("127.0.0.1", 0))
|
||
sock.listen(128)
|
||
port = sock.getsockname()[1]
|
||
server = uvicorn.Server(uvicorn.Config(app, log_level="critical", access_log=False, lifespan="on"))
|
||
task = asyncio.create_task(server.serve(sockets=[sock]))
|
||
for _ in range(200):
|
||
if server.started:
|
||
return server, task, port
|
||
if task.done():
|
||
task.result()
|
||
raise RuntimeError("server failed")
|
||
await asyncio.sleep(0.01)
|
||
raise RuntimeError("server startup timeout")
|
||
|
||
|
||
@pytest_asyncio.fixture
|
||
async def env(tmp_path):
|
||
init_project(tmp_path, "localhost")
|
||
settings = Settings(environment="test", admin_secret="a" * 40, internal_secret="b" * 40,
|
||
data_dir=tmp_path / "runtime/connector", ca_cert=tmp_path / "runtime/trust/ca.pem",
|
||
connector_key=tmp_path / "runtime/connector/connector.key",
|
||
connector_public_key=tmp_path / "runtime/trust/connector.pub",
|
||
feishu_enabled=True, feishu_app_id="cli_test", feishu_app_secret="fake-app-secret",
|
||
feishu_encrypt_key="fake-encrypt-key", feishu_verification_token="fake-verification",
|
||
public_url="http://localhost", router_url="ws://localhost/device/ws", request_timeout=2)
|
||
redis = fakeredis.aioredis.FakeRedis(decode_responses=True)
|
||
platform = PlatformStub()
|
||
connector = connector_app(settings, redis=redis, platform=platform)
|
||
router = router_app(settings, redis=redis)
|
||
cs, ct, cp = await serve(connector)
|
||
rs, rt, rp = await serve(router)
|
||
client = httpx.AsyncClient(base_url=f"http://127.0.0.1:{cp}", timeout=10)
|
||
state = {"settings": settings, "redis": redis, "platform": platform, "connector": connector,
|
||
"router": router, "client": client, "root": tmp_path,
|
||
"connector_url": f"http://127.0.0.1:{cp}", "router_url": f"ws://127.0.0.1:{rp}/device/ws",
|
||
"admin": {"X-Admin-Secret": settings.admin_secret}, "tasks": []}
|
||
yield state
|
||
for task in state["tasks"]:
|
||
task.cancel()
|
||
await asyncio.gather(*state["tasks"], return_exceptions=True)
|
||
await client.aclose()
|
||
cs.should_exit = rs.should_exit = True
|
||
await asyncio.wait_for(asyncio.gather(ct, rt), timeout=10)
|
||
await redis.aclose()
|
||
|
||
|
||
async def provision(env, owner="ou_test"):
|
||
directory = env["root"] / owner
|
||
device_request(directory)
|
||
output = env["root"] / (owner + "-issued")
|
||
issue(env["root"], directory / "request.json", output)
|
||
for name in ["device.pem", "ca.pem", "connector.pub", "device.json"]:
|
||
(directory / name).write_bytes((output / name).read_bytes())
|
||
registration = json.loads((output / "registration.json").read_text())
|
||
response = await env["client"].post("/admin/devices", json=registration, headers=env["admin"])
|
||
assert response.status_code == 201, response.text
|
||
response = await env["client"].post("/admin/test/binding-code", json={"open_id": owner, "text": "ignored"}, headers=env["admin"])
|
||
code = response.json()["message"].split(":")[-1]
|
||
from relay.device import bind_device
|
||
await bind_device(directory, env["connector_url"], code)
|
||
return directory, registration["host_id"]
|
||
|
||
|
||
async def connect_device(env, directory, root=None):
|
||
from relay.device import run_device
|
||
connected = asyncio.Event()
|
||
task = asyncio.create_task(run_device(directory, env["router_url"], root=root, connected_event=connected))
|
||
env["tasks"].append(task)
|
||
await asyncio.wait_for(connected.wait(), 5)
|
||
return task
|