Files
ecs-relay-service/deployment-source/tests/conftest.py

117 lines
4.7 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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