chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,866 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import {
|
||||
expandImageConsumers,
|
||||
makeLiveRedeploy,
|
||||
parseArgs,
|
||||
runRedeploy,
|
||||
resolveTargetServices,
|
||||
} from "./redeploy-env";
|
||||
import {
|
||||
ENV_IDS,
|
||||
ENV_ID_BY_NAME,
|
||||
PRODUCTION_ENV_ID,
|
||||
SERVICES,
|
||||
} from "./railway-envs";
|
||||
|
||||
describe("runRedeploy", () => {
|
||||
let consoleErrSpy: ReturnType<typeof vi.spyOn>;
|
||||
let consoleLogSpy: ReturnType<typeof vi.spyOn>;
|
||||
let stdoutWriteSpy: ReturnType<typeof vi.spyOn>;
|
||||
let summary: string;
|
||||
|
||||
beforeEach(() => {
|
||||
consoleErrSpy = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
|
||||
// runRedeploy's per-service progress lines go to process.stdout.write
|
||||
// (NOT console.log); spy on that too or tests spam the terminal.
|
||||
stdoutWriteSpy = vi
|
||||
.spyOn(process.stdout, "write")
|
||||
.mockImplementation(() => true);
|
||||
summary = "";
|
||||
// runRedeploy unconditionally honors $REDEPLOY_SUMMARY_JSON — if the
|
||||
// test process inherits it (e.g. from a CI step), every runRedeploy
|
||||
// call here would write a real file. Stub it out (undefined deletes
|
||||
// the var) so tests never touch the filesystem.
|
||||
vi.stubEnv("REDEPLOY_SUMMARY_JSON", undefined);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
consoleErrSpy.mockRestore();
|
||||
consoleLogSpy.mockRestore();
|
||||
stdoutWriteSpy.mockRestore();
|
||||
// vi.restoreAllMocks/mockRestore do NOT undo stubEnv — unstub
|
||||
// explicitly or the stub leaks into other files under fork reuse.
|
||||
vi.unstubAllEnvs();
|
||||
});
|
||||
|
||||
const appendSummary = (s: string) => {
|
||||
summary += s + "\n";
|
||||
};
|
||||
|
||||
it("default staging scope = 39 CI-built services + their imageOf consumers (harness-workers)", async () => {
|
||||
const seenNames: string[] = [];
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
// Reverse-lookup the SSOT name from serviceId so the test can
|
||||
// assert exact membership rather than counting opaquely.
|
||||
const name = Object.entries(SERVICES).find(
|
||||
([, e]) => e.serviceId === serviceId,
|
||||
)?.[0];
|
||||
if (name) seenNames.push(name);
|
||||
return { ok: true as const };
|
||||
});
|
||||
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
// services omitted → default = CI_BUILT_SERVICES ∪ imageOf consumers
|
||||
});
|
||||
|
||||
expect(result.exitCode).toBe(0);
|
||||
// 39 CI-built (27 showcase/infra incl. showcase-strands-typescript,
|
||||
// now dual-env, + 12 starters) + harness-workers (imageOf consumer of
|
||||
// showcase-harness) = 40. All 39 declare staging, so the env-aware
|
||||
// default scope keeps every one of them.
|
||||
expect(result.attempted).toBe(40);
|
||||
expect(result.succeeded).toBe(40);
|
||||
expect(redeploy).toHaveBeenCalledTimes(40);
|
||||
// pocketbase is now CI-built, so it IS in the default redeploy scope.
|
||||
expect(seenNames).toContain("pocketbase");
|
||||
// The TypeScript Strands integration declares staging, so it IS in the
|
||||
// staging default scope (and now prod too — see below).
|
||||
expect(seenNames).toContain("showcase-strands-typescript");
|
||||
// S2: starters are CI-built, so they JOIN the default redeploy scope.
|
||||
expect(seenNames).toContain("starter-adk");
|
||||
expect(seenNames).toContain("starter-mastra");
|
||||
// harness-workers runs the shared showcase-harness image (imageOf:
|
||||
// "harness") and must follow the scheduler into the staging scope.
|
||||
expect(seenNames).toContain("harness-workers");
|
||||
// webhooks remains out-of-band.
|
||||
expect(seenNames).not.toContain("webhooks");
|
||||
});
|
||||
|
||||
it("explicit --services harness pulls in its imageOf consumer harness-workers (staging)", async () => {
|
||||
// THE regression behind PR #5352: CI rebuilds showcase-harness:latest
|
||||
// and passes only the built slot (`showcase-harness` dispatch_name) to
|
||||
// redeploy-env.ts — the workers run the SAME image and silently kept
|
||||
// the stale one. The scope must expand to every imageOf consumer.
|
||||
const seenIds: string[] = [];
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
seenIds.push(serviceId);
|
||||
return { ok: true as const };
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-harness"], // the build matrix dispatch_name
|
||||
});
|
||||
expect(result.attempted).toBe(2);
|
||||
expect(seenIds).toEqual([
|
||||
SERVICES.harness.serviceId, // alphabetical iteration
|
||||
SERVICES["harness-workers"].serviceId,
|
||||
]);
|
||||
});
|
||||
|
||||
it("CONTRACT PIN: an explicitly-named service is attempted even in an env it does not declare (harness-workers on prod)", async () => {
|
||||
// Documented in the header: the env filter applies ONLY to consumers
|
||||
// added by imageOf expansion — a service the caller explicitly names
|
||||
// in --services is attempted even in an env it does not declare.
|
||||
// harness-workers is staging-only, yet an explicit prod request must
|
||||
// still fire against the prod env id. If a future "cleanup"
|
||||
// env-filters explicit requests, this test fails loudly against that
|
||||
// documented contract; change the docs AND this pin together or not
|
||||
// at all.
|
||||
const calls: Array<{ serviceId: string; environmentId: string }> = [];
|
||||
const redeploy = vi.fn(async (serviceId: string, environmentId: string) => {
|
||||
calls.push({ serviceId, environmentId });
|
||||
return { ok: true as const };
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "prod",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["harness-workers"],
|
||||
});
|
||||
expect(result.attempted).toBe(1);
|
||||
expect(calls).toEqual([
|
||||
{
|
||||
serviceId: SERVICES["harness-workers"].serviceId,
|
||||
environmentId: PRODUCTION_ENV_ID,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it("default prod scope includes the dual-env worker (harness-workers) and dual-env showcase-strands-typescript", async () => {
|
||||
// The default scope is env-aware: a service joins the prod scope when it
|
||||
// declares a prod env. harness-workers is now dual-env (the prod worker was
|
||||
// backfilled into the SSOT), so the env-aware imageOf expansion pulls it
|
||||
// into the prod scope as a showcase-harness consumer. showcase-strands-typescript
|
||||
// is also dual-env and joins. The prod default = the 40 services that
|
||||
// declare prod (27 CI-built showcase/infra incl. showcase-strands-typescript
|
||||
// + 12 starters + the imageOf-consumer harness-workers).
|
||||
const seenNames: string[] = [];
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
const name = Object.entries(SERVICES).find(
|
||||
([, e]) => e.serviceId === serviceId,
|
||||
)?.[0];
|
||||
if (name) seenNames.push(name);
|
||||
return { ok: true as const };
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "prod",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
});
|
||||
expect(result.attempted).toBe(40);
|
||||
// harness-workers is now dual-env, so a prod redeploy of its showcase-harness
|
||||
// image bounces the prod worker too (it used to be silently skipped).
|
||||
expect(seenNames).toContain("harness-workers");
|
||||
// showcase-strands-typescript is dual-env, so it joins the prod scope.
|
||||
expect(seenNames).toContain("showcase-strands-typescript");
|
||||
// S2: starters ARE in the default prod scope (CI-built, dual-env).
|
||||
expect(seenNames).toContain("starter-adk");
|
||||
});
|
||||
|
||||
it("default whole-env staging redeploy NEVER bounces webhooks (out-of-band)", async () => {
|
||||
// Anti-regression: webhooks is released by its own repo's workflow
|
||||
// and must stay out of the default redeploy scope. pocketbase, by
|
||||
// contrast, is now CI-built and IS legitimately in the default scope.
|
||||
const seenIds = new Set<string>();
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
seenIds.add(serviceId);
|
||||
return { ok: true as const };
|
||||
});
|
||||
await runRedeploy({ env: "staging", redeploy, appendSummary });
|
||||
expect(seenIds.has(SERVICES.webhooks.serviceId)).toBe(false);
|
||||
expect(seenIds.has(SERVICES.pocketbase.serviceId)).toBe(true);
|
||||
});
|
||||
|
||||
it("explicit --services list targets exactly that subset", async () => {
|
||||
const seenIds: string[] = [];
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
seenIds.push(serviceId);
|
||||
return { ok: true as const };
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra", "showcase-ag2"],
|
||||
});
|
||||
expect(result.attempted).toBe(2);
|
||||
expect(seenIds).toEqual([
|
||||
SERVICES["showcase-ag2"].serviceId, // alphabetical iteration
|
||||
SERVICES["showcase-mastra"].serviceId,
|
||||
]);
|
||||
});
|
||||
|
||||
it("targets the staging env id", async () => {
|
||||
const calls: Array<{ environmentId: string }> = [];
|
||||
const redeploy = vi.fn(async (_svc: string, environmentId: string) => {
|
||||
calls.push({ environmentId });
|
||||
return { ok: true as const };
|
||||
});
|
||||
await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
for (const c of calls) {
|
||||
expect(c.environmentId).toBe("8edfef02-ea09-4a20-8689-261f21cc2849");
|
||||
}
|
||||
});
|
||||
|
||||
it("targets the prod env id when env=prod", async () => {
|
||||
const calls: Array<{ environmentId: string }> = [];
|
||||
const redeploy = vi.fn(async (_svc: string, environmentId: string) => {
|
||||
calls.push({ environmentId });
|
||||
return { ok: true as const };
|
||||
});
|
||||
await runRedeploy({
|
||||
env: "prod",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
for (const c of calls) {
|
||||
expect(c.environmentId).toBe("b14919f4-6417-429f-848d-c6ae2201e04f");
|
||||
}
|
||||
});
|
||||
|
||||
it("treats per-service failures as non-fatal and exits 0", async () => {
|
||||
// Deterministic: fail on a specific named service so the test does
|
||||
// not depend on the size of the default scope.
|
||||
const failTarget = SERVICES["showcase-mastra"].serviceId;
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
if (serviceId === failTarget) {
|
||||
return { ok: false as const, error: "boom" };
|
||||
}
|
||||
return { ok: true as const };
|
||||
});
|
||||
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
});
|
||||
|
||||
expect(result.exitCode).toBe(0);
|
||||
expect(result.failed).toBe(1);
|
||||
expect(result.succeeded + result.failed).toBe(result.attempted);
|
||||
// Failure must be visible in the summary.
|
||||
expect(summary).toMatch(/FAIL/);
|
||||
expect(summary).toMatch(/boom/);
|
||||
});
|
||||
|
||||
it("per-service catch records non-Error throws (null, string) as failures without crashing", async () => {
|
||||
// Catch block previously did `(e as Error).message ?? String(e)`,
|
||||
// which throws TypeError when e is null.
|
||||
const failTarget = SERVICES["showcase-mastra"].serviceId;
|
||||
const redeploy = vi.fn(async (serviceId: string) => {
|
||||
if (serviceId === failTarget) {
|
||||
throw null;
|
||||
}
|
||||
return { ok: true as const };
|
||||
});
|
||||
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
});
|
||||
|
||||
expect(result.exitCode).toBe(0);
|
||||
expect(result.failed).toBe(1);
|
||||
expect(summary).toMatch(/FAIL/);
|
||||
});
|
||||
|
||||
it("env=prod returns non-zero exitCode on per-service failure", async () => {
|
||||
// Prod isn't wired yet, but the design must NOT silently swallow
|
||||
// prod per-service failures the way staging intentionally does.
|
||||
const redeploy = vi.fn(async () => ({
|
||||
ok: false as const,
|
||||
error: "kaboom",
|
||||
}));
|
||||
const result = await runRedeploy({
|
||||
env: "prod",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.failed).toBe(1);
|
||||
expect(result.exitCode).not.toBe(0);
|
||||
});
|
||||
|
||||
it("a registered NON-staging third env gets fail-loud semantics (exit 1 on per-service failure)", async () => {
|
||||
// Exit-code policy is fail-loud by DEFAULT: staging is the single
|
||||
// documented carve-out (non-fatal; verify-deploy is its gate). A future
|
||||
// "preview" env must inherit prod-style fatal semantics without anyone
|
||||
// remembering to extend an env allowlist.
|
||||
ENV_ID_BY_NAME.preview = "preview-env-id-000";
|
||||
try {
|
||||
const redeploy = vi.fn(async () => ({
|
||||
ok: false as const,
|
||||
error: "boom",
|
||||
}));
|
||||
const result = await runRedeploy({
|
||||
env: "preview",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.failed).toBe(1);
|
||||
expect(result.exitCode).toBe(1);
|
||||
// The "non-fatal" summary note is staging-only — a fatal env must
|
||||
// not claim its failures are non-fatal.
|
||||
expect(summary).not.toMatch(/non-fatal/);
|
||||
} finally {
|
||||
delete ENV_ID_BY_NAME.preview;
|
||||
}
|
||||
});
|
||||
|
||||
it("staging keeps the non-fatal note in the failure summary (the documented carve-out)", async () => {
|
||||
const redeploy = vi.fn(async () => ({
|
||||
ok: false as const,
|
||||
error: "boom",
|
||||
}));
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.exitCode).toBe(0);
|
||||
expect(summary).toMatch(/non-fatal/);
|
||||
});
|
||||
|
||||
it("sanitizes per-service THROWN error messages through sanitizeErrorBody", async () => {
|
||||
// The non-throw FAIL path gets pre-sanitized errors from
|
||||
// makeLiveRedeploy, but a rejection thrown by the redeploy fn (e.g. an
|
||||
// AbortSignal timeout wrapping a Cloudflare HTML page) bypassed that —
|
||||
// the raw message landed in the records + markdown summary.
|
||||
const redeploy = vi.fn(async () => {
|
||||
throw new Error(`boom <script>\nline2 ${"x".repeat(300)}`);
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.failed).toBe(1);
|
||||
expect(summary).not.toMatch(/<script>/);
|
||||
expect(summary).toMatch(/boom scriptline2/);
|
||||
// Capped at 200 chars with the sanitizer's ellipsis.
|
||||
expect(summary).toMatch(/…/);
|
||||
});
|
||||
|
||||
it("strips bare carriage returns (no \\n) from the summary table row", async () => {
|
||||
const redeploy = vi.fn(async () => ({
|
||||
ok: false as const,
|
||||
error: "part1\rpart2",
|
||||
}));
|
||||
await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(summary).toMatch(/part1 part2/);
|
||||
expect(summary).not.toMatch(/\r/);
|
||||
});
|
||||
|
||||
it("warns to stderr when REDEPLOY_SUMMARY_JSON is set but empty", async () => {
|
||||
// An empty-string REDEPLOY_SUMMARY_JSON silently disabled the JSON
|
||||
// summary (falsy check) — the CI consumer then saw "no artifact" with
|
||||
// zero signal about why. Warn loudly; still skip the write.
|
||||
vi.stubEnv("REDEPLOY_SUMMARY_JSON", "");
|
||||
const stderrSpy = vi
|
||||
.spyOn(process.stderr, "write")
|
||||
.mockImplementation(() => true);
|
||||
try {
|
||||
const redeploy = vi.fn(async () => ({ ok: true as const }));
|
||||
await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
|
||||
expect(written).toMatch(/REDEPLOY_SUMMARY_JSON is set but empty/);
|
||||
} finally {
|
||||
stderrSpy.mockRestore();
|
||||
}
|
||||
});
|
||||
|
||||
it("warns to stderr when REDEPLOY_SUMMARY_JSON is whitespace-only (trimmed before the set-but-empty check)", async () => {
|
||||
// A whitespace-only value is exactly as unusable as the empty string,
|
||||
// but without trimming it is truthy — it would skip the loud warn and
|
||||
// attempt a JSON write against a garbage path instead.
|
||||
vi.stubEnv("REDEPLOY_SUMMARY_JSON", " \n\t");
|
||||
const stderrSpy = vi
|
||||
.spyOn(process.stderr, "write")
|
||||
.mockImplementation(() => true);
|
||||
try {
|
||||
const redeploy = vi.fn(async () => ({ ok: true as const }));
|
||||
await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
|
||||
expect(written).toMatch(/REDEPLOY_SUMMARY_JSON is set but empty/);
|
||||
} finally {
|
||||
stderrSpy.mockRestore();
|
||||
}
|
||||
});
|
||||
|
||||
it("env=prod returns exitCode 0 when all services succeed", async () => {
|
||||
const redeploy = vi.fn(async () => ({ ok: true as const }));
|
||||
const result = await runRedeploy({
|
||||
env: "prod",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.exitCode).toBe(0);
|
||||
});
|
||||
|
||||
it("reports zero failures with empty failure list in summary", async () => {
|
||||
const redeploy = vi.fn(async () => ({ ok: true as const }));
|
||||
await runRedeploy({ env: "staging", redeploy, appendSummary });
|
||||
expect(summary).toMatch(/- failed: \*\*0\*\*/);
|
||||
});
|
||||
|
||||
it("flattens CRLF newlines in failure errors to keep the markdown table on one row", async () => {
|
||||
const redeploy = vi.fn(async () => ({
|
||||
ok: false as const,
|
||||
error: "line one\r\nline two",
|
||||
}));
|
||||
await runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(summary).toMatch(/line one line two/);
|
||||
expect(summary).not.toMatch(/\r/);
|
||||
});
|
||||
|
||||
it("throws on a --services entry that doesn't resolve to a known SSOT key", async () => {
|
||||
const redeploy = vi.fn();
|
||||
await expect(
|
||||
runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: ["nonsense"],
|
||||
}),
|
||||
).rejects.toThrow(/Unknown service/);
|
||||
expect(redeploy).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects unknown env names", async () => {
|
||||
const redeploy = vi.fn();
|
||||
await expect(
|
||||
runRedeploy({ env: "dev", redeploy, appendSummary }),
|
||||
).rejects.toThrow(/Unknown env/);
|
||||
expect(redeploy).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects an unnormalized env synonym, pointing at resolveEnv", async () => {
|
||||
// "production" is a resolveEnv synonym, not a registered SSOT env key.
|
||||
// runRedeploy must resolve env ids via the registry (open-env
|
||||
// contract), so the synonym fails loud with a normalization hint.
|
||||
const redeploy = vi.fn();
|
||||
await expect(
|
||||
runRedeploy({ env: "production", redeploy, appendSummary }),
|
||||
).rejects.toThrow(/Unknown env "production".*resolveEnv/);
|
||||
expect(redeploy).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("resolves the env id via the ENV_ID_BY_NAME registry (open-env contract)", async () => {
|
||||
// The SSOT's documented contract: a new env needs only a registry
|
||||
// entry — runRedeploy must NOT hardcode the prod/staging pair.
|
||||
// Register a hypothetical env and verify the redeploy fires against
|
||||
// its registered env id.
|
||||
ENV_ID_BY_NAME.preview = "preview-env-id-000";
|
||||
try {
|
||||
const calls: Array<{ environmentId: string }> = [];
|
||||
const redeploy = vi.fn(async (_svc: string, environmentId: string) => {
|
||||
calls.push({ environmentId });
|
||||
return { ok: true as const };
|
||||
});
|
||||
const result = await runRedeploy({
|
||||
env: "preview",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
// Explicitly-named services are attempted even in an env they do
|
||||
// not declare (the documented contract pinned above).
|
||||
services: ["showcase-mastra"],
|
||||
});
|
||||
expect(result.attempted).toBe(1);
|
||||
expect(calls).toEqual([{ environmentId: "preview-env-id-000" }]);
|
||||
} finally {
|
||||
delete ENV_ID_BY_NAME.preview;
|
||||
}
|
||||
});
|
||||
|
||||
it("throws when an explicitly-provided services list resolves to zero entries", async () => {
|
||||
// A provided-but-all-blank list silently redeploying NOTHING with
|
||||
// exit 0 is the silent-no-op class this script's header forbids.
|
||||
const redeploy = vi.fn();
|
||||
await expect(
|
||||
runRedeploy({
|
||||
env: "staging",
|
||||
redeploy,
|
||||
appendSummary,
|
||||
services: [" ", ""],
|
||||
}),
|
||||
).rejects.toThrow(/resolved to zero services/);
|
||||
expect(redeploy).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
describe("resolveTargetServices", () => {
|
||||
it("accepts SSOT keys verbatim and resolves CI dispatch_names too", () => {
|
||||
// The workflow passes detect-changes.outputs.matrix .dispatch_name
|
||||
// values, but a human operator might pass SSOT keys directly.
|
||||
// Both forms must resolve.
|
||||
const resolved = resolveTargetServices([
|
||||
"showcase-mastra", // already an SSOT key
|
||||
"mastra", // dispatch_name → showcase-mastra
|
||||
"shell-dashboard", // dispatch_name → dashboard
|
||||
"showcase-aimock", // dispatch_name → aimock
|
||||
]);
|
||||
expect(resolved).toEqual(["showcase-mastra", "dashboard", "aimock"]);
|
||||
// Dedupes the duplicate showcase-mastra ↔ mastra.
|
||||
});
|
||||
|
||||
it("throws on inputs that match neither SSOT keys nor dispatch_names", () => {
|
||||
expect(() => resolveTargetServices(["mastra", "garbage"])).toThrow(
|
||||
/Unknown service "garbage"/,
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects inherited Object.prototype keys as unknown services", () => {
|
||||
// `SERVICES[name]` with name "toString" resolves to the inherited
|
||||
// Object.prototype method — a truthy non-entry. The lookup must use
|
||||
// an own-property check, or a prototype key sails through as a
|
||||
// "valid" service whose entry.serviceId is undefined downstream,
|
||||
// violating the header's "unknown service ALWAYS fails loud" contract.
|
||||
expect(() => resolveTargetServices(["toString"])).toThrow(
|
||||
/Unknown service "toString"/,
|
||||
);
|
||||
expect(() => resolveTargetServices(["constructor"])).toThrow(
|
||||
/Unknown service "constructor"/,
|
||||
);
|
||||
expect(() => resolveTargetServices(["hasOwnProperty"])).toThrow(
|
||||
/Unknown service "hasOwnProperty"/,
|
||||
);
|
||||
});
|
||||
|
||||
it("returns the CI_BUILT_SERVICES set sorted when given undefined", () => {
|
||||
const resolved = resolveTargetServices(undefined);
|
||||
// 27 showcase/infra CI-built (incl. showcase-strands-typescript) + 12
|
||||
// starters = 39. resolveTargetServices returns the FULL CI_BUILT set;
|
||||
// the env-aware narrowing happens later in runRedeploy, not here.
|
||||
expect(resolved.length).toBe(39);
|
||||
// pocketbase is now CI-built and part of the default scope.
|
||||
expect(resolved).toContain("pocketbase");
|
||||
// S2: starters are CI-built and part of the default scope.
|
||||
expect(resolved).toContain("starter-adk");
|
||||
// webhooks remains out-of-band.
|
||||
expect(resolved).not.toContain("webhooks");
|
||||
});
|
||||
|
||||
it("throws when a provided list resolves empty instead of silently no-opping", () => {
|
||||
// parseArgs already rejects empty CSV at the CLI boundary; this guards
|
||||
// the programmatic path (e.g. a caller passing whitespace-only entries)
|
||||
// so an explicit request can never resolve to a zero-service no-op.
|
||||
expect(() => resolveTargetServices([""])).toThrow(
|
||||
/resolved to zero services/,
|
||||
);
|
||||
expect(() => resolveTargetServices([" ", "\t"])).toThrow(
|
||||
/resolved to zero services/,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("makeLiveRedeploy", () => {
|
||||
afterEach(() => {
|
||||
// restoreAllMocks does NOT undo stubGlobal — unstub explicitly or the
|
||||
// fetch stub leaks into other files under fork reuse.
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
|
||||
function stubFetch(
|
||||
impl: (url: unknown, init?: RequestInit) => Promise<unknown>,
|
||||
) {
|
||||
const fetchMock = vi.fn(impl);
|
||||
vi.stubGlobal("fetch", fetchMock);
|
||||
return fetchMock;
|
||||
}
|
||||
|
||||
it("passes an abort signal so a hung Railway API records a per-service FAIL", async () => {
|
||||
// Without a timeout signal a hung Railway API stalls the CI job until
|
||||
// the runner's global timeout; the AbortSignal rejection is caught by
|
||||
// runRedeploy's per-service try/catch and recorded as FAIL instead.
|
||||
let capturedInit: RequestInit | undefined;
|
||||
stubFetch(async (_url, init) => {
|
||||
capturedInit = init;
|
||||
return {
|
||||
ok: true,
|
||||
json: async () => ({ data: { serviceInstanceRedeploy: true } }),
|
||||
};
|
||||
});
|
||||
const redeploy = makeLiveRedeploy("test-token");
|
||||
const outcome = await redeploy("svc-id", "env-id");
|
||||
expect(outcome).toEqual({ ok: true });
|
||||
expect(capturedInit?.signal).toBeInstanceOf(AbortSignal);
|
||||
});
|
||||
|
||||
it("sanitizes GraphQL errors[].message through sanitizeErrorBody", async () => {
|
||||
// Consistency with the HTTP-error path: GraphQL error strings can be
|
||||
// multi-KB / markdown-breaking too. Angle brackets + newlines must be
|
||||
// stripped and long messages capped (200 chars + ellipsis).
|
||||
stubFetch(async () => ({
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
errors: [
|
||||
{ message: "boom <script>\nline2" },
|
||||
{ message: "x".repeat(250) },
|
||||
],
|
||||
}),
|
||||
}));
|
||||
const redeploy = makeLiveRedeploy("test-token");
|
||||
const outcome = await redeploy("svc-id", "env-id");
|
||||
expect(outcome.ok).toBe(false);
|
||||
if (!outcome.ok) {
|
||||
expect(outcome.error).toBe(`boom scriptline2; ${"x".repeat(200)}…`);
|
||||
}
|
||||
});
|
||||
|
||||
it("returns a sanitized HTTP-status failure when the response is not ok", async () => {
|
||||
// Non-2xx path: the body (often a multi-KB Cloudflare HTML page) must
|
||||
// go through sanitizeErrorBody — no angle brackets, no newlines, capped.
|
||||
stubFetch(async () => ({
|
||||
ok: false,
|
||||
status: 503,
|
||||
text: async () =>
|
||||
`<html>\nCloudflare error page</html>${"y".repeat(300)}`,
|
||||
}));
|
||||
const redeploy = makeLiveRedeploy("test-token");
|
||||
const outcome = await redeploy("svc-id", "env-id");
|
||||
expect(outcome.ok).toBe(false);
|
||||
if (!outcome.ok) {
|
||||
expect(outcome.error).toMatch(/^HTTP 503: /);
|
||||
expect(outcome.error).not.toMatch(/[<>\n]/);
|
||||
expect(outcome.error).toMatch(/…$/);
|
||||
}
|
||||
});
|
||||
|
||||
it("fails when serviceInstanceRedeploy returns a non-true value", async () => {
|
||||
// A 200 response whose mutation result is false/undefined is NOT a
|
||||
// success — Railway acknowledged the call but did not redeploy.
|
||||
stubFetch(async () => ({
|
||||
ok: true,
|
||||
json: async () => ({ data: { serviceInstanceRedeploy: false } }),
|
||||
}));
|
||||
const redeploy = makeLiveRedeploy("test-token");
|
||||
const outcome = await redeploy("svc-id", "env-id");
|
||||
expect(outcome).toEqual({
|
||||
ok: false,
|
||||
error: "serviceInstanceRedeploy returned false",
|
||||
});
|
||||
|
||||
stubFetch(async () => ({
|
||||
ok: true,
|
||||
json: async () => ({ data: {} }),
|
||||
}));
|
||||
const outcome2 = await makeLiveRedeploy("test-token")("svc-id", "env-id");
|
||||
expect(outcome2).toEqual({
|
||||
ok: false,
|
||||
error: "serviceInstanceRedeploy returned undefined",
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("expandImageConsumers", () => {
|
||||
it("adds imageOf consumers of a built service for staging", () => {
|
||||
expect(expandImageConsumers(["harness"], "staging")).toEqual([
|
||||
"harness",
|
||||
"harness-workers",
|
||||
]);
|
||||
});
|
||||
|
||||
it("includes a dual-env consumer (harness-workers) in the prod expansion", () => {
|
||||
// harness-workers is now dual-env (the prod worker was backfilled into the
|
||||
// SSOT), so a prod redeploy of its showcase-harness image MUST also bounce
|
||||
// the prod worker — the env-aware expansion pulls it in for prod just like
|
||||
// staging. (The env-aware EXCLUSION branch — skipping a consumer that does
|
||||
// not declare the target env — is exercised by expandImageConsumers' own
|
||||
// Object.hasOwn(entry.environments, env) guard; there is no longer a
|
||||
// single-env imageOf consumer in the SSOT to demonstrate it end-to-end.)
|
||||
expect(expandImageConsumers(["harness"], "prod")).toEqual([
|
||||
"harness",
|
||||
"harness-workers",
|
||||
]);
|
||||
});
|
||||
|
||||
it("returns the input unchanged for services without consumers", () => {
|
||||
expect(
|
||||
expandImageConsumers(["showcase-mastra", "aimock"], "staging"),
|
||||
).toEqual(["showcase-mastra", "aimock"]);
|
||||
});
|
||||
|
||||
it("does not duplicate a consumer that is already in the input", () => {
|
||||
expect(
|
||||
expandImageConsumers(["harness", "harness-workers"], "staging"),
|
||||
).toEqual(["harness", "harness-workers"]);
|
||||
});
|
||||
|
||||
it("throws on an unnormalized env synonym instead of silently not expanding", () => {
|
||||
// "production" is a resolveEnv synonym, NOT an SSOT `environments` key.
|
||||
// A silent no-expansion here would recreate the exact stale-image class
|
||||
// this function exists to prevent (harness-workers left running a stale
|
||||
// image because the env string didn't match any `environments` key).
|
||||
expect(() => expandImageConsumers(["harness"], "production")).toThrow(
|
||||
/Unknown env "production".*resolveEnv/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws on an inherited prototype key as env instead of silently not expanding", () => {
|
||||
// The registry own-key validation rejects a prototype-named env up
|
||||
// front, and the per-entry skip-check is itself an own-property test
|
||||
// (`Object.hasOwn(entry.environments, env)`), so even a registered
|
||||
// prototype-named env could not match a truthy inherited value.
|
||||
expect(() => expandImageConsumers(["harness"], "constructor")).toThrow(
|
||||
/Unknown env "constructor"/,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseArgs", () => {
|
||||
it("parses bare env name", () => {
|
||||
expect(parseArgs(["staging"])).toEqual({ env: "staging" });
|
||||
});
|
||||
|
||||
it("parses --services with CSV value", () => {
|
||||
expect(parseArgs(["staging", "--services", "mastra,ag2"])).toEqual({
|
||||
env: "staging",
|
||||
services: ["mastra", "ag2"],
|
||||
});
|
||||
});
|
||||
|
||||
it("parses --services=csv form", () => {
|
||||
expect(parseArgs(["staging", "--services=mastra,ag2"])).toEqual({
|
||||
env: "staging",
|
||||
services: ["mastra", "ag2"],
|
||||
});
|
||||
});
|
||||
|
||||
it("throws when --services has no following value (bare flag at end)", () => {
|
||||
expect(() => parseArgs(["staging", "--services"])).toThrow(
|
||||
/--services requires a non-empty comma-separated value/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws when --services value is the empty string", () => {
|
||||
expect(() => parseArgs(["staging", "--services", ""])).toThrow(
|
||||
/--services requires a non-empty comma-separated value/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws when --services value is only commas/whitespace", () => {
|
||||
expect(() => parseArgs(["staging", "--services", ","])).toThrow(
|
||||
/--services requires a non-empty comma-separated value/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws when --services= value empties after split/filter", () => {
|
||||
expect(() => parseArgs(["staging", "--services="])).toThrow(
|
||||
/--services requires a non-empty comma-separated value/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws on duplicate --services flags (either form, mixed too)", () => {
|
||||
expect(() =>
|
||||
parseArgs(["staging", "--services", "mastra", "--services", "ag2"]),
|
||||
).toThrow(/Duplicate --services/);
|
||||
expect(() =>
|
||||
parseArgs(["staging", "--services=mastra", "--services=ag2"]),
|
||||
).toThrow(/Duplicate --services/);
|
||||
expect(() =>
|
||||
parseArgs(["staging", "--services", "mastra", "--services=ag2"]),
|
||||
).toThrow(/Duplicate --services/);
|
||||
});
|
||||
|
||||
it("throws when --services is followed by a flag-like token instead of a value", () => {
|
||||
// Without this guard, `--services --bogus` would swallow `--bogus` as
|
||||
// the CSV — a silent misparse instead of a loud operator error.
|
||||
expect(() => parseArgs(["staging", "--services", "--bogus"])).toThrow(
|
||||
/--services requires a value/,
|
||||
);
|
||||
expect(() => parseArgs(["staging", "--services", "-x"])).toThrow(
|
||||
/--services requires a value/,
|
||||
);
|
||||
});
|
||||
|
||||
it("throws on unknown argument", () => {
|
||||
expect(() => parseArgs(["staging", "--bogus"])).toThrow(/Unknown argument/);
|
||||
});
|
||||
|
||||
it("throws on empty argv", () => {
|
||||
expect(() => parseArgs([])).toThrow();
|
||||
});
|
||||
|
||||
it("rejects flag-like entries inside the --services CSV (both forms)", () => {
|
||||
// The space form already rejects a flag-like NEXT TOKEN; the = form and
|
||||
// individual CSV parts had no such guard, so `--services=--bogus`
|
||||
// silently became a service name destined for an Unknown-service throw
|
||||
// far from the CLI boundary.
|
||||
expect(() => parseArgs(["staging", "--services=--bogus"])).toThrow(
|
||||
/flag-like/,
|
||||
);
|
||||
expect(() => parseArgs(["staging", "--services", "mastra,-x"])).toThrow(
|
||||
/flag-like/,
|
||||
);
|
||||
expect(() => parseArgs(["staging", "--services=mastra,--force"])).toThrow(
|
||||
/flag-like/,
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects a flag-like first argument as a missing env argument", () => {
|
||||
// `redeploy-env.ts --services mastra` forgot the env — the old parse
|
||||
// consumed "--services" AS the env and failed later/elsewhere.
|
||||
expect(() => parseArgs(["--services", "mastra"])).toThrow(
|
||||
/missing env argument/i,
|
||||
);
|
||||
expect(() => parseArgs(["-h"])).toThrow(/missing env argument/i);
|
||||
});
|
||||
|
||||
it("derives the usage env list from ENV_IDS (a registered spelling appears with no code change)", () => {
|
||||
// Open-env contract at the CLI boundary: the usage string must list
|
||||
// whatever ENV_IDS currently accepts, not a hardcoded triple.
|
||||
ENV_IDS.preview = "preview-env-id-000";
|
||||
try {
|
||||
expect(() => parseArgs([])).toThrow(/preview/);
|
||||
} finally {
|
||||
delete ENV_IDS.preview;
|
||||
}
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user