483 lines
19 KiB
TypeScript
483 lines
19 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
|
import { render, screen, fireEvent, waitFor } from "@testing-library/react";
|
|
import { PrPanel } from "../PrPanel";
|
|
|
|
vi.mock("../../api", () => ({
|
|
refreshPrStatus: vi.fn(),
|
|
fetchPrChecks: vi.fn(),
|
|
fetchPrReviews: vi.fn(),
|
|
mergePr: vi.fn(),
|
|
reclaimPrConflict: vi.fn(),
|
|
setAutoMergeOnGreen: vi.fn(),
|
|
unlinkPr: vi.fn(),
|
|
}));
|
|
|
|
import { refreshPrStatus, fetchPrChecks, fetchPrReviews, mergePr, reclaimPrConflict, setAutoMergeOnGreen, unlinkPr } from "../../api";
|
|
|
|
const originalClipboard = navigator.clipboard;
|
|
const mockAddToast = vi.fn();
|
|
const mockOnPrUpdated = vi.fn();
|
|
const mockOnRequestCreatePr = vi.fn();
|
|
|
|
const mockPrInfo = {
|
|
url: "https://github.com/owner/repo/pull/42",
|
|
number: 42,
|
|
status: "open" as const,
|
|
title: "Fix the bug",
|
|
headBranch: "fusion/fn-001",
|
|
baseBranch: "main",
|
|
commentCount: 3,
|
|
lastCommentAt: "2026-01-01T00:00:00.000Z",
|
|
};
|
|
|
|
const checksByRollup = {
|
|
success: [{ name: "build", required: true, state: "success", detailsUrl: "https://ci.example/build" }],
|
|
failure: [{ name: "build", required: true, state: "failure", detailsUrl: "https://ci.example/build" }],
|
|
pending: [{ name: "build", required: true, state: "pending", detailsUrl: "https://ci.example/build" }],
|
|
none: [],
|
|
} as const;
|
|
|
|
describe("PrPanel", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
(fetchPrChecks as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
checks: [],
|
|
rollup: "unknown",
|
|
lastCheckedAt: new Date().toISOString(),
|
|
});
|
|
(fetchPrReviews as ReturnType<typeof vi.fn>).mockResolvedValue({ snapshot: { decision: null, items: [] }, comments: [] });
|
|
(mergePr as ReturnType<typeof vi.fn>).mockResolvedValue({ prInfo: { ...mockPrInfo, status: "merged" } });
|
|
(setAutoMergeOnGreen as ReturnType<typeof vi.fn>).mockResolvedValue({ prInfo: { ...mockPrInfo, autoMergeOnGreen: true } });
|
|
Object.defineProperty(navigator, "clipboard", {
|
|
configurable: true,
|
|
value: { writeText: vi.fn().mockResolvedValue(undefined) },
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
Object.defineProperty(navigator, "clipboard", {
|
|
configurable: true,
|
|
value: originalClipboard,
|
|
});
|
|
});
|
|
|
|
it("renders create button and calls onRequestCreatePr", () => {
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
prAuthAvailable={true}
|
|
onRequestCreatePr={mockOnRequestCreatePr}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>
|
|
);
|
|
|
|
fireEvent.click(screen.getByRole("button", { name: /Create PR/i }));
|
|
expect(mockOnRequestCreatePr).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("does not render input or textarea in no-PR state", () => {
|
|
render(<PrPanel taskId="FN-001" prAuthAvailable={true} onRequestCreatePr={mockOnRequestCreatePr} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
expect(document.querySelector("input")).toBeNull();
|
|
expect(document.querySelector("textarea")).toBeNull();
|
|
});
|
|
|
|
it("disables create button and shows auth hint when pr auth unavailable", () => {
|
|
render(<PrPanel taskId="FN-001" prAuthAvailable={false} onRequestCreatePr={mockOnRequestCreatePr} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
const button = screen.getByRole("button", { name: /Create PR/i }) as HTMLButtonElement;
|
|
expect(button.disabled).toBe(true);
|
|
expect(screen.getByText(/gh auth login/i)).toBeInTheDocument();
|
|
});
|
|
|
|
it("shows creating-pr automation hint", () => {
|
|
render(<PrPanel taskId="FN-001" automationStatus="creating-pr" prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
expect(screen.getByText(/creating a pull request automatically/i)).toBeInTheDocument();
|
|
expect(screen.queryByRole("button", { name: /Create PR/i })).toBeNull();
|
|
});
|
|
|
|
it("shows autoMerge hint in no-PR state", () => {
|
|
render(<PrPanel taskId="FN-001" autoMerge={true} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
expect(screen.getByText(/Auto-merge will handle this task automatically./i)).toBeInTheDocument();
|
|
});
|
|
|
|
it("renders PR details when prInfo exists", () => {
|
|
render(<PrPanel taskId="FN-001" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
expect(screen.getByText("#42")).toBeInTheDocument();
|
|
expect(screen.getByText("open")).toBeInTheDocument();
|
|
expect(screen.getByText("fusion/fn-001")).toBeInTheDocument();
|
|
expect(screen.getByText("main")).toBeInTheDocument();
|
|
expect(screen.getByText("3")).toBeInTheDocument();
|
|
expect(screen.getByRole("link", { name: /View on GitHub/i })).toBeInTheDocument();
|
|
});
|
|
|
|
it("refreshes PR status and updates toast/callback", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: { ...mockPrInfo, status: "merged" },
|
|
checks: [],
|
|
reviewDecision: null,
|
|
blockingReasons: [],
|
|
primary: {
|
|
prInfo: { ...mockPrInfo, status: "merged" },
|
|
checks: [],
|
|
reviewDecision: null,
|
|
blockingReasons: [],
|
|
mergeReady: false,
|
|
},
|
|
all: [{
|
|
prInfo: { ...mockPrInfo, status: "merged" },
|
|
checks: [],
|
|
reviewDecision: null,
|
|
blockingReasons: [],
|
|
mergeReady: false,
|
|
}],
|
|
mergeReady: false,
|
|
});
|
|
|
|
render(<PrPanel taskId="FN-001" projectId="project-1" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
|
|
await waitFor(() => {
|
|
expect(refreshPrStatus).toHaveBeenCalledWith("FN-001", "project-1");
|
|
});
|
|
expect(mockOnPrUpdated).toHaveBeenCalledWith(expect.objectContaining({ status: "merged" }));
|
|
expect(mockAddToast).toHaveBeenCalledWith("PR status refreshed", "success");
|
|
});
|
|
|
|
it("renders checks rollup after refresh", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: mockPrInfo,
|
|
checks: [
|
|
{ name: "build", required: true, state: "success" },
|
|
{ name: "lint", required: false, state: "failure" },
|
|
{ name: "e2e", required: true, state: "pending" },
|
|
],
|
|
reviewDecision: null,
|
|
blockingReasons: [],
|
|
});
|
|
|
|
render(<PrPanel taskId="FN-001" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
|
|
expect(await screen.findByText("1 passing, 1 failing, 1 pending")).toBeInTheDocument();
|
|
expect(screen.getByText("build")).toBeInTheDocument();
|
|
expect(screen.getByText("lint")).toBeInTheDocument();
|
|
expect(screen.getByText("e2e")).toBeInTheDocument();
|
|
expect(screen.getAllByText("Required").length).toBe(2);
|
|
});
|
|
|
|
it("handles undefined checks payload without rendering checks list", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: mockPrInfo,
|
|
checks: undefined,
|
|
reviewDecision: null,
|
|
blockingReasons: [],
|
|
});
|
|
|
|
render(<PrPanel taskId="FN-001" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
|
|
expect(await screen.findByText(/No checks reported yet/i)).toBeInTheDocument();
|
|
});
|
|
|
|
it.each([
|
|
{ status: "open", rollup: "success", expectMerge: true, expectReadonly: false, expectChecksVisible: true },
|
|
{ status: "draft", rollup: "failure", expectMerge: false, expectReadonly: true, expectChecksVisible: true },
|
|
{ status: "merged", rollup: "pending", expectMerge: false, expectReadonly: true, expectChecksVisible: false },
|
|
{ status: "closed", rollup: "none", expectMerge: false, expectReadonly: true, expectChecksVisible: false },
|
|
])("handles state=$status and checks=$rollup", async ({ status, rollup, expectMerge, expectReadonly, expectChecksVisible }) => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: { ...mockPrInfo, status, draft: status === "draft" },
|
|
checks: checksByRollup[rollup],
|
|
reviewDecision: null,
|
|
blockingReasons: status === "open" && rollup === "success" ? [] : ["waiting"],
|
|
mergeReady: status === "open" && rollup === "success",
|
|
});
|
|
|
|
render(<PrPanel taskId="FN-001" prInfo={{ ...mockPrInfo, status, draft: status === "draft" }} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
|
|
await screen.findByText(/View on GitHub/i);
|
|
if (expectChecksVisible) {
|
|
expect(screen.getByText(/passing, .*failing, .*pending/i)).toBeInTheDocument();
|
|
} else {
|
|
expect(screen.queryByText(/passing, .*failing, .*pending/i)).toBeNull();
|
|
}
|
|
|
|
const mergeButton = screen.queryByRole("button", { name: /merge pull request/i });
|
|
if (expectMerge) {
|
|
expect(mergeButton).toBeInTheDocument();
|
|
} else {
|
|
expect(mergeButton).toBeNull();
|
|
}
|
|
|
|
if (expectReadonly) {
|
|
expect(screen.queryByRole("combobox")).toBeNull();
|
|
}
|
|
});
|
|
|
|
it("renders review decision states", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>)
|
|
.mockResolvedValueOnce({ prInfo: mockPrInfo, checks: [], reviewDecision: "CHANGES_REQUESTED", blockingReasons: [] })
|
|
.mockResolvedValueOnce({ prInfo: mockPrInfo, checks: [], reviewDecision: "APPROVED", blockingReasons: [] })
|
|
.mockResolvedValueOnce({ prInfo: mockPrInfo, checks: [], reviewDecision: null, blockingReasons: [] });
|
|
|
|
render(<PrPanel taskId="FN-001" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
expect(await screen.findByText("CHANGES_REQUESTED")).toBeInTheDocument();
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
expect(await screen.findByText("APPROVED")).toBeInTheDocument();
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
expect(await screen.findByText("No reviews yet")).toBeInTheDocument();
|
|
});
|
|
|
|
it("renders conflict hint and retries conflict reclaim", async () => {
|
|
(reclaimPrConflict as ReturnType<typeof vi.fn>).mockResolvedValue({ queued: true });
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: { ...mockPrInfo, mergeable: "conflicting" },
|
|
checks: [],
|
|
reviewDecision: null,
|
|
blockingReasons: ["conflict"],
|
|
mergeReady: false,
|
|
});
|
|
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
projectId="project-1"
|
|
prInfo={{ ...mockPrInfo, mergeable: "conflicting" }}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
fireEvent.click(screen.getByRole("button", { name: /Retry conflict reclaim/i }));
|
|
|
|
await waitFor(() => {
|
|
expect(reclaimPrConflict).toHaveBeenCalledWith("FN-001", "project-1");
|
|
expect(refreshPrStatus).toHaveBeenCalledWith("FN-001", "project-1");
|
|
});
|
|
});
|
|
|
|
it("shows reviewer feedback hint when changes are requested and task is in todo", async () => {
|
|
(fetchPrReviews as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
snapshot: {
|
|
decision: "CHANGES_REQUESTED",
|
|
items: [
|
|
{
|
|
id: "gh-review-1",
|
|
state: "CHANGES_REQUESTED",
|
|
body: "Please split this function",
|
|
author: { login: "reviewer" },
|
|
htmlUrl: "https://github.com/owner/repo/pull/42#review-1",
|
|
},
|
|
],
|
|
},
|
|
comments: [],
|
|
});
|
|
|
|
render(<PrPanel taskId="FN-001" taskColumn="todo" prInfo={mockPrInfo} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
|
|
expect(await screen.findByText(/Auto-moved to Todo/i)).toBeInTheDocument();
|
|
expect(screen.getByText(/Please split this function/i)).toBeInTheDocument();
|
|
});
|
|
|
|
it("renders conflict diagnostics subsection with files and commands", () => {
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
prInfo={{
|
|
...mockPrInfo,
|
|
mergeable: "conflicting",
|
|
conflictDiagnostics: {
|
|
conflictingFiles: ["packages/dashboard/src/github.ts", "packages/core/src/types.ts"],
|
|
suggestedCommands: ["git fetch origin", "git checkout fusion/fn-001", "git rebase origin/main", "# Resolve conflicts then: git add <files> && git rebase --continue"],
|
|
capturedAt: "2026-05-18T00:00:00.000Z",
|
|
},
|
|
}}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
expect(screen.getByText("packages/dashboard/src/github.ts")).toBeInTheDocument();
|
|
expect(screen.getByText("packages/core/src/types.ts")).toBeInTheDocument();
|
|
expect(screen.getByText(/git checkout fusion\/fn-001/)).toBeInTheDocument();
|
|
});
|
|
|
|
it("hides conflict diagnostics subsection when not conflicting and no diagnostics", () => {
|
|
render(<PrPanel taskId="FN-001" prInfo={{ ...mockPrInfo, mergeable: "clean" }} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
expect(screen.queryByText("Conflicts")).toBeNull();
|
|
expect(screen.queryByRole("button", { name: "Re-check conflicts" })).toBeNull();
|
|
});
|
|
|
|
it("copies suggested commands from diagnostics", async () => {
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
prInfo={{
|
|
...mockPrInfo,
|
|
mergeable: "conflicting",
|
|
conflictDiagnostics: {
|
|
conflictingFiles: ["packages/dashboard/src/github.ts"],
|
|
suggestedCommands: ["git fetch origin", "git checkout fusion/fn-001"],
|
|
capturedAt: "2026-05-18T00:00:00.000Z",
|
|
},
|
|
}}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
fireEvent.click(screen.getByRole("button", { name: "Copy" }));
|
|
await waitFor(() => {
|
|
expect(navigator.clipboard.writeText).toHaveBeenCalledWith("git fetch origin\ngit checkout fusion/fn-001");
|
|
});
|
|
});
|
|
|
|
it("renders multi-pr summary and unlinks targeted PR", async () => {
|
|
const onPrUnlinked = vi.fn();
|
|
const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
projectId="project-1"
|
|
prInfos={[mockPrInfo, { ...mockPrInfo, number: 99, url: "https://github.com/owner/repo/pull/99", title: "Another" }]}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
onPrUnlinked={onPrUnlinked}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
expect(screen.getByText("2 pull requests")).toBeInTheDocument();
|
|
expect(document.querySelector(".pr-panel-summary-badge")?.textContent).toBe("open");
|
|
fireEvent.click(screen.getAllByRole("button", { name: "Unlink" })[1]!);
|
|
await waitFor(() => expect(unlinkPr).toHaveBeenCalledWith("FN-001", 99, "project-1"));
|
|
expect(onPrUnlinked).toHaveBeenCalledWith(99);
|
|
confirmSpy.mockRestore();
|
|
});
|
|
|
|
it("uses worst rollup state badge for multi-pr summary", () => {
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
prInfos={[{ ...mockPrInfo, mergeable: "conflicting" as const }, { ...mockPrInfo, number: 100, url: "https://github.com/owner/repo/pull/100" }]}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
expect(screen.getByText("conflicting")).toBeInTheDocument();
|
|
});
|
|
|
|
it("re-check conflicts triggers refreshPrStatus", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({ prInfo: mockPrInfo, checks: [], reviewDecision: null, blockingReasons: [] });
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
projectId="project-1"
|
|
prInfo={{
|
|
...mockPrInfo,
|
|
mergeable: "conflicting",
|
|
conflictDiagnostics: {
|
|
conflictingFiles: ["packages/dashboard/src/github.ts"],
|
|
suggestedCommands: ["git fetch origin"],
|
|
capturedAt: "2026-05-18T00:00:00.000Z",
|
|
},
|
|
}}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
fireEvent.click(screen.getByRole("button", { name: "Re-check conflicts" }));
|
|
await waitFor(() => {
|
|
expect(refreshPrStatus).toHaveBeenCalledWith("FN-001", "project-1");
|
|
});
|
|
});
|
|
|
|
it("shows conflict hint from blocking reasons after refresh", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
prInfo: mockPrInfo,
|
|
checks: [],
|
|
reviewDecision: null,
|
|
blockingReasons: ["merge conflict"],
|
|
mergeReady: false,
|
|
});
|
|
|
|
render(
|
|
<PrPanel
|
|
taskId="FN-001"
|
|
prInfo={mockPrInfo}
|
|
prAuthAvailable={true}
|
|
onPrUpdated={mockOnPrUpdated}
|
|
addToast={mockAddToast}
|
|
/>,
|
|
);
|
|
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
expect(await screen.findByRole("button", { name: /Retry conflict reclaim/i })).toBeInTheDocument();
|
|
});
|
|
|
|
it("shows inline structured refresh error and retries", async () => {
|
|
(refreshPrStatus as ReturnType<typeof vi.fn>)
|
|
.mockRejectedValueOnce(Object.assign(new Error("auth failed"), {
|
|
details: {
|
|
githubError: {
|
|
code: "not-authenticated",
|
|
message: "GitHub CLI is not authenticated.",
|
|
hint: "Run 'gh auth login' to authenticate with GitHub.",
|
|
action: { kind: "shell", command: "gh auth login" },
|
|
retryable: true,
|
|
},
|
|
},
|
|
}))
|
|
.mockResolvedValueOnce({ prInfo: mockPrInfo, checks: [], reviewDecision: null, blockingReasons: [] });
|
|
|
|
render(<PrPanel taskId="FN-001" prInfo={{ ...mockPrInfo, draft: true }} prAuthAvailable={true} onPrUpdated={mockOnPrUpdated} addToast={mockAddToast} />);
|
|
await waitFor(() => {
|
|
expect(screen.getByTitle("Refresh PR status")).toBeEnabled();
|
|
});
|
|
fireEvent.click(screen.getByTitle("Refresh PR status"));
|
|
|
|
expect((await screen.findAllByText(/gh auth login/i)).length).toBeGreaterThan(0);
|
|
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
|
|
await waitFor(() => {
|
|
expect(refreshPrStatus).toHaveBeenCalledTimes(2);
|
|
});
|
|
});
|
|
});
|