238 lines
7.8 KiB
Python
238 lines
7.8 KiB
Python
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping, Sequence
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
from fastapi.testclient import TestClient
|
|
|
|
from game_data_capture.config import ServerConfig
|
|
from game_data_capture.web.app import (
|
|
CaptureRecord,
|
|
CaptureSessionStatus,
|
|
ControlOutcome,
|
|
MediaDescriptor,
|
|
MutationOutcome,
|
|
WebConfig,
|
|
create_app,
|
|
)
|
|
from game_data_capture.web.security import new_bootstrap_token
|
|
|
|
_ID = "capture-00000000000000000000000000000002"
|
|
|
|
|
|
@dataclass
|
|
class CaptureControl:
|
|
armed: bool = False
|
|
|
|
def status(self) -> CaptureSessionStatus:
|
|
return CaptureSessionStatus(self.armed, 1, 64)
|
|
|
|
def start_session(self) -> ControlOutcome:
|
|
self.armed = True
|
|
return "started"
|
|
|
|
def stop_session(self) -> ControlOutcome:
|
|
self.armed = False
|
|
return "stopped"
|
|
|
|
|
|
class Corpus:
|
|
def __init__(self) -> None:
|
|
self.record = CaptureRecord(_ID, "stored", "2026-07-31T00:00:00Z", None)
|
|
self.rejected = False
|
|
self.deleted = False
|
|
|
|
def list_captures(self, *, limit: int) -> Sequence[CaptureRecord]:
|
|
return (self.record,)
|
|
|
|
def get_capture(self, capture_id: str) -> CaptureRecord | None:
|
|
return self.record if capture_id == _ID else None
|
|
|
|
def open_media(self, capture_id: str) -> MediaDescriptor | None:
|
|
return MediaDescriptor("image/png", 3, [b"png"]) if capture_id == _ID else None
|
|
|
|
def label(self, capture_id: str, classification: Mapping[str, object]) -> MutationOutcome:
|
|
if capture_id != _ID:
|
|
return "not_found"
|
|
self.record = CaptureRecord(_ID, "stored", "2026-07-31T00:00:00Z", dict(classification))
|
|
return "updated"
|
|
|
|
def reject_preserving_evidence(self, capture_id: str) -> MutationOutcome:
|
|
if capture_id != _ID:
|
|
return "not_found"
|
|
self.rejected = True
|
|
return "updated"
|
|
|
|
def delete_with_retention(self, capture_id: str) -> MutationOutcome:
|
|
if capture_id != _ID:
|
|
return "not_found"
|
|
self.deleted = True
|
|
return "updated"
|
|
|
|
|
|
def test_private_capture_labeling_flow_preserves_rejection_before_retention_delete() -> None:
|
|
token = new_bootstrap_token()
|
|
control = CaptureControl()
|
|
corpus = Corpus()
|
|
client = TestClient(
|
|
create_app(
|
|
config=WebConfig(ServerConfig()),
|
|
capture_control=control,
|
|
corpus=corpus,
|
|
bootstrap_token=token,
|
|
),
|
|
base_url="http://127.0.0.1:8765",
|
|
)
|
|
origin = "http://127.0.0.1:8765"
|
|
csrf = str(
|
|
client.post("/api/bootstrap", headers={"Origin": origin}, json={"token": token}).json()[
|
|
"csrf_token"
|
|
]
|
|
)
|
|
label = {
|
|
"family": "gear",
|
|
"view": "detail",
|
|
"gear_slot": "Mask",
|
|
"record_types": ["gear", "brand_set"],
|
|
"confidence": 1.0,
|
|
"abstention_reason": None,
|
|
}
|
|
|
|
response = client.post(
|
|
f"/api/captures/{_ID}/label", headers={"Origin": origin, "X-CSRF-Token": csrf}, json=label
|
|
)
|
|
assert response.status_code == 200
|
|
csrf = str(response.json()["csrf_token"])
|
|
assert client.get(f"/api/captures/{_ID}").json()["capture"]["classification"] == label
|
|
response = client.post(
|
|
f"/api/captures/{_ID}/reject",
|
|
headers={"Origin": origin, "X-CSRF-Token": csrf},
|
|
json={"confirmation": "REJECT"},
|
|
)
|
|
assert response.status_code == 200
|
|
csrf = str(response.json()["csrf_token"])
|
|
assert corpus.rejected is True
|
|
response = client.post(
|
|
f"/api/captures/{_ID}/delete",
|
|
headers={"Origin": origin, "X-CSRF-Token": csrf},
|
|
json={"confirmation": "DELETE"},
|
|
)
|
|
assert response.status_code == 200
|
|
assert corpus.deleted is True
|
|
|
|
|
|
def test_mod_labels_round_trip_through_the_reviewed_label_route() -> None:
|
|
token = new_bootstrap_token()
|
|
client = TestClient(
|
|
create_app(
|
|
config=WebConfig(ServerConfig()),
|
|
capture_control=CaptureControl(),
|
|
corpus=Corpus(),
|
|
bootstrap_token=token,
|
|
),
|
|
base_url="http://127.0.0.1:8765",
|
|
)
|
|
origin = "http://127.0.0.1:8765"
|
|
csrf = str(
|
|
client.post("/api/bootstrap", headers={"Origin": origin}, json={"token": token}).json()[
|
|
"csrf_token"
|
|
]
|
|
)
|
|
|
|
for family, record_type in (("weapon_mod", "weapon_mod"), ("gear_mod", "gear_mod")):
|
|
label = {
|
|
"family": family,
|
|
"view": "detail",
|
|
"gear_slot": None,
|
|
"record_types": [record_type],
|
|
"confidence": 1.0,
|
|
"abstention_reason": None,
|
|
}
|
|
response = client.post(
|
|
f"/api/captures/{_ID}/label",
|
|
headers={"Origin": origin, "X-CSRF-Token": csrf},
|
|
json=label,
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
csrf = str(response.json()["csrf_token"])
|
|
assert client.get(f"/api/captures/{_ID}").json()["capture"]["classification"] == label
|
|
|
|
|
|
def test_review_ui_uses_local_external_assets_and_keeps_guardrails_in_static_source() -> None:
|
|
web_root = Path(__file__).parents[2] / "src" / "game_data_capture" / "web"
|
|
template = (web_root / "templates" / "index.html").read_text(encoding="utf-8")
|
|
script = (web_root / "static" / "review.js").read_text(encoding="utf-8")
|
|
stylesheet = (web_root / "static" / "review.css").read_text(encoding="utf-8")
|
|
|
|
assert 'href="/static/review.css"' in template
|
|
assert 'src="/static/review.js"' in template
|
|
assert "<style" not in template
|
|
assert "<script>" not in template
|
|
assert "http://" not in template + script + stylesheet
|
|
assert "https://" not in template + script + stylesheet
|
|
assert "innerHTML" not in script
|
|
assert "Origin" not in script
|
|
assert (
|
|
'history.replaceState(null, "", `${window.location.pathname}${window.location.search}`)'
|
|
in script
|
|
)
|
|
assert '"/api/session/start"' in script
|
|
assert "JSON.stringify({ confirmation })" in script
|
|
assert "confidence: 1.0" in script
|
|
assert 'credentials: "same-origin"' in script
|
|
assert "localStorage" not in script
|
|
assert "sessionStorage" not in script
|
|
assert "document.cookie" not in script
|
|
for expected in (
|
|
"weapon",
|
|
"gear",
|
|
"skill_chip",
|
|
"os_protocol",
|
|
"specialization",
|
|
"weapon_mod",
|
|
"gear_mod",
|
|
"unknown",
|
|
"Mask",
|
|
"Gloves",
|
|
"Backpack",
|
|
"Body Armor",
|
|
"Holster",
|
|
"Knee Pads",
|
|
"prefers-reduced-motion",
|
|
):
|
|
assert expected in script + stylesheet
|
|
|
|
|
|
def test_review_page_and_local_static_assets_serve_with_security_headers() -> None:
|
|
client = TestClient(
|
|
create_app(
|
|
config=WebConfig(ServerConfig()),
|
|
capture_control=CaptureControl(),
|
|
corpus=Corpus(),
|
|
bootstrap_token=new_bootstrap_token(),
|
|
),
|
|
base_url="http://127.0.0.1:8765",
|
|
)
|
|
|
|
page = client.get("/")
|
|
stylesheet = client.get("/static/review.css")
|
|
script = client.get("/static/review.js")
|
|
|
|
for response in (page, stylesheet, script):
|
|
assert response.status_code == 200
|
|
assert response.headers["content-security-policy"].startswith("default-src 'self'")
|
|
assert response.headers["referrer-policy"] == "no-referrer"
|
|
assert response.headers["x-content-type-options"] == "nosniff"
|
|
assert response.headers["x-frame-options"] == "DENY"
|
|
assert "http://" not in response.text
|
|
assert "https://" not in response.text
|
|
assert 'href="/static/review.css"' in page.text
|
|
assert 'src="/static/review.js"' in page.text
|
|
assert stylesheet.headers["content-type"].startswith("text/css")
|
|
assert "csrfPattern" in script.text
|
|
assert "setCheckedMembers" in script.text
|
|
assert "announce: false" in script.text
|
|
assert 'id="hide-reviewed"' in page.text
|