Files
kandev/apps/web/components/automations/automation-payload.test.ts
T

213 lines
7.2 KiB
TypeScript

import { afterEach, describe, expect, it, vi } from "vitest";
const createRepositoryAction = vi.fn();
vi.mock("@/app/actions/workspaces", () => ({
createRepositoryAction: (...args: unknown[]) => createRepositoryAction(...args),
}));
import {
buildCreatePayload,
buildUpdatePayload,
resolveNormalizedRepositoryIds,
resolveRepositoryIdsForMode,
resolveRepositoryIds,
} from "./automation-payload";
import type { FormState } from "./automation-payload";
function baseForm(overrides: Partial<FormState> = {}): FormState {
return {
name: "Test",
description: "",
workflowId: "wf-1",
workflowStepId: "step-1",
agentProfileId: "agent-1",
executorProfileId: "exec-1",
taskMode: "automation_run",
repositoryMode: "none",
repositorySelections: [],
prompt: "Run it",
taskTitleTemplate: "",
enabled: true,
maxConcurrentRuns: 1,
continuationPolicy: "new_task",
...overrides,
};
}
describe("resolveRepositoryIds", () => {
afterEach(() => {
createRepositoryAction.mockReset();
});
it("resolves a mix of registered and discovered selections, in order", async () => {
createRepositoryAction.mockResolvedValue({ id: "repo-new" });
const result = await resolveRepositoryIds("ws-1", [
{ kind: "registered", id: "repo-a", branch: "release/1" },
{
kind: "discovered",
path: "/tmp/repo-b",
name: "repo-b",
defaultBranch: "main",
branch: "develop",
},
]);
expect(result.ids).toEqual(["repo-a", "repo-new"]);
expect(result.selections).toEqual([
{ kind: "registered", id: "repo-a", branch: "release/1" },
{ kind: "registered", id: "repo-new", key: undefined, branch: "develop" },
]);
expect(result.repositories).toEqual([
{ repository_id: "repo-a", base_branch: "release/1" },
{ repository_id: "repo-new", base_branch: "develop" },
]);
expect(createRepositoryAction).toHaveBeenCalledTimes(1);
expect(createRepositoryAction).toHaveBeenCalledWith(
expect.objectContaining({ workspace_id: "ws-1", local_path: "/tmp/repo-b" }),
);
});
it("resolves an empty selections list to empty output without registering anything", async () => {
const result = await resolveRepositoryIds("ws-1", []);
expect(result.ids).toEqual([]);
expect(result.repositories).toEqual([]);
expect(result.selections).toEqual([]);
expect(createRepositoryAction).not.toHaveBeenCalled();
});
it("does not promote a registered selection", async () => {
const result = await resolveRepositoryIds("ws-1", [{ kind: "registered", id: "repo-a" }]);
expect(result.selections).toEqual([{ kind: "registered", id: "repo-a" }]);
expect(createRepositoryAction).not.toHaveBeenCalled();
});
});
describe("resolveNormalizedRepositoryIds", () => {
afterEach(() => {
createRepositoryAction.mockReset();
});
const twoRegistered = [
{ kind: "registered" as const, id: "repo-a", branch: "main" },
{ kind: "registered" as const, id: "repo-b", branch: "develop" },
];
it("resolves every selection when the executor supports multi-repo", async () => {
const result = await resolveNormalizedRepositoryIds("ws-1", twoRegistered, {
supportsMultiRepo: true,
});
expect(result.ids).toEqual(["repo-a", "repo-b"]);
});
it("truncates a stale multi-repository selection to one ID when the executor no longer supports multi-repo", async () => {
// Regression: the picker only *renders* repositorySelections[0] once the
// executor stops supporting multi-repo, it doesn't truncate the
// underlying form state — a save that skipped normalization would send
// both stale repository_ids here.
const result = await resolveNormalizedRepositoryIds("ws-1", twoRegistered, {
supportsMultiRepo: false,
});
expect(result.ids).toEqual(["repo-a"]);
});
it("feeds the truncated ids straight into buildUpdatePayload", async () => {
const { ids } = await resolveNormalizedRepositoryIds("ws-1", twoRegistered, {
supportsMultiRepo: false,
});
const payload = buildUpdatePayload(
baseForm(),
ids.map((repository_id) => ({ repository_id, base_branch: "main" })),
);
expect(payload.repository_ids).toEqual(["repo-a"]);
});
it("feeds the truncated ids straight into buildCreatePayload", async () => {
const { ids } = await resolveNormalizedRepositoryIds("ws-1", twoRegistered, {
supportsMultiRepo: false,
});
const payload = buildCreatePayload(
"ws-1",
baseForm(),
ids.map((repository_id) => ({ repository_id, base_branch: "main" })),
[],
);
expect(payload.repository_ids).toEqual(["repo-a"]);
});
});
describe("buildCreatePayload / buildUpdatePayload", () => {
it("leaves workflow step resolution to normal task creation", () => {
const form = baseForm({ workflowStepId: "stale-step" });
expect(buildCreatePayload("ws-1", form, [], []).workflow_step_id).toBe("");
expect(buildUpdatePayload(form, []).workflow_step_id).toBe("");
});
it("sends repository_ids in row order on create", () => {
const payload = buildCreatePayload(
"ws-1",
baseForm(),
[
{ repository_id: "repo-a", base_branch: "main" },
{ repository_id: "repo-b", base_branch: "develop" },
],
[],
);
expect(payload.repository_ids).toEqual(["repo-a", "repo-b"]);
expect(payload.repositories).toEqual([
{ repository_id: "repo-a", base_branch: "main" },
{ repository_id: "repo-b", base_branch: "develop" },
]);
});
it("sends repository_ids in row order on update", () => {
const payload = buildUpdatePayload(baseForm(), [
{ repository_id: "repo-b", base_branch: "develop" },
{ repository_id: "repo-a", base_branch: "main" },
]);
expect(payload.repository_ids).toEqual(["repo-b", "repo-a"]);
});
it("sends an empty repository_ids array when no repositories are selected", () => {
const payload = buildCreatePayload("ws-1", baseForm(), [], []);
expect(payload.repository_ids).toEqual([]);
});
it("sends the selected continuation policy on create and update", () => {
const form = baseForm({ continuationPolicy: "reuse_thread" });
expect(buildCreatePayload("ws-1", form, [], []).continuation_policy).toBe("reuse_thread");
expect(buildUpdatePayload(form, []).continuation_policy).toBe("reuse_thread");
});
it("sends the target and repository modes on create and update", () => {
const form = baseForm({ taskMode: "normal_task", repositoryMode: "selected" });
const repositories = [{ repository_id: "repo-a", base_branch: "main" }];
expect(buildCreatePayload("ws-1", form, repositories, [])).toMatchObject({
task_mode: "normal_task",
repository_mode: "selected",
});
expect(buildUpdatePayload(form, repositories)).toMatchObject({
task_mode: "normal_task",
repository_mode: "selected",
});
});
it("does not resolve stale repository selections for non-selected modes", async () => {
const result = await resolveRepositoryIdsForMode(
"ws-1",
[{ kind: "discovered", path: "/tmp/stale", name: "stale", defaultBranch: "main" }],
"none",
{ supportsMultiRepo: true },
);
expect(result.ids).toEqual([]);
expect(createRepositoryAction).not.toHaveBeenCalled();
});
});