swadhin / opencodehub public
/ opencodehub / tests / integration / pr-required-reviewers-route.test.ts
swadhinbiswas Complete required-reviewers-per-state policy guidance · 2/19/2026
73b1fe0
141 lines · 4.7 KB
Raw Download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
import { beforeEach, describe, expect, it, vi } from "vitest";

const {
  canReadRepoMock,
  fakeSchema,
} = vi.hoisted(() => ({
  canReadRepoMock: vi.fn(async () => true),
  fakeSchema: {
    users: { username: {} },
    repositories: { ownerId: {}, name: {}, id: {} },
    pullRequests: { repositoryId: {}, number: {}, id: {}, stateId: {} },
    pullRequestReviewers: { pullRequestId: {}, isRequired: {} },
    pullRequestReviews: { pullRequestId: {}, submittedAt: {} },
    prStateDefinitions: { repositoryId: {}, id: {}, name: {} },
    prStateReviewers: { stateDefinitionId: {}, userId: {}, teamId: {} },
    teamMembers: { teamId: {}, userId: {} },
  } as any,
}));

let mockDb: any;

vi.mock("@/db", () => ({
  getDatabase: () => mockDb,
  schema: fakeSchema,
}));

vi.mock("@/lib/permissions", () => ({
  canReadRepo: canReadRepoMock,
}));

import { GET as requiredReviewersGet } from "@/pages/api/repos/[owner]/[repo]/pulls/[number]/required-reviewers";

function makeDb() {
  return {
    query: {
      users: {
        findFirst: vi.fn(async () => ({ id: "owner-1" })),
      },
      repositories: {
        findFirst: vi.fn(async () => ({ id: "repo-1", ownerId: "owner-1", name: "demo" })),
      },
      pullRequests: {
        findFirst: vi.fn(async () => ({ id: "pr-1", number: 12, stateId: null })),
      },
      pullRequestReviewers: {
        findMany: vi.fn(async () => ([
          { userId: "u1", user: { username: "alice", displayName: "Alice" } },
          { userId: "u2", user: { username: "bob", displayName: "Bob" } },
        ])),
      },
      pullRequestReviews: {
        findMany: vi.fn(async () => ([
          { reviewerId: "u1", state: "approved", submittedAt: new Date("2026-02-19T00:00:00Z"), createdAt: new Date("2026-02-19T00:00:00Z") },
          { reviewerId: "u2", state: "changes_requested", submittedAt: new Date("2026-02-18T00:00:00Z"), createdAt: new Date("2026-02-18T00:00:00Z") },
        ])),
      },
      prStateDefinitions: {
        findFirst: vi.fn(async () => ({ id: "state-1", name: "in_review", displayName: "In Review" })),
      },
      prStateReviewers: {
        findMany: vi.fn(async () => ([
          {
            userId: "u1",
            teamId: null,
            requiredCount: 1,
            user: { id: "u1", username: "alice", displayName: "Alice" },
            team: null,
          },
          {
            userId: null,
            teamId: "team-1",
            requiredCount: 2,
            user: null,
            team: { id: "team-1", name: "Platform" },
          },
        ])),
      },
      teamMembers: {
        findMany: vi.fn(async () => [
          { userId: "u1" },
          { userId: "u3" },
          { userId: "u4" },
        ]),
      },
    },
  };
}

async function readJson(response: Response): Promise<any> {
  return response.json();
}

describe("required reviewers route", () => {
  beforeEach(() => {
    mockDb = makeDb();
    canReadRepoMock.mockResolvedValue(true);
  });

  it("returns 401 for unauthenticated users", async () => {
    const response = await requiredReviewersGet({
      params: { owner: "owner-1", repo: "demo", number: "12" },
      locals: {},
      request: new Request("http://localhost/api/repos/owner-1/demo/pulls/12/required-reviewers"),
    } as any);

    expect(response.status).toBe(401);
  });

  it("returns required reviewer approval status", async () => {
    const response = await requiredReviewersGet({
      params: { owner: "owner-1", repo: "demo", number: "12" },
      locals: { user: { id: "user-1", isAdmin: false } },
      request: new Request("http://localhost/api/repos/owner-1/demo/pulls/12/required-reviewers"),
    } as any);

    const body = await readJson(response);
    expect(response.status).toBe(200);
    expect(body?.data?.totalRequired).toBe(2);
    expect(body?.data?.approvedRequired).toBe(1);
    expect(body?.data?.missingRequired).toBe(1);
    expect(body?.data?.reviewers?.[0]?.username).toBe("alice");
    expect(body?.data?.policySource).toBe("assigned");
  });

  it("returns state-policy reviewer requirements when stateId is provided", async () => {
    const response = await requiredReviewersGet({
      params: { owner: "owner-1", repo: "demo", number: "12" },
      locals: { user: { id: "user-1", isAdmin: false } },
      request: new Request("http://localhost/api/repos/owner-1/demo/pulls/12/required-reviewers?stateId=state-1"),
    } as any);

    const body = await readJson(response);
    expect(response.status).toBe(200);
    expect(body?.data?.policySource).toBe("state");
    expect(body?.data?.targetState?.id).toBe("state-1");
    expect(body?.data?.reviewers?.[0]?.username).toBe("alice");
    expect(body?.data?.teamRequirements?.[0]?.teamName).toBe("Platform");
    expect(body?.data?.missingRequired).toBeGreaterThanOrEqual(1);
  });
});