@norskvideo/ctl-test-harness 0.1.31 → 0.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-test-harness",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "exports": {
     ".": {

package/smoke.d.ts

@@ -41,6 +41,12 @@ export interface SmokeContext {
 interface Structural {
     structural?: boolean;
 }
+/** The manifest's nav slot, as ctl's product page renders it. */
+export interface SidebarEntry {
+    label: string;
+    icon?: string;
+    route: string;
+}
 export type SmokeObservation = Structural & ({
     kind: "components";
     ids: string[];
@@ -137,6 +143,21 @@ export interface SmokeDeps {
     ensureNetwork(): ReturnType<typeof ensureRunnerOnNetwork>;
     supportsNoPublish(): Promise<boolean>;
     containerUser(): string | undefined;
+    /** Diagnostic dump for a satisfied-phase timeout, taken while the instance
+     *  is still up. Optional so an existing custom-deps consumer keeps working;
+     *  the default reads every container carrying the instance's label. */
+    diagnose?(instanceId: string): string;
+    /** GET a manifest-declared route through the daemon's product proxy — the
+     *  same URL ctl's product page links to. */
+    fetchProductRoute(opts: {
+        daemonPort: number;
+        product: string;
+        route: string;
+        storeDir: string;
+    }): Promise<{
+        status: number;
+        body: string;
+    }>;
     log(line: string): void;
 }
 /** Per-slug port band, above the product integration harnesses' own bands:
@@ -148,6 +169,20 @@ export interface SmokePorts extends BaseHarnessPorts {
 }
 export declare function smokePorts(slug: string, overrides?: Partial<SmokePorts>): SmokePorts;
 export declare const defaultSmokeDeps: SmokeDeps;
+/** A manifest's `ui.sidebarEntries` are what ctl's product page renders as
+ *  links, under /products/<name>/<route>. Nothing else checks that the product
+ *  serves them, so a button that 404s ships silently — the shape 04c calls a
+ *  declaration nothing checks. Image registrations only: the routes are served
+ *  out of the image (the docs bundle is baked by `build:image`), so a dev-url
+ *  run would fail on an artefact that is not under test. */
+export declare function assertManifestRoutesServed(opts: {
+    entries: readonly SidebarEntry[];
+    product: string;
+    daemonPort: number;
+    storeDir: string;
+    fetchRoute: SmokeDeps["fetchProductRoute"];
+    log(line: string): void;
+}): Promise<void>;
 /** Whether an observation depends on a source being pumped. Structural ones
  *  (`components`, or anything the spec marks `structural`) run the satisfied
  *  phase only. */

package/smoke.js

@@ -18,8 +18,9 @@
 // not a dependency of this package (daemon.ts's cleanupDaemon has the same
 // rule); a product wanting typed commands bridges with toArgv in its own spec.
 import { spawnSync } from "node:child_process";
-import { existsSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { dumpInstanceContainerLogs } from "./container-logs.js";
 import { ensureRunnerOnNetwork, netReachMode, STUDIO_INTERNAL_PORT, studioBaseFrom, } from "./container-net.js";
 import { cleanupDaemon, requireLicenseFile, runCli, startDaemon, } from "./daemon.js";
 import { hashSlot } from "./harness-config.js";
@@ -81,8 +82,49 @@ export const defaultSmokeDeps = {
     ensureNetwork: () => ensureRunnerOnNetwork(),
     supportsNoPublish: ctlSupportsNoPublish,
     containerUser: runnerContainerUser,
+    diagnose: (instanceId) => dumpInstanceContainerLogs(instanceId),
+    fetchProductRoute: async ({ daemonPort, product, route, storeDir }) => {
+        // The daemon fronts the product proxy with the same auth guard as /api/*,
+        // so the secret travels when the store has one (source-pump's rule).
+        const secretFile = join(storeDir, "proxy-secret");
+        const secret = existsSync(secretFile) ? readFileSync(secretFile, "utf8").trim() : "";
+        const url = `http://localhost:${daemonPort}/products/${encodeURIComponent(product)}${route.startsWith("/") ? route : `/${route}`}`;
+        const res = await fetch(url, {
+            headers: secret ? { "x-norsk-proxy": secret } : {},
+            redirect: "manual",
+            signal: AbortSignal.timeout(10_000),
+        });
+        return { status: res.status, body: (await res.text()).slice(0, 200) };
+    },
     log: (line) => console.log(`[smoke] ${line}`),
 };
+/** A manifest's `ui.sidebarEntries` are what ctl's product page renders as
+ *  links, under /products/<name>/<route>. Nothing else checks that the product
+ *  serves them, so a button that 404s ships silently — the shape 04c calls a
+ *  declaration nothing checks. Image registrations only: the routes are served
+ *  out of the image (the docs bundle is baked by `build:image`), so a dev-url
+ *  run would fail on an artefact that is not under test. */
+export async function assertManifestRoutesServed(opts) {
+    if (opts.entries.length === 0) {
+        opts.log("manifest declares no sidebar routes to check");
+        return;
+    }
+    for (const entry of opts.entries) {
+        const where = `/products/${opts.product}${entry.route}`;
+        const { status, body } = await opts.fetchRoute({
+            daemonPort: opts.daemonPort,
+            product: opts.product,
+            route: entry.route,
+            storeDir: opts.storeDir,
+        });
+        // A redirect is served: /docs 301s to /docs/, which is the link working.
+        if (status >= 400) {
+            throw new Error(`manifest sidebar entry "${entry.label}" points at ${where}, which the product does not serve ` +
+                `(${status}: ${body.replace(/\s+/g, " ").trim().slice(0, 120)})`);
+        }
+        opts.log(`sidebar entry "${entry.label}" -> ${where} (${status})`);
+    }
+}
 function describeObservation(o) {
     switch (o.kind) {
         case "components":
@@ -228,6 +270,19 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
             throw new Error(`product add registered '${added.name}', expected '${spec.product.name}'`);
         }
         registered = true;
+        if ("image" in spec.product.register) {
+            await assertManifestRoutesServed({
+                entries: added.manifest?.ui?.sidebarEntries ?? [],
+                product: spec.product.name,
+                daemonPort: ports.daemonPort,
+                storeDir,
+                fetchRoute: deps.fetchProductRoute,
+                log: (line) => deps.log(`${slug}: ${line}`),
+            });
+        }
+        else {
+            deps.log(`${slug}: dev-url registration — manifest routes not checked (they are served out of the image)`);
+        }
         // Template.
         let templateName;
         if ("name" in spec.template) {
@@ -304,11 +359,21 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
             });
         }
         for (const o of spec.observe) {
-            await pollUntil(() => observationSatisfied(o, ctx, deps.readers), {
-                timeoutMs: timeouts.observeMs,
-                intervalMs: 1000,
-                label: `${describeObservation(o)} never satisfied${vacuous ? "" : " while the sources pumped"}`,
-            });
+            try {
+                await pollUntil(() => observationSatisfied(o, ctx, deps.readers), {
+                    timeoutMs: timeouts.observeMs,
+                    intervalMs: 1000,
+                    label: `${describeObservation(o)} never satisfied${vacuous ? "" : " while the sources pumped"}`,
+                });
+            }
+            catch (e) {
+                // Only this phase: a not-yet or cleared failure is a statement about the
+                // observable itself, where a container dump adds noise, not cause. Here
+                // the predicate stayed false for a reason that lives in the containers
+                // -- and cleanup removes them moments from now.
+                const dump = deps.diagnose?.(instanceId) ?? "";
+                throw dump ? new Error(`${e instanceof Error ? e.message : String(e)}\n${dump}`, { cause: e }) : e;
+            }
         }
         deps.log(`${slug}: satisfied phase passed for ${spec.observe.length} observation(s)`);
         if (!vacuous) {