test: port the v1 endpoint and browser tests to v2

HTTP tests against a running controller (make test-api HOST=ip). They
snapshot every collection through /db and restore it afterwards. v1
behaviour v2 does not have yet is marked as a strict xfail.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Opus 5.5 committed 2026-11-03 01:33:08 +13:00
1 parent 9d628aa3c8
commit 4b42391a46
15 files changed
+2055 -1

No files matched your search

+27
View File
@@ -0,0 +1,27 @@
# API tests
HTTP tests against a running controller, ported from the v1 Python app's `tests/test_endpoints_pytest.py` and `tests/test_endpoints.py`. They need `pytest` and `requests`.
```bash
make test-api HOST=10.1.1.180
```
or `python3 -m pytest test/api --host <ip>` (or set `LED_HOST`). Without a host every test is skipped.
The tests create and delete profiles, presets, zones and so on. Before the run they save every collection (`GET /db/<name>`), and afterwards they write each one back (`PUT /db/<name>`). Zone play and preset send do go out over ESP-NOW. They use made-up driver names (`pytest-a`, `pytest-nobody`) so real drivers ignore them.
## v1 features v2 does not have yet
A test for v1 behaviour that v2 is missing is marked `@missing("<feature>")`. That is a strict `xfail`, so the test shows as `x`, and it fails as `XPASS(strict)` once the feature works. When that happens, remove the marker. To list what is still missing:
```bash
python3 -m pytest test/api --host <ip> -rx
```
v1 tests that were not ported:
- the model and engine unit tests (`tests/models/`, `tests/engine_tests/`), which test Python modules that have no C counterpart;
- the Wi-Fi/TCP/UDP driver test servers.
The checks on exact driver messages became checks on status codes and replies, because ESP-NOW frames can't be captured from outside the board.
The Selenium UI tests are in `test/browser/` (`make test-browser HOST=<ip>`).
+76
View File
@@ -0,0 +1,76 @@
"""Black-box HTTP tests against a running controller.
Ported from the v1 Python app's tests (tests/test_endpoints_pytest.py, tests/test_endpoints.py).
Point them at a board with --host <ip> or LED_HOST; without one every test is skipped.
The board's stored collections are snapshotted first and written back afterwards.
"""
import os
import pytest
import requests
# Store collections (main/store.c NAMES), all reachable through GET/PUT /db/<name>
COLLECTIONS = ["device", "zone", "preset", "profile", "palette", "pattern",
"sequence", "scene", "group", "output", "settings"]
TIMEOUT = 10
def pytest_addoption(parser):
parser.addoption("--host", default=os.environ.get("LED_HOST"),
help="controller address (or set LED_HOST)")
def pytest_collection_modifyitems(config, items):
if config.getoption("--host"):
return
skip = pytest.mark.skip(reason="no controller: pass --host or set LED_HOST")
for item in items:
item.add_marker(skip)
class Client(requests.Session):
"""requests.Session that takes paths relative to the controller."""
def __init__(self, base_url):
super().__init__()
self.base_url = base_url
self.headers.update({"User-Agent": "pytest/requests", "Accept": "application/json"})
def request(self, method, url, *args, **kwargs):
kwargs.setdefault("timeout", TIMEOUT)
return super().request(method, self.base_url + url, *args, **kwargs)
@pytest.fixture(scope="session")
def base_url(request):
host = request.config.getoption("--host")
return host if host.startswith("http") else f"http://{host}"
@pytest.fixture(scope="session")
def c(base_url):
with Client(base_url) as client:
yield client
@pytest.fixture(scope="session", autouse=True)
def restore_db(request):
"""Snapshot every collection before the run and write it back afterwards."""
if not request.config.getoption("--host"):
yield
return
client = request.getfixturevalue("c")
snapshot = {}
for name in COLLECTIONS:
resp = client.get(f"/db/{name}")
resp.raise_for_status()
snapshot[name] = resp.json()
yield snapshot
failed = []
for name, data in snapshot.items():
resp = client.put(f"/db/{name}", json=data)
if resp.status_code != 200:
failed.append(f"{name}: {resp.status_code}")
assert not failed, f"could not restore the controller's data: {failed}"
+27
View File
@@ -0,0 +1,27 @@
import uuid
import pytest
def unique(prefix):
return f"{prefix}-{uuid.uuid4().hex[:8]}"
def new_id(resp):
"""Id of a created record: replies are {"<id>": record} or a record with "id"."""
data = resp.json()
if "id" in data and not isinstance(data["id"], dict):
return str(data["id"])
return str(next(iter(data)))
def find_id_by_field(listing, field, value):
for obj_id, data in listing.items():
if isinstance(data, dict) and data.get(field) == value:
return str(obj_id)
raise AssertionError(f"Could not find id for {field}={value!r}")
def missing(feature):
"""Mark a test for v1 behaviour v2 does not have yet; strict, so it fails once the feature lands."""
return pytest.mark.xfail(strict=True, reason=f"v2: {feature} not implemented")
+102
View File
@@ -0,0 +1,102 @@
"""Groups, sequences, scenes and palettes."""
from helpers import find_id_by_field, missing, new_id, unique
def test_groups(c):
name = unique("pytest-group")
assert c.post("/groups", json={"name": name}).status_code == 201
gid = find_id_by_field(c.get("/groups").json(), "name", name)
resp = c.get(f"/groups/{gid}")
assert resp.status_code == 200
assert resp.json()["name"] == name
resp = c.put(f"/groups/{gid}", json={"brightness": 10})
assert resp.status_code == 200
assert resp.json()["brightness"] == 10
assert c.delete(f"/groups/{gid}").status_code == 200
def test_sequences_crud(c):
name = unique("pytest-seq")
resp = c.post("/sequences", json={"name": name, "steps": [{"preset_id": "1", "duration_s": 2}]})
assert resp.status_code == 201
sid = find_id_by_field(c.get("/sequences").json(), "name", name)
resp = c.get(f"/sequences/{sid}")
assert resp.status_code == 200
assert resp.json()["steps"] == [{"preset_id": "1", "duration_s": 2.0}]
resp = c.put(f"/sequences/{sid}", json={"loop": False, "repeat_count": 2})
assert resp.status_code == 200
assert resp.json()["loop"] is False and resp.json()["repeat_count"] == 2
assert c.get("/sequences/status").status_code == 200
assert c.delete(f"/sequences/{sid}").status_code == 200
@missing("sequence step validation")
def test_sequence_step_needs_preset(c):
sid = new_id(c.post("/sequences", json={"name": unique("pytest-seq"), "steps": []}))
assert c.put(f"/sequences/{sid}", json={"steps": [{"duration_s": 1}]}).status_code == 400
c.delete(f"/sequences/{sid}")
@missing("400 for a sequence without zone_id")
def test_sequence_without_zone_cannot_play(c):
sid = new_id(c.post("/sequences", json={"name": unique("pytest-seq"),
"steps": [{"preset_id": "1", "duration_s": 1}]}))
assert c.post(f"/sequences/{sid}/play").status_code == 400
c.delete(f"/sequences/{sid}")
@missing("sequence play/stop status replies and active flag")
def test_sequence_play_and_stop(c):
profile = new_id(c.post("/profiles", json={"name": unique("pytest-engine")}))
c.post(f"/profiles/{profile}/apply")
preset = new_id(c.post("/presets", json={"name": "pytest-on", "pattern": "on", "colors": ["#ff0000"]}))
zone = new_id(c.post("/zones", json={"name": "pytest-engine-zone", "names": ["pytest-nobody"]}))
c.post("/sequences", json={"name": "pytest-engine-seq", "zone_id": zone, "loop": False,
"steps": [{"preset_id": preset, "duration_s": 0.5}]})
sid = find_id_by_field(c.get("/sequences").json(), "name", "pytest-engine-seq")
resp = c.post(f"/sequences/{sid}/play")
assert resp.status_code == 200
assert resp.json()["zone_id"] == zone
assert c.get(f"/sequences/{sid}").json()["active"] is True
resp = c.post(f"/sequences/{sid}/stop")
assert resp.json()["stopped"] is True
assert c.get(f"/sequences/{sid}").json()["active"] is False
c.delete(f"/sequences/{sid}")
c.delete(f"/zones/{zone}")
c.delete(f"/profiles/{profile}")
def test_scenes(c):
name = unique("pytest-scene")
assert c.post("/scenes", json={"name": name}).status_code == 201
sid = find_id_by_field(c.get("/scenes").json(), "name", name)
assert c.get(f"/scenes/{sid}").status_code == 200
resp = c.put(f"/scenes/{sid}", json={"name": name + "-updated"})
assert resp.status_code == 200
assert resp.json()["name"].endswith("-updated")
assert c.delete(f"/scenes/{sid}").status_code == 200
@missing("v1 palette shape ({id, colors})")
def test_palettes(c):
resp = c.post("/palettes", json={"colors": ["#112233", "#445566"]})
assert resp.status_code == 201
pid = str(resp.json()["id"])
assert resp.json()["colors"] == ["#112233", "#445566"]
resp = c.get(f"/palettes/{pid}")
assert resp.status_code == 200
assert resp.json()["id"] == pid
resp = c.put(f"/palettes/{pid}", json={"colors": ["#000000"]})
assert resp.status_code == 200
assert resp.json()["colors"] == ["#000000"]
assert c.delete(f"/palettes/{pid}").status_code == 200
@missing("v1 palette shape ({id, colors})")
def test_palettes_list_is_colour_lists(c):
pid = str(c.post("/palettes", json={"colors": ["#abcdef"]}).json()["id"])
assert c.get("/palettes").json()[pid] == ["#abcdef"]
c.delete(f"/palettes/{pid}")
+136
View File
@@ -0,0 +1,136 @@
import pytest
from helpers import missing
# Test MACs from v1; no real driver has them
ESPNOW_MAC = "aabbccddeeff"
WIFI_MAC = "102030405060"
WIFI_MAC2 = "102030405061"
@pytest.fixture
def espnow_dev(c):
c.delete(f"/devices/{ESPNOW_MAC}")
resp = c.post("/devices", json={"name": "pytest-dev", "address": "aa:bb:cc:dd:ee:ff"})
assert resp.status_code == 201, resp.text
yield resp
c.delete(f"/devices/{ESPNOW_MAC}")
@pytest.fixture
def wifi_dev(c):
c.delete(f"/devices/{WIFI_MAC}")
resp = c.post("/devices", json={"name": "pytest-wifi", "type": "led", "transport": "wifi",
"address": "192.168.50.10", "mac": WIFI_MAC})
assert resp.status_code == 201, resp.text
yield resp
c.delete(f"/devices/{WIFI_MAC}")
def test_list(c):
resp = c.get("/devices")
assert resp.status_code == 200
assert isinstance(resp.json(), dict)
@missing("v1 device registry (MAC keys, validation)")
def test_create_requires_name(c):
assert c.post("/devices", json={}).status_code == 400
@missing("v1 device registry (MAC keys, validation)")
def test_create_espnow_keyed_by_mac(espnow_dev):
dev = espnow_dev.json()
assert list(dev) == [ESPNOW_MAC]
rec = dev[ESPNOW_MAC]
assert rec["name"] == "pytest-dev"
assert rec["id"] == ESPNOW_MAC
assert rec["type"] == "led"
assert rec["transport"] == "espnow"
assert rec["address"] == ESPNOW_MAC
@missing("v1 device registry (MAC keys, validation)")
def test_get_espnow_has_no_connection_state(c, espnow_dev):
resp = c.get(f"/devices/{ESPNOW_MAC}")
assert resp.status_code == 200
assert resp.json()["name"] == "pytest-dev"
assert resp.json().get("connected") is None
assert c.get("/devices").json()[ESPNOW_MAC].get("connected") is None
@missing("v1 device registry (MAC keys, validation)")
def test_create_wifi(c, wifi_dev):
rec = wifi_dev.json()[WIFI_MAC]
assert rec["transport"] == "wifi"
assert rec["address"] == "192.168.50.10"
assert c.get(f"/devices/{WIFI_MAC}").json().get("connected") is False
@missing("v1 device registry (MAC keys, validation)")
def test_create_second_wifi_same_name(c, wifi_dev):
resp = c.post("/devices", json={"name": "pytest-wifi", "transport": "wifi",
"address": "192.168.50.11", "mac": WIFI_MAC2})
assert resp.status_code == 201
assert resp.json()[WIFI_MAC2]["name"] == "pytest-wifi"
assert c.delete(f"/devices/{WIFI_MAC2}").status_code == 200
@missing("v1 device registry (MAC keys, validation)")
def test_create_duplicate_mac(c, wifi_dev):
resp = c.post("/devices", json={"name": "pytest-wifi-dupmac", "transport": "wifi",
"address": "192.168.50.99", "mac": WIFI_MAC})
assert resp.status_code == 409
@missing("v1 device registry (MAC keys, validation)")
def test_create_wifi_requires_mac(c):
resp = c.post("/devices", json={"name": "no-mac-wifi", "transport": "wifi", "address": "192.168.50.12"})
assert resp.status_code == 400
@missing("v1 device registry (MAC keys, validation)")
def test_create_rejects_unknown_transport(c):
assert c.post("/devices", json={"name": "bad-tr", "transport": "serial"}).status_code == 400
@missing("v1 device registry (MAC keys, validation)")
def test_rename_blank(c, espnow_dev):
assert c.put(f"/devices/{ESPNOW_MAC}", json={"name": " "}).status_code == 400
@missing("v1 device registry (MAC keys, validation)")
def test_rename(c, espnow_dev, wifi_dev):
for mac in (ESPNOW_MAC, WIFI_MAC):
resp = c.put(f"/devices/{mac}", json={"name": "renamed"})
assert resp.status_code == 200
assert resp.json()["name"] == "renamed"
@missing("v1 device registry (MAC keys, validation)")
def test_cannot_change_mac(c, espnow_dev):
assert c.put(f"/devices/{ESPNOW_MAC}", json={"mac": "001122334455"}).status_code == 400
@missing("device identify")
def test_identify(c, espnow_dev):
resp = c.post(f"/devices/{ESPNOW_MAC}/identify")
assert resp.status_code == 200
assert resp.json().get("message")
@missing("device identify")
def test_identify_unknown(c):
assert c.post("/devices/000000000000/identify").status_code == 404
def test_status(c):
resp = c.get("/devices/status")
assert resp.status_code == 200
assert isinstance(resp.json(), dict)
@missing("v1 device registry (MAC keys, validation)")
def test_delete(c, espnow_dev):
assert c.delete(f"/devices/{ESPNOW_MAC}").status_code == 200
assert c.get(f"/devices/{ESPNOW_MAC}").status_code == 404
+20
View File
@@ -0,0 +1,20 @@
"""led-tool: configure drivers over USB serial (v1 controllers/led_tool.py)."""
from helpers import missing
# Every test here fails on v2
pytestmark = missing("led-tool (USB serial)")
def test_ports(c):
resp = c.get("/led-tool/ports")
assert resp.status_code == 200
assert isinstance(resp.json()["ports"], list)
def test_settings_requires_port(c):
assert c.get("/led-tool/settings").status_code == 400
def test_reset_requires_port(c):
assert c.post("/led-tool/reset", json={}).status_code == 400
+55
View File
@@ -0,0 +1,55 @@
import pytest
from helpers import missing
# Every test here fails on v2
pytestmark = missing("pixel outputs (DDP, Art-Net, sACN, DMX)")
@pytest.fixture
def output(c):
# 127.0.0.1 is the board itself, so the test frames go nowhere
resp = c.post("/outputs", json={"name": "pytest-wall", "protocol": "ddp", "host": "127.0.0.1",
"port": 9, "pixel_count": 10})
assert resp.status_code == 201, resp.text
oid = str(resp.json()["id"])
yield oid
c.delete(f"/outputs/{oid}")
def test_ddp_requires_host(c):
resp = c.post("/outputs", json={"name": "wall", "protocol": "ddp"})
assert resp.status_code == 400
assert "host" in resp.json()["error"]
def test_rejects_unknown_protocol(c):
assert c.post("/outputs", json={"name": "wall", "protocol": "hdmi", "host": "x"}).status_code == 400
def test_defaults(c, output):
rec = c.get(f"/outputs/{output}").json()
assert rec["color_order"] == "rgb"
assert rec["fps"] == 40
assert rec["enabled"] is True
def test_update(c, output):
resp = c.put(f"/outputs/{output}", json={"color_order": "grb"})
assert resp.status_code == 200
assert resp.json()["color_order"] == "grb"
def test_update_validates(c, output):
assert c.put(f"/outputs/{output}", json={"color_order": "xyz"}).status_code == 400
def test_test_pattern(c, output):
resp = c.post(f"/outputs/{output}/test", json={"step_s": 0.1})
assert resp.status_code == 200
assert resp.json()["status"]["frames"] > 0
def test_delete(c, output):
assert c.delete(f"/outputs/{output}").status_code == 200
assert c.get(f"/outputs/{output}").status_code == 404
+73
View File
@@ -0,0 +1,73 @@
from helpers import missing, unique
@missing("/patterns/definitions")
def test_definitions(c):
resp = c.get("/patterns/definitions")
assert resp.status_code == 200
assert isinstance(resp.json(), dict)
@missing("driver pattern files in /patterns")
def test_list_includes_driver_patterns(c):
resp = c.get("/patterns")
assert resp.status_code == 200
assert "blink" in resp.json()
@missing("v1 pattern create ({name, data})")
def test_crud(c):
pid = unique("pytest_pattern").replace("-", "_")
resp = c.post("/patterns", json={"name": pid, "data": {"foo": "bar"}})
assert resp.status_code == 201
assert resp.json()["foo"] == "bar"
resp = c.get(f"/patterns/{pid}")
assert resp.status_code == 200
assert resp.json()["foo"] == "bar"
resp = c.put(f"/patterns/{pid}", json={"baz": 1})
assert resp.status_code == 200
assert resp.json()["baz"] == 1
assert c.delete(f"/patterns/{pid}").status_code == 200
@missing("/patterns/ota/file")
def test_ota_file(c):
resp = c.get("/patterns/ota/file/blink.py")
assert resp.status_code == 200
assert resp.headers["Content-Type"].startswith("text/plain")
assert "class" in resp.text
@missing("/patterns/ota/file")
def test_ota_file_rejects_builtin(c):
# on/off are built into the driver firmware, not OTA files
resp = c.get("/patterns/ota/file/on.py")
assert resp.status_code == 400
assert "error" in resp.json()
@missing("/patterns/ota/manifest")
def test_ota_manifest(c):
resp = c.get("/patterns/ota/manifest")
assert resp.status_code == 200
names = [f["name"] for f in resp.json()["files"]]
assert "blink.py" in names
@missing("/patterns/<name>/send")
def test_send_rejects_builtin(c):
resp = c.post("/patterns/off/send", json={})
assert resp.status_code == 400
assert "error" in resp.json()
@missing("/patterns/upload")
def test_upload_rejects_builtin(c):
resp = c.post("/patterns/upload", json={"name": "on.py", "code": "class On:\n def run(self, p):\n yield\n"})
assert resp.status_code == 400
@missing("/patterns/driver")
def test_driver_rejects_builtin(c):
resp = c.post("/patterns/driver", json={"name": "off", "code": "class Off:\n def run(self, p):\n yield\n"})
assert resp.status_code == 400
+87
View File
@@ -0,0 +1,87 @@
import pytest
from helpers import missing, new_id, unique
@pytest.fixture
def profile(c):
pid = new_id(c.post("/profiles", json={"name": unique("pytest-profile")}))
assert c.post(f"/profiles/{pid}/apply").status_code == 200
yield pid
c.delete(f"/profiles/{pid}")
@pytest.fixture
def preset(c, profile):
resp = c.post("/presets", json={"name": unique("pytest-preset"), "pattern": "on",
"colors": ["#ff0000"], "brightness": 123, "delay": 100})
assert resp.status_code == 201
pid = new_id(resp)
yield pid
c.delete(f"/presets/{pid}")
@missing("seeded presets for a new profile")
def test_list_and_get(c, profile):
resp = c.get("/presets")
assert resp.status_code == 200
presets = resp.json()
assert presets
first = next(iter(presets))
resp = c.get(f"/presets/{first}")
assert resp.status_code == 200
assert resp.json()
def test_create_belongs_to_current_profile(c, profile):
resp = c.post("/presets", json={"name": unique("pytest-preset"), "pattern": "on", "colors": ["#ff0000"]})
assert resp.status_code == 201
pid = new_id(resp)
assert str(resp.json()[pid]["profile_id"]) == profile
@missing("preset defaults on create")
def test_create_fills_defaults(c, profile):
resp = c.post("/presets", json={"name": unique("pytest-preset"), "pattern": "on"})
rec = resp.json()[new_id(resp)]
for key in ("colors", "brightness", "delay", "n1", "n8"):
assert key in rec, key
def test_presets_scoped_to_profile(c, preset):
other = new_id(c.post("/profiles", json={"name": unique("pytest-profile")}))
c.post(f"/profiles/{other}/apply")
assert preset not in c.get("/presets").json()
assert c.get(f"/presets/{preset}").status_code == 404
c.delete(f"/profiles/{other}")
def test_update(c, preset):
resp = c.put(f"/presets/{preset}", json={"brightness": 77})
assert resp.status_code == 200
assert resp.json()["brightness"] == 77
def test_send(c, preset):
resp = c.post("/presets/send", json={"preset_ids": [preset], "save": False})
assert resp.status_code == 200
assert resp.json()["presets_sent"] >= 1
def test_send_requires_ids(c, profile):
assert c.post("/presets/send", json={"preset_ids": []}).status_code == 400
def test_push(c):
resp = c.post("/presets/push", json={"payload": {"v": "1", "select": {"pytest-nobody": ["off"]}}})
assert resp.status_code == 200
assert resp.json()["message"] == "Delivered"
def test_push_requires_payload(c):
assert c.post("/presets/push", json={"targets": []}).status_code == 400
def test_delete(c, preset):
assert c.delete(f"/presets/{preset}").status_code == 200
assert c.get(f"/presets/{preset}").status_code == 404
+89
View File
@@ -0,0 +1,89 @@
import pytest
from helpers import missing, new_id, unique
# Presets every new profile is seeded with (v1 controllers/profile.py)
SEEDED = {"on", "off", "rainbow", "Colour Cycle", "transition", "flicker", "flame", "twinkle"}
@pytest.fixture
def profile(c):
resp = c.post("/profiles", json={"name": unique("pytest-profile")})
assert resp.status_code == 201
pid = new_id(resp)
assert c.post(f"/profiles/{pid}/apply").status_code == 200
yield pid
c.delete(f"/profiles/{pid}")
def test_list(c, profile):
resp = c.get("/profiles")
assert resp.status_code == 200
data = resp.json()
assert profile in data["profiles"]
assert data["current_profile_id"] == profile
def test_apply_sets_current(c, profile):
resp = c.get("/profiles/current")
assert resp.status_code == 200
assert str(resp.json()["id"]) == profile
assert resp.json()["profile"]["name"].startswith("pytest-profile")
def test_apply_unknown_profile(c):
assert c.post("/profiles/999999/apply").status_code == 404
@missing("profile seeding (presets, default zone, palette)")
def test_new_profile_is_seeded(c, profile):
presets = c.get("/presets").json()
assert SEEDED <= {p["name"] for p in presets.values()}
rec = c.get(f"/profiles/{profile}").json()
assert rec["palette_id"] in c.get("/palettes").json()
zones = rec["zones"]
assert len(zones) == 1
zone = c.get(f"/zones/{zones[0]}").json()
assert zone["name"] == "default"
assert set(zone["presets_flat"]) == set(presets)
def test_put_current(c, profile):
name = unique("pytest-renamed")
assert c.put("/profiles/current", json={"name": name}).status_code == 200
assert c.get(f"/profiles/{profile}").json()["name"] == name
def test_put(c, profile):
name = unique("pytest-renamed")
resp = c.put(f"/profiles/{profile}", json={"name": name})
assert resp.status_code == 200
assert resp.json()["name"] == name
@missing("profile clone")
def test_clone(c, profile):
name = unique("pytest-profile-clone")
resp = c.post(f"/profiles/{profile}/clone", json={"name": name})
assert resp.status_code == 201
clone = new_id(resp)
assert clone != profile
assert resp.json()[clone]["name"] == name
src_presets = c.get("/presets").json()
assert c.post(f"/profiles/{clone}/apply").status_code == 200
cloned_presets = c.get("/presets").json()
# The clone gets its own copies of the presets, zones and palette
assert not set(cloned_presets) & set(src_presets)
assert sorted(p["name"] for p in cloned_presets.values()) == sorted(p["name"] for p in src_presets.values())
src, dst = c.get(f"/profiles/{profile}").json(), c.get(f"/profiles/{clone}").json()
assert dst["palette_id"] != src["palette_id"]
assert len(dst["zones"]) == len(src["zones"]) and not set(dst["zones"]) & set(src["zones"])
assert c.delete(f"/profiles/{clone}").status_code == 200
def test_delete(c):
pid = new_id(c.post("/profiles", json={"name": unique("pytest-profile")}))
assert c.delete(f"/profiles/{pid}").status_code == 200
assert c.get(f"/profiles/{pid}").status_code == 404
+31
View File
@@ -0,0 +1,31 @@
import pytest
from helpers import missing
def test_index(c):
resp = c.get("/")
assert resp.status_code == 200
assert "LED Controller" in resp.text
def test_favicon(c):
assert c.get("/favicon.ico").status_code == 204
@pytest.mark.parametrize("path", ["style.css", "zones.js", "presets.js", "profiles.js", "devices.js"])
def test_static(c, path):
assert c.get(f"/static/{path}").status_code == 200
def test_settings_page(c):
resp = c.get("/settings/page")
assert resp.status_code == 200
assert "LED Controller" in resp.text
@missing("/ws")
def test_ws_rejects_plain_get(c):
# A websocket endpoint refuses a request that is not an upgrade
resp = c.get("/ws")
assert resp.status_code in {400, 401, 403, 405, 426}
+58
View File
@@ -0,0 +1,58 @@
from helpers import missing, unique
@missing("settings defaults")
def test_get_settings(c):
resp = c.get("/settings")
assert resp.status_code == 200
assert "wifi_channel" in resp.json()
@missing("/settings/wifi/ap")
def test_wifi_ap_get(c):
resp = c.get("/settings/wifi/ap")
assert resp.status_code == 200
ap = resp.json()
assert "saved_ssid" in ap
assert "active" in ap
@missing("/settings/wifi/ap")
def test_wifi_ap_post(c):
ssid = unique("pytest-ssid")
resp = c.post("/settings/wifi/ap", json={"ssid": ssid, "password": "secret", "channel": 1})
assert resp.status_code == 200
assert resp.json()["ssid"] == ssid
assert resp.json()["channel"] == 1
assert c.get("/settings/wifi/ap").json()["saved_ssid"] == ssid
@missing("/settings/wifi/ap")
def test_wifi_ap_rejects_bad_channel(c):
resp = c.post("/settings/wifi/ap", json={"ssid": "bad-ssid", "password": "secret", "channel": 12})
assert resp.status_code == 400
@missing("/settings/wifi/ap")
def test_wifi_ap_requires_ssid(c):
assert c.post("/settings/wifi/ap", json={"password": "secret"}).status_code == 400
def test_wifi_channel(c):
assert c.put("/settings/settings", json={"wifi_channel": 11}).status_code == 200
assert c.get("/settings").json()["wifi_channel"] == 11
@missing("settings validation")
def test_wifi_channel_out_of_range(c):
assert c.put("/settings/settings", json={"wifi_channel": 12}).status_code == 400
def test_global_brightness(c):
assert c.put("/settings/settings", json={"global_brightness": 42}).status_code == 200
assert c.get("/settings").json().get("global_brightness") == 42
@missing("settings validation")
def test_global_brightness_out_of_range(c):
assert c.put("/settings/settings", json={"global_brightness": 300}).status_code == 400
+130
View File
@@ -0,0 +1,130 @@
import pytest
from helpers import missing, new_id, unique
@pytest.fixture
def profile(c):
pid = new_id(c.post("/profiles", json={"name": unique("pytest-profile")}))
assert c.post(f"/profiles/{pid}/apply").status_code == 200
yield pid
c.delete(f"/profiles/{pid}")
@pytest.fixture
def zone(c, profile):
name = unique("pytest-zone")
resp = c.post("/zones", json={"name": name, "names": ["pytest-a", "pytest-b"]})
assert resp.status_code == 201
zid = new_id(resp)
yield zid
c.delete(f"/zones/{zid}")
@missing("v1 zone list shape and profile zone order")
def test_list(c, profile, zone):
resp = c.get("/zones")
assert resp.status_code == 200
data = resp.json()
assert zone in data["zones"]
assert zone in data["zone_order"]
assert str(data["profile_id"]) == profile
assert "current_zone_id" in data
@missing("adding new zones to the current profile")
def test_create_adds_to_profile(c, profile, zone):
assert zone in c.get(f"/profiles/{profile}").json()["zones"]
@missing("zone validation")
def test_create_requires_name(c, profile):
assert c.post("/zones", json={"names": ["1"]}).status_code == 400
def test_get(c, zone):
resp = c.get(f"/zones/{zone}")
assert resp.status_code == 200
assert resp.json()["name"].startswith("pytest-zone")
@missing("zone set-current")
def test_set_current(c, zone):
resp = c.post(f"/zones/{zone}/set-current")
assert resp.status_code == 200
assert resp.json()["zone_id"] == zone
assert c.cookies.get("current_zone") == zone
resp = c.get("/zones/current")
assert resp.status_code == 200
assert resp.json()["zone_id"] == zone
@missing("zone set-current")
def test_set_current_unknown(c):
assert c.post("/zones/999999/set-current").status_code == 404
def test_edit_workflow(c, zone):
# From v1 tests/test_endpoints.py test_zone_edit_workflow
resp = c.put(f"/zones/{zone}", json={"name": "Edited Zone Name", "names": ["2", "3", "4"]})
assert resp.status_code == 200
assert resp.json()["name"] == "Edited Zone Name"
assert resp.json()["names"] == ["2", "3", "4"]
stored = c.get(f"/zones/{zone}").json()
assert stored["name"] == "Edited Zone Name"
assert stored["names"] == ["2", "3", "4"]
@missing("zone clone")
def test_clone(c, profile, zone):
resp = c.post(f"/zones/{zone}/clone", json={"name": "pytest-zone-clone"})
assert resp.status_code == 201
clone = new_id(resp)
assert clone != zone
rec = c.get(f"/zones/{clone}").json()
assert rec["name"] == "pytest-zone-clone"
assert rec["names"] == ["pytest-a", "pytest-b"]
assert clone in c.get(f"/profiles/{profile}").json()["zones"]
assert c.delete(f"/zones/{clone}").status_code == 200
@missing("zone clone")
def test_clone_default_name(c, zone):
resp = c.post(f"/zones/{zone}/clone", json={})
clone = new_id(resp)
assert resp.json()[clone]["name"].endswith(" Copy")
c.delete(f"/zones/{clone}")
@missing("zone content-fragment")
def test_content_fragment(c, zone):
resp = c.get(f"/zones/{zone}/content-fragment", headers={"HX-Request": "true", "Accept": "text/html"})
assert resp.status_code == 200
assert f'data-zone-id="{zone}"' in resp.text
@missing("removing deleted zones from the profile")
def test_delete_removes_from_profile(c, profile):
zid = new_id(c.post("/zones", json={"name": unique("pytest-zone"), "names": ["1"]}))
assert c.delete(f"/zones/{zid}").status_code == 200
assert c.get(f"/zones/{zid}").status_code == 404
assert zid not in c.get(f"/profiles/{profile}").json()["zones"]
def test_play_requires_preset(c, zone):
assert c.post(f"/zones/{zone}/play", json={}).status_code == 400
def test_play_unknown_preset(c, zone):
assert c.post(f"/zones/{zone}/play", json={"preset_id": "nope"}).status_code == 404
@missing("zone stop reply ({stopped})")
def test_play_and_stop(c, zone):
preset = new_id(c.post("/presets", json={"name": "pytest-on", "pattern": "on", "colors": ["#ff0000"]}))
resp = c.post(f"/zones/{zone}/play", json={"preset_id": preset})
assert resp.status_code == 200, resp.text
assert c.get("/zones/engine/status").status_code == 200
resp = c.post(f"/zones/{zone}/stop")
assert resp.status_code == 200
assert resp.json()["stopped"] is True