@norskvideo/ctl-test-harness 0.1.74 → 0.1.75

package/container-net.d.ts

@@ -18,7 +18,9 @@ export declare const authority: (e: Endpoint) => string;
 export declare function productServiceHost(instanceId: string, service: string): string;
 export interface ResolveOpts {
     instanceId: string;
-    service: "studio" | "media";
+    /** A compose service name: "studio" and "media" for a Studio product, or a
+     *  direct-SDK product's own control service (the smoke `surface`). */
+    service: string;
     /** Port the listener binds INSIDE the container (studio 8000, media SRT its
      *  own configured port). Used in `direct` mode. */
     internalPort: number;

package/package.json

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

package/smoke.d.ts

@@ -33,6 +33,25 @@ export interface SmokeContext {
         output?: "json" | "yaml";
     }): Promise<CliResult>;
     fetchStudio(path: string): Promise<Response>;
+    /** The spec's `surface` (Studio's by default), reached the same two ways:
+     *  the banded published port, or `<id>-<service>-1:<internalPort>` direct. */
+    surfaceUrl(path: string): string;
+    /** GET surfaceUrl(path) through the injected reader -- for observations. A
+     *  prepare step that acts (POST, DELETE) uses fetch(ctx.surfaceUrl(...)). */
+    fetchSurface(path: string): Promise<Response>;
+}
+/** The instance service whose HTTP surface the journey publishes and reaches.
+ *  Studio's by default; a direct-SDK product (no Studio, e.g. norsk-relay)
+ *  names its own control API. */
+export interface SmokeSurface {
+    service: string;
+    internalPort: number;
+    /** The host port the TEMPLATE publishes the surface on (a `--param` the spec
+     *  sets). ctl emits `--host-ports` only for Studio and media -- one naming any
+     *  other service is persisted but never wired -- so a direct-SDK product's
+     *  surface is published by its own compose. Given, no `--host-ports` is
+     *  passed and publish mode dials this port. */
+    hostPort?: number;
 }
 /** Set on any observation that holds with or without a source — a resilient
  *  switch that keeps a ladder fed from a slate, a control surface that is up
@@ -85,6 +104,14 @@ export interface SmokeSpec {
         licenseFile?: string;
     };
     template: SmokeTemplate;
+    /** Default { service: "studio", internalPort: 8000 }. Published on the banded
+     *  studioHostPort; STUDIO_HOST_PORT is passed instead only for Studio's. */
+    surface?: SmokeSurface;
+    /** Runs once the instance reports running, before the not-yet phase: what a
+     *  product needs in place before its sources can be accepted (the relay
+     *  refuses SRT for a stream nobody declared). Not an observation -- it may
+     *  act, and a throw fails the journey. */
+    prepare?(ctx: SmokeContext): Promise<void>;
     /** Extra `--param NAME=value`. INSTANCE_NAME is always passed; STUDIO_HOST_PORT
      *  when the template declares it (else the port is pinned with --host-ports). */
     params?: string[];
@@ -206,5 +233,15 @@ export declare function assertManifestRoutesServed(opts: {
 export declare function sourceDependent(o: SmokeObservation): boolean;
 /** One sample of an observation — the predicate the three phases poll. */
 export declare function observationSatisfied(o: SmokeObservation, ctx: SmokeContext, readers: SmokeReaders): Promise<boolean>;
+/** A direct-SDK product's licence identity -- the sdk-client cert and key it
+ *  answers the engine's V2 handshake with, base64 -- from what smoke.yml
+ *  exports (repo secrets NORSK_SDK_CLIENT_CERT_B64 / NORSK_SDK_CLIENT_KEY_B64).
+ *  Undefined when neither is set (a Studio product, or a local run without
+ *  one); half a pair is a misconfigured repo, so it throws rather than
+ *  launching an instance that restarts on "License handshake required". */
+export declare function sdkClientIdentityFromEnv(env?: Record<string, string | undefined>): {
+    certB64: string;
+    keyB64: string;
+} | undefined;
 export declare function runProductSmoke(slug: string, spec: SmokeSpec, deps?: SmokeDeps): Promise<void>;
 export {};

package/smoke.js

@@ -20,7 +20,7 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { dumpInstanceContainerLogs, preserveEngineLogs, preserveInstanceContainerLogs } from "./container-logs.js";
-import { ensureRunnerOnNetwork, netReachMode, STUDIO_INTERNAL_PORT, studioBaseFrom, } from "./container-net.js";
+import { authority, ensureRunnerOnNetwork, netReachMode, resolveEndpoint, STUDIO_INTERNAL_PORT, studioBaseFrom, } from "./container-net.js";
 import { cleanupDaemon, ctlSupportsEphemeralPorts, PROXY_PORT_FILE, requireLicenseFile, runCli, startDaemon, } from "./daemon.js";
 import { hashSlot } from "./harness-config.js";
 import { ctlSupportsNoPublish, ctlSupportsPublishDebugPorts, runnerContainerUser } from "./launch.js";
@@ -191,6 +191,22 @@ function parseJson(r, what) {
         throw new Error(`${what}: not JSON: ${r.stdout.slice(0, 200)}`);
     }
 }
+/** A direct-SDK product's licence identity -- the sdk-client cert and key it
+ *  answers the engine's V2 handshake with, base64 -- from what smoke.yml
+ *  exports (repo secrets NORSK_SDK_CLIENT_CERT_B64 / NORSK_SDK_CLIENT_KEY_B64).
+ *  Undefined when neither is set (a Studio product, or a local run without
+ *  one); half a pair is a misconfigured repo, so it throws rather than
+ *  launching an instance that restarts on "License handshake required". */
+export function sdkClientIdentityFromEnv(env = process.env) {
+    const certB64 = env.NORSK_SDK_CLIENT_CERT_B64 ?? "";
+    const keyB64 = env.NORSK_SDK_CLIENT_KEY_B64 ?? "";
+    if (!certB64 && !keyB64)
+        return undefined;
+    if (!certB64 || !keyB64) {
+        throw new Error(`NORSK_SDK_CLIENT_${certB64 ? "KEY" : "CERT"}_B64 is empty but its pair is set -- set both repo secrets or neither`);
+    }
+    return { certB64, keyB64 };
+}
 export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
     const ports = smokePorts(slug, spec.ports);
     const storeDir = deps.storeDir(slug);
@@ -202,6 +218,8 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
     };
     const mode = netReachMode();
     const studio = { instanceId, studioHostPort: ports.studioHostPort };
+    const surface = spec.surface ?? { service: "studio", internalPort: STUDIO_INTERNAL_PORT };
+    const studioSurface = surface.service === "studio" && surface.internalPort === STUDIO_INTERNAL_PORT;
     const cli = async (argv, opts = {}) => {
         const full = ["--port", String(ports.daemonPort), ...argv, ...(opts.output ? ["-o", opts.output] : [])];
         return deps.cli(storeDir, full);
@@ -223,6 +241,18 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
         studio,
         cli,
         fetchStudio: (path) => deps.readers.fetch(`${studioBaseFrom(studio, process.env.NORSK_TEST_HOST ?? "localhost", mode)}${path}`),
+        surfaceUrl: (path) => {
+            const e = resolveEndpoint({
+                instanceId,
+                service: surface.service,
+                internalPort: surface.internalPort,
+                publishHost: process.env.NORSK_TEST_HOST ?? "localhost",
+                publishPort: surface.hostPort ?? ports.studioHostPort,
+                mode,
+            });
+            return `http://${authority(e)}${path}`;
+        },
+        fetchSurface: (path) => deps.readers.fetch(ctx.surfaceUrl(path)),
     };
     let daemon = null;
     let launched = false;
@@ -335,10 +365,12 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
         const params = [`INSTANCE_NAME=${instanceId}`, ...(spec.params ?? [])];
         const launchArgv = ["instance", "launch-template", instanceId, "--template", templateName];
         const internalOnly = mode === "direct" && (await deps.supportsNoPublish());
-        if (declared.has(STUDIO_HOST_PORT_PARAM))
+        if (studioSurface && declared.has(STUDIO_HOST_PORT_PARAM)) {
             params.push(`${STUDIO_HOST_PORT_PARAM}=${ports.studioHostPort}`);
-        else if (!internalOnly)
-            launchArgv.push("--host-ports", `${ports.studioHostPort}:${STUDIO_INTERNAL_PORT}@studio`);
+        }
+        else if (!internalOnly && surface.hostPort === undefined) {
+            launchArgv.push("--host-ports", `${ports.studioHostPort}:${surface.internalPort}@${surface.service}`);
+        }
         for (const p of params)
             launchArgv.push("--param", p);
         if (spec.hardware)
@@ -376,6 +408,10 @@ export async function runProductSmoke(slug, spec, deps = defaultSmokeDeps) {
             const inst = parseJson(r, "instance list").instances?.find((i) => i.id === instanceId);
             return inst?.status === "running" || inst?.status === "healthy";
         }, { timeoutMs: timeouts.healthyMs, intervalMs: 1000, label: `instance ${instanceId} never reported running` });
+        if (spec.prepare) {
+            await spec.prepare(ctx);
+            deps.log(`${slug}: prepare done`);
+        }
         // Phases.
         const vacuous = spec.sources.length === 0;
         if (vacuous) {