feat(github): re-request dismissed reviews (#1921)

This commit is contained in:
José Almeida
2026-07-24 15:55:57 +01:00
committed by GitHub
parent b56bca5a4d
commit 7e4f2bb1e5
44 changed files with 2954 additions and 87 deletions
@@ -1,7 +1,74 @@
import { describe, it, expect } from "vitest";
import { shouldHideApproveButton } from "./pr-detail-panel";
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { createElement, useEffect } from "react";
import { TooltipProvider } from "@kandev/ui/tooltip";
import { afterEach, describe, it, expect, vi } from "vitest";
import {
PRDetailContent,
shouldHideApproveButton,
shouldShowReRequestReviewAction,
} from "./pr-detail-panel";
import {
clearPRReviewRequestRegistryForTests,
usePRScopedReviewRequest,
} from "./use-pr-scoped-review-request";
import type { TaskPR, PRFeedback, GitHubPR, PRReview } from "@/lib/types/github";
const feedbackMocks = vi.hoisted(() => ({
refresh: vi.fn(),
value: null as PRFeedback | null,
}));
const reviewMocks = vi.hoisted(() => ({ requestReviewers: vi.fn(), submitReview: vi.fn() }));
const RE_REQUEST_BUTTON = "pr-rerequest-review-octocat";
const PENDING_REVIEWER = "pr-pending-reviewer-octocat";
const DISMISSED_REVIEWED_AT = "2026-01-01T00:00:00Z";
vi.mock("@/hooks/domains/github/use-pr-feedback", () => ({
usePRFeedback: () => ({
feedback: feedbackMocks.value,
loading: false,
refresh: feedbackMocks.refresh,
}),
}));
vi.mock("@/lib/api/domains/github-review-api", () => ({
requestPRReviewers: reviewMocks.requestReviewers,
submitPRReview: reviewMocks.submitReview,
}));
vi.mock("@/components/state-provider", () => ({
useAppStore: (selector: (state: { setTaskPR: () => void }) => unknown) =>
selector({ setTaskPR: vi.fn() }),
}));
vi.mock("@/lib/state/slices/comments", () => ({
isPRFeedbackComment: () => false,
useCommentsStore: (
selector: (state: {
addComment: () => void;
pendingForChat: string[];
byId: object;
}) => unknown,
) => selector({ addComment: vi.fn(), pendingForChat: [], byId: {} }),
}));
vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast: vi.fn() }) }));
vi.mock("@/hooks/domains/github/use-github-status", () => ({
useGitHubStatus: () => ({ status: null }),
}));
vi.mock("./pr-merge-button", () => ({ PRMergeButton: () => null }));
vi.mock("./pr-mergeability-notice", () => ({
PRMergeabilityNotice: () => null,
buildConflictResolutionMessage: () => "",
}));
vi.mock("./pr-checks-section", () => ({ ChecksSection: () => null }));
vi.mock("./pr-comments-section", () => ({ CommentsSection: () => null }));
afterEach(() => {
vi.useRealTimers();
cleanup();
feedbackMocks.refresh.mockReset();
feedbackMocks.value = null;
reviewMocks.requestReviewers.mockReset();
reviewMocks.submitReview.mockReset();
clearPRReviewRequestRegistryForTests();
});
function makeTaskPR(overrides: Partial<TaskPR> = {}): TaskPR {
return {
id: "id",
@@ -70,11 +137,51 @@ function makeFeedback(
};
}
function ReviewRequestHarness({
onReady,
requestedReviewers = [],
reviews = [],
}: {
onReady: (reviewRequest: ReturnType<typeof usePRScopedReviewRequest>) => void;
requestedReviewers?: { login: string; type: "user" }[];
reviews?: PRReview[];
}) {
const reviewRequest = usePRScopedReviewRequest(
makeTaskPR(),
requestedReviewers,
reviews,
vi.fn(),
vi.fn(),
);
useEffect(() => onReady(reviewRequest), [onReady, reviewRequest]);
return null;
}
function dismissedReview(id = 1): PRReview {
return {
id,
author: "octocat",
author_avatar: "",
state: "DISMISSED",
body: "",
created_at: DISMISSED_REVIEWED_AT,
};
}
function renderPRDetail() {
return render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
}
describe("shouldHideApproveButton", () => {
it("hides when PR is closed", () => {
expect(shouldHideApproveButton(makeTaskPR({ state: "closed" }), null, "bob")).toBe(true);
});
it("hides when PR is merged", () => {
expect(shouldHideApproveButton(makeTaskPR({ state: "merged" }), null, "bob")).toBe(true);
});
@@ -129,3 +236,395 @@ describe("shouldHideApproveButton", () => {
);
});
});
describe("shouldShowReRequestReviewAction", () => {
it("only permits dismissed reviews on an open PR", () => {
expect(shouldShowReRequestReviewAction("open", "DISMISSED")).toBe(true);
expect(shouldShowReRequestReviewAction("open", "APPROVED")).toBe(false);
expect(shouldShowReRequestReviewAction("closed", "DISMISSED")).toBe(false);
expect(shouldShowReRequestReviewAction("merged", "DISMISSED")).toBe(false);
});
});
describe("PRDetailContent deferred re-request", () => {
it("keeps a successfully re-requested reviewer pending when feedback refresh is deferred", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
await waitFor(() => {
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
});
expect(screen.queryByTestId(RE_REQUEST_BUTTON)).toBeNull();
});
});
describe("PRDetailContent remount lifecycle", () => {
it("keeps an in-flight request locked across a same-PR remount", () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined));
const firstPanel = render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
firstPanel.unmount();
render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce();
});
});
describe("PRDetailContent optimistic review reconciliation", () => {
it("reclaims optimism when a newer submitted review bypasses requested-reviewer feedback", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
const view = renderPRDetail();
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
feedbackMocks.value = makeFeedback({
reviews: [
{
id: 2,
author: "octocat",
author_avatar: "",
state: "APPROVED",
body: "Looks good",
created_at: "2026-01-02T00:00:00Z",
},
],
});
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await waitFor(() => {
expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull();
});
expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull();
});
});
describe("PRDetailContent same-timestamp review reconciliation", () => {
it("uses the review ID to resolve same-timestamp reviewer state", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
const view = renderPRDetail();
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
feedbackMocks.value = makeFeedback({
reviews: [
dismissedReview(),
{
id: 2,
author: "octocat",
author_avatar: "",
state: "APPROVED",
body: "Looks good",
created_at: DISMISSED_REVIEWED_AT,
},
],
});
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await waitFor(() => expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull());
expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull();
});
});
describe("PRDetailContent confirmed review request", () => {
it("reclaims confirmed pending state from the persistent registry", async () => {
feedbackMocks.value = makeFeedback({
reviews: [dismissedReview()],
});
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
const view = render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
feedbackMocks.value = makeFeedback({
pr: { requested_reviewers: [{ login: "octocat", type: "user" }] },
reviews: [
{
id: 1,
author: "octocat",
author_avatar: "",
state: "DISMISSED",
body: "",
created_at: DISMISSED_REVIEWED_AT,
},
],
});
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await waitFor(() => {
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
});
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await waitFor(() => {
expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull();
});
});
});
describe("PRDetailContent same-tick re-request", () => {
it("posts once when invoked twice before React has a chance to re-render", () => {
reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined));
let reRequest: (reviewer: string) => Promise<void> = async () => undefined;
render(
createElement(ReviewRequestHarness, {
onReady: (request) => {
reRequest = request.reRequest;
},
}),
);
act(() => {
void reRequest("octocat");
void reRequest("octocat");
});
expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce();
});
});
describe("PRDetailContent persistent request expiry", () => {
it("keeps an unresolved request locked beyond the optimistic expiry window", () => {
vi.useFakeTimers();
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
const deferred = new Promise(() => undefined);
reviewMocks.requestReviewers.mockReturnValue(deferred);
const view = renderPRDetail();
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
act(() => vi.advanceTimersByTime(5 * 60 * 1000));
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(true);
vi.useRealTimers();
});
it("expires successful optimism and updates the panel without a rerender", async () => {
vi.useFakeTimers();
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
renderPRDetail();
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
expect(vi.getTimerCount()).toBe(1);
act(() => vi.advanceTimersByTime(5 * 60 * 1000));
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false);
vi.useRealTimers();
});
it("clears the expiry timer when feedback confirms the request", async () => {
vi.useFakeTimers();
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
const view = renderPRDetail();
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
expect(vi.getTimerCount()).toBe(1);
feedbackMocks.value = makeFeedback({
pr: { requested_reviewers: [{ login: "octocat", type: "user" }] },
});
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await act(async () => undefined);
expect(vi.getTimerCount()).toBe(0);
vi.useRealTimers();
});
it("reschedules to the next optimistic expiry after the first expires", async () => {
vi.useFakeTimers();
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
let reviewRequest: ReturnType<typeof usePRScopedReviewRequest> | undefined;
render(
createElement(ReviewRequestHarness, {
onReady: (value) => {
reviewRequest = value;
},
}),
);
await act(async () => reviewRequest?.reRequest("octocat"));
act(() => vi.advanceTimersByTime(60 * 1000));
await act(async () => reviewRequest?.reRequest("hubot"));
act(() => vi.advanceTimersByTime(4 * 60 * 1000));
expect(reviewRequest?.requestedReviewers).toEqual([{ login: "hubot", type: "user" }]);
vi.useRealTimers();
});
});
describe("PRDetailContent request operation ownership", () => {
it("does not let an old completion change a newer request", async () => {
let resolveFirst: () => void = () => undefined;
const firstRequest = new Promise<void>((resolve) => {
resolveFirst = resolve;
});
const secondRequest = new Promise(() => undefined);
reviewMocks.requestReviewers
.mockReturnValueOnce(firstRequest)
.mockReturnValueOnce(secondRequest);
let reviewRequest: ReturnType<typeof usePRScopedReviewRequest> | undefined;
const onReady = (value: ReturnType<typeof usePRScopedReviewRequest>) => {
reviewRequest = value;
};
const view = render(createElement(ReviewRequestHarness, { onReady }));
act(() => void reviewRequest?.reRequest("octocat"));
view.rerender(
createElement(ReviewRequestHarness, {
onReady,
requestedReviewers: [{ login: "octocat", type: "user" }],
}),
);
view.rerender(createElement(ReviewRequestHarness, { onReady }));
act(() => void reviewRequest?.reRequest("octocat"));
await act(async () => resolveFirst());
expect(reviewRequest?.requestingReviewers).toEqual(["octocat"]);
});
});
describe("PRDetailContent failed feedback refresh", () => {
it("keeps the successful re-request optimistic", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
feedbackMocks.refresh.mockImplementation(() => {
throw new Error("Feedback refresh failed");
});
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
renderPRDetail();
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
});
});
describe("PRDetailContent failed re-request", () => {
it("clears failed writes so the dismissed reviewer can be retried", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockRejectedValue(new Error("GitHub denied request"));
renderPRDetail();
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
await waitFor(() => {
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false);
});
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
expect(reviewMocks.requestReviewers).toHaveBeenCalledTimes(2);
});
});
describe("PRDetailContent PR identity changes", () => {
it("does not retain optimistic reviewers after the repository PR identity changes", async () => {
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
const view = render(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
),
);
await act(async () => {
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
});
await waitFor(() => {
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
});
view.rerender(
createElement(
TooltipProvider,
undefined,
createElement(PRDetailContent, {
taskPR: makeTaskPR({ pr_number: 2 }),
sessionId: "session-1",
}),
),
);
expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull();
});
});
+19 -7
View File
@@ -23,7 +23,7 @@ import { useGitHubStatus } from "@/hooks/domains/github/use-github-status";
import { useCommentsStore, isPRFeedbackComment } from "@/lib/state/slices/comments";
import type { PRFeedbackComment } from "@/lib/state/slices/comments";
import { useToast } from "@/components/toast-provider";
import { submitPRReview } from "@/lib/api/domains/github-api";
import { submitPRReview } from "@/lib/api/domains/github-review-api";
import type { TaskPR, PRFeedback } from "@/lib/types/github";
import {
formatTimeAgo,
@@ -38,6 +38,7 @@ import { ReviewStateBadge } from "./pr-reviews-section";
import { ChecksSection } from "./pr-checks-section";
import { ReviewsSection } from "./pr-reviews-section";
import { CommentsSection } from "./pr-comments-section";
import { usePRScopedReviewRequest } from "./use-pr-scoped-review-request";
// --- Dockview panel wrapper ---
@@ -215,8 +216,6 @@ function derivePanelMetrics(taskPR: TaskPR, feedback: PRFeedback | null): PRPane
};
}
// --- Main content ---
function DescriptionSection({ body }: { body: string }) {
if (!body) return null;
return (
@@ -251,6 +250,10 @@ export function shouldHideApproveButton(
);
}
export function shouldShowReRequestReviewAction(prState: string, reviewState: string): boolean {
return prState === "open" && reviewState === "DISMISSED";
}
function ApproveButton({
taskPR,
feedback,
@@ -305,6 +308,14 @@ function ApproveButton({
export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; sessionId: string }) {
const { feedback, loading, refresh } = usePRFeedback(taskPR.owner, taskPR.repo, taskPR.pr_number);
const { addAsContext } = useAddPRFeedbackAsContext(sessionId, taskPR.pr_number);
const { toast } = useToast();
const reviewRequest = usePRScopedReviewRequest(
taskPR,
feedback?.pr.requested_reviewers ?? [],
feedback?.reviews ?? [],
refresh,
toast,
);
useSyncLivePRState(taskPR, feedback);
@@ -350,7 +361,7 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
/>
<Separator />
<ScrollArea className="flex-1 overflow-hidden">
<div className="p-3 space-y-1">
<div className="box-border w-0 min-w-full max-w-full overflow-x-hidden p-3 space-y-1">
{loading && !feedback && (
<div className="flex items-center justify-center py-8">
<IconLoader2 className="h-6 w-6 text-blue-500 animate-spin" />
@@ -361,11 +372,14 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
<DescriptionSection body={feedback.pr.body ?? ""} />
<ReviewsSection
reviews={feedback.reviews ?? []}
requestedReviewers={feedback.pr.requested_reviewers ?? []}
requestedReviewers={reviewRequest.requestedReviewers}
prUrl={taskPR.pr_url}
reviewState={metrics.reviewState}
pendingReviewCount={metrics.pendingReviewCount}
onAddAsContext={(msg) => addAsContext("review", msg)}
canReRequest={shouldShowReRequestReviewAction(feedback.pr.state, "DISMISSED")}
requestingReviewers={reviewRequest.requestingReviewers}
onReRequest={reviewRequest.reRequest}
/>
<ChecksSection
checks={feedback.checks ?? []}
@@ -392,8 +406,6 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
);
}
// --- Header ---
function StateBadge({ state }: { state: string }) {
const styles: Record<string, string> = {
open: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
@@ -0,0 +1,126 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen } from "@testing-library/react";
import { TooltipProvider } from "@kandev/ui/tooltip";
import { reconcileReviews, ReviewsSection } from "./pr-reviews-section";
import type { PRReview, RequestedReviewer } from "@/lib/types/github";
function review(author: string, state: string, created_at = "2026-07-23T10:00:00Z"): PRReview {
return { id: 1, author, author_avatar: "", state, body: "", created_at };
}
function requested(login: string): RequestedReviewer {
return { login, type: "user" };
}
function renderReviews(ui: React.ReactElement) {
return render(<TooltipProvider>{ui}</TooltipProvider>);
}
afterEach(() => cleanup());
describe("reconcileReviews", () => {
it("keeps only latest review per author and enables its dismissed re-request action", () => {
const result = reconcileReviews(
[review("octocat", "APPROVED", "2026-07-22T10:00:00Z"), review("octocat", "DISMISSED")],
[],
);
expect(result.reviews).toEqual([review("octocat", "DISMISSED")]);
expect(result.pendingReviewers).toEqual([]);
});
it("makes current requests win over dismissed history case-insensitively", () => {
const result = reconcileReviews([review("OctoCat", "DISMISSED")], [requested("octocat")]);
expect(result.reviews).toEqual([]);
expect(result.pendingReviewers).toEqual([requested("octocat")]);
});
it("deduplicates current requested reviewers case-insensitively", () => {
const result = reconcileReviews([], [requested("OctoCat"), requested("octocat")]);
expect(result.pendingReviewers).toEqual([requested("OctoCat")]);
});
});
describe("ReviewsSection re-request action", () => {
it("names dismissed reviewer and blocks repeated submission while busy", () => {
const onReRequest = vi.fn();
renderReviews(
<ReviewsSection
reviews={[review("octocat", "DISMISSED")]}
requestedReviewers={[]}
prUrl="https://github.com/acme/site/pull/1"
reviewState="pending"
pendingReviewCount={0}
onAddAsContext={vi.fn()}
canReRequest
requestingReviewers={["OCTOCAT"]}
onReRequest={onReRequest}
/>,
);
const action = screen.getByRole("button", { name: "Re-request review from octocat" });
expect(action).toHaveProperty("disabled", true);
expect(action.className).toContain("min-h-11");
fireEvent.click(action);
expect(onReRequest).not.toHaveBeenCalled();
});
it("wraps a long reviewer row so the 44px action stays on-screen on phones", () => {
const longLogin = "reviewer-with-a-near-maximum-practical-github-login";
renderReviews(
<ReviewsSection
reviews={[review(longLogin, "DISMISSED")]}
requestedReviewers={[]}
prUrl="https://github.com/acme/site/pull/1"
reviewState="pending"
pendingReviewCount={0}
onAddAsContext={vi.fn()}
canReRequest
onReRequest={vi.fn()}
/>,
);
const action = screen.getByRole("button", {
name: `Re-request review from ${longLogin}`,
});
const author = screen.getByRole("link", { name: longLogin });
expect(action.className).toContain("min-h-11");
expect(action.parentElement?.className).toContain("basis-full");
expect(author.className).toContain("inline-block");
expect(author.className).toContain("max-w-full");
});
it("does not show action for a closed PR or a currently requested reviewer", () => {
const { rerender } = renderReviews(
<ReviewsSection
reviews={[review("octocat", "DISMISSED")]}
requestedReviewers={[]}
prUrl="https://github.com/acme/site/pull/1"
reviewState="pending"
pendingReviewCount={0}
onAddAsContext={vi.fn()}
/>,
);
expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull();
rerender(
<TooltipProvider>
<ReviewsSection
reviews={[review("octocat", "DISMISSED")]}
requestedReviewers={[requested("OctoCat")]}
prUrl="https://github.com/acme/site/pull/1"
reviewState="pending"
pendingReviewCount={1}
onAddAsContext={vi.fn()}
canReRequest
onReRequest={vi.fn()}
/>
,
</TooltipProvider>,
);
expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull();
expect(screen.getByText("OctoCat")).not.toBeNull();
});
});
@@ -1,5 +1,6 @@
import { IconCheck, IconX, IconClock } from "@tabler/icons-react";
import { Badge } from "@kandev/ui/badge";
import { Button } from "@kandev/ui/button";
import type { PRReview, RequestedReviewer } from "@/lib/types/github";
import { CollapsibleSection, FeedbackItemRow } from "./pr-shared";
@@ -59,15 +60,30 @@ function buildAllReviewsMessage(reviews: PRReview[], prUrl: string): string {
return parts.join("\n");
}
function deduplicateReviews(reviews: PRReview[]): PRReview[] {
function normalizeLogin(login: string): string {
return login.trim().toLowerCase();
}
export function reconcileReviews(reviews: PRReview[], requestedReviewers: RequestedReviewer[]) {
const latestByAuthor = new Map<string, PRReview>();
for (const review of reviews) {
const current = latestByAuthor.get(review.author);
const author = normalizeLogin(review.author);
const current = latestByAuthor.get(author);
if (!current || new Date(review.created_at) > new Date(current.created_at)) {
latestByAuthor.set(review.author, review);
latestByAuthor.set(author, review);
}
}
return Array.from(latestByAuthor.values());
const requestedByLogin = new Map<string, RequestedReviewer>();
for (const reviewer of requestedReviewers) {
const login = normalizeLogin(reviewer.login);
if (!requestedByLogin.has(login)) requestedByLogin.set(login, reviewer);
}
return {
reviews: Array.from(latestByAuthor.entries())
.filter(([author]) => !requestedByLogin.has(author))
.map(([, review]) => review),
pendingReviewers: Array.from(requestedByLogin.values()),
};
}
function formatPendingReviewer(reviewer: RequestedReviewer): string {
@@ -114,29 +130,58 @@ function SubmittedReviewRow({
review,
prUrl,
onAddAsContext,
canReRequest,
isRequesting,
onReRequest,
}: {
review: PRReview;
prUrl: string;
onAddAsContext: (message: string) => void;
canReRequest: boolean;
isRequesting: boolean;
onReRequest?: (reviewer: string) => void;
}) {
const hasActionable = review.state === "CHANGES_REQUESTED" || !!review.body;
return (
<FeedbackItemRow
author={review.author}
authorAvatar={review.author_avatar}
body={review.body || undefined}
createdAt={review.created_at}
metaBadge={<ReviewMetaBadge state={review.state} />}
onAddAsContext={
hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined
}
/>
<div data-testid={`pr-submitted-review-${normalizeLogin(review.author)}`}>
<FeedbackItemRow
author={review.author}
authorAvatar={review.author_avatar}
body={review.body || undefined}
createdAt={review.created_at}
metaBadge={<ReviewMetaBadge state={review.state} />}
trailingAction={
canReRequest && review.state === "DISMISSED" && onReRequest ? (
<div className="basis-full w-full sm:basis-auto sm:w-auto">
<Button
type="button"
size="sm"
variant="outline"
className="h-8 min-h-11 w-full max-w-full sm:w-auto sm:min-h-0 shrink-0 cursor-pointer px-2 text-[10px] [@media(pointer:coarse)]:min-h-11"
data-testid={`pr-rerequest-review-${normalizeLogin(review.author)}`}
aria-label={`Re-request review from ${review.author}`}
onClick={() => onReRequest(review.author)}
disabled={isRequesting}
>
{isRequesting ? "Requesting..." : "Re-request review"}
</Button>
</div>
) : undefined
}
onAddAsContext={
hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined
}
/>
</div>
);
}
function PendingReviewRow({ reviewer }: { reviewer: RequestedReviewer }) {
return (
<div className="px-2.5 py-1.5 rounded-md border border-border bg-muted/30">
<div
className="px-2.5 py-1.5 rounded-md border border-border bg-muted/30"
data-testid={`pr-pending-reviewer-${normalizeLogin(reviewer.login)}`}
>
<div className="flex items-center gap-2">
<IconClock className="h-3.5 w-3.5 text-yellow-500 shrink-0" />
<span className="text-xs font-medium">{formatPendingReviewer(reviewer)}</span>
@@ -153,6 +198,9 @@ export function ReviewsSection({
reviewState,
pendingReviewCount,
onAddAsContext,
canReRequest = false,
requestingReviewers = [],
onReRequest,
}: {
reviews: PRReview[];
requestedReviewers: RequestedReviewer[];
@@ -160,16 +208,19 @@ export function ReviewsSection({
reviewState: string;
pendingReviewCount: number;
onAddAsContext: (message: string) => void;
canReRequest?: boolean;
requestingReviewers?: string[];
onReRequest?: (reviewer: string) => void;
}) {
const dedupedReviews = deduplicateReviews(reviews);
const reviewedAuthors = new Set(
dedupedReviews.filter((r) => r.state !== "PENDING").map((r) => r.author),
const { reviews: reconciledReviews, pendingReviewers } = reconcileReviews(
reviews,
requestedReviewers,
);
const pendingOnly = requestedReviewers.filter((r) => !reviewedAuthors.has(r.login));
const requestingReviewerLogins = new Set(requestingReviewers.map(normalizeLogin));
const { pendingCount, summary, totalCount } = computeSectionSummary(
dedupedReviews,
pendingOnly,
reconciledReviews,
pendingReviewers,
pendingReviewCount,
);
const pendingText = pendingCount > 0 ? ` (${pendingCount} pending)` : "";
@@ -188,24 +239,27 @@ export function ReviewsSection({
defaultOpen
subtitle={subtitle}
onAddAll={
dedupedReviews.length > 0
? () => onAddAsContext(buildAllReviewsMessage(dedupedReviews, prUrl))
reconciledReviews.length > 0
? () => onAddAsContext(buildAllReviewsMessage(reconciledReviews, prUrl))
: undefined
}
addAllLabel="Add all reviews to chat context"
>
{dedupedReviews.length === 0 && pendingCount === 0 && (
{reconciledReviews.length === 0 && pendingCount === 0 && (
<p className="text-xs text-muted-foreground px-2 py-2">No reviews yet</p>
)}
{dedupedReviews.map((review) => (
{reconciledReviews.map((review) => (
<SubmittedReviewRow
key={review.id}
review={review}
prUrl={prUrl}
onAddAsContext={onAddAsContext}
canReRequest={canReRequest}
isRequesting={requestingReviewerLogins.has(normalizeLogin(review.author))}
onReRequest={onReRequest}
/>
))}
{pendingOnly.map((reviewer) => (
{pendingReviewers.map((reviewer) => (
<PendingReviewRow key={`pending-${reviewer.type}-${reviewer.login}`} reviewer={reviewer} />
))}
</CollapsibleSection>
+5 -2
View File
@@ -68,7 +68,7 @@ export function AuthorLink({ author }: { author: string }) {
href={`https://github.com/${author}`}
target="_blank"
rel="noopener noreferrer"
className="text-xs font-medium hover:underline cursor-pointer"
className="inline-block min-w-0 max-w-full truncate text-xs font-medium hover:underline cursor-pointer sm:max-w-none"
>
{author}
</a>
@@ -217,6 +217,7 @@ export function FeedbackItemRow({
createdAt,
metaBadge,
onAddAsContext,
trailingAction,
isReply,
}: {
author: string;
@@ -225,12 +226,13 @@ export function FeedbackItemRow({
createdAt: string;
metaBadge?: React.ReactNode;
onAddAsContext?: () => void;
trailingAction?: React.ReactNode;
isReply?: boolean;
}) {
return (
<div className={isReply ? "ml-4 pl-2.5 border-l-2 border-border" : ""}>
<div className="px-2.5 py-2 rounded-md border border-border bg-muted/30 space-y-1">
<div className="flex items-center gap-2">
<div className="block sm:flex sm:flex-nowrap sm:items-center sm:gap-2">
<AuthorAvatar src={authorAvatar} author={author} />
<AuthorLink author={author} />
{metaBadge}
@@ -238,6 +240,7 @@ export function FeedbackItemRow({
{formatTimeAgo(createdAt)}
</span>
{onAddAsContext && <AddToContextButton onClick={onAddAsContext} />}
{trailingAction}
</div>
{body && <ExpandableBody body={body} className="pl-7" />}
</div>
@@ -0,0 +1,238 @@
import { useCallback, useEffect, useSyncExternalStore } from "react";
import { requestPRReviewers } from "@/lib/api/domains/github-review-api";
import type { PRReview, RequestedReviewer, TaskPR } from "@/lib/types/github";
type Toast = (message: {
title?: string;
description: string;
variant: "error" | "success";
}) => void;
type ReviewBaseline = Pick<PRReview, "id" | "author" | "created_at" | "state">;
type RequestEntry = {
identity: string;
reviewer: string;
baseline: ReviewBaseline | null;
status: "requesting" | "optimistic";
operationId: number;
expiresAt: number | null;
};
const ENTRY_TTL_MS = 5 * 60 * 1000;
const entries = new Map<string, RequestEntry>();
const listeners = new Set<() => void>();
let revision = 0;
let nextOperationId = 0;
let expiryTimer: ReturnType<typeof setTimeout> | undefined;
function normalizeLogin(login: string) {
return login.trim().toLowerCase();
}
function prIdentity(taskPR: TaskPR) {
return `${taskPR.owner.toLowerCase()}:${taskPR.repo.toLowerCase()}:${taskPR.pr_number}`;
}
function entryKey(identity: string, reviewer: string) {
return `${identity}:${normalizeLogin(reviewer)}`;
}
function notify() {
revision += 1;
listeners.forEach((listener) => listener());
}
function pruneExpired(now = Date.now()) {
let removed = false;
for (const [key, entry] of entries) {
if (entry.status === "optimistic" && entry.expiresAt !== null && entry.expiresAt <= now) {
entries.delete(key);
removed = true;
}
}
return removed;
}
function rescheduleExpiryTimer() {
if (expiryTimer !== undefined) {
clearTimeout(expiryTimer);
expiryTimer = undefined;
}
if (typeof window === "undefined") return;
const nextExpiry = Array.from(entries.values()).reduce<number | null>((nearest, entry) => {
if (entry.status !== "optimistic" || entry.expiresAt === null) return nearest;
return nearest === null || entry.expiresAt < nearest ? entry.expiresAt : nearest;
}, null);
if (nextExpiry === null) return;
expiryTimer = setTimeout(
() => {
expiryTimer = undefined;
if (pruneExpired()) notify();
rescheduleExpiryTimer();
},
Math.max(0, nextExpiry - Date.now()),
);
}
function latestReview(reviews: PRReview[], reviewer: string) {
const normalizedReviewer = normalizeLogin(reviewer);
return reviews
.filter((review) => normalizeLogin(review.author) === normalizedReviewer)
.reduce<PRReview | null>((latest, review) => {
if (!latest) return review;
const reviewTime = new Date(review.created_at).getTime();
const latestTime = new Date(latest.created_at).getTime();
return reviewTime > latestTime || (reviewTime === latestTime && review.id > latest.id)
? review
: latest;
}, null);
}
function supersedesBaseline(review: PRReview | null, baseline: ReviewBaseline | null) {
if (!review || !baseline || review.state === "DISMISSED") return false;
const reviewTime = new Date(review.created_at).getTime();
const baselineTime = new Date(baseline.created_at).getTime();
return reviewTime > baselineTime || (reviewTime === baselineTime && review.id > baseline.id);
}
function reconcile(identity: string, requestedReviewers: RequestedReviewer[], reviews: PRReview[]) {
let removed = pruneExpired();
const requestedLogins = new Set(
requestedReviewers.map((reviewer) => normalizeLogin(reviewer.login)),
);
for (const [key, entry] of entries) {
if (entry.identity !== identity) continue;
if (
requestedLogins.has(entry.reviewer) ||
supersedesBaseline(latestReview(reviews, entry.reviewer), entry.baseline)
) {
entries.delete(key);
removed = true;
}
}
rescheduleExpiryTimer();
if (removed) notify();
}
function beginRequest(identity: string, reviewer: string, baseline: ReviewBaseline | null) {
const expired = pruneExpired();
const key = entryKey(identity, reviewer);
if (entries.has(key)) {
if (expired) {
rescheduleExpiryTimer();
notify();
}
return null;
}
const operationId = ++nextOperationId;
entries.set(key, {
identity,
reviewer: normalizeLogin(reviewer),
baseline,
status: "requesting",
operationId,
expiresAt: null,
});
rescheduleExpiryTimer();
notify();
return operationId;
}
function finishRequest(
identity: string,
reviewer: string,
operationId: number,
succeeded: boolean,
) {
const key = entryKey(identity, reviewer);
const entry = entries.get(key);
if (!entry || entry.operationId !== operationId) return;
if (!succeeded) {
entries.delete(key);
} else {
entries.set(key, { ...entry, status: "optimistic", expiresAt: Date.now() + ENTRY_TTL_MS });
}
rescheduleExpiryTimer();
notify();
}
function getEntries(identity: string) {
return Array.from(entries.values()).filter((entry) => entry.identity === identity);
}
function subscribe(listener: () => void) {
listeners.add(listener);
return () => listeners.delete(listener);
}
export function clearPRReviewRequestRegistryForTests() {
entries.clear();
nextOperationId = 0;
rescheduleExpiryTimer();
notify();
}
export function usePRScopedReviewRequest(
taskPR: TaskPR,
requestedReviewers: RequestedReviewer[],
reviews: PRReview[],
refresh: () => void,
toast: Toast,
) {
const identity = prIdentity(taskPR);
useSyncExternalStore(
subscribe,
() => revision,
() => revision,
);
useEffect(() => {
reconcile(identity, requestedReviewers, reviews);
}, [identity, requestedReviewers, reviews]);
const reRequest = useCallback(
async (reviewer: string) => {
const baseline = latestReview(reviews, reviewer);
const operationId = beginRequest(identity, reviewer, baseline);
if (operationId === null) return;
try {
await requestPRReviewers(taskPR.owner, taskPR.repo, taskPR.pr_number, [reviewer]);
} catch (error) {
finishRequest(identity, reviewer, operationId, false);
toast({
title: "Failed to re-request review",
description: error instanceof Error ? error.message : "An error occurred",
variant: "error",
});
return;
}
finishRequest(identity, reviewer, operationId, true);
toast({ description: `Review re-requested from ${reviewer}`, variant: "success" });
try {
refresh();
} catch {
// The request remains optimistic until the bounded registry expires or server data resolves it.
}
},
[identity, refresh, reviews, taskPR.owner, taskPR.pr_number, taskPR.repo, toast],
);
const activeEntries = getEntries(identity);
const requestingReviewers = activeEntries
.filter((entry) => entry.status === "requesting")
.map((entry) => entry.reviewer);
const optimisticReviewers = activeEntries
.filter((entry) => entry.status === "optimistic")
.filter(
(entry) =>
!requestedReviewers.some((reviewer) => normalizeLogin(reviewer.login) === entry.reviewer),
)
.map((entry) => ({ login: entry.reviewer, type: "user" as const }));
return {
reRequest,
requestingReviewers,
requestedReviewers: [...requestedReviewers, ...optimisticReviewers],
};
}