Check builds keep Go's modules and caches between runs (refs #118)

On sneak's rulings in sneak/prompts#113 and
sneak/prompts#130. REPO_POLICIES.md and
script/test, script/lint, script/docker and script/cibuild are the
sneak/prompts copies at 0653579: the scripts pass a new CACHEBUST value
instead of --no-cache, and the lint and test builds write no image. In
each Dockerfile stage the system packages and the Go module download
come above ARG CACHEBUST; every step that lints, tests or compiles, and
the node stages' yarn install, comes after it. Go's build cache and
golangci-lint's are cache mounts, and both go test runs carry -count=1.
README.md and TODO.md say the same.

Model: opus-5-5

Dockerfile

@@ -98,7 +98,10 @@ COPY --from=frontend-test /app/yarn.lock /dev/null
 FROM frontend-test AS frontend-build
 COPY --from=lint /src/go.sum /dev/null
 COPY --from=test /src/go.sum /dev/null
-# vite.config.js reads the commit for the page's footer with git.
+# vite.config.js reads the commit for the page's footer with git. git is
+# installed again on every image build, although it comes above
+# ARG CACHEBUST, because this stage starts from frontend-test, whose
+# steps run again on every build.
 RUN apk add --no-cache git
 ARG CACHEBUST
 RUN yarn build

README.md

@@ -101,10 +101,13 @@ either one is broken. We provide:
 new `CACHEBUST` value, so every step in `Dockerfile` that lints, tests or
 compiles runs again even when nothing has changed. Docker keeps the system
 packages and the Go modules from earlier builds until the base image, the step
-that installs them, or `go.mod` and `go.sum` change. Go's build cache and
-golangci-lint's are kept as well, and each reuses a result only when everything
-it was made from is unchanged. Both `go test` runs carry `-count=1`, so no test
-result is reused. The yarn packages are installed again on every build.
+that installs them, or `go.mod` and `go.sum` change. The `frontend-build` stage
+is the exception: it installs git again on every image build, because it starts
+from the `frontend-test` stage, whose steps run again on every build. Go's build
+cache and golangci-lint's are kept as well, and each reuses a result only when
+everything it was made from is unchanged. Both `go test` runs carry `-count=1`,
+so no test result is reused. The yarn packages are installed again on every
+build.
 
 ## Responsive layout
 

TODO.md

@@ -34,6 +34,13 @@ Run `make frontend-viewport-test` in CI as its own step; it is not part of
   cache and golangci-lint's are cache mounts, and both `go test` runs carry
   `-count=1`. The test phase's Go caches used to be in memory, empty on every
   build
+- 2026-10-19: the three unit tests of a check whose result is discarded (its
+  round given up, the user paused, or the first round) also check that the
+  host's history is still empty, its status still `pending`, and nothing was
+  written to the console
+  ([#151](https://git.eeqj.de/sneak/netwatch/issues/151)). They checked only the
+  row, so a change that recorded the result and skipped only the row would have
+  kept them passing
 - 2026-10-18: when the backend runs on its own, a `DATA_DIR` that cannot be
   created or read, or where no file can be created, stops the start with an
   error naming `DATA_DIR` and its value, as the other settings' errors do

test/unit/main.test.js

@@ -83,6 +83,11 @@ function statusText(state, host) {
     return elements[`.status-text[data-host="${index}"]`]?.innerHTML;
 }
 
+// What this test wrote to the browser console with console[method].
+function consoleLines(method) {
+    return console[method].mock.calls.map((call) => call.arguments[0]);
+}
+
 // Mocks the clock for test t, so that a check lasting seconds takes no real
 // time, and replaces fetch with targets that each answer after
 // answerAfter(url) milliseconds of that clock, or never when that is
@@ -202,9 +207,10 @@ test("at a 30000ms interval, a target answering after 1000ms shows in its row wh
 });
 
 // In the next three tests, the answering target's check is still waiting
-// when something happens after which its result must not show.
+// when something happens after which its result must not be recorded or
+// show in its row, and the check must write nothing to the console.
 
-test("at a 30000ms interval, a check still waiting when its round is given up does not show in its row", async (t) => {
+test("at a 30000ms interval, a check still waiting when its round is given up is not recorded and does not show in its row", async (t) => {
     CONFIG.updateInterval = 30000;
     const state = new AppState([
         { name: "Answering", url: "https://answering.test" },
@@ -220,9 +226,13 @@ test("at a 30000ms interval, a check still waiting when its round is given up do
     roundChecks.abort();
     assert.notEqual(await settled(round), "still waiting");
     assert.equal(latencyFigure(state, answering), undefined);
+    assert.deepEqual(answering.history, []);
+    assert.equal(answering.status, "pending");
+    assert.deepEqual(consoleLines("error"), []);
+    assert.deepEqual(consoleLines("info"), []);
 });
 
-test("at a 30000ms interval, a check still waiting when the user pauses does not show in its row", async (t) => {
+test("at a 30000ms interval, a check still waiting when the user pauses is not recorded and does not show in its row", async (t) => {
     CONFIG.updateInterval = 30000;
     const state = new AppState([
         { name: "Answering", url: "https://answering.test" },
@@ -237,9 +247,13 @@ test("at a 30000ms interval, a check still waiting when the user pauses does not
     t.mock.timers.tick(500);
     assert.equal(await settled(round), "still waiting");
     assert.equal(latencyFigure(state, answering), undefined);
+    assert.deepEqual(answering.history, []);
+    assert.equal(answering.status, "pending");
+    assert.deepEqual(consoleLines("error"), []);
+    assert.deepEqual(consoleLines("info"), []);
 });
 
-test("at a 30000ms interval, a check in the first round does not show in its row", async (t) => {
+test("at a 30000ms interval, a check in the first round is not recorded and does not show in its row", async (t) => {
     CONFIG.updateInterval = 30000;
     const state = new AppState([
         { name: "Answering", url: "https://answering.test" },
@@ -251,6 +265,10 @@ test("at a 30000ms interval, a check in the first round does not show in its row
     t.mock.timers.tick(1000);
     assert.equal(await settled(round), "still waiting");
     assert.equal(latencyFigure(state, answering), undefined);
+    assert.deepEqual(answering.history, []);
+    assert.equal(answering.status, "pending");
+    assert.deepEqual(consoleLines("error"), []);
+    assert.deepEqual(consoleLines("info"), []);
 });
 
 test("at a 30000ms interval, after the user pauses and resumes during a round, no row reads paused once its last check ends", async (t) => {
@@ -300,11 +318,6 @@ function stateWithOneTarget() {
     return { state, target: state.local[0] };
 }
 
-// What this test wrote to the browser console with console[method].
-function consoleLines(method) {
-    return console[method].mock.calls.map((call) => call.arguments[0]);
-}
-
 test("a check that fails with a network error writes one console line with the target, the time, the error and how long the request took", async (t) => {
     const { state, target } = stateWithOneTarget();
     mockTargets(t, () => 23, target.url);