chore(sync): mirror backend .py + Dockerfile to Space (hf-sync-backend)

Automated backend sync from szl-holdings/a11oy main via hf-sync-backend.
Updated (differed from the Space): (none)
Deleted (gone from the repo + Dockerfile COPY set): test/test_atlas_registry_alignment.py, test/test_brainhealth_wiring.py, test/test_council_contract.py, test/test_holographic_zero_cdn.py, test/test_public_verify_routes.py, test/test_source_attestation.py, tools/readiness-harness/test_experience_contract.py

Keeps the Space-built backend (serve.py + the Dockerfile-COPY'd .py
modules) identical to GitHub main so the Space never rebuilds from a
stale backend, new endpoints don't 404 there, and orphaned modules
removed from the repo don't linger in the Space tree.

test/test_atlas_registry_alignment.py

@@ -1,71 +0,0 @@
-"""Regression tests for the canonical Atlas roster and brain-trust lens."""
-from __future__ import annotations
-
-import re
-import unittest
-from pathlib import Path
-
-import szl3d_holographic
-import szl_kc_atlas
-
-
-class AtlasRegistryAlignmentTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.map = szl_kc_atlas.atlas_map(seed=42)
-
-    def test_denominator_is_the_canonical_shell_registry(self) -> None:
-        shell_ids = [row["id"] for row in szl3d_holographic.SURFACES]
-        atlas_ids = [
-            row["id"]
-            for cluster in self.map["clusters"]
-            for row in cluster["surfaces"]
-        ]
-        self.assertEqual(self.map["registry"]["source"], "szl3d_holographic.SURFACES")
-        self.assertTrue(self.map["registry"]["loaded"])
-        self.assertEqual(self.map["surface_count"], len(shell_ids))
-        self.assertCountEqual(atlas_ids, shell_ids)
-        self.assertEqual(len(atlas_ids), len(set(atlas_ids)))
-
-    def test_coverage_cannot_hide_roster_drift(self) -> None:
-        self.assertEqual(self.map["coverage_denominator"], "szl3d_holographic.SURFACES")
-        self.assertEqual(self.map["total_classified"], self.map["surface_count"])
-        self.assertEqual(self.map["coverage"], 1.0)
-        self.assertEqual(self.map["orphans"], [])
-        self.assertEqual(self.map["unknown_assignments"], [])
-        self.assertEqual(self.map["double_counts"], [])
-        self.assertRegex(self.map["registry"]["sha256"], r"^[0-9a-f]{64}$")
-
-    def test_atlas_is_included_and_unclaimed_labels_stay_unspecified(self) -> None:
-        by_id = {
-            row["id"]: row
-            for cluster in self.map["clusters"]
-            for row in cluster["surfaces"]
-        }
-        self.assertIn("atlas", by_id)
-        self.assertTrue(self.map["atlas_membership"]["included_in_surface_count"])
-        self.assertEqual(by_id["atlas"]["label"], "MODELED")
-        # `circuits` was added after the embedded Wave-27 label snapshot and its canonical
-        # title makes no maturity claim. The Atlas must not silently promote it.
-        self.assertEqual(by_id["circuits"]["label"], "UNSPECIFIED")
-
-    def test_brain_lens_is_read_only_and_reproducible_in_the_surface(self) -> None:
-        js = (Path(__file__).parents[1] / "static" / "3d" / "surfaces" / "atlas.js").read_text(encoding="utf-8")
-        self.assertIn("/api/a11oy/v1/brain/health", js)
-        self.assertIn("/api/a11oy/v1/brain/gaps", js)
-        self.assertIn("brain/health?q=", js)
-        self.assertIn("brain/gaps?q=", js)
-        self.assertIn("Purpose · Try · Evidence · Limits · Reproduce", js)
-        self.assertIn("no memory write, no model call, no action", js)
-        self.assertNotRegex(js, re.compile(r"fetch\([^\n]+method\s*:\s*[\"']POST", re.I))
-
-    def test_registry_module_aliases_resolve(self) -> None:
-        surface_dir = Path(__file__).parents[1] / "static" / "3d" / "surfaces"
-        for surface in szl3d_holographic.SURFACES:
-            module_id = surface.get("module", surface["id"])
-            self.assertTrue((surface_dir / (module_id + ".js")).is_file(), surface["id"])
-        markets = next(row for row in szl3d_holographic.SURFACES if row["id"] == "markets")
-        self.assertEqual(markets["module"], "finance")
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_brainhealth_wiring.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import unittest
-
-import szl_brainhealth as health
-
-
-class BrainHealthWiringTests(unittest.TestCase):
-    def test_real_sibling_entrypoints_and_call_styles_are_explicit(self) -> None:
-        specs = {row["key"]: row for row in health.COMPONENTS}
-        self.assertEqual(specs["freshness"]["funcs"], ("build_aggregate",))
-        self.assertEqual(specs["provenance"]["call_style"], "ns_q_k")
-        self.assertEqual(specs["contradiction"]["funcs"], ("run_detection",))
-        self.assertEqual(specs["uncertainty"]["funcs"], ("handle_uncertainty",))
-
-    def test_uncertainty_is_inverted_to_trust_direction(self) -> None:
-        payload = health._normalize_component_payload(
-            "uncertainty",
-            {"label": "MODELED", "verdict": "HIGHLY-UNCERTAIN", "uncertainty": 0.91, "abstain_recommended": True},
-        )
-        self.assertEqual(payload["trust_value"], 0.09)
-        self.assertTrue(payload["abstain"])
-
-    def test_descriptive_prose_does_not_create_a_false_adverse_signal(self) -> None:
-        payload = {
-            "label": "MODELED",
-            "verdict": "WEAK-GROUNDING",
-            "should_abstain": False,
-            "note": "the system abstains only when evidence is insufficient",
-        }
-        self.assertIsNone(health._detect_adverse(payload, ("ungrounded",)))
-
-    def test_freshness_uses_real_node_distribution(self) -> None:
-        payload = health._normalize_component_payload(
-            "freshness",
-            {"label": "MEASURED", "node_count": 100, "verdict_counts": {"FRESH": 5, "AGING": 15, "STALE": 80}},
-        )
-        self.assertEqual(payload["trust_value"], 0.2)
-        self.assertTrue(payload["stale_dominant"])
-        self.assertEqual(payload["verdict"], "STALE-DOMINANT")
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_council_contract.py

@@ -1,82 +0,0 @@
-import unittest
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-import a11oy_ayllu as ayllu
-import a11oy_nemo_core as nemo
-
-
-class CouncilContractTests(unittest.TestCase):
-    def _result(self):
-        return {
-            "participants": ["Amaru", "Yupaq"],
-            "mode": "single-round",
-            "rounds": [
-                {"persona": "Amaru", "round": 1, "model": "test-model",
-                 "stub": False, "answer": "Architecture proposal."},
-                {"persona": "Yupaq", "round": 1, "model": "test-model",
-                 "stub": False, "answer": "Evidence gap."},
-            ],
-        }
-
-    def test_generic_nemo_route_is_governance_first(self):
-        route = nemo.govern_route("Review a high-consequence agent action", top_k=2)
-        self.assertEqual(route["experts_selected"], ["governance", "code"])
-        self.assertEqual(route["routing_evidence_state"], "HEURISTIC")
-        self.assertEqual(route["experts"][0]["selection_basis"],
-                         "explicit-governance-first-fallback")
-
-    def test_contract_is_proposal_only_and_replay_is_deterministic(self):
-        routing = {"state": "HEURISTIC", "experts_selected": ["governance"]}
-        one = ayllu._build_council_contract("review this", self._result(), routing)
-        two = ayllu._build_council_contract("review this", self._result(), routing)
-        self.assertEqual(one["schema"], ayllu.COUNCIL_SCHEMA)
-        self.assertEqual(one["decision_state"], "PROPOSAL_ONLY")
-        self.assertEqual(one["semantic_consensus"]["state"], "NOT_MEASURED")
-        self.assertTrue(one["human_checkpoint"]["required"])
-        self.assertEqual(one["evidence_state"], "LIVE")
-        self.assertEqual(one["replay"]["key"], two["replay"]["key"])
-
-    def test_runtime_signer_is_preferred(self):
-        def signer(payload):
-            return {"signed": True, "payload": "encoded", "signatures": [{"sig": "x"}]}
-
-        receipt = ayllu._make_receipt({"decision": "proposal"}, sign_fn=signer)
-        self.assertTrue(receipt["signed"])
-        self.assertEqual(receipt["payload"], "encoded")
-
-    def test_manifest_discloses_no_trained_weights(self):
-        manifest = ayllu.council_manifest()
-        self.assertFalse(manifest["nemo"]["weights_present"])
-        self.assertEqual(manifest["nemo"]["training_state"], "NOT_PERFORMED")
-        self.assertEqual(manifest["limits"]["decision_state"], "PROPOSAL_ONLY")
-
-    def test_http_council_emits_signed_contract(self):
-        app = FastAPI()
-        app.state.szl_sign_receipt = lambda payload: {
-            "signed": True, "payload": "encoded", "signatures": [{"sig": "test"}]}
-        ayllu.register(app)
-
-        async def fake_complete(system, prompt, **kwargs):
-            return {"text": "bounded answer", "model": "test-model", "stub": False}
-
-        original = ayllu._backend.model_complete
-        ayllu._backend.model_complete = fake_complete
-        try:
-            response = TestClient(app).post(
-                "/api/a11oy/v1/ayllu/council",
-                json={"prompt": "Review this proposal", "personas": ["Amaru"]})
-        finally:
-            ayllu._backend.model_complete = original
-        self.assertEqual(response.status_code, 200)
-        body = response.json()
-        self.assertEqual(body["contract"]["decision_state"], "PROPOSAL_ONLY")
-        self.assertTrue(body["receipt"]["signed"])
-        self.assertEqual(body["contract"]["routing"]["state"], "HEURISTIC")
-        self.assertEqual(body["contract"]["chain"]["state"], "LIVE")
-        self.assertTrue(body["contract"]["chain"]["chain_verified"])
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_holographic_zero_cdn.py

@@ -1,133 +0,0 @@
-"""Zero-CDN and honest same-origin evidence contract regressions."""
-from __future__ import annotations
-
-import hashlib
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-import szl3d_holographic as holographic
-
-
-class HolographicZeroCdnTests(unittest.TestCase):
-    def _json(self, url: str):
-        if "api/models" in url:
-            return [{"downloads": 3}, {"downloads": 7}]
-        if "api/datasets" in url:
-            return [{"downloads": 11}]
-        if "api/spaces" in url:
-            return [{"likes": 5}]
-        if "api/collections" in url:
-            return [{"slug": "governed-estate"}]
-        if "api.github.com" in url:
-            return [{"stargazers_count": 2}]
-        raise AssertionError(f"unexpected test URL: {url}")
-
-    @staticmethod
-    def _health(_url: str):
-        return {"read_state": "LIVE", "health_state": "ok", "up": True}
-
-    def test_authored_3d_tree_has_no_external_runtime_fetch(self):
-        violations = list(holographic.no_cdn_violations(holographic._base_dir()))
-        self.assertEqual(violations, [])
-        brain = (Path(__file__).parents[1] / "static" / "3d" / "brain.html").read_text(encoding="utf-8")
-        self.assertIn('fetch(BRAIN_EVIDENCE', brain)
-        self.assertIn('const BRAIN_EVIDENCE = "/api/a11oy/v1/holographic/brain/evidence"', brain)
-        self.assertNotIn('fetch("https://', brain)
-        self.assertNotIn("fetch('https://", brain)
-
-    def test_complete_observation_is_live_and_measured(self):
-        formula_source = "theorem one : True := by trivial\n  theorem two : True := by trivial\n"
-        payload = holographic.brain_evidence(
-            fetch_json=self._json,
-            fetch_text=lambda _url: formula_source,
-            fetch_health=self._health,
-            expected_formula_sha256=hashlib.sha256(formula_source.encode("utf-8")).hexdigest(),
-        )
-        self.assertEqual(payload["state"], "LIVE")
-        self.assertEqual(payload["live_lobes"], payload["lobe_count"])
-        self.assertEqual(payload["lobes"]["formulas"]["theorem_count"], 2)
-        self.assertEqual(payload["lobes"]["formulas"]["integrity_state"], "VERIFIED")
-        self.assertFalse(payload["lobes"]["formulas"]["mutable_reference"])
-        self.assertEqual(payload["lobes"]["models"]["downloads_sum"], 10)
-        self.assertEqual(payload["lobes"]["fleet"]["up_count"], 5)
-        self.assertFalse(payload["limits"]["cache_or_last_good_fallback"])
-        self.assertTrue(payload["limits"]["fixed_allowlist"])
-
-    def test_failed_composite_source_is_not_hidden_by_partial_count(self):
-        def partial_json(url: str):
-            if "author=zai-org" in url:
-                raise TimeoutError("test timeout")
-            return self._json(url)
-
-        formula_source = "theorem one : True := by trivial\n"
-        payload = holographic.brain_evidence(
-            fetch_json=partial_json,
-            fetch_text=lambda _url: formula_source,
-            fetch_health=self._health,
-            expected_formula_sha256=hashlib.sha256(formula_source.encode("utf-8")).hexdigest(),
-        )
-        frontier = payload["lobes"]["frontier"]
-        self.assertEqual(payload["state"], "DEGRADED")
-        self.assertEqual(frontier["state"], "UNAVAILABLE")
-        self.assertIsNone(frontier["count"])
-        failed = next(row for row in frontier["sources"] if row["org"] == "zai-org")
-        self.assertEqual(failed["reason"], "upstream_unreachable_or_timeout")
-
-    def test_formula_source_is_commit_pinned_and_hash_allowlisted(self):
-        url = holographic._BRAIN_SOURCES["formulas"]
-        self.assertIn(holographic._BRAIN_FORMULA_COMMIT, url)
-        self.assertNotIn("/main/", url)
-        self.assertEqual(len(holographic._BRAIN_FORMULA_COMMIT), 40)
-        self.assertEqual(len(holographic._BRAIN_FORMULA_SHA256), 64)
-
-    def test_formula_integrity_is_persistently_visible_not_hover_only(self):
-        brain = (Path(__file__).parents[1] / "static" / "3d" / "brain.html").read_text(encoding="utf-8")
-        self.assertIn('proof.id = "formula-attestation"', brain)
-        self.assertIn('proof.setAttribute("aria-live", "polite")', brain)
-        self.assertIn('s.source_commit', brain)
-        self.assertIn('s.content_sha256', brain)
-        self.assertIn('s.integrity_state', brain)
-        self.assertIn('setFormulaAttestation(s.attestation, "VERIFIED")', brain)
-        self.assertIn('integrity UNAVAILABLE · no theorem count trusted', brain)
-
-    def test_formula_hash_mismatch_is_unavailable_not_measured(self):
-        payload = holographic.brain_evidence(
-            fetch_json=self._json,
-            fetch_text=lambda _url: "theorem tampered : True := by trivial\n",
-            fetch_health=self._health,
-        )
-        formula = payload["lobes"]["formulas"]
-        self.assertEqual(payload["state"], "DEGRADED")
-        self.assertEqual(formula["state"], "UNAVAILABLE")
-        self.assertEqual(formula["reason"], "source_integrity_mismatch")
-        self.assertNotIn("theorem_count", formula)
-
-    def test_route_is_get_only_no_store_and_same_contract(self):
-        app = FastAPI()
-        expected = {
-            "schema": "a11oy.holographic.brain-evidence.v1",
-            "state": "UNAVAILABLE",
-            "lobes": {},
-        }
-        with patch.object(holographic, "brain_evidence", return_value=expected):
-            holographic.register(app, ns="a11oy")
-            client = TestClient(app)
-            response = client.get("/api/a11oy/v1/holographic/brain/evidence")
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), expected)
-        self.assertEqual(response.headers["cache-control"], "no-store")
-        methods = {
-            method
-            for route in app.routes
-            if getattr(route, "path", None) == "/api/a11oy/v1/holographic/brain/evidence"
-            for method in route.methods
-        }
-        self.assertEqual(methods, {"GET"})
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_public_verify_routes.py

@@ -1,56 +0,0 @@
-import base64
-import json
-import unittest
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-import szl_public_verify
-
-
-class PublicVerifyRouteTests(unittest.TestCase):
-    def setUp(self):
-        self.app = FastAPI()
-
-        @self.app.api_route("/api/a11oy/{path:path}", methods=["GET", "POST"])
-        async def proxy_catch_all(path: str):
-            return {"caught_by": "proxy", "path": path}
-
-        szl_public_verify.register(self.app, ns="a11oy")
-        self.client = TestClient(self.app)
-
-    def test_exact_routes_are_before_proxy(self):
-        paths = [getattr(route, "path", None) for route in self.app.router.routes]
-        self.assertLess(paths.index("/api/a11oy/v1/verify/receipt"),
-                        paths.index("/api/a11oy/{path:path}"))
-
-    def test_get_exact_path_returns_manifest(self):
-        response = self.client.get("/api/a11oy/v1/verify/receipt")
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json()["schema"],
-                         "szl.public-receipt-verifier/manifest/v1")
-
-    def test_post_exact_path_reaches_verifier(self):
-        response = self.client.post("/api/a11oy/v1/verify/receipt", json={})
-        self.assertEqual(response.status_code, 400)
-        self.assertNotIn("caught_by", response.json())
-
-    def test_in_image_receipt_uses_runtime_verifier(self):
-        self.app.state.szl_verify_receipt = lambda envelope: {
-            "signature_valid": True, "detail": "verified by test runtime key"}
-        payload = base64.b64encode(json.dumps({"decision": "proposal"}).encode()).decode()
-        envelope = {
-            "payloadType": "application/vnd.szl.receipt+json",
-            "payload": payload,
-            "signatures": [{"keyid": "a11oy-inimage-ecdsa-p256", "sig": "test"}],
-        }
-        response = self.client.post("/api/a11oy/v1/verify/receipt",
-                                    json={"envelope": envelope})
-        self.assertEqual(response.status_code, 200)
-        signature = response.json()["checks"][0]
-        self.assertEqual(signature["status"], "VERIFIED")
-        self.assertEqual(signature["verify_key_url"], "/cosign.pub")
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_source_attestation.py

@@ -1,64 +0,0 @@
-import os
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
-from fastapi.testclient import TestClient
-
-import szl_source_attestation as source
-
-
-ROOT = Path(__file__).resolve().parents[1]
-SOURCE_OBSERVATION = {
-    "repository": "szl-holdings/a11oy",
-    "commit": "adac37574f88a30ff099f3ec7f548685d4166e6f",
-    "path": "",
-    "relation": "declared-source-with-hf-overlay",
-    "state": "VERIFIED_REFERENCE",
-    "evidence_url": "https://github.com/szl-holdings/a11oy/commit/adac37574f88a30ff099f3ec7f548685d4166e6f",
-}
-
-
-class SourceAttestationTests(unittest.TestCase):
-    def setUp(self):
-        self.app = FastAPI()
-
-        @self.app.get("/{full_path:path}")
-        async def spa_fallback(full_path: str):  # noqa: ARG001
-            return HTMLResponse("<html>SPA</html>")
-
-        source.register(
-            self.app,
-            "SZLHOLDINGS/a11oy",
-            SOURCE_OBSERVATION,
-            "PENDING_GITHUB_SYNC",
-        )
-        self.client = TestClient(self.app)
-
-    def test_exact_route_precedes_spa_and_returns_bounded_json(self):
-        paths = [getattr(route, "path", None) for route in self.app.router.routes]
-        self.assertLess(paths.index("/.well-known/szl-source.json"), paths.index("/{full_path:path}"))
-        with patch.dict(os.environ, {"SPACE_REPOSITORY_COMMIT": "a" * 40}):
-            response = self.client.get("/.well-known/szl-source.json")
-        self.assertEqual(200, response.status_code)
-        self.assertEqual("application/json", response.headers["content-type"])
-        self.assertEqual("no-store", response.headers["cache-control"])
-        self.assertEqual("COMPUTED", response.headers["x-szl-evidence-state"])
-        self.assertEqual("STRUCTURAL_ONLY", response.headers["x-szl-verification-state"])
-        self.assertEqual("READ_ONLY", response.headers["x-szl-authority-state"])
-        body = response.json()
-        self.assertEqual("a" * 40, body["deployment"]["hf_revision"])
-        self.assertEqual("PENDING_GITHUB_SYNC", body["alignment_state"])
-        self.assertEqual("VERIFIED_REFERENCE", body["source"]["state"])
-        for claim in ("github_parity", "reproducible_build", "build_provenance"):
-            self.assertEqual("NOT_CLAIMED", body["claims"][claim])
-
-    def test_docker_runtime_includes_module(self):
-        dockerfile = (ROOT / "Dockerfile").read_text(encoding="utf-8")
-        self.assertIn("szl_source_attestation.py", dockerfile)
-
-
-if __name__ == "__main__":
-    unittest.main()

tools/readiness-harness/test_experience_contract.py

@@ -1,60 +0,0 @@
-"""Static regression checks for the A11OY experience/data-contract first wave."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-import unittest
-
-
-ROOT = Path(__file__).resolve().parents[2]
-
-
-class ExperienceContractTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls) -> None:
-        cls.matrix = json.loads((ROOT / "tools/readiness-harness/tabs.json").read_text(encoding="utf-8"))
-        cls.landing = (ROOT / "a11oy_landing.html").read_text(encoding="utf-8")
-        cls.console = (ROOT / "pages/console.html").read_text(encoding="utf-8")
-        cls.server = (ROOT / "serve.py").read_text(encoding="utf-8")
-        cls.dockerfile = (ROOT / "Dockerfile").read_text(encoding="utf-8")
-
-    def test_matrix_is_publicly_shipped(self) -> None:
-        self.assertIn(
-            "COPY tools/readiness-harness/tabs.json ./tools/readiness-harness/tabs.json",
-            self.dockerfile,
-        )
-        self.assertEqual(self.matrix["version"], "1.1")
-        self.assertEqual(set(self.matrix["stateVocabulary"]), {
-            "LIVE", "MEASURED", "MODELED", "SNAPSHOT", "SAMPLE", "CACHED", "UNAVAILABLE",
-        })
-
-    def test_endpoint_methods_match_console_calls(self) -> None:
-        endpoints = self.matrix["endpoints"]
-        self.assertEqual(endpoints["/api/a11oy/v1/policy/compliance"]["method"], "POST")
-        self.assertEqual(endpoints["/api/a11oy/v1/operator/recommend"]["method"], "GET")
-        self.assertIn("orgPost('core','/api/a11oy/v1/policy/compliance'", self.console)
-        self.assertIn("orgGet('core','/api/a11oy/v1/operator/recommend'", self.console)
-
-    def test_readiness_endpoint_has_compact_honest_state(self) -> None:
-        self.assertIn('view: str = "full"', self.server)
-        self.assertIn('"X-A11OY-Data-State": "SNAPSHOT"', self.server)
-        self.assertIn('"X-A11OY-Transport-State": "REACHABLE"', self.server)
-        self.assertIn('"X-A11OY-Data-State": "UNAVAILABLE"', self.server)
-        self.assertIn('matrix if view != "summary" else None', self.server)
-
-    def test_landing_has_accessible_live_pulse(self) -> None:
-        self.assertIn('class="skip-link" href="#main"', self.landing)
-        self.assertIn('id="estate-pulse"', self.landing)
-        self.assertIn('/readiness/tab-matrix?view=summary', self.landing)
-        self.assertNotIn('href="/warhacker"', self.landing)
-
-    def test_console_navigation_is_keyboard_native_and_runtime_checked(self) -> None:
-        self.assertIn("document.createElement('button')", self.console)
-        self.assertIn('id="runtime-status" role="status" aria-live="polite"', self.console)
-        self.assertIn('class="skip-link" href="#content"', self.console)
-        self.assertNotIn('<span class="live"><span class="live-dot"></span>LIVE</span>', self.console)
-
-
-if __name__ == "__main__":
-    unittest.main()