From 474e14e0e89b29c91b7c3f53ebea438aa9730b1c Mon Sep 17 00:00:00 2001 From: ScottW514 Date: Fri, 21 Aug 2026 09:49:35 -0400 Subject: [PATCH] Make the acceptance page answer the operator, not the timer Presses on Start and Continue were being swallowed. Every poll rebuilt the whole test table and the prompt buttons with innerHTML, and a button destroyed between mousedown and mouseup raises no click event at all: the press simply vanished. Measured on the page as it stood, a Start button node was replaced 13 times in 40 seconds, and with a poll landing mid-press 8 presses out of 8 were lost. Rows, prompt buttons and tool entries are now built once and afterwards only updated in place through setters that skip the write when the value has not changed; under the same test 8 presses out of 8 land. The page also felt slow because each poll re-read and re-parsed the whole result log and recomputed all 42 domain fingerprints. A result record carries its run log, so the file reaches megabytes over a campaign and the poll cost grew with it. The log now parses each line once and reads only the bytes appended since, and a fingerprint is memoized against the manifest's content hash. On the same manifest, catalog and log, one /state goes from 8.89 ms to 0.10 ms at 0.89 MB and from 41.79 ms to 0.23 ms at 10.62 MB, and no longer grows with the log. Actions now report on the press instead of on the next poll: Start greys every Start and marks the row, Continue and Abort grey themselves, and each pulls the next poll forward. /state carries an ETag so an idle page polls for a 304, the poll ticks faster during a run, and the connection is kept alive rather than handshaking per request. Keeping the connection alive exposed a hazard worth naming: a POST refused before its body was read left that body in the socket, where the next read took it for a request line. A refusal now ends the connection. forgetest is a dev-only component and can never appear in a coverage map, so this has no acceptance catalog consequence; the host tests carry the proof, including one that fails if a per-poll innerHTML rebuild ever comes back. --- forgetest/forgetest/catalog.py | 13 +- forgetest/forgetest/log.py | 58 +++++-- forgetest/forgetest/manifest.py | 19 +- forgetest/forgetest/page.py | 231 ++++++++++++++++++------- forgetest/forgetest/server.py | 45 ++++- forgetest/tests/test_responsiveness.py | 199 +++++++++++++++++++++ forgetest/tests/test_server.py | 74 +++++++- 7 files changed, 552 insertions(+), 87 deletions(-) create mode 100644 forgetest/tests/test_responsiveness.py diff --git a/forgetest/forgetest/catalog.py b/forgetest/forgetest/catalog.py index 06d91f1..e9fb64f 100644 --- a/forgetest/forgetest/catalog.py +++ b/forgetest/forgetest/catalog.py @@ -39,6 +39,7 @@ class Test: self.description = description or (fn.__doc__ or "").strip() self.fn = fn self._source_sha = None + self._fp = (None, None) # (manifest content sha, fingerprint) @property def source_sha(self): @@ -51,7 +52,17 @@ class Test: return self._source_sha def fingerprint(self, manifest): - return _manifest.fingerprint(manifest, self.covers, extra=[self.source_sha]) + """The domain fingerprint on this manifest, memoized by the + manifest's content hash: the page recomputes every test's + fingerprint on every poll, and a manifest never changes under a + running tool.""" + key = manifest.content_sha + if key and self._fp[0] == key: + return self._fp[1] + fp = _manifest.fingerprint(manifest, self.covers, extra=[self.source_sha]) + if key: + self._fp = (key, fp) + return fp def definition(self): """The gate-visible definition (no implementation, no prose).""" diff --git a/forgetest/forgetest/log.py b/forgetest/forgetest/log.py index ce2a47c..27e8c27 100644 --- a/forgetest/forgetest/log.py +++ b/forgetest/forgetest/log.py @@ -13,6 +13,11 @@ One JSON object per line under the data directory (default Every record carries "t" (type) and "ts" (UTC, ISO 8601, seconds). The file is only ever appended; a corrupt line is skipped, counted, and reported, never repaired in place. + +Because the file only grows, `read` parses each line once and keeps what +it parsed; a later call reads only the bytes appended since. A result +record carries the whole run log, so the file reaches megabytes over a +campaign, and the page asks for the state every second or two. """ import json import os @@ -35,6 +40,9 @@ class Log: self.path = path or os.path.join(data_dir(), "results.jsonl") self._lock = threading.Lock() self.corrupt = 0 + self._recs = [] # every record parsed so far, in file order + self._offset = 0 # bytes of the file already consumed + self._tail = b"" # bytes past the last newline: not a record yet def append(self, rec): rec = dict(rec) @@ -48,28 +56,54 @@ class Log: os.fsync(f.fileno()) return rec - def read(self): - recs = [] + def _forget(self): + """Drop what was parsed: the next read starts from the top.""" + self._recs = [] + self._offset = 0 + self._tail = b"" self.corrupt = 0 - if not os.path.exists(self.path): - return recs - with self._lock: - with open(self.path, "r", encoding="utf-8") as f: - lines = f.readlines() - for line in lines: + + def _consume(self, chunk): + """Parse the whole lines in `chunk`, holding back a partial tail.""" + data = self._tail + chunk + cut = data.rfind(b"\n") + if cut < 0: + self._tail = data + return + self._tail = data[cut + 1:] + for line in data[:cut].split(b"\n"): line = line.strip() if not line: continue try: - rec = json.loads(line) - except ValueError: + rec = json.loads(line.decode("utf-8")) + except (ValueError, UnicodeDecodeError): self.corrupt += 1 continue if isinstance(rec, dict) and "t" in rec: - recs.append(rec) + self._recs.append(rec) else: self.corrupt += 1 - return recs + + def read(self): + """Every record, in file order. Only the bytes appended since the + last call are parsed; a file that shrank or was replaced is read + again from the top.""" + with self._lock: + try: + size = os.path.getsize(self.path) + except OSError: + self._forget() + return [] + if size < self._offset: + self._forget() + if size != self._offset: + with open(self.path, "rb") as f: + f.seek(self._offset) + chunk = f.read() + self._offset += len(chunk) + self._consume(chunk) + return list(self._recs) def raw(self): if not os.path.exists(self.path): diff --git a/forgetest/forgetest/manifest.py b/forgetest/forgetest/manifest.py index 561909a..3930a43 100644 --- a/forgetest/forgetest/manifest.py +++ b/forgetest/forgetest/manifest.py @@ -10,6 +10,7 @@ plus the test's own implementation. A recorded PASS applies to a build exactly when the fingerprint recomputed from that build's manifest is the same - the same code runs on the board and in the release gate. """ +import functools import hashlib import json import os @@ -32,9 +33,11 @@ def sha256_text(text): return hashlib.sha256(text.encode("utf-8")).hexdigest() +@functools.lru_cache(maxsize=512) def glob_to_regex(pattern): """Coverage glob -> anchored regex. '**' spans directories, '*' and '?' - stay inside one path segment. Paths use '/' (git paths).""" + stay inside one path segment. Paths use '/' (git paths). Cached: the + catalog matches the same few hundred globs over and over.""" out = [] i, n = 0, len(pattern) while i < n: @@ -71,6 +74,7 @@ class Manifest: self.platform = data.get("platform", {}) or {} self.image = data.get("image", {}) or {} self.content_sha = data.get("content_sha256") + self._files = {} @classmethod def load(cls, path=None): @@ -91,12 +95,15 @@ class Manifest: return self.image.get("name") or "unknown" def files(self, component): - """The [path, blob] list of a component, or None if the component - is not in this manifest.""" + """The (path, blob) pairs of a component, or None if the component + is not in this manifest. Built once per component: the manifest is + immutable and every coverage glob asks for the same lists.""" + if component in self._files: + return self._files[component] c = self.components.get(component) - if c is None: - return None - return [tuple(x) for x in c.get("files", [])] + out = None if c is None else [tuple(x) for x in c.get("files", [])] + self._files[component] = out + return out def component_names(self): return sorted(self.components) diff --git a/forgetest/forgetest/page.py b/forgetest/forgetest/page.py index 2850261..2f839e6 100644 --- a/forgetest/forgetest/page.py +++ b/forgetest/forgetest/page.py @@ -1,8 +1,16 @@ """The single page: acceptance tab + bench tab. Self-contained (inline CSS/JS, ES5, no external assets); the visual identity follows the -forgectrl control panel. State comes from GET /state on a 2 s poll; the -catalog and the bench listing are fetched once per tab and refreshed -after a run finishes.""" +forgectrl control panel. State comes from GET /state, polled every 2 s +when the machine is idle and every second during a run; the catalog and +the bench listing are fetched once per tab and refreshed after a run +finishes. + +Rows, prompt buttons and tool entries are built once and thereafter only +updated in place. A poll that rebuilt them would swallow the click it +landed on: the button that took the mousedown would be gone before the +mouseup, so no click event would ever be raised. Every action also greys +its control out on the press and pulls the next poll forward, so the page +answers the operator rather than the timer.""" _HTML = r""" @@ -81,7 +89,7 @@ pre#log{background:#1d1e26;color:#d7dae0;font-family:ui-monospace,Consolas,monos
- + @@ -120,107 +128,208 @@ pre#log{background:#1d1e26;color:#d7dae0;font-family:ui-monospace,Consolas,monos diff --git a/forgetest/forgetest/server.py b/forgetest/forgetest/server.py index 07228a4..697dce1 100644 --- a/forgetest/forgetest/server.py +++ b/forgetest/forgetest/server.py @@ -9,7 +9,10 @@ page. Read-only calls need the origin checks only. Routes GET / the page - GET /state campaign + per-test state + running run + GET /state campaign + per-test state + running run. + Carries an ETag; If-None-Match on an + unchanged state gets a 304, which is what an + idle page polls for. GET /catalog test definitions (title, steps, covers...) GET /bench bench tool listing GET /result?test&ts one full result record (log, evidence) @@ -23,6 +26,7 @@ Routes POST /reset {reason} POST /export build + save the artifact, returns it """ +import hashlib import hmac import json import os @@ -96,6 +100,11 @@ class App: class Handler(BaseHTTPRequestHandler): server_version = "forgetest" + # Keep-alive: the page polls, so a handshake and a fresh thread per + # request is pure overhead. Idle connections are dropped after the + # timeout rather than holding a thread forever. + protocol_version = "HTTP/1.1" + timeout = 30 app = None # set on the server class # -- plumbing --------------------------------------------------------- @@ -108,6 +117,7 @@ class Handler(BaseHTTPRequestHandler): body = json.dumps(body, sort_keys=True).encode("utf-8") elif isinstance(body, str): body = body.encode("utf-8") + self.responded = True self.send_response(status) self.send_header("Content-Type", ctype + ("; charset=utf-8" if ctype.startswith("text/") else "")) self.send_header("Content-Length", str(len(body))) @@ -119,8 +129,25 @@ class Handler(BaseHTTPRequestHandler): if self.command != "HEAD": self.wfile.write(body) + def _send_304(self, etag): + self.responded = True + self.send_response(304) + self.send_header("ETag", etag) + self.send_header("Cache-Control", "no-store") + self.send_header("Content-Length", "0") + self.end_headers() + def _deny(self, status, msg): - self._send(status, {"error": msg}) + # One response per request: on a kept-alive connection a second + # one would desynchronize the stream. + if getattr(self, "responded", False): + return + # A refused POST still has its body in the socket. Leaving it + # there would make the next read on this connection take the + # body for a request line, so the connection ends here. + # send_header sets close_connection from this. + extra = None if getattr(self, "body_read", True) else {"Connection": "close"} + self._send(status, {"error": msg}, extra=extra) def _read_ok(self): if not origin_ok(self.headers): @@ -141,10 +168,12 @@ class Handler(BaseHTTPRequestHandler): def _body_json(self): n = int(self.headers.get("Content-Length") or 0) if n <= 0: + self.body_read = True return {} if n > 1 << 20: raise ValueError("body too large") raw = self.rfile.read(n) + self.body_read = True ctype = self.headers.get("Content-Type", "") if "json" in ctype: data = json.loads(raw.decode("utf-8")) @@ -161,14 +190,22 @@ class Handler(BaseHTTPRequestHandler): path = url.path query = urllib.parse.parse_qs(url.query) r = self.app.runner + self.responded = False if not self._read_ok(): return try: if path == "/": self._send(200, _page.render(self.app.token), "text/html") elif path == "/state": + # Conditional: an idle page polls an unchanged state, and + # a 304 spares both ends the payload and the re-render. state, _ = r.state() - self._send(200, state) + body = json.dumps(state, sort_keys=True).encode("utf-8") + etag = '"%s"' % hashlib.sha256(body).hexdigest()[:32] + if self.headers.get("If-None-Match") == etag: + self._send_304(etag) + else: + self._send(200, body, extra={"ETag": etag}) elif path == "/catalog": self._send(200, {"tests": [t.describe() for t in r.tests()], "catalog_hash": r.catalog_hash}) @@ -210,6 +247,8 @@ class Handler(BaseHTTPRequestHandler): path = url.path query = urllib.parse.parse_qs(url.query) r = self.app.runner + self.responded = False + self.body_read = False if not self._write_ok(query): return try: diff --git a/forgetest/tests/test_responsiveness.py b/forgetest/tests/test_responsiveness.py new file mode 100644 index 0000000..1ec39ad --- /dev/null +++ b/forgetest/tests/test_responsiveness.py @@ -0,0 +1,199 @@ +"""What keeps the page answering the operator instead of the timer. + +Two things went wrong on the bench and are pinned here: + + - the state cost. Every poll re-read and re-parsed the whole result log, + and recomputed every test's domain fingerprint. A result record carries + its run log, so the file reaches megabytes over a campaign and the poll + grew with it. Both are now parsed and computed once. + - the wasted payload. An idle page polls an unchanged state; it now gets + a 304 instead of the whole thing. + +The click-swallowing defect these were found with lives in the page's +JavaScript and is not reachable from here: rows, prompt buttons and tool +entries are built once and afterwards only updated in place, because a +poll that rebuilt them removed the button between the operator's mousedown +and mouseup, and no click event was ever raised. `test_page_never_rebuilds` +holds the shape of that rule. +""" +import json +import os +import shutil +import tempfile +import unittest + +import helpers +from forgetest import catalog, manifest as manifest_mod, page +from forgetest.log import Log + + +def t_noop(ctx): + pass + + +class LogCacheTests(unittest.TestCase): + """The log is append-only, so a read parses each line exactly once.""" + + def setUp(self): + self.tmp = tempfile.mkdtemp(prefix="forgetest-log-") + self.path = os.path.join(self.tmp, "results.jsonl") + self.log = Log(self.path) + + def tearDown(self): + shutil.rmtree(self.tmp, ignore_errors=True) + + def write(self, *lines): + with open(self.path, "a", encoding="utf-8") as f: + for line in lines: + f.write(line + "\n") + + def test_missing_file_reads_empty(self): + self.assertEqual(self.log.read(), []) + + def test_appends_are_picked_up(self): + self.log.append({"t": "campaign", "id": "c1"}) + self.assertEqual([r["id"] for r in self.log.read()], ["c1"]) + self.log.append({"t": "result", "test": "a.b"}) + self.log.append({"t": "result", "test": "c.d"}) + recs = self.log.read() + self.assertEqual([r["t"] for r in recs], ["campaign", "result", "result"]) + self.assertEqual(recs[2]["test"], "c.d") + + def test_only_new_bytes_are_parsed(self): + for i in range(5): + self.log.append({"t": "result", "test": "t%d" % i}) + self.log.read() + # a second read must not touch the file at all + real_open = open + opened = [] + + def counting_open(*a, **kw): + opened.append(a[0]) + return real_open(*a, **kw) + + import builtins + builtins.open = counting_open + try: + recs = self.log.read() + finally: + builtins.open = real_open + self.assertEqual(opened, [], "an unchanged log was re-opened") + self.assertEqual(len(recs), 5) + + def test_read_returns_a_fresh_list(self): + """Callers filter and sort the result; the cache must not be theirs.""" + self.log.append({"t": "result", "test": "a.b"}) + first = self.log.read() + first.append({"t": "bogus"}) + self.assertEqual(len(self.log.read()), 1) + + def test_partial_trailing_line_is_held_not_counted_corrupt(self): + self.write('{"t":"result","test":"a.b"}') + with open(self.path, "a", encoding="utf-8") as f: + f.write('{"t":"result","te') # a line still being written + recs = self.log.read() + self.assertEqual(len(recs), 1) + self.assertEqual(self.log.corrupt, 0) + with open(self.path, "a", encoding="utf-8") as f: + f.write('st":"c.d"}\n') # ... now finished + recs = self.log.read() + self.assertEqual([r["test"] for r in recs], ["a.b", "c.d"]) + self.assertEqual(self.log.corrupt, 0) + + def test_corrupt_lines_counted_once_not_per_read(self): + self.write('{"t":"result","test":"a.b"}', "not json at all", '["not","a","record"]', + '{"t":"result","test":"c.d"}') + recs = self.log.read() + self.assertEqual([r["test"] for r in recs], ["a.b", "c.d"]) + self.assertEqual(self.log.corrupt, 2) + self.log.read() + self.log.read() + self.assertEqual(self.log.corrupt, 2, "corrupt lines re-counted on every read") + + def test_replaced_file_is_read_again(self): + self.write('{"t":"result","test":"a.b"}', '{"t":"result","test":"c.d"}') + self.assertEqual(len(self.log.read()), 2) + with open(self.path, "w", encoding="utf-8") as f: + f.write('{"t":"campaign","id":"c9"}\n') + recs = self.log.read() + self.assertEqual([r.get("id") for r in recs], ["c9"]) + + def test_blank_lines_are_not_corrupt(self): + self.write('{"t":"result","test":"a.b"}', "", " ", '{"t":"result","test":"c.d"}') + self.assertEqual(len(self.log.read()), 2) + self.assertEqual(self.log.corrupt, 0) + + +class FingerprintCacheTests(unittest.TestCase): + """Memoized per manifest: the page recomputes every test's fingerprint + on every poll, and a manifest never changes under a running tool.""" + + def setUp(self): + self.man = helpers.make_manifest() + self.t = helpers.make_test("fake.fp", [("forgectrl", "src/ui.c")], fn=t_noop) + + def test_repeat_calls_agree(self): + first = self.t.fingerprint(self.man) + self.assertEqual(self.t.fingerprint(self.man), first) + self.assertEqual(self.t.fingerprint(self.man), first) + + def test_a_changed_manifest_is_not_served_from_the_cache(self): + first = self.t.fingerprint(self.man) + man2 = helpers.with_file(self.man, "forgectrl", "src/ui.c", "ui v2") + self.assertNotEqual(self.t.fingerprint(man2), first) + # and back again: the cache must not have latched the new one either + self.assertEqual(self.t.fingerprint(self.man), first) + + def test_a_file_outside_the_coverage_does_not_move_it(self): + first = self.t.fingerprint(self.man) + man2 = helpers.with_file(self.man, "forgectrl", "src/cool.c", "cool v2") + self.assertEqual(self.t.fingerprint(man2), first) + + def test_manifest_without_a_content_hash_is_not_cached(self): + """The cache is keyed by the manifest's content hash. A manifest + that has none must still fingerprint correctly, not collide.""" + a = manifest_mod.Manifest({"components": {"forgectrl": {"files": [["src/ui.c", "aaa"]]}}, + "platform": {}}) + b = manifest_mod.Manifest({"components": {"forgectrl": {"files": [["src/ui.c", "bbb"]]}}, + "platform": {}}) + self.assertIsNone(a.content_sha) + self.assertNotEqual(self.t.fingerprint(a), self.t.fingerprint(b)) + + def test_component_file_list_is_stable_and_read_only(self): + files = self.man.files("forgectrl") + self.assertEqual(files, self.man.files("forgectrl")) + self.assertIsNone(self.man.files("no-such-component")) + + +class PageTests(unittest.TestCase): + def test_page_never_rebuilds_what_the_operator_may_be_pressing(self): + """A poll must update rows, prompt buttons and tool entries in + place. Assigning innerHTML to their containers on every poll is + what swallowed the clicks; only the one-time build may do it.""" + html = page.render("0" * 32) + for container, builder in (("groups", "buildGroups"), ("tools", "buildBench")): + self.assertIn("function %s(" % builder, html, + "no one-time builder for #%s" % container) + assigns = html.count("$('%s').innerHTML=" % container) + self.assertEqual(assigns, 1, + "#%s is assigned innerHTML %d times; it belongs to the " + "builder alone" % (container, assigns)) + # the per-poll path writes through the guarded setters only + self.assertIn("function setHtml(e,h){if(e&&e.__h!==h)", html) + self.assertIn("function updateGroups()", html) + self.assertIn("function updateBench()", html) + # the prompt buttons are rebuilt only when the prompt changes + self.assertIn("if(pk!==promptKey)", html) + + def test_page_is_self_contained_ascii(self): + html = page.render("0" * 32) + self.assertNotIn("__TOKEN__", html) + html.encode("ascii") # no stray typography in an embedded page + stray = sorted(set(hex(ord(c)) for c in html if ord(c) < 32 and c != "\n")) + self.assertEqual(stray, [], "control characters in the page source") + for remote in ("http://", "https://", "//cdn"): + self.assertNotIn(remote, html) + + +if __name__ == "__main__": + unittest.main() diff --git a/forgetest/tests/test_server.py b/forgetest/tests/test_server.py index cd18038..b540c89 100644 --- a/forgetest/tests/test_server.py +++ b/forgetest/tests/test_server.py @@ -97,6 +97,11 @@ class ServerTests(unittest.TestCase): # -- helpers ---------------------------------------------------------- def call(self, method, path, body=None, token=True, headers=None): + st, payload, _ = self.call_h(method, path, body, token, headers) + return st, payload + + def call_h(self, method, path, body=None, token=True, headers=None): + """As call, plus the response headers.""" url = "http://127.0.0.1:%d%s" % (self.port, path) hdrs = {"Host": "127.0.0.1:%d" % self.port} if token: @@ -112,14 +117,15 @@ class ServerTests(unittest.TestCase): with urllib.request.urlopen(req, timeout=10) as r: raw = r.read() st = r.status - ct = r.headers.get("Content-Type", "") + rh = r.headers except urllib.error.HTTPError as e: raw = e.read() st = e.code - ct = e.headers.get("Content-Type", "") + rh = e.headers + ct = rh.get("Content-Type", "") if "json" in ct: - return st, json.loads(raw.decode()) - return st, raw + return st, json.loads(raw.decode()), rh + return st, raw, rh def wait_idle(self, timeout=10): deadline = time.time() + timeout @@ -161,6 +167,66 @@ class ServerTests(unittest.TestCase): st, d = self.call("GET", "/nope") self.assertEqual(st, 404) + def test_01b_state_is_conditional(self): + """The page polls; an unchanged state must cost a 304, and the + ETag must move as soon as the state does.""" + st, d, hdrs = self.call_h("GET", "/state") + self.assertEqual(st, 200) + etag = hdrs.get("ETag") + self.assertTrue(etag and etag.startswith('"'), "no ETag on /state") + st, _, hdrs2 = self.call_h("GET", "/state", headers={"If-None-Match": etag}) + self.assertEqual(st, 304) + self.assertEqual(hdrs2.get("ETag"), etag) + # a stale validator must not be honored + st, _, _ = self.call_h("GET", "/state", headers={"If-None-Match": '"stale"'}) + self.assertEqual(st, 200) + # and the validator moves with the state + self.call("POST", "/invalidate", {"reason": "etag check"}) + st, _, hdrs3 = self.call_h("GET", "/state", headers={"If-None-Match": etag}) + self.assertEqual(st, 200) + self.assertNotEqual(hdrs3.get("ETag"), etag) + + def test_01c_connection_is_kept_alive(self): + """A poll per second over a fresh TCP connection each time is + waste the board does not need to pay.""" + import http.client + c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10) + try: + for _ in range(3): + c.request("GET", "/state", headers={"Host": "127.0.0.1:%d" % self.port}) + r = c.getresponse() + r.read() + self.assertEqual(r.status, 200) + self.assertEqual(r.version, 11) + self.assertNotEqual((r.getheader("Connection") or "").lower(), "close") + self.assertIsNotNone(r.getheader("Content-Length")) + finally: + c.close() + + def test_01d_refused_post_does_not_poison_the_connection(self): + """A POST refused before its body is read leaves that body in the + socket. On a kept-alive connection the next read would take it for + a request line, so a refusal must end the connection instead.""" + import http.client + c = http.client.HTTPConnection("127.0.0.1", self.port, timeout=10) + try: + body = json.dumps({"test": "fake.pass"}).encode() + c.request("POST", "/start", body=body, + headers={"Host": "127.0.0.1:%d" % self.port, + "Content-Type": "application/json"}) # no token + r = c.getresponse() + payload = json.loads(r.read().decode()) + self.assertEqual(r.status, 403) + self.assertEqual(payload["error"], "authentication required") + self.assertEqual((r.getheader("Connection") or "").lower(), "close", + "an unread body was left on a connection kept alive") + finally: + c.close() + # the server is still healthy, and the body was never taken for a request + st, d = self.call("GET", "/state") + self.assertEqual(st, 200) + self.assertIsNone(d["running"]) + def test_02_run_pass_opens_campaign(self): st, d = self.call("GET", "/state") self.assertIsNone(d["campaign"])