diff --git a/scripts/test-projects.test-support.mjs b/scripts/test-projects.test-support.mjs index 80221ed121ff..e09e8cc6e80b 100644 --- a/scripts/test-projects.test-support.mjs +++ b/scripts/test-projects.test-support.mjs @@ -451,6 +451,7 @@ const TOOLING_SOURCE_TEST_TARGETS = new Map([ ["test/scripts/package-acceptance-workflow.test.ts"], ], ["scripts/clawtributors-map.json", ["test/scripts/update-clawtributors.test.ts"]], + ["scripts/tsconfig.json", ["test/scripts/oxlint-config.test.ts"]], ["scripts/build-all.mjs", ["test/scripts/build-all.test.ts"]], ["scripts/build-stamp.mjs", ["src/infra/build-stamp.test.ts"]], ["scripts/crabbox-wrapper.mjs", ["test/scripts/crabbox-wrapper.test.ts"]], @@ -2669,6 +2670,20 @@ function resolveUpgradeSurvivorConfigRecipeTargets(changedPath) { return ["test/scripts/upgrade-survivor-config-recipe.test.ts"]; } +function resolveDocsI18nBehaviorTargets(changedPath) { + if (!/^scripts\/docs-i18n\/testdata\/behavior\/[^/]+\/[^/]+$/u.test(changedPath)) { + return null; + } + return ["test/scripts/docs-i18n-behavior.test.ts"]; +} + +function resolveK8sManifestTargets(changedPath) { + if (!/^scripts\/k8s\/manifests\/[^/]+\.yaml$/u.test(changedPath)) { + return null; + } + return ["test/scripts/k8s-manifests.test.ts"]; +} + function resolveParallelsToolingTestTargets(changedPath) { if ( !/^scripts\/e2e\/parallels\/[^/]+\.ts$/u.test(changedPath) && @@ -2698,6 +2713,8 @@ function resolveToolingTestTargets(changedPath, cwd = process.cwd()) { TOOLING_SOURCE_TEST_TARGETS.get(changedPath) ?? TOOLING_TEST_TARGETS.get(changedPath) ?? resolveUpgradeSurvivorConfigRecipeTargets(changedPath) ?? + resolveDocsI18nBehaviorTargets(changedPath) ?? + resolveK8sManifestTargets(changedPath) ?? resolveParallelsToolingTestTargets(changedPath); const conventionalTargets = resolveConventionalToolingTestTargets(changedPath, cwd); if (explicitTargets && conventionalTargets) { diff --git a/test/scripts/docs-i18n-behavior.test.ts b/test/scripts/docs-i18n-behavior.test.ts new file mode 100644 index 000000000000..a0f5185fb061 --- /dev/null +++ b/test/scripts/docs-i18n-behavior.test.ts @@ -0,0 +1,19 @@ +// Docs i18n behavior tests keep JSON fixture edits tied to the Go baseline suite. +import { spawnSync } from "node:child_process"; +import { describe, expect, it } from "vitest"; + +describe("docs-i18n behavior baselines", () => { + it("keeps behavior fixtures passing", () => { + const result = spawnSync( + "go", + ["test", "./...", "-run", "TestDocsI18nBehaviorBaselines", "-count=1"], + { + cwd: "scripts/docs-i18n", + encoding: "utf8", + }, + ); + + expect(result.error).toBeUndefined(); + expect(result.status, result.stderr || result.stdout).toBe(0); + }); +}); diff --git a/test/scripts/k8s-manifests.test.ts b/test/scripts/k8s-manifests.test.ts new file mode 100644 index 000000000000..a720e09ff071 --- /dev/null +++ b/test/scripts/k8s-manifests.test.ts @@ -0,0 +1,144 @@ +// K8s manifest tests cover the deployable Kubernetes bundle shape. +import { readFileSync } from "node:fs"; +import { describe, expect, it } from "vitest"; +import { parse } from "yaml"; + +type Manifest = Record; + +function readManifest(name: string): Manifest { + const parsed = parse(readFileSync(`scripts/k8s/manifests/${name}`, "utf8")) as unknown; + expect(parsed).toBeTypeOf("object"); + expect(parsed).not.toBeNull(); + expect(Array.isArray(parsed)).toBe(false); + return parsed as Manifest; +} + +function asRecord(value: unknown, label: string): Record { + expect(value, label).toBeTypeOf("object"); + expect(value, label).not.toBeNull(); + expect(Array.isArray(value), label).toBe(false); + return value as Record; +} + +function asRecords(value: unknown, label: string): Record[] { + expect(Array.isArray(value), label).toBe(true); + return value as Record[]; +} + +function asStrings(value: unknown, label: string): string[] { + expect(Array.isArray(value), label).toBe(true); + for (const entry of value as unknown[]) { + expect(entry, label).toBeTypeOf("string"); + } + return value as string[]; +} + +function findNamed(records: Record[], name: string): Record { + const record = records.find((entry) => entry.name === name); + expect(record, name).toBeDefined(); + return record as Record; +} + +describe("k8s manifests", () => { + it("keeps kustomization resources aligned with shipped manifests", () => { + const kustomization = readManifest("kustomization.yaml"); + + expect(kustomization).toMatchObject({ + apiVersion: "kustomize.config.k8s.io/v1beta1", + kind: "Kustomization", + }); + expect(asStrings(kustomization.resources, "kustomization resources").sort()).toEqual([ + "configmap.yaml", + "deployment.yaml", + "pvc.yaml", + "service.yaml", + ]); + }); + + it("keeps gateway service selectors and ports aligned with deployment labels", () => { + const deployment = readManifest("deployment.yaml"); + const service = readManifest("service.yaml"); + const deploymentSpec = asRecord(deployment.spec, "deployment spec"); + const selector = asRecord(deploymentSpec.selector, "deployment selector"); + const matchLabels = asRecord(selector.matchLabels, "deployment match labels"); + const template = asRecord(deploymentSpec.template, "deployment template"); + const templateMetadata = asRecord(template.metadata, "deployment template metadata"); + const templateLabels = asRecord(templateMetadata.labels, "deployment template labels"); + const serviceSpec = asRecord(service.spec, "service spec"); + const serviceSelector = asRecord(serviceSpec.selector, "service selector"); + const ports = asRecords(serviceSpec.ports, "service ports"); + + expect(deployment).toMatchObject({ + apiVersion: "apps/v1", + kind: "Deployment", + metadata: { name: "openclaw" }, + }); + expect(matchLabels).toEqual({ app: "openclaw" }); + expect(templateLabels).toMatchObject(matchLabels); + expect(serviceSelector).toEqual(matchLabels); + expect(ports).toContainEqual({ + name: "gateway", + port: 18789, + protocol: "TCP", + targetPort: 18789, + }); + }); + + it("keeps deployment mounts, secrets, and security posture deployable", () => { + const deployment = readManifest("deployment.yaml"); + const spec = asRecord(deployment.spec, "deployment spec"); + const template = asRecord(spec.template, "deployment template"); + const podSpec = asRecord(template.spec, "pod spec"); + const containers = asRecords(podSpec.containers, "containers"); + const gateway = findNamed(containers, "gateway"); + const env = asRecords(gateway.env, "gateway env"); + const volumes = asRecords(podSpec.volumes, "pod volumes"); + const securityContext = asRecord(gateway.securityContext, "gateway security context"); + + expect(gateway.command).toEqual(["node", "/app/dist/index.js", "gateway", "run"]); + expect(findNamed(env, "HOME")).toMatchObject({ value: "/home/node" }); + expect(findNamed(env, "OPENCLAW_CONFIG_DIR")).toMatchObject({ value: "/home/node/.openclaw" }); + expect(findNamed(env, "OPENCLAW_GATEWAY_TOKEN")).toMatchObject({ + valueFrom: { secretKeyRef: { key: "OPENCLAW_GATEWAY_TOKEN", name: "openclaw-secrets" } }, + }); + expect(findNamed(volumes, "openclaw-home")).toMatchObject({ + persistentVolumeClaim: { claimName: "openclaw-home-pvc" }, + }); + expect(findNamed(volumes, "config")).toMatchObject({ configMap: { name: "openclaw-config" } }); + expect(securityContext).toMatchObject({ + allowPrivilegeEscalation: false, + readOnlyRootFilesystem: true, + runAsNonRoot: true, + }); + }); + + it("keeps config and persistence manifests aligned with the gateway", () => { + const configMap = readManifest("configmap.yaml"); + const pvc = readManifest("pvc.yaml"); + const data = asRecord(configMap.data, "configmap data"); + const config = JSON.parse(String(data["openclaw.json"])) as Record; + const gateway = asRecord(config.gateway, "openclaw config gateway"); + const auth = asRecord(gateway.auth, "openclaw config auth"); + const agents = asRecord(config.agents, "openclaw config agents"); + const defaults = asRecord(agents.defaults, "openclaw config agent defaults"); + const pvcSpec = asRecord(pvc.spec, "pvc spec"); + const resources = asRecord(pvcSpec.resources, "pvc resources"); + const requests = asRecord(resources.requests, "pvc resource requests"); + + expect(configMap).toMatchObject({ + apiVersion: "v1", + kind: "ConfigMap", + metadata: { name: "openclaw-config" }, + }); + expect(gateway).toMatchObject({ mode: "local", port: 18789 }); + expect(auth).toMatchObject({ mode: "token" }); + expect(defaults).toMatchObject({ workspace: "~/.openclaw/workspace" }); + expect(data["AGENTS.md"]).toContain("OpenClaw Assistant"); + expect(pvc).toMatchObject({ + apiVersion: "v1", + kind: "PersistentVolumeClaim", + metadata: { name: "openclaw-home-pvc" }, + }); + expect(requests).toMatchObject({ storage: "10Gi" }); + }); +}); diff --git a/test/scripts/test-projects.test.ts b/test/scripts/test-projects.test.ts index 305f32ed367d..abc997184859 100644 --- a/test/scripts/test-projects.test.ts +++ b/test/scripts/test-projects.test.ts @@ -1065,6 +1065,32 @@ describe("scripts/test-projects changed-target routing", () => { }); }); + it("keeps scripts tsconfig edits on oxlint config tests", () => { + expect(resolveChangedTestTargetPlan(["scripts/tsconfig.json"])).toEqual({ + mode: "targets", + targets: ["test/scripts/oxlint-config.test.ts"], + }); + }); + + it("keeps docs i18n behavior fixture edits on behavior baseline tests", () => { + for (const fixturePath of [ + "scripts/docs-i18n/testdata/behavior/fenced-singleton-retry/case.json", + "scripts/docs-i18n/testdata/behavior/fenced-singleton-retry/source.txt", + ]) { + expect(resolveChangedTestTargetPlan([fixturePath]), fixturePath).toEqual({ + mode: "targets", + targets: ["test/scripts/docs-i18n-behavior.test.ts"], + }); + } + }); + + it("keeps k8s manifest edits on manifest tests", () => { + expect(resolveChangedTestTargetPlan(["scripts/k8s/manifests/configmap.yaml"])).toEqual({ + mode: "targets", + targets: ["test/scripts/k8s-manifests.test.ts"], + }); + }); + it("keeps Crabbox runner script edits on their regression tests", () => { expect(resolveChangedTestTargetPlan(["scripts/crabbox-wrapper.mjs"])).toEqual({ mode: "targets",