Add test infrastructure: 50 unit tests + 13 Playwright E2E tests

Tier 1 (tests/test_api.py): 50 backend unit tests using FastAPI TestClient
- Slugify, state endpoint, record/play/stop/delete endpoints
- Dataset CRUD, registry persistence, moves refresh, experiments
- Runs in <1s without hardware

Tier 3 (tests/e2e/test_ui.py): 13 Playwright browser tests
- Page load, idle state display, form validation, recording submission
- Dataset UI, cross-browser (Chromium + Firefox verified)
- Runs in ~16s with a real uvicorn server on port 18042

Run all: pytest tests/ --browser chromium
Run unit only: pytest tests/test_api.py

tests/conftest.py

@@ -0,0 +1,67 @@
+"""Shared fixtures for Marionette tests."""
+
+import json
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from marionette.main import Marionette, create_app
+
+
+@pytest.fixture()
+def tmp_registry(tmp_path: Path) -> Path:
+    """Return a path for a temporary dataset registry file."""
+    return tmp_path / "dataset_registry.json"
+
+
+@pytest.fixture()
+def tmp_dataset_root(tmp_path: Path) -> Path:
+    """Return a temporary directory for datasets."""
+    root = tmp_path / "datasets"
+    root.mkdir()
+    return root
+
+
+@pytest.fixture()
+def marionette_app(tmp_registry: Path, tmp_dataset_root: Path) -> tuple[TestClient, Marionette]:
+    """Create a Marionette app with TestClient, using isolated temp paths."""
+    app, m = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+    client = TestClient(app)
+    return client, m
+
+
+@pytest.fixture()
+def client(marionette_app: tuple[TestClient, Marionette]) -> TestClient:
+    """Convenience fixture: just the TestClient."""
+    return marionette_app[0]
+
+
+@pytest.fixture()
+def marionette(marionette_app: tuple[TestClient, Marionette]) -> Marionette:
+    """Convenience fixture: just the Marionette instance."""
+    return marionette_app[1]
+
+
+@pytest.fixture()
+def sample_move_json() -> dict:
+    """A minimal valid move JSON structure matching RecordedMove expectations."""
+    timestamps = [i * 0.01 for i in range(500)]  # 5 seconds at 100Hz
+    frames = []
+    for _ in timestamps:
+        frames.append({
+            "head": [
+                [1.0, 0.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
+            "antennas": [0.0, 0.0],
+            "body_yaw": 0.0,
+            "check_collision": False,
+        })
+    return {
+        "description": "test move",
+        "time": timestamps,
+        "set_target_data": frames,
+    }

tests/e2e/conftest.py

@@ -0,0 +1,62 @@
+"""Fixtures for Playwright E2E tests.
+
+Starts a real Marionette server (with temp paths) and provides the base URL.
+"""
+
+import threading
+import time
+
+import pytest
+import uvicorn
+
+from marionette.main import create_app
+
+# Use a high port to avoid conflicts
+TEST_PORT = 18042
+
+
+class _ServerThread:
+    """Runs a uvicorn server in a background thread."""
+
+    def __init__(self, app, port: int):
+        self.config = uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning")
+        self.server = uvicorn.Server(self.config)
+        self.thread = threading.Thread(target=self.server.run, daemon=True)
+
+    def start(self):
+        self.thread.start()
+        # Wait for the server to be ready
+        for _ in range(50):
+            if self.server.started:
+                break
+            time.sleep(0.1)
+
+    def stop(self):
+        self.server.should_exit = True
+        self.thread.join(timeout=5)
+
+
+@pytest.fixture(scope="session")
+def _test_server(tmp_path_factory):
+    """Start a Marionette server for the entire test session."""
+    tmp = tmp_path_factory.mktemp("e2e")
+    app, marionette = create_app(
+        registry_path=tmp / "registry.json",
+        dataset_root=tmp / "datasets",
+    )
+    srv = _ServerThread(app, TEST_PORT)
+    srv.start()
+    yield f"http://127.0.0.1:{TEST_PORT}", marionette
+    srv.stop()
+
+
+@pytest.fixture(scope="session")
+def base_url(_test_server):
+    """Return the base URL of the test server (session-scoped for pytest-playwright)."""
+    return _test_server[0]
+
+
+@pytest.fixture(scope="session")
+def test_marionette(_test_server):
+    """Return the Marionette instance backing the test server."""
+    return _test_server[1]

tests/e2e/test_ui.py

@@ -0,0 +1,132 @@
+"""Tier 3 — Playwright E2E browser tests for Marionette.
+
+Run without hardware, without daemon. Tests the frontend UI in real browsers.
+Uses a real Marionette server with temp paths (no robot connection needed for
+these tests — they only test the web UI behavior).
+"""
+
+import re
+import pytest
+from playwright.sync_api import Page, expect
+
+
+# ──────── Page load tests ─────────────────────────────────────────────
+
+
+class TestPageLoad:
+    def test_page_loads_successfully(self, page: Page, base_url: str):
+        page.goto(base_url)
+        expect(page).to_have_title(re.compile("Marionette", re.IGNORECASE))
+
+    def test_main_sections_visible(self, page: Page, base_url: str):
+        page.goto(base_url)
+        # Record section
+        expect(page.locator("#record-form")).to_be_visible()
+        # Moves section
+        expect(page.locator("#moves-list")).to_be_visible()
+        # Record button
+        expect(page.locator("#record-btn")).to_be_visible()
+
+    def test_mode_pill_shows_idle(self, page: Page, base_url: str):
+        page.goto(base_url)
+        pill = page.locator("#mode-pill")
+        expect(pill).to_be_visible()
+        # Wait for first poll to update the pill
+        page.wait_for_timeout(2000)
+        expect(pill).to_contain_text(re.compile("idle", re.IGNORECASE))
+
+
+# ──────── Idle state display ──────────────────────────────────────────
+
+
+class TestIdleState:
+    def test_record_button_enabled(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        btn = page.locator("#record-btn")
+        expect(btn).to_be_enabled()
+
+    def test_stop_buttons_hidden(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        expect(page.locator("#stop-recording-btn")).to_be_hidden()
+        expect(page.locator("#stop-playback-btn")).to_be_hidden()
+
+    def test_progress_bar_empty(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        fill = page.locator("#progress-fill")
+        width = fill.evaluate("el => el.style.width")
+        assert width == "0%" or width == ""
+
+
+# ──────── Form validation tests ───────────────────────────────────────
+
+
+class TestFormValidation:
+    def test_duration_field_exists(self, page: Page, base_url: str):
+        page.goto(base_url)
+        duration = page.locator("#duration")
+        expect(duration).to_be_visible()
+        # Check it has a default value
+        value = duration.input_value()
+        assert float(value) > 0
+
+    def test_duration_accepts_decimal(self, page: Page, base_url: str):
+        page.goto(base_url)
+        duration = page.locator("#duration")
+        duration.fill("3.7")
+        assert duration.input_value() == "3.7"
+
+    def test_audio_source_radios_exist(self, page: Page, base_url: str):
+        page.goto(base_url)
+        expect(page.locator("#audio-source-mic")).to_be_visible()
+        expect(page.locator("#audio-source-none")).to_be_visible()
+
+    def test_label_field_exists(self, page: Page, base_url: str):
+        page.goto(base_url)
+        expect(page.locator("#label")).to_be_visible()
+
+
+# ──────── Recording submission tests ──────────────────────────────────
+
+
+class TestRecordingSubmission:
+    def test_submit_recording_changes_mode(self, page: Page, base_url: str, test_marionette):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+
+        # Set audio source to "none" to avoid audio backend requirement
+        page.locator("#audio-source-none").check()
+        page.locator("#duration").fill("2")
+        page.locator("#label").fill("e2e-test")
+
+        # Submit
+        page.locator("#record-btn").click()
+
+        # Wait for state to update
+        page.wait_for_timeout(2000)
+
+        # Mode pill should show something other than "idle"
+        pill_text = page.locator("#mode-pill").text_content()
+        assert pill_text is not None
+        # Mode should be queued (since no robot is running to process it)
+        assert "queued" in pill_text.lower() or "countdown" in pill_text.lower() or "recording" in pill_text.lower()
+
+        # Reset for other tests
+        test_marionette._set_idle_state()
+        test_marionette._pending_recording = None
+
+
+# ──────── Dataset UI tests ────────────────────────────────────────────
+
+
+class TestDatasetUI:
+    def test_dataset_selector_visible(self, page: Page, base_url: str):
+        page.goto(base_url)
+        page.wait_for_timeout(2000)
+        expect(page.locator("#dataset-select")).to_be_visible()
+
+    def test_new_dataset_button_exists(self, page: Page, base_url: str):
+        page.goto(base_url)
+        expect(page.locator("#new-dataset-btn")).to_be_visible()

tests/test_api.py

@@ -0,0 +1,438 @@
+"""Tier 1 — Backend unit tests for Marionette.
+
+Run without hardware, without daemon, in under 5 seconds.
+Tests the HTTP API layer, state machine, data validation, and persistence.
+"""
+
+import json
+from io import BytesIO
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from marionette.main import (
+    Marionette,
+    _slugify,
+    create_app,
+    DEFAULT_DURATION,
+    COUNTDOWN_SECONDS,
+    MOTION_SAMPLE_RATE,
+    DATASET_DATA_SUBDIR,
+)
+
+
+# ──────── Utility function tests ──────────────────────────────────────
+
+
+class TestSlugify:
+    def test_simple_lowercase(self):
+        assert _slugify("Hello World") == "hello-world"
+
+    def test_special_chars(self):
+        assert _slugify("my@move#1!") == "my-move-1"
+
+    def test_leading_trailing_hyphens(self):
+        assert _slugify("---test---") == "test"
+
+    def test_empty_string(self):
+        assert _slugify("") == "take"
+
+    def test_unicode(self):
+        result = _slugify("café résumé")
+        assert result == "caf-r-sum"
+
+    def test_already_slugified(self):
+        assert _slugify("gentle-nod") == "gentle-nod"
+
+    def test_numbers(self):
+        assert _slugify("take 42") == "take-42"
+
+
+# ──────── State endpoint tests ────────────────────────────────────────
+
+
+class TestStateEndpoint:
+    def test_returns_200(self, client: TestClient):
+        resp = client.get("/api/state")
+        assert resp.status_code == 200
+
+    def test_initial_mode_is_idle(self, client: TestClient):
+        data = client.get("/api/state").json()
+        assert data["mode"] == "idle"
+
+    def test_initial_message(self, client: TestClient):
+        data = client.get("/api/state").json()
+        assert data["message"] == "Ready to capture moves"
+
+    def test_state_shape(self, client: TestClient):
+        data = client.get("/api/state").json()
+        required_keys = {
+            "mode", "message", "active_move", "countdown_ends_at",
+            "recording_started_at", "recording_duration", "recording_stats",
+            "pending_recording", "pending_playback", "pending_denoise",
+            "moves", "config", "datasets",
+        }
+        assert required_keys.issubset(data.keys())
+
+    def test_config_shape(self, client: TestClient):
+        config = client.get("/api/state").json()["config"]
+        assert config["default_duration"] == DEFAULT_DURATION
+        assert config["countdown_seconds"] == COUNTDOWN_SECONDS
+        assert config["motion_sample_rate"] == MOTION_SAMPLE_RATE
+        assert isinstance(config["audio_available"], bool)
+        assert isinstance(config["features"], dict)
+
+    def test_initial_moves_empty(self, client: TestClient):
+        data = client.get("/api/state").json()
+        assert data["moves"] == []
+
+    def test_initial_no_pending(self, client: TestClient):
+        data = client.get("/api/state").json()
+        assert data["pending_recording"] is None
+        assert data["pending_playback"] is None
+        assert data["pending_denoise"] is None
+
+
+# ──────── Recording endpoint tests ────────────────────────────────────
+
+
+class TestRecordEndpoint:
+    def test_accept_basic_recording(self, client: TestClient):
+        resp = client.post("/api/record", json={
+            "duration": 3.0,
+            "record_audio": False,
+        })
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["accepted"] is True
+        assert "move_id" in data
+
+    def test_mode_becomes_queued(self, client: TestClient):
+        client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        state = client.get("/api/state").json()
+        assert state["mode"] == "queued"
+
+    def test_reject_when_busy(self, client: TestClient):
+        # First recording is accepted
+        resp1 = client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        assert resp1.status_code == 200
+        # Second recording is rejected (mode is now "queued")
+        resp2 = client.post("/api/record", json={"duration": 3.0, "record_audio": False})
+        assert resp2.status_code == 409
+
+    def test_reject_invalid_duration_too_low(self, client: TestClient):
+        resp = client.post("/api/record", json={"duration": 0.1, "record_audio": False})
+        assert resp.status_code == 422  # Pydantic validation
+
+    def test_reject_invalid_duration_too_high(self, client: TestClient):
+        resp = client.post("/api/record", json={"duration": 999.0, "record_audio": False})
+        assert resp.status_code == 422
+
+    def test_accept_duration_edge_cases(self, client: TestClient, marionette: Marionette):
+        # Just above minimum
+        resp = client.post("/api/record", json={"duration": 0.6, "record_audio": False})
+        assert resp.status_code == 200
+        # Reset for next test
+        marionette._set_idle_state()
+        marionette._pending_recording = None
+
+        # At maximum
+        resp = client.post("/api/record", json={"duration": 300.0, "record_audio": False})
+        assert resp.status_code == 200
+
+    def test_custom_label(self, client: TestClient):
+        resp = client.post("/api/record", json={
+            "duration": 3.0,
+            "record_audio": False,
+            "label": "happy-dance",
+        })
+        data = resp.json()
+        assert data["label"] == "happy-dance"
+        assert data["move_id"] == "happy-dance"
+
+    def test_label_collision_appends_index(
+        self, client: TestClient, marionette: Marionette, tmp_dataset_root: Path
+    ):
+        # Create a file that would collide
+        data_dir = tmp_dataset_root / "local_dataset" / DATASET_DATA_SUBDIR
+        data_dir.mkdir(parents=True, exist_ok=True)
+        (data_dir / "happy-dance.json").write_text("{}")
+
+        resp = client.post("/api/record", json={
+            "duration": 3.0,
+            "record_audio": False,
+            "label": "happy-dance",
+        })
+        data = resp.json()
+        assert data["move_id"] == "happy-dance-1"
+
+    def test_preferred_duration_saved(self, client: TestClient, marionette: Marionette):
+        client.post("/api/record", json={"duration": 7.5, "record_audio": False})
+        assert marionette._preferred_duration == 7.5
+
+
+# ──────── Playback endpoint tests ─────────────────────────────────────
+
+
+class TestPlayEndpoint:
+    def test_reject_missing_move(self, client: TestClient):
+        resp = client.post("/api/play", json={"move_id": "nonexistent"})
+        assert resp.status_code == 404
+
+    def test_accept_existing_move(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        # Write a move file to the dataset
+        data_dir = marionette._dataset_dir
+        move_path = data_dir / "test-move.json"
+        move_path.write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        resp = client.post("/api/play", json={"move_id": "test-move"})
+        assert resp.status_code == 200
+        assert resp.json()["accepted"] is True
+
+    def test_reject_play_when_busy(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "test-move.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        # First play is accepted
+        resp1 = client.post("/api/play", json={"move_id": "test-move"})
+        assert resp1.status_code == 200
+        # Second play is rejected (mode is queued)
+        resp2 = client.post("/api/play", json={"move_id": "test-move"})
+        assert resp2.status_code == 409
+
+
+# ──────── Stop endpoints ──────────────────────────────────────────────
+
+
+class TestStopEndpoints:
+    def test_stop_playback_when_not_playing(self, client: TestClient):
+        resp = client.post("/api/play/stop")
+        assert resp.status_code == 200
+        assert resp.json()["stopped"] is False
+
+    def test_stop_recording_when_not_recording(self, client: TestClient):
+        resp = client.post("/api/record/stop")
+        assert resp.status_code == 200
+        assert resp.json()["stopped"] is False
+
+
+# ──────── Move deletion tests ─────────────────────────────────────────
+
+
+class TestMoveDelete:
+    def test_delete_existing_move(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        move_path = data_dir / "to-delete.json"
+        move_path.write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        resp = client.delete("/api/moves/to-delete")
+        assert resp.status_code == 200
+        assert not move_path.exists()
+
+    def test_delete_nonexistent_move(self, client: TestClient):
+        resp = client.delete("/api/moves/nonexistent")
+        assert resp.status_code == 404
+
+    def test_delete_removes_wav(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "with-audio.json").write_text(json.dumps(sample_move_json))
+        (data_dir / "with-audio.wav").write_bytes(b"RIFF" + b"\x00" * 100)
+        marionette._refresh_recordings()
+
+        client.delete("/api/moves/with-audio")
+        assert not (data_dir / "with-audio.json").exists()
+        assert not (data_dir / "with-audio.wav").exists()
+
+    def test_delete_updates_move_list(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "test-move.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        state_before = client.get("/api/state").json()
+        assert len(state_before["moves"]) == 1
+
+        client.delete("/api/moves/test-move")
+        state_after = client.get("/api/state").json()
+        assert len(state_after["moves"]) == 0
+
+
+# ──────── Dataset management tests ────────────────────────────────────
+
+
+class TestDatasets:
+    def test_initial_default_dataset(self, client: TestClient):
+        data = client.get("/api/state").json()
+        datasets = data["datasets"]
+        assert datasets["active_id"] is not None
+        assert len(datasets["entries"]) >= 1
+
+    def test_create_dataset(self, client: TestClient):
+        resp = client.post("/api/datasets", json={"name": "My Dances"})
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "created"
+        assert data["dataset"]["folder"] == "my-dances"
+
+    def test_create_duplicate_dataset_rejected(self, client: TestClient):
+        client.post("/api/datasets", json={"name": "dances"})
+        resp = client.post("/api/datasets", json={"name": "dances"})
+        assert resp.status_code == 409
+
+    def test_select_dataset(self, client: TestClient):
+        # Create a second dataset
+        resp = client.post("/api/datasets", json={"name": "second"})
+        dataset_id = resp.json()["dataset"]["id"]
+
+        # Default is auto-selected after create, so select the original
+        state = client.get("/api/state").json()
+        original_id = [
+            e["id"] for e in state["datasets"]["entries"]
+            if e["id"] != dataset_id
+        ][0]
+
+        resp = client.post("/api/datasets/select", json={"dataset_id": original_id})
+        assert resp.status_code == 200
+
+    def test_select_nonexistent_dataset(self, client: TestClient):
+        resp = client.post("/api/datasets/select", json={"dataset_id": "fake"})
+        assert resp.status_code == 404
+
+    def test_dataset_root_change(self, client: TestClient, tmp_path: Path):
+        new_root = tmp_path / "new_root"
+        new_root.mkdir()
+        resp = client.post("/api/datasets/root", json={"path": str(new_root)})
+        assert resp.status_code == 200
+        assert resp.json()["root_path"] == str(new_root)
+
+
+# ──────── Registry persistence tests ──────────────────────────────────
+
+
+class TestRegistryPersistence:
+    def test_registry_created_on_init(self, tmp_registry: Path, tmp_dataset_root: Path):
+        create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        assert tmp_registry.exists()
+        data = json.loads(tmp_registry.read_text())
+        assert "active" in data
+        assert "datasets" in data
+
+    def test_registry_survives_restart(self, tmp_registry: Path, tmp_dataset_root: Path):
+        # First instance creates a dataset
+        app1, m1 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        client1 = TestClient(app1)
+        client1.post("/api/datasets", json={"name": "persistent-ds"})
+
+        # Second instance should see it
+        app2, m2 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        client2 = TestClient(app2)
+        state = client2.get("/api/state").json()
+        folders = [e["folder"] for e in state["datasets"]["entries"]]
+        assert "persistent-ds" in folders
+
+    def test_preferred_duration_persisted(self, tmp_registry: Path, tmp_dataset_root: Path):
+        app1, m1 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        client1 = TestClient(app1)
+        client1.post("/api/record", json={"duration": 8.5, "record_audio": False})
+
+        # Re-create and check
+        _, m2 = create_app(registry_path=tmp_registry, dataset_root=tmp_dataset_root)
+        assert m2._preferred_duration == 8.5
+
+
+# ──────── Moves list / refresh tests ──────────────────────────────────
+
+
+class TestMovesRefresh:
+    def test_moves_appear_after_file_creation(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "my-move.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        state = client.get("/api/state").json()
+        move_ids = [m["id"] for m in state["moves"]]
+        assert "my-move" in move_ids
+
+    def test_move_duration_computed_correctly(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "timed.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        state = client.get("/api/state").json()
+        move = next(m for m in state["moves"] if m["id"] == "timed")
+        # 500 frames at 100Hz = 4.99s (last timestamp is 4.99)
+        assert 4.5 < move["duration"] < 5.5
+
+    def test_move_has_audio_flag(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "audio-move.json").write_text(json.dumps(sample_move_json))
+        (data_dir / "audio-move.wav").write_bytes(b"RIFF" + b"\x00" * 100)
+        marionette._refresh_recordings()
+
+        state = client.get("/api/state").json()
+        move = next(m for m in state["moves"] if m["id"] == "audio-move")
+        assert move["has_audio"] is True
+
+    def test_move_without_audio(
+        self, client: TestClient, marionette: Marionette, sample_move_json: dict
+    ):
+        data_dir = marionette._dataset_dir
+        (data_dir / "silent-move.json").write_text(json.dumps(sample_move_json))
+        marionette._refresh_recordings()
+
+        state = client.get("/api/state").json()
+        move = next(m for m in state["moves"] if m["id"] == "silent-move")
+        assert move["has_audio"] is False
+
+
+# ──────── Experiment / feature toggle tests ───────────────────────────
+
+
+class TestExperiments:
+    def test_toggle_denoise(self, client: TestClient):
+        resp = client.post("/api/experiments", json={"denoise": True})
+        assert resp.status_code == 200
+        assert resp.json()["features"]["denoise"] is True
+
+    def test_toggle_motion_models(self, client: TestClient):
+        resp = client.post("/api/experiments", json={"motion_models": True})
+        assert resp.status_code == 200
+        assert resp.json()["features"]["motion_models"] is True
+
+    def test_update_duration(self, client: TestClient):
+        resp = client.post("/api/experiments", json={"duration_seconds": 10.0})
+        assert resp.status_code == 200
+        assert resp.json()["preferred_duration"] == 10.0
+
+    def test_no_changes(self, client: TestClient):
+        resp = client.post("/api/experiments", json={})
+        assert resp.json()["status"] == "unchanged"
+
+
+# ──────── Sensor data dummy endpoint ──────────────────────────────────
+
+
+class TestSensorData:
+    def test_returns_empty(self, client: TestClient):
+        resp = client.get("/sensor_data")
+        assert resp.status_code == 200
+        assert resp.json() == {}