@specific.dev/spectest 0.91.1 → 0.91.2

package/dist/components/k3s.d.ts

@@ -328,6 +328,8 @@ export interface K3sHelpers {
         limit?: number;
     }): Promise<Wrapped<KubernetesListObject<T>>>;
 }
+/** @internal Exported for regression tests; not part of the components API. */
+export declare function isTransientApplyError(err: unknown): boolean;
 export declare function k3s(opts?: K3sOptions): {
     image: {
         type: "registry";

package/dist/components/k3s.js

@@ -910,8 +910,33 @@ const TRANSIENT_APPLY_PATTERNS = [
 function errorText(err) {
     return err?.message ?? String(err);
 }
-function isTransientApplyError(err) {
-    const msg = errorText(err);
+/** ApiException formats its body with JSON.stringify, escaping Status.message.
+ * Read the actual response instead of matching that presentation string. */
+function applyErrorStatus(err) {
+    let body = err?.body;
+    if (typeof body === "string") {
+        try {
+            body = JSON.parse(body);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return body && typeof body === "object" && !Array.isArray(body) ? body : undefined;
+}
+/** @internal Exported for regression tests; not part of the components API. */
+export function isTransientApplyError(err) {
+    const status = applyErrorStatus(err);
+    const code = status?.code ?? err?.code;
+    if ([429, 500, 503, 504].includes(code))
+        return true;
+    // A missing namespace can converge while another apply creates it. An
+    // arbitrary resource 404 cannot: don't classify by HTTP status alone.
+    if (code === 404 && status?.reason === "NotFound" &&
+        status.details?.kind === "namespaces" && !status.details.group &&
+        typeof status.details.name === "string" && status.details.name.length > 0)
+        return true;
+    const msg = typeof status?.message === "string" ? status.message : errorText(err);
     return TRANSIENT_APPLY_PATTERNS.some((re) => re.test(msg));
 }
 function describeDoc(doc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.91.1",
+  "version": "0.91.2",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/k3s-apply.test.ts

@@ -0,0 +1,90 @@
+import { expect, spyOn, test } from "bun:test";
+import { KubernetesObjectApi } from "@kubernetes/client-node";
+import { ApiException } from "@kubernetes/client-node/dist/gen/apis/exception.js";
+import { isTransientApplyError, k3s } from "./k3s";
+
+const missingNamespace = {
+  apiVersion: "v1", kind: "Status", status: "Failure", code: 404, reason: "NotFound",
+  message: 'namespaces "agent-sandbox-system" not found',
+  details: { name: "agent-sandbox-system", kind: "namespaces" },
+};
+const exception = (code: number, body: unknown) => new ApiException(code, "Unknown API Status Code!", body, {});
+
+for (const format of ["object", "JSON string"] as const) {
+  const encode = (body: unknown) => format === "object" ? body : JSON.stringify(body);
+  test(`missing-namespace ApiException with ${format} body is transient`, () => {
+    const error = exception(404, encode(missingNamespace));
+    // This is the production client's escaped representation, not a hand-made Error.
+    expect(/namespaces? "[^"]+" not found/i.test(error.message)).toBe(false);
+    expect(isTransientApplyError(error)).toBe(true);
+    expect(isTransientApplyError(exception(404, encode({ ...missingNamespace, message: "Not Found" })))).toBe(true);
+    // The Status message also works when structured details are absent.
+    expect(isTransientApplyError(exception(404, encode({ ...missingNamespace, details: undefined })))).toBe(true);
+  });
+
+  test(`apply converges after a missing namespace with ${format} response body`, async () => {
+    const error = exception(404, encode(missingNamespace));
+    let attempts = 0;
+    const patch = spyOn(KubernetesObjectApi.prototype, "patch").mockImplementation(async doc => {
+      if (++attempts === 1) throw error;
+      return doc as never;
+    });
+    try {
+      const helpers = await makeHelpers();
+      const applied = await helpers.apply(JSON.stringify(policy), { timeoutMs: 2000 });
+      expect(attempts).toBe(2);
+      expect(applied[0].unwrap()).toEqual(policy);
+    } finally { patch.mockRestore(); }
+  });
+
+  test(`unrelated 404, forbidden and invalid Status bodies remain terminal (${format})`, () => {
+    for (const body of [
+      { ...missingNamespace, message: 'deployments.apps "controller" not found', details: { name: "controller", kind: "deployments", group: "apps" } },
+      { ...missingNamespace, message: 'namespaces.example.dev "widget" not found', details: { name: "widget", kind: "namespaces", group: "example.dev" } },
+      { code: 404, reason: "NotFound", message: "Not Found" },
+      { code: 403, reason: "Forbidden", message: 'namespaces "agent-sandbox-system" is forbidden', details: missingNamespace.details },
+      { code: 422, reason: "Invalid", message: 'NetworkPolicy "policy" is invalid', details: { causes: [{ message: missingNamespace.message }] } },
+    ]) expect(isTransientApplyError(exception(body.code, encode(body)))).toBe(false);
+  });
+}
+
+test("plain client errors and transient HTTP statuses retain their retry behavior", () => {
+  for (const code of [429, 500, 503, 504]) {
+    expect(isTransientApplyError(exception(code, { message: "Try again" }))).toBe(true);
+  }
+  for (const message of [missingNamespace.message, 'no matches for kind "Widget"', "Failed to fetch resource metadata", "failed calling webhook", "HTTP-Code: 503\nMessage: unavailable"]) {
+    expect(isTransientApplyError(new Error(message))).toBe(true);
+  }
+  for (const body of ["not JSON", "{", null, [], 42]) {
+    expect(isTransientApplyError(exception(404, body))).toBe(false);
+  }
+  expect(isTransientApplyError(null)).toBe(false);
+});
+
+const policy = {
+  apiVersion: "networking.k8s.io/v1", kind: "NetworkPolicy",
+  metadata: { name: "policy", namespace: "agent-sandbox-system" },
+  spec: { podSelector: {}, policyTypes: ["Ingress"] },
+};
+
+async function makeHelpers() {
+  return k3s().helpers({ name: "cluster", exec: async () => ({ exitCode: 0, stderr: "", stdout: JSON.stringify({
+    apiVersion: "v1", kind: "Config", clusters: [{ name: "test", cluster: { server: "https://cluster.internal:6443" } }],
+    users: [{ name: "test", user: {} }], contexts: [{ name: "test", context: { cluster: "test", user: "test" } }],
+    "current-context": "test",
+  }) }) } as never);
+}
+
+test("apply fails immediately on an unrelated 404 and still times out on a missing namespace", async () => {
+  const helpers = await makeHelpers();
+  const patch = spyOn(KubernetesObjectApi.prototype, "patch");
+  try {
+    patch.mockRejectedValue(exception(404, { reason: "NotFound", message: 'deployments.apps "controller" not found' }));
+    await expect(helpers.apply(JSON.stringify(policy))).rejects.toThrow("applying NetworkPolicy/policy");
+    expect(patch).toHaveBeenCalledTimes(1);
+    patch.mockClear();
+    patch.mockRejectedValue(exception(404, missingNamespace));
+    await expect(helpers.apply(JSON.stringify(policy), { timeoutMs: 0 })).rejects.toThrow("apply did not converge");
+    expect(patch).toHaveBeenCalledTimes(1);
+  } finally { patch.mockRestore(); }
+});

package/src/components/k3s.ts

@@ -1421,8 +1421,27 @@ function errorText(err: unknown): string {
   return (err as Error)?.message ?? String(err);
 }
 
-function isTransientApplyError(err: unknown): boolean {
-  const msg = errorText(err);
+/** ApiException formats its body with JSON.stringify, escaping Status.message.
+ * Read the actual response instead of matching that presentation string. */
+function applyErrorStatus(err: unknown): V1Status | undefined {
+  let body = (err as { body?: unknown } | null)?.body;
+  if (typeof body === "string") {
+    try { body = JSON.parse(body); } catch { return undefined; }
+  }
+  return body && typeof body === "object" && !Array.isArray(body) ? body as V1Status : undefined;
+}
+
+/** @internal Exported for regression tests; not part of the components API. */
+export function isTransientApplyError(err: unknown): boolean {
+  const status = applyErrorStatus(err);
+  const code = status?.code ?? (err as { code?: unknown } | null)?.code;
+  if ([429, 500, 503, 504].includes(code as number)) return true;
+  // A missing namespace can converge while another apply creates it. An
+  // arbitrary resource 404 cannot: don't classify by HTTP status alone.
+  if (code === 404 && status?.reason === "NotFound" &&
+      status.details?.kind === "namespaces" && !status.details.group &&
+      typeof status.details.name === "string" && status.details.name.length > 0) return true;
+  const msg = typeof status?.message === "string" ? status.message : errorText(err);
   return TRANSIENT_APPLY_PATTERNS.some((re) => re.test(msg));
 }