sailfork / t3code-github / packages/ source-control-bitbucket/ src/ server/ BitbucketPullRequestApi.test.ts

import { afterEach, assert, expect, it, vi } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import * as BitbucketApi from "./BitbucketApi.ts";
import * as BitbucketPullRequestApi from "./BitbucketPullRequestApi.ts";

const mockedRequest = vi.fn<BitbucketApi.BitbucketApi["Service"]["request"]>();

const layer = it.layer(
  BitbucketPullRequestApi.layer.pipe(
    Layer.provide(
      Layer.mock(BitbucketApi.BitbucketApi)({
        request: mockedRequest,
      }),
    ),
  ),
);

function response(body: string) {
  return { body, truncated: false };
}

function page(count: number, firstNumber: number, next?: string): string {
  return JSON.stringify({
    pagelen: 50,
    size: count,
    values: Array.from({ length: count }, (_, index) => ({
      id: firstNumber + index,
      title: `Pull request ${firstNumber + index}`,
      state: "OPEN",
      created_on: "2026-06-16T05:04:32+00:00",
      updated_on: "2026-06-16T05:04:33+00:00",
      source: { branch: { name: "feat/page" } },
      destination: { branch: { name: "master" } },
      links: { html: { href: `https://bitbucket.org/acme/web/pull-requests/${firstNumber}` } },
    })),
    ...(next === undefined ? {} : { next }),
  });
}

function valuePage(values: ReadonlyArray<unknown>, next?: string): string {
  return JSON.stringify({ values, ...(next === undefined ? {} : { next }) });
}

const bilal = { uuid: "{bilal}", nickname: "bilal" };
const octocat = { uuid: "{octocat}", nickname: "octocat" };
const hubot = { uuid: "{hubot}", nickname: "hubot" };

function pullRequestJson(overrides: Record<string, unknown>): string {
  return JSON.stringify({
    id: 7,
    title: "Pull request 7",
    state: "OPEN",
    author: bilal,
    created_on: "2026-06-16T05:04:32+00:00",
    updated_on: "2026-06-16T05:04:33+00:00",
    source: { branch: { name: "feat/page" } },
    destination: { branch: { name: "master" } },
    links: { html: { href: "https://bitbucket.org/acme/web/pull-requests/7" } },
    ...overrides,
  });
}

function callAt(index: number) {
  const call = mockedRequest.mock.calls[index];
  assert.isDefined(call);
  return call[0];
}

function filterOfCall(index: number): string | null {
  const url = callAt(index).url;
  return new URLSearchParams(url.slice(url.indexOf("?") + 1)).get("q");
}

afterEach(() => {
  mockedRequest.mockReset();
});

layer("BitbucketPullRequestApi.layer", (it) => {
  it.effect("follows the cursor Bitbucket sends rather than counting offsets", () =>
    Effect.gen(function* () {
      const next = "https://api.bitbucket.org/2.0/repositories/acme/web/pullrequests?page=2";
      mockedRequest
        .mockReturnValueOnce(Effect.succeed(response(page(50, 1, next))))
        .mockReturnValueOnce(Effect.succeed(response(page(50, 51))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const batch = yield* api.listPullRequests({
        repository: "acme/web",
        state: "open",
        limit: 100,
      });

      assert.strictEqual(batch.items.length, 100);
      assert.isFalse(batch.truncated);
      assert.strictEqual(callAt(1).url, next);
    }),
  );

  it.effect("counts the rows it walked past as more to come", () =>
    Effect.gen(function* () {
      const next = "https://api.bitbucket.org/2.0/repositories/acme/web/pullrequests?page=2";
      mockedRequest
        .mockReturnValueOnce(Effect.succeed(response(page(50, 1, next))))
        .mockReturnValueOnce(Effect.succeed(response(page(50, 51))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const batch = yield* api.listPullRequests({
        repository: "acme/web",
        state: "open",
        limit: 99,
      });

      assert.strictEqual(batch.items.length, 99);
      assert.isTrue(batch.truncated);
    }),
  );

  it.effect("escapes a quote and a backslash, so a search cannot reshape the filter", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(Effect.succeed(response(page(0, 1))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.listPullRequests({
        repository: "acme/web",
        state: "open",
        limit: 50,
        query: String.raw`a\" OR state = "MERGED"`,
      });

      const literal = String.raw`a\\\" OR state = \"MERGED\"`;
      expect(filterOfCall(0)).toBe(`(title ~ "${literal}" OR description ~ "${literal}")`);
    }),
  );

  it.effect("narrows by the reader's words and by where it left off at once", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(Effect.succeed(response(page(0, 1))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.listPullRequests({
        repository: "acme/web",
        state: "open",
        limit: 50,
        query: "page",
        cursor: { updatedBefore: "2026-07-02T00:00:00+00:00", delivered: 50 },
      });

      expect(filterOfCall(0)).toBe(
        '(title ~ "page" OR description ~ "page") AND updated_on < 2026-07-02T00:00:00.001Z',
      );
    }),
  );

  it.effect("narrows by author and draft state in the same query", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(Effect.succeed(response(page(0, 1))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.listPullRequests({
        repository: "acme/web",
        state: "open",
        limit: 50,
        author: 'ana"',
        draft: false,
      });

      expect(filterOfCall(0)).toBe(
        '(author.nickname = "ana\\"" OR author.display_name = "ana\\"") AND draft = false',
      );
    }),
  );

  it.effect("refuses a repository that is not workspace and slug", () =>
    Effect.gen(function* () {
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const error = yield* Effect.flip(
        api.listPullRequests({ repository: "acme/team/web", state: "open", limit: 50 }),
      );

      assert.strictEqual(error._tag, "BitbucketRepositoryUnsupportedError");
      assert.strictEqual(mockedRequest.mock.calls.length, 0);
    }),
  );

  it.effect("refuses a commit that is not a sha rather than reading it into a URL", () =>
    Effect.gen(function* () {
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const error = yield* Effect.flip(
        api.getPullRequestDiff({
          repository: "acme/web",
          number: 7,
          commit: "../../acme/other/diff/deadbeef",
        }),
      );

      assert.strictEqual(error._tag, "BitbucketDiffCommitError");
      assert.strictEqual(mockedRequest.mock.calls.length, 0);
    }),
  );

  it.effect("reads every file version the patch states, not only the paths asked about", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(
        Effect.succeed(
          response(
            [
              "diff --git a/a.ts b/a.ts",
              "index 1111111..2222222 100644",
              "--- a/a.ts",
              "+++ b/a.ts",
              "@@ -1 +1 @@",
              "-a",
              "+b",
              "diff --git a/b.ts b/b.ts",
              "index 3333333..4444444 100644",
              "--- a/b.ts",
              "+++ b/b.ts",
              "@@ -1 +1 @@",
              "-c",
              "+d",
              "",
            ].join("\n"),
          ),
        ),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const revisions = yield* api.getFileRevisions({
        repository: "acme/web",
        number: 71,
        paths: ["a.ts", "missing.ts"],
      });

      assert.deepStrictEqual(
        [...revisions.revisions],
        [
          ["a.ts", "2222222"],
          ["b.ts", "4444444"],
          ["missing.ts", ""],
        ],
      );
      assert.strictEqual(revisions.complete, true);
      expect(callAt(0)).toMatchObject({ url: "/repositories/acme/web/pullrequests/71/diff" });
    }),
  );

  it.effect("says nothing about the files past the end of a patch it could not read whole", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(
        Effect.succeed({
          body: "diff --git a/a.ts b/a.ts\nindex 1111111..2222222 100644\n@@ -1 +1 @@\n",
          truncated: true,
        }),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const revisions = yield* api.getFileRevisions({
        repository: "acme/web",
        number: 72,
        paths: ["a.ts", "past-the-cut.ts"],
      });

      assert.deepStrictEqual([...revisions.revisions], [["a.ts", "2222222"]]);
      assert.strictEqual(revisions.complete, false);
    }),
  );

  it.effect("returns the complete commit timeline oldest first across pages", () =>
    Effect.gen(function* () {
      const next = "https://api.bitbucket.org/2.0/commits?page=2";
      mockedRequest
        .mockReturnValueOnce(
          Effect.succeed(
            response(
              valuePage(
                [
                  { hash: "ddd", message: "fourth", date: "2026-07-04T00:00:00Z" },
                  { hash: "ccc", message: "third", date: "2026-07-03T00:00:00Z" },
                ],
                next,
              ),
            ),
          ),
        )
        .mockReturnValueOnce(
          Effect.succeed(
            response(
              valuePage([
                { hash: "bbb", message: "second", date: "2026-07-02T00:00:00Z" },
                { hash: "aaa", message: "first", date: "2026-07-01T00:00:00Z" },
              ]),
            ),
          ),
        );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const commits = yield* api.listCommits({ repository: "acme/web", number: 7 });

      expect(commits.map((commit) => commit.oid)).toEqual(["aaa", "bbb", "ccc", "ddd"]);
      expect(callAt(1).url).toBe(next);
    }),
  );

  it.effect("posts a comment as a JSON document, so the body stays text", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValue(Effect.succeed(response("{}")));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.comment({ repository: "acme/web", number: 7, body: "true" });

      expect(callAt(0)).toMatchObject({
        method: "POST",
        url: "/repositories/acme/web/pullrequests/7/comments",
        body: '{"content":{"raw":"true"}}',
      });
    }),
  );

  it.effect("asks for the time a pull request closed, which Bitbucket leaves out by default", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(
        Effect.succeed(
          response(
            pullRequestJson({ state: "MERGED", closed_on: "2025-06-16T23:40:46.222238+00:00" }),
          ),
        ),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const pullRequest = yield* api.getPullRequest({ repository: "acme/web", number: 7 });

      expect(callAt(0).url).toBe("/repositories/acme/web/pullrequests/7?fields=%2Bclosed_on");
      assert.strictEqual(pullRequest.closedAt, "2025-06-16T23:40:46.222Z");
    }),
  );

  it.effect("stops the comment walk at its bound and says the conversation was cut short", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValue(
        Effect.succeed(
          response(
            JSON.stringify({
              next: "https://api.bitbucket.org/2.0/comments?page=2",
              values: [
                {
                  id: 10,
                  content: { raw: "again" },
                  created_on: "2026-06-16T05:04:32+00:00",
                },
              ],
            }),
          ),
        ),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const { truncated } = yield* api.listComments({ repository: "acme/web", number: 7 });

      assert.strictEqual(mockedRequest.mock.calls.length, 10);
      assert.isTrue(truncated);
    }),
  );

  it.effect("reassembles a thread from the flat comment list, replies included", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValueOnce(
        Effect.succeed(
          response(
            JSON.stringify({
              values: [
                {
                  id: 10,
                  content: { raw: "rename this" },
                  user: { nickname: "bilal" },
                  created_on: "2026-06-16T05:04:32+00:00",
                  inline: { path: "src/a.ts", to: 12, from: null },
                  resolution: { type: "pullrequest_comment_resolution" },
                },
                {
                  id: 11,
                  content: { raw: "done" },
                  user: { nickname: "julius" },
                  created_on: "2026-06-16T06:04:32+00:00",
                  parent: { id: 10 },
                },
                {
                  id: 12,
                  content: { raw: "thanks" },
                  user: { nickname: "bilal" },
                  created_on: "2026-06-16T07:04:32+00:00",
                  parent: { id: 11 },
                },
                {
                  id: 13,
                  content: { raw: "ship it" },
                  user: { nickname: "bilal" },
                  created_on: "2026-06-16T08:04:32+00:00",
                },
              ],
            }),
          ),
        ),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const { threads } = yield* api.listComments({ repository: "acme/web", number: 7 });

      assert.strictEqual(threads.length, 1);
      expect(threads[0]).toMatchObject({
        id: "10",
        path: "src/a.ts",
        line: 12,
        side: "right",
        isResolved: true,
      });
      expect(threads[0]?.comments.map((comment) => comment.id)).toEqual(["10", "11", "12"]);
    }),
  );

  it.effect("asks for the credentials' permission on this repository, and nobody else's", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValue(
        Effect.succeed(
          response(
            JSON.stringify({ values: [{ type: "repository_permission", permission: "read" }] }),
          ),
        ),
      );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      assert.isFalse(yield* api.getRepositoryPermission({ repository: "acme/web" }));

      expect(new URL(callAt(0).url, "https://api.bitbucket.org").pathname).toBe(
        "/user/workspaces/acme/permissions/repositories",
      );
      assert.strictEqual(filterOfCall(0), 'repository.full_name="acme/web"');
    }),
  );

  it.effect("escapes a repository name before it goes inside a filter literal", () =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValue(Effect.succeed(response(JSON.stringify({ values: [] }))));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.getRepositoryPermission({ repository: 'acme/we"b' });

      assert.strictEqual(filterOfCall(0), 'repository.full_name="acme/we\\"b"');
    }),
  );

  const permissionFailure = (status: number) =>
    Effect.fail(
      new BitbucketApi.BitbucketResponseError({
        operation: "request",
        status,
        responseBodyLength: 0,
      }),
    );

  it.effect.each([403, 404, 410])(
    "reads HTTP %s from the permissions endpoint as an unknown permission",
    (status) =>
      Effect.gen(function* () {
        mockedRequest.mockReturnValue(permissionFailure(status));
        const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

        assert.isTrue(yield* api.getRepositoryPermission({ repository: "acme/web" }));
      }),
  );

  it.effect.each([401, 500])("still fails the permission read on HTTP %s", (status) =>
    Effect.gen(function* () {
      mockedRequest.mockReturnValue(permissionFailure(status));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const error = yield* Effect.flip(api.getRepositoryPermission({ repository: "acme/web" }));
      assert.strictEqual(error._tag, "BitbucketResponseError");
      if (error._tag === "BitbucketResponseError") {
        assert.strictEqual(error.status, status);
      }
    }),
  );

  it.effect("reads the workspace's people and marks whoever is already a reviewer", () =>
    Effect.gen(function* () {
      mockedRequest
        .mockReturnValueOnce(Effect.succeed(response(pullRequestJson({ reviewers: [octocat] }))))
        .mockReturnValueOnce(
          Effect.succeed(
            response(
              JSON.stringify({ values: [{ user: bilal }, { user: octocat }, { user: hubot }] }),
            ),
          ),
        );
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      const list = yield* api.listReviewerCandidates({ repository: "acme/web", number: 7 });

      expect(callAt(1).url).toBe("/workspaces/acme/members?pagelen=50");
      expect(list.candidates.map((candidate) => [candidate.id, candidate.isRequested])).toEqual([
        ["{octocat}", true],
        ["{hubot}", false],
      ]);
      assert.isFalse(list.truncated);
    }),
  );

  it.effect("writes the reviewer set back with the one being asked added to it", () =>
    Effect.gen(function* () {
      mockedRequest
        .mockReturnValueOnce(Effect.succeed(response(pullRequestJson({ reviewers: [octocat] }))))
        .mockReturnValueOnce(Effect.succeed(response("{}")));
      const api = yield* BitbucketPullRequestApi.BitbucketPullRequestApi;

      yield* api.setReviewerRequest({
        repository: "acme/web",
        number: 7,
        reviewers: [{ id: "{hubot}" }],
        requested: true,
      });

      const call = callAt(1);
      expect(call.method).toBe("PUT");
      expect(call.url).toBe("/repositories/acme/web/pullrequests/7");
      expect(JSON.parse(call.body ?? "")).toEqual({
        reviewers: [{ uuid: "{octocat}" }, { uuid: "{hubot}" }],
      });
    }),
  );
});