import { expect, it } from "@effect/vitest";import * as Layer from "effect/Layer";import * as Effect from "effect/Effect";import * as Fiber from "effect/Fiber";import * as TestClock from "effect/testing/TestClock";import { ChildProcessSpawner } from "effect/unstable/process";import * as GitHubCli from "../sourceControl/GitHubCli.ts";import { runGitHubStackAction as runStackAction } from "./githubStackActions.ts"; const runGitHubStackAction = (  execute: GitHubCli.GitHubCli["Service"]["execute"],  input: Parameters<typeof runStackAction>[0],) => runStackAction(input).pipe(Effect.provide(Layer.mock(GitHubCli.GitHubCli)({ execute }))); const stack = [  {    number: 50,    url: "https://api.github.com/repos/acme/web/stacks/50",    base: { ref: "main" },    pull_requests: [      {        number: 1,        title: "Base",        head: { ref: "base", sha: "aaa" },        state: "closed",        merged_at: "2026-01-01T00:00:00Z",      },      {        number: 2,        title: "Middle",        head: { ref: "middle", sha: "bbb" },        state: "open",        draft: false,      },      { number: 3, title: "Top", head: { ref: "top", sha: "ccc" }, state: "open", draft: false },    ],  },];const input = {  cwd: "/repo",  repository: "acme/web",  host: "github.com",  number: 3,  stackNumber: 50,  expectedStackHeads: [    { number: 2, headSha: "bbb" },    { number: 3, headSha: "ccc" },  ],  action: "merge" as const,};const access = {  data: {    repository: {      pr2: { headRepository: { viewerPermission: "WRITE" }, maintainerCanModify: false },      pr3: { headRepository: { viewerPermission: "WRITE" }, maintainerCanModify: false },    },  },}; const branch = (number: number, headRefOid: string, behindBy = 1, processed: string[] = []) => ({  data: {    processed: processed.map((headRefOid) => ({ headRefOid })),    repository: {      pullRequest: { id: `PR_${number}`, headRefOid, baseRef: { compare: { behindBy } } },    },  },});const rebased = {  data: { updatePullRequestBranch: { pullRequest: { headRefOid: "rebased-sha" } } },};const rebaseResponses = [branch(2, "bbb"), rebased, branch(3, "ccc", 1, ["rebased-sha"]), rebased]; function fake(responses: readonly unknown[]) {  const calls: ReadonlyArray<string>[] = [];  const execute: GitHubCli.GitHubCli["Service"]["execute"] = (request) =>    Effect.sync(() => {      calls.push(request.args);      const value = responses[calls.length - 1];      if (value === undefined) throw new Error("Unexpected GitHub request");      return {        exitCode: ChildProcessSpawner.ExitCode(0),        // @effect-diagnostics-next-line preferSchemaOverJson:off        stdout: JSON.stringify(value),        stderr: "",        stdoutTruncated: false,        stderrTruncated: false,        stdoutInvalidUtf8: false,      };    });  return { execute, calls };} it.effect("submits one atomic merge with the reviewed head and respects the merge queue", () =>  Effect.gen(function* () {    const api = fake([stack, { status: "enqueued", details: {} }]);    yield* runGitHubStackAction(api.execute, { ...input, mergeMethod: "squash" });    expect(api.calls).toHaveLength(2);    expect(api.calls[1]).toContain("repos/acme/web/pulls/3/merge-async");    expect(api.calls[1]).toContain("sha=ccc");    expect(api.calls[1]).toContain("merge_action=default");    expect(api.calls[1]).toContain("merge_method=squash");  }),); it.effect("merges through the selected layer without including later draft layers", () =>  Effect.gen(function* () {    const fiveLayers = [      {        ...stack[0],        pull_requests: Array.from({ length: 5 }, (_, index) => ({          number: index + 1,          head: { ref: `layer-${index + 1}`, sha: `sha-${index + 1}` },          state: "open",          draft: index >= 3,        })),      },    ];    const api = fake([fiveLayers, { status: "merged", details: {} }]);    yield* runGitHubStackAction(api.execute, {      ...input,      number: 3,      expectedStackHeads: [1, 2, 3].map((number) => ({ number, headSha: `sha-${number}` })),    });    expect(api.calls).toHaveLength(2);    expect(api.calls[1]).toContain("repos/acme/web/pulls/3/merge-async");    expect(api.calls[1]).toContain("sha=sha-3");    expect(api.calls[1]).toContain("merge_action=default");  }),); it.effect("rejects stale reviewed heads below a selected middle layer", () =>  Effect.gen(function* () {    const api = fake([stack]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      number: 2,      expectedStackHeads: [{ number: 2, headSha: "old-head" }],    }).pipe(Effect.result);    expect(result).toMatchObject({ _tag: "Failure", failure: { _tag: "GitHubStackChangedError" } });    expect(api.calls).toHaveLength(1);  }),); it.effect("does not merge from an already merged layer", () =>  Effect.gen(function* () {    const api = fake([stack]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      number: 1,      expectedStackHeads: [],    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackUnsupportedError" },    });    expect(api.calls).toHaveLength(1);  }),); it.effect("polls an accepted merge and reports a later rule rejection", () =>  Effect.gen(function* () {    const api = fake([      stack,      { status: "pending", details: { uuid: "operation" } },      { status: "failed", details: { message: "Required checks have not passed" } },    ]);    const fiber = yield* runGitHubStackAction(api.execute, input).pipe(      Effect.result,      Effect.forkChild,    );    yield* TestClock.adjust("1 second");    const result = yield* Fiber.join(fiber);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackMergeRejectedError" },    });    expect(api.calls[2]).toContain("repos/acme/web/pulls/3/merge-async/operation");  }),); it.effect("retains stack identity and a rejection response without a message", () =>  Effect.gen(function* () {    const rejection = { status: "failed", details: {} };    const api = fake([stack, rejection]);    const result = yield* runGitHubStackAction(api.execute, input).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: {        _tag: "GitHubStackMergeRejectedError",        repository: input.repository,        number: input.number,        stackNumber: input.stackNumber,        cause: rejection,      },    });  }),); it.effect("refuses a changed stack before performing any mutation", () =>  Effect.gen(function* () {    const api = fake([stack]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      expectedStackHeads: [        { number: 2, headSha: "old" },        { number: 3, headSha: "ccc" },      ],    }).pipe(Effect.result);    expect(result).toMatchObject({ _tag: "Failure", failure: { _tag: "GitHubStackChangedError" } });    expect(api.calls).toHaveLength(1);  }),); it.effect("rebases unmerged layers bottom to top without local git commands", () =>  Effect.gen(function* () {    const api = fake([stack, access, ...rebaseResponses]);    yield* runGitHubStackAction(api.execute, { ...input, action: "update-branch" });    const mutations = api.calls.filter((args) =>      args.some((arg) => arg.startsWith("query=mutation")),    );    expect(mutations).toHaveLength(2);    expect(mutations[0]).toContain("id=PR_2");    expect(mutations[0]).toContain("sha=bbb");    expect(mutations[1]).toContain("id=PR_3");    expect(mutations[1]).toContain("sha=ccc");    expect(api.calls.every((args) => args[0] === "api")).toBe(true);  }),); it.effect("does not update later layers after a rebase failure", () =>  Effect.gen(function* () {    const api = fake([stack, access, branch(2, "bbb")]);    const execute: typeof api.execute = (request) =>      !request.args.some((arg) => arg.startsWith("query=mutation"))        ? api.execute(request)        : Effect.fail(            new GitHubCli.GitHubCliAuthenticationError({              command: "gh",              cwd: "/repo",              cause: new Error("denied"),            }),          );    const result = yield* runGitHubStackAction(execute, { ...input, action: "update-branch" }).pipe(      Effect.result,    );    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackRebaseFailedError", number: 2, completed: 0 },    });  }),); it.effect("refuses the entire rebase before mutation when a later fork denies write access", () =>  Effect.gen(function* () {    const api = fake([      stack,      {        data: {          repository: {            ...access.data.repository,            pr3: { headRepository: { viewerPermission: "READ" }, maintainerCanModify: false },          },        },      },    ]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      action: "update-branch",    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackPermissionError" },    });    expect(api.calls).toHaveLength(2);    expect(api.calls.every((args) => args[0] === "api")).toBe(true);  }),); it.effect("allows a fork that explicitly permits maintainer updates", () =>  Effect.gen(function* () {    const api = fake([      stack,      {        data: {          repository: {            ...access.data.repository,            pr3: { headRepository: { viewerPermission: "READ" }, maintainerCanModify: true },          },        },      },      ...rebaseResponses,    ]);    yield* runGitHubStackAction(api.execute, { ...input, action: "update-branch" });    expect(api.calls.at(-1)).toContain("id=PR_3");  }),); it.effect("bounds polling and reports a still-running merge without claiming success", () =>  Effect.gen(function* () {    const api = fake([      stack,      ...Array.from({ length: 40 }, () => ({ status: "pending", details: { uuid: "operation" } })),    ]);    const fiber = yield* runGitHubStackAction(api.execute, input).pipe(      Effect.result,      Effect.forkChild,    );    yield* TestClock.adjust("6 minutes");    expect(yield* Fiber.join(fiber)).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackMergePendingError" },    });    expect(api.calls.length).toBeLessThan(40);  }),); it.effect("rejects a push after preflight without rebasing the new revision", () =>  Effect.gen(function* () {    const api = fake([stack, access, branch(2, "new-head")]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      action: "update-branch",    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackChangedError", number: 2, completed: 0 },    });    expect(api.calls).toHaveLength(3);  }),); it.effect("skips current layers without submitting a rebase mutation", () =>  Effect.gen(function* () {    const api = fake([stack, access, branch(2, "bbb", 0), branch(3, "ccc", 0, ["bbb"])]);    yield* runGitHubStackAction(api.execute, { ...input, action: "update-branch" });    expect(api.calls.some((args) => args.some((arg) => arg.startsWith("query=mutation")))).toBe(      false,    );  }),); it.effect("keeps earlier progress and stops after a later layer fails", () =>  Effect.gen(function* () {    const api = fake([      stack,      access,      branch(2, "bbb"),      rebased,      branch(3, "ccc", 1, ["rebased-sha"]),      { data: { updatePullRequestBranch: null } },    ]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      action: "update-branch",    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackRebaseFailedError", number: 3, completed: 1 },    });  }),); it.effect("reports partial progress when a later head changes during the rebase", () =>  Effect.gen(function* () {    const api = fake([      stack,      access,      branch(2, "bbb"),      rebased,      branch(3, "concurrent-head", 1, ["rebased-sha"]),    ]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      action: "update-branch",    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackChangedError", number: 3, completed: 1 },    });    if (result._tag === "Failure") {      expect(result.failure.message).toContain("Earlier updates remain on GitHub");    }    expect(      api.calls.filter((args) => args.some((arg) => arg.startsWith("query=mutation"))),    ).toHaveLength(1);  }),); it.effect.each([false, true])("rejects a push to a processed layer, rebased=%s", (rebasedParent) =>  Effect.gen(function* () {    const api = fake([      stack,      access,      branch(2, "bbb", rebasedParent ? 1 : 0),      ...(rebasedParent ? [rebased] : []),      branch(3, "ccc", 1, ["concurrent-parent-head"]),    ]);    const result = yield* runGitHubStackAction(api.execute, {      ...input,      action: "update-branch",    }).pipe(Effect.result);    expect(result).toMatchObject({      _tag: "Failure",      failure: { _tag: "GitHubStackChangedError", number: 2, completed: 1 },    });    expect(api.calls.at(-1)?.some((arg) => arg.includes('processed:nodes(ids:["PR_2"])'))).toBe(      true,    );    expect(      api.calls.filter((args) => args.some((arg) => arg.startsWith("query=mutation"))),    ).toHaveLength(rebasedParent ? 1 : 0);  }),);