@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

package/src/core/__tests__/job-submission.test.ts

@@ -0,0 +1,396 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  submitSeed,
+  submitUploadedSeed,
+  type SubmitSuccessResult,
+  type SubmitFailureResult,
+} from "../job-submission.ts";
+import { SEED_FILENAME_PATTERN, parseSeedFilename } from "../seed-naming.ts";
+
+async function readJson(filePath: string): Promise<unknown> {
+  const text = await Bun.file(filePath).text();
+  return JSON.parse(text) as unknown;
+}
+
+async function scaffoldWorkspace(tmpDir: string): Promise<void> {
+  const pipelineConfigDir = join(tmpDir, "pipeline-config", "test-pipeline");
+
+  await mkdir(pipelineConfigDir, { recursive: true });
+  await mkdir(join(pipelineConfigDir, "tasks"), { recursive: true });
+  await mkdir(join(tmpDir, "pipeline-data", "pending"), { recursive: true });
+  await mkdir(join(tmpDir, "pipeline-data", "current"), { recursive: true });
+  await mkdir(join(tmpDir, "pipeline-data", "complete"), { recursive: true });
+
+  await Bun.write(
+    join(tmpDir, "pipeline-config", "registry.json"),
+    JSON.stringify({
+      version: 1,
+      pipelines: {
+        "test-pipeline": {
+          name: "Test Pipeline",
+          description: "test pipeline",
+          configDir: join(tmpDir, "pipeline-config", "test-pipeline"),
+          tasksDir: join(tmpDir, "pipeline-config", "test-pipeline", "tasks"),
+        },
+      },
+    }),
+  );
+
+  await Bun.write(
+    join(pipelineConfigDir, "pipeline.json"),
+    JSON.stringify({ name: "test-pipeline", tasks: [] }),
+  );
+}
+
+const UUID_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+describe("submitSeed", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "pop-job-submission-test-"));
+    await scaffoldWorkspace(tmpDir);
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("writes pending seed file with UUID jobId and returns success", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+    });
+
+    expect(result.success).toBe(true);
+    const success = result as SubmitSuccessResult;
+    expect(success.jobId).toMatch(UUID_PATTERN);
+    expect(success.jobName).toBe(success.jobId);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const seedFile = pendingFiles.find((f) => f.endsWith("-seed.json"));
+    expect(seedFile).toBeDefined();
+    expect(seedFile).toBe(`${success.jobId}-seed.json`);
+
+    const written = await readJson(join(tmpDir, "pipeline-data", "pending", seedFile!));
+    expect(written).toEqual({ pipeline: "test-pipeline" });
+  });
+
+  it("uses the seed's name as jobName when provided", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline", name: "my-job" },
+    });
+
+    expect(result.success).toBe(true);
+    expect((result as SubmitSuccessResult).jobName).toBe("my-job");
+  });
+
+  it("writes the seed file with a name matching SEED_FILENAME_PATTERN", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+    });
+
+    const success = result as SubmitSuccessResult;
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const seedFile = pendingFiles.find((f) => f.endsWith("-seed.json"))!;
+    expect(SEED_FILENAME_PATTERN.exec(seedFile)).not.toBeNull();
+    expect(parseSeedFilename(seedFile)).toBe(success.jobId);
+  });
+
+  it("does not leave a .tmp file in pending after a successful write", async () => {
+    await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+    });
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const tmpFiles = pendingFiles.filter((f) => f.endsWith(".tmp"));
+    expect(tmpFiles).toEqual([]);
+  });
+
+  it("produces distinct jobIds and files for two submits with identical name", async () => {
+    const first = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline", name: "same-name" },
+    });
+    const second = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline", name: "same-name" },
+    });
+
+    expect(first.success).toBe(true);
+    expect(second.success).toBe(true);
+
+    const firstSuccess = first as SubmitSuccessResult;
+    const secondSuccess = second as SubmitSuccessResult;
+    expect(firstSuccess.jobId).not.toBe(secondSuccess.jobId);
+    expect(firstSuccess.jobName).toBe("same-name");
+    expect(secondSuccess.jobName).toBe("same-name");
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const seedFiles = pendingFiles.filter((f) => f.endsWith("-seed.json"));
+    expect(seedFiles).toContain(`${firstSuccess.jobId}-seed.json`);
+    expect(seedFiles).toContain(`${secondSuccess.jobId}-seed.json`);
+    expect(seedFiles.length).toBe(2);
+  });
+
+  it("rejects a non-object seed with the exact pinned message", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: "not an object",
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
+  });
+
+  it("rejects an array seed with the exact pinned message", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: [1, 2, 3],
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
+  });
+
+  it("rejects a null seed with the exact pinned message", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: null,
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
+  });
+
+  it("rejects an empty pipeline string with the exact pinned message", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "" },
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe(
+      "seed.pipeline must be a non-empty string",
+    );
+  });
+
+  it("passes through the underlying error for an unknown pipeline slug", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "does-not-exist" },
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe(
+      "Pipeline 'does-not-exist' not found in registry",
+    );
+  });
+
+  it("rejects an empty name string with the exact pinned message", async () => {
+    const result = await submitSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline", name: "" },
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe(
+      "seed.name must be a non-empty string if provided",
+    );
+  });
+});
+
+async function pathExists(target: string): Promise<boolean> {
+  try {
+    await stat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+describe("submitUploadedSeed", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "pop-job-submission-upload-test-"));
+    await scaffoldWorkspace(tmpDir);
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("stages artifacts under pipeline-data/staging/<jobId>/ before writing the pending seed", async () => {
+    const content = new TextEncoder().encode("artifact bytes");
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline", name: "upload-job" },
+      artifacts: [{ filename: "notes.md", content }],
+    });
+
+    expect(result.success).toBe(true);
+    const success = result as SubmitSuccessResult;
+
+    const stagedPath = join(tmpDir, "pipeline-data", "staging", success.jobId, "notes.md");
+    const stagedBytes = await readFile(stagedPath);
+    expect(Array.from(stagedBytes)).toEqual(Array.from(content));
+
+    const pendingPath = join(
+      tmpDir,
+      "pipeline-data",
+      "pending",
+      `${success.jobId}-seed.json`,
+    );
+    const pendingJson = (await readJson(pendingPath)) as { pipeline: string; name: string };
+    expect(pendingJson).toEqual({ pipeline: "test-pipeline", name: "upload-job" });
+  });
+
+  it("stages nested artifacts preserving their subpath under staging/<jobId>/", async () => {
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [
+        { filename: "out.json", content: new TextEncoder().encode("{}") },
+        {
+          filename: "data/foo.json",
+          content: new TextEncoder().encode('{"a":1}'),
+        },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+    const success = result as SubmitSuccessResult;
+    const stagingJobDir = join(tmpDir, "pipeline-data", "staging", success.jobId);
+
+    expect(await pathExists(join(stagingJobDir, "out.json"))).toBe(true);
+    expect(await pathExists(join(stagingJobDir, "data", "foo.json"))).toBe(true);
+  });
+
+  it("rejects a parent-traversal artifact path with the pinned message and writes nothing", async () => {
+    const filename = "../escape.txt";
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [{ filename, content: new TextEncoder().encode("escape") }],
+    });
+
+    expect(result.success).toBe(false);
+    const failure = result as SubmitFailureResult;
+    expect(failure.message.startsWith("unsafe artifact path: ")).toBe(true);
+    expect(failure.message).toContain(filename);
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+    expect(await pathExists(join(tmpDir, "escape.txt"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+
+  it("rejects an absolute artifact path with the pinned message and writes nothing", async () => {
+    const filename = "/etc/passwd";
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [{ filename, content: new TextEncoder().encode("data") }],
+    });
+
+    expect(result.success).toBe(false);
+    const failure = result as SubmitFailureResult;
+    expect(failure.message.startsWith("unsafe artifact path: ")).toBe(true);
+    expect(failure.message).toContain(filename);
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+
+  it("rejects a dir/.. artifact path with the pinned message and writes nothing", async () => {
+    const filename = "dir/..";
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [{ filename, content: new TextEncoder().encode("root") }],
+    });
+
+    expect(result.success).toBe(false);
+    const failure = result as SubmitFailureResult;
+    expect(failure.message.startsWith("unsafe artifact path: ")).toBe(true);
+    expect(failure.message).toContain(filename);
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+
+  it("rejects the root '.' artifact path with the pinned message and writes nothing", async () => {
+    const filename = ".";
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [{ filename, content: new TextEncoder().encode("root") }],
+    });
+
+    expect(result.success).toBe(false);
+    const failure = result as SubmitFailureResult;
+    expect(failure.message.startsWith("unsafe artifact path: ")).toBe(true);
+    expect(failure.message).toContain(filename);
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+
+  it("rejects a mixed safe+unsafe artifact array with no partial writes", async () => {
+    const unsafeFilename = "../escape.txt";
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+      artifacts: [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+        { filename: unsafeFilename, content: new TextEncoder().encode("escape") },
+      ],
+    });
+
+    expect(result.success).toBe(false);
+    const failure = result as SubmitFailureResult;
+    expect(failure.message.startsWith("unsafe artifact path: ")).toBe(true);
+    expect(failure.message).toContain(unsafeFilename);
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+
+  it("rejects an unknown pipeline slug with artifacts and writes no staging dir or seed", async () => {
+    const result = await submitUploadedSeed({
+      root: tmpDir,
+      seedObject: { pipeline: "does-not-exist", name: "upload-job" },
+      artifacts: [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+      ],
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe(
+      "Pipeline 'does-not-exist' not found in registry",
+    );
+
+    expect(await pathExists(join(tmpDir, "pipeline-data", "staging"))).toBe(false);
+
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    expect(pendingFiles.filter((f) => f.endsWith("-seed.json"))).toEqual([]);
+  });
+});