mirror of
https://github.com/rstrouse/ESPSomfy-RTS.git
synced 2026-10-31 13:52:15 +01:00
cfa298f053
- e2e: the heap check uses a socket slot now, so it waits for the device to free it, and test_every_client_reconnecting_at_once closes its clients before the check runs. - Comments and docs that still named removed things (the /controller read, the event buffer, memStatus, SocketEmitter, ModelSnapshot). - ESPNetwork::emitSockets is emitStatus: one socket, and it sends the status. - Unused includes, whitespace-only lines left by the toJSON removal. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
92 lines
3.3 KiB
Python
92 lines
3.3 KiB
Python
"""The device must survive the loads that ran its heap out
|
|
(docs/adr/0005-one-websocket-protocol.md): every client reconnecting at once,
|
|
and a browser loading the page."""
|
|
import threading
|
|
import time
|
|
import urllib.request
|
|
|
|
import pytest
|
|
|
|
from proto_client import ProtoClient, heap, run_sync
|
|
|
|
# What the heap may drop to under load. Below it the next allocation in the
|
|
# web server is close to failing, which aborts.
|
|
HEAP_FLOOR = 20 * 1024
|
|
MAX_CLIENTS = 5
|
|
|
|
|
|
@pytest.fixture
|
|
def watch_heap(host, token):
|
|
"""Fails the test when the device rebooted or its heap fell under the floor.
|
|
|
|
The device reports its lowest heap since it booted, so a dip under the
|
|
floor only shows while that low is still above it."""
|
|
before = heap(host, token)
|
|
if before["min"] < HEAP_FLOOR:
|
|
pytest.skip("the heap has been down to %u bytes since boot: reboot the device to check the floor" % before["min"])
|
|
yield before
|
|
after = heap(host, token)
|
|
assert after["uptime"] > before["uptime"], "the device rebooted"
|
|
assert after["min"] >= HEAP_FLOOR, "the heap fell to %u bytes (floor %u)" % (after["min"], HEAP_FLOOR)
|
|
|
|
|
|
@pytest.fixture
|
|
def all_slots_free(host, token):
|
|
"""Skips unless every socket slot is free. The web UI holds one per open
|
|
tab, which would leave these tests a client short."""
|
|
clients = [ProtoClient(host, params={"apikey": token} if token else None) for _ in range(MAX_CLIENTS)]
|
|
try:
|
|
time.sleep(1)
|
|
taken = sum(1 for c in clients if c.closed.is_set())
|
|
finally:
|
|
for c in clients:
|
|
c.close()
|
|
# The device frees a slot when it sees the disconnect.
|
|
time.sleep(0.5)
|
|
if taken:
|
|
pytest.skip("%u socket slot(s) in use, likely by the web UI: close its tabs" % taken)
|
|
|
|
|
|
# watch_heap comes before connect so pytest tears connect down first: the
|
|
# heap check after the test needs a free slot.
|
|
def test_every_client_reconnecting_at_once(watch_heap, all_slots_free, connect, schema):
|
|
clients = [connect() for _ in range(MAX_CLIENTS)]
|
|
errors = []
|
|
|
|
def sync(c):
|
|
try:
|
|
run_sync(c, timeout=60)
|
|
except Exception as e: # reported below
|
|
errors.append(e)
|
|
threads = [threading.Thread(target=sync, args=(c,)) for c in clients]
|
|
[t.start() for t in threads]
|
|
[t.join() for t in threads]
|
|
assert not errors, errors
|
|
|
|
|
|
def test_one_client_too_many_is_closed(connect, schema, all_slots_free):
|
|
clients = [connect(schema=schema.hash) for _ in range(MAX_CLIENTS)]
|
|
for c in clients:
|
|
run_sync(c)
|
|
extra = connect(schema=schema.hash)
|
|
assert extra.closed.wait(5), "a sixth client stayed connected"
|
|
|
|
|
|
def test_page_load(host, token, connect, watch_heap):
|
|
"""The static files in parallel, as a browser fetches them, then the socket."""
|
|
files = ["/", "/app.css", "/index.js", "/icon.png"]
|
|
errors = []
|
|
|
|
def get(path):
|
|
try:
|
|
req = urllib.request.Request(f"http://{host}{path}", headers={"Accept-Encoding": "gzip"})
|
|
with urllib.request.urlopen(req, timeout=60) as r:
|
|
r.read()
|
|
except Exception as e: # reported below
|
|
errors.append((path, e))
|
|
threads = [threading.Thread(target=get, args=(p,)) for p in files]
|
|
[t.start() for t in threads]
|
|
c = connect()
|
|
run_sync(c, timeout=60)
|
|
[t.join() for t in threads]
|
|
assert not errors, errors
|