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

import { SecretProviderId, SourceControlProviderKind } from "@t3tools/contracts";
import { assert, it, vi } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as ConfigProvider from "effect/ConfigProvider";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";

import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
import type * as SourceControlHost from "@t3tools/source-control-core/server/SourceControlHost";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";

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

type HostGit = SourceControlHost.SourceControlHost["Service"]["git"];

const isBitbucketRepositoryLocatorError = Schema.is(BitbucketApi.BitbucketRepositoryLocatorError);

const bitbucketPullRequest = {
  id: 42,
  title: "Add Bitbucket provider",
  state: "OPEN",
  updated_on: "2026-01-02T00:00:00.000Z",
  links: {
    html: {
      href: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
    },
  },
  source: {
    branch: { name: "feature/source-control" },
    repository: {
      full_name: "octocat/t3code",
      workspace: { slug: "octocat" },
    },
  },
  destination: {
    branch: { name: "main" },
    repository: {
      full_name: "pingdotgg/t3code",
      workspace: { slug: "pingdotgg" },
    },
  },
};

const repositoryJson = {
  full_name: "pingdotgg/t3code",
  links: {
    html: { href: "https://bitbucket.org/pingdotgg/t3code" },
    clone: [
      { name: "https", href: "https://bitbucket.org/pingdotgg/t3code.git" },
      { name: "ssh", href: "git@bitbucket.org:pingdotgg/t3code.git" },
    ],
  },
  mainbranch: { name: "main" },
};

function makeLayer(input: {
  readonly response: (request: HttpClientRequest.HttpClientRequest) => Response;
  /** Holds the answer until it resolves, in place of answering at once. */
  readonly answer?: (response: Response) => Effect.Effect<Response>;
  readonly requestFailure?: (
    request: HttpClientRequest.HttpClientRequest,
  ) => HttpClientError.HttpClientError;
  readonly stall?: boolean;
  readonly git?: Partial<HostGit>;
  readonly env?: Record<string, string>;
  readonly remoteUrl?: string;
}) {
  const execute = vi.fn((request: HttpClientRequest.HttpClientRequest) =>
    input.stall
      ? Effect.never
      : input.requestFailure
        ? Effect.fail(input.requestFailure(request))
        : (input.answer ?? Effect.succeed)(input.response(request)).pipe(
            Effect.map((response) => HttpClientResponse.fromWeb(request, response)),
          ),
  );
  const gitMock = {
    readConfigValue: vi.fn<HostGit["readConfigValue"]>(() =>
      Effect.succeed<string | null>("git@bitbucket.org:pingdotgg/t3code.git"),
    ),
    resolvePrimaryRemoteName: vi.fn<HostGit["resolvePrimaryRemoteName"]>(() =>
      Effect.succeed("origin"),
    ),
    ensureRemote: vi.fn<HostGit["ensureRemote"]>(() => Effect.succeed("octocat")),
    fetchRemoteBranch: vi.fn<HostGit["fetchRemoteBranch"]>(() => Effect.void),
    fetchRemoteTrackingBranch: vi.fn<HostGit["fetchRemoteTrackingBranch"]>(() => Effect.void),
    setBranchUpstream: vi.fn<HostGit["setBranchUpstream"]>(() => Effect.void),
    switchRef: vi.fn<HostGit["switchRef"]>((request) =>
      Effect.succeed({ refName: request.refName }),
    ),
    listLocalBranchNames: vi.fn<HostGit["listLocalBranchNames"]>(() => Effect.succeed([])),
  };
  const git = {
    ...gitMock,
    ...input.git,
  } satisfies Partial<HostGit>;

  const listRemotes = vi.fn(() =>
    Effect.succeed({
      remotes: [
        {
          name: "origin",
          url: input.remoteUrl ?? "git@bitbucket.org:pingdotgg/t3code.git",
          pushUrl: Option.none(),
          isPrimary: true,
        },
      ],
      freshness: {
        source: "live-local" as const,
        observedAt: DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"),
        expiresAt: Option.none(),
      },
    }),
  );
  // The outer effect resolves the repository; the inner one lists its remotes.
  const resolve = vi.fn((_cwd: string) => Effect.succeed(Effect.suspend(listRemotes)));

  const layer = BitbucketApi.layer.pipe(
    Layer.provide(SourceControlRateLimit.layer),
    Layer.provide(
      Layer.succeed(
        HttpClient.HttpClient,
        HttpClient.make((request) => execute(request)),
      ),
    ),
    Layer.provide(
      ConfigProvider.layer(
        ConfigProvider.fromEnv({
          env: input.env ?? {
            T3CODE_BITBUCKET_API_BASE_URL: "https://api.test.local/2.0",
            T3CODE_BITBUCKET_EMAIL: "user@example.com",
            T3CODE_BITBUCKET_API_TOKEN: "token",
          },
        }),
      ),
    ),
    Layer.provideMerge(TestSourceControlHost.layer({ git: { ...git, remotes: resolve } })),
    Layer.provideMerge(NodeServices.layer),
  );

  return { execute, git: gitMock, resolve, listRemotes, layer };
}

it.effect("parses pull request responses from the Bitbucket REST API", () => {
  const { execute, layer } = makeLayer({
    response: () =>
      Response.json({
        ...bitbucketPullRequest,
      }),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const result = yield* bitbucket.getPullRequest({
      cwd: "/repo",
      reference: "#42",
    });

    assert.deepStrictEqual(result, {
      number: 42,
      title: "Add Bitbucket provider",
      url: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
      baseRefName: "main",
      headRefName: "feature/source-control",
      state: "open",
      updatedAt: Option.some(DateTime.makeUnsafe("2026-01-02T00:00:00.000Z")),
      isCrossRepository: true,
      headRepositoryNameWithOwner: "octocat/t3code",
      headRepositoryOwnerLogin: "octocat",
    });
    assert.strictEqual(
      execute.mock.calls[0]?.[0].url,
      "https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests/42",
    );
  }).pipe(Effect.provide(layer));
});

it.effect.each([false, true])("honors PR URL repositories, context=%s", (withContext) => {
  const { execute, git, layer } = makeLayer({
    response: (request) =>
      Response.json(
        request.url.endsWith("/pullrequests/42")
          ? {
              ...bitbucketPullRequest,
              source: {
                branch: { name: "feature/source-control" },
                repository: { full_name: "another/app" },
              },
              destination: { branch: { name: "main" }, repository: { full_name: "another/app" } },
            }
          : {
              ...repositoryJson,
              full_name: "another/app",
              links: { clone: [{ name: "ssh", href: "git@bitbucket.org:another/app.git" }] },
            },
      ),
  });
  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const input = {
      cwd: "/repo",
      reference: "https://bitbucket.org/another/app/pull-requests/42",
      ...(withContext
        ? {
            context: {
              provider: {
                kind: SourceControlProviderKind.make("bitbucket"),
                name: "Bitbucket",
                baseUrl: "https://bitbucket.org",
              },
              remoteName: "origin",
              remoteUrl: "git@bitbucket.org:pingdotgg/t3code.git",
            },
          }
        : {}),
    };
    yield* bitbucket.getPullRequest(input);
    yield* bitbucket.checkoutPullRequest(input);
    assert.deepStrictEqual(
      execute.mock.calls.slice(0, 2).map(([request]) => request.url),
      [
        "https://api.test.local/2.0/repositories/another/app/pullrequests/42",
        "https://api.test.local/2.0/repositories/another/app/pullrequests/42",
      ],
    );
    assert.deepStrictEqual(git.ensureRemote.mock.calls[0]?.[0], {
      cwd: "/repo",
      preferredName: "another",
      url: "git@bitbucket.org:another/app.git",
    });
    assert.deepStrictEqual(git.fetchRemoteBranch.mock.calls[0]?.[0], {
      cwd: "/repo",
      remoteName: "octocat",
      remoteBranch: "feature/source-control",
      localBranch: "feature/source-control",
    });
    assert.deepStrictEqual(git.setBranchUpstream.mock.calls[0]?.[0], {
      cwd: "/repo",
      branch: "feature/source-control",
      remoteName: "octocat",
      remoteBranch: "feature/source-control",
    });
  }).pipe(Effect.provide(layer));
});

it.effect.each([false, true])(
  "reuses matching checkout remotes for numeric references, context=%s",
  (withContext) => {
    const { git, layer } = makeLayer({
      response: () =>
        Response.json({
          ...bitbucketPullRequest,
          source: { ...bitbucketPullRequest.source, repository: { full_name: "pingdotgg/t3code" } },
        }),
    });
    return Effect.gen(function* () {
      const bitbucket = yield* BitbucketApi.BitbucketApi;
      yield* bitbucket.checkoutPullRequest({
        cwd: "/repo",
        reference: "#42",
        ...(withContext
          ? {
              context: {
                provider: {
                  kind: SourceControlProviderKind.make("bitbucket"),
                  name: "Bitbucket",
                  baseUrl: "https://bitbucket.org",
                },
                remoteName: "upstream",
                remoteUrl: "git@bitbucket.org:PingDotGG/T3Code.git",
              },
            }
          : {}),
      });
      assert.strictEqual(git.ensureRemote.mock.calls.length, 0);
      assert.deepStrictEqual(git.fetchRemoteBranch.mock.calls[0]?.[0], {
        cwd: "/repo",
        remoteName: withContext ? "upstream" : "origin",
        remoteBranch: "feature/source-control",
        localBranch: "feature/source-control",
      });
    }).pipe(Effect.provide(layer));
  },
);

it.effect("lists pull requests with Bitbucket state and source branch query params", () => {
  const { execute, layer } = makeLayer({
    response: () =>
      Response.json({
        values: [
          {
            ...bitbucketPullRequest,
            id: 7,
            state: "MERGED",
            source: {
              branch: { name: "feature/merged" },
              repository: { full_name: "pingdotgg/t3code" },
            },
          },
        ],
      }),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const result = yield* bitbucket.listPullRequests({
      cwd: "/repo",
      headSelector: "origin:feature/merged",
      state: "merged",
      limit: 10,
    });

    assert.strictEqual(result[0]?.state, "merged");
    const request = execute.mock.calls[0]?.[0];
    assert.strictEqual(
      request?.url,
      "https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests",
    );
    assert.deepStrictEqual(request?.urlParams.params, [
      ["pagelen", "10"],
      ["sort", "-updated_on"],
      ["q", 'source.branch.name = "feature/merged" AND state = "MERGED"'],
      ["state", "MERGED"],
    ]);
  }).pipe(Effect.provide(layer));
});

it.effect("reads repository clone URLs and default branch", () => {
  const { layer } = makeLayer({
    response: (request) =>
      Response.json(
        request.url.endsWith("/branching-model")
          ? {
              development: {
                branch: { name: "main" },
                name: "main",
                use_mainbranch: true,
              },
            }
          : repositoryJson,
      ),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const cloneUrls = yield* bitbucket.getRepositoryCloneUrls({
      cwd: "/repo",
      repository: "pingdotgg/t3code",
    });
    const defaultBranch = yield* bitbucket.getDefaultBranch({ cwd: "/repo" });

    assert.deepStrictEqual(cloneUrls, {
      nameWithOwner: "pingdotgg/t3code",
      url: "https://bitbucket.org/pingdotgg/t3code.git",
      sshUrl: "git@bitbucket.org:pingdotgg/t3code.git",
    });
    assert.strictEqual(defaultBranch, "main");
  }).pipe(Effect.provide(layer));
});

it.effect.each([false, true])(
  "rejects invalid explicit repositories before fallback, context=%s",
  (withContext) => {
    const { execute, resolve, listRemotes, layer } = makeLayer({
      response: () => Response.json(repositoryJson),
    });

    return Effect.gen(function* () {
      const bitbucket = yield* BitbucketApi.BitbucketApi;
      for (const repository of ["t3code", "", " \t "]) {
        const error = yield* bitbucket
          .getRepositoryCloneUrls({
            cwd: "/repo",
            repository,
            ...(withContext
              ? {
                  context: {
                    provider: {
                      kind: SourceControlProviderKind.make("bitbucket"),
                      name: "Bitbucket",
                      baseUrl: "https://bitbucket.org",
                    },
                    remoteName: "origin",
                    remoteUrl: "git@bitbucket.org:pingdotgg/t3code.git",
                  },
                }
              : {}),
          })
          .pipe(Effect.match({ onFailure: (error) => error, onSuccess: () => null }));

        assert.instanceOf(error, BitbucketApi.BitbucketRepositoryLocatorError);
        assert.strictEqual(
          isBitbucketRepositoryLocatorError(error) ? error.repository : null,
          repository,
        );
        assert.strictEqual(resolve.mock.calls.length, 0);
        assert.strictEqual(listRemotes.mock.calls.length, 0);
        assert.strictEqual(execute.mock.calls.length, 0);
      }
    }).pipe(Effect.provide(layer));
  },
);

it.effect("prefers an explicit repository and uses context when the repository is omitted", () => {
  const { execute, resolve, listRemotes, layer } = makeLayer({
    response: (request) =>
      Response.json(request.url.endsWith("/branching-model") ? {} : repositoryJson),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const context = {
      provider: {
        kind: SourceControlProviderKind.make("bitbucket"),
        name: "Bitbucket",
        baseUrl: "https://bitbucket.org",
      },
      remoteName: "origin",
      remoteUrl: "git@bitbucket.org:another/context.git",
    };
    for (const repository of ["pingdotgg/t3code", "https://bitbucket.org/pingdotgg/t3code.git"]) {
      yield* bitbucket.getRepositoryCloneUrls({ cwd: "/repo", context, repository });
    }
    yield* bitbucket.getDefaultBranch({ cwd: "/repo", context });

    assert.deepStrictEqual(
      execute.mock.calls.map(([request]) => request.url).toSorted(),
      [
        "https://api.test.local/2.0/repositories/pingdotgg/t3code",
        "https://api.test.local/2.0/repositories/pingdotgg/t3code",
        "https://api.test.local/2.0/repositories/another/context",
        "https://api.test.local/2.0/repositories/another/context/branching-model",
      ].toSorted(),
    );
    assert.strictEqual(resolve.mock.calls.length, 0);
    assert.strictEqual(listRemotes.mock.calls.length, 0);
  }).pipe(Effect.provide(layer));
});

it.effect("sends a self-hosted Bitbucket remote nowhere unless an API base url is configured", () =>
  Effect.gen(function* () {
    const remoteUrl = "https://bitbucket.example.com/scm/proj/repo.git";
    const context = {
      provider: {
        kind: SourceControlProviderKind.make("bitbucket"),
        name: "Bitbucket Self-Hosted",
        baseUrl: "https://bitbucket.example.com",
      },
      remoteName: "origin",
      remoteUrl,
    };
    const cloudEnv = {
      T3CODE_BITBUCKET_EMAIL: "user@example.com",
      T3CODE_BITBUCKET_API_TOKEN: "t",
    };
    const response = (request: HttpClientRequest.HttpClientRequest) =>
      Response.json(request.url.endsWith("/branching-model") ? {} : repositoryJson);
    const defaultBranch = (setup: ReturnType<typeof makeLayer>, withContext: boolean) =>
      BitbucketApi.BitbucketApi.pipe(
        Effect.flatMap((bitbucket) =>
          bitbucket.getDefaultBranch({ cwd: "/repo", ...(withContext ? { context } : {}) }),
        ),
        Effect.provide(setup.layer),
      );
    const requestedUrls = (setup: ReturnType<typeof makeLayer>) =>
      setup.execute.mock.calls.map(([request]) => request.url).toSorted();

    // A self-hosted remote in the checkout, then a self-hosted context beside a Cloud remote.
    for (const [setup, withContext] of [
      [makeLayer({ response, env: cloudEnv, remoteUrl }), false],
      [makeLayer({ response, env: cloudEnv }), true],
    ] as const) {
      const result = yield* defaultBranch(setup, withContext).pipe(Effect.result);
      assert.deepStrictEqual(requestedUrls(setup), []);
      assert.strictEqual(
        Result.isFailure(result) && result.failure._tag,
        "BitbucketRepositoryRemoteNotFoundError",
      );
    }

    // An explicit repository does not let a self-hosted context reach the Cloud API.
    const explicit = makeLayer({ response, env: cloudEnv });
    const cloneUrls = yield* BitbucketApi.BitbucketApi.pipe(
      Effect.flatMap((bitbucket) =>
        bitbucket.getRepositoryCloneUrls({ cwd: "/repo", context, repository: "proj/repo" }),
      ),
      Effect.provide(explicit.layer),
      Effect.result,
    );
    assert.deepStrictEqual(requestedUrls(explicit), []);
    assert.strictEqual(
      Result.isFailure(cloneUrls) && cloneUrls.failure._tag,
      "BitbucketRepositoryRemoteNotFoundError",
    );

    const cloud = makeLayer({ response, env: cloudEnv });
    yield* defaultBranch(cloud, false);
    assert.deepStrictEqual(requestedUrls(cloud), [
      "https://api.bitbucket.org/2.0/repositories/pingdotgg/t3code",
      "https://api.bitbucket.org/2.0/repositories/pingdotgg/t3code/branching-model",
    ]);

    const configured = makeLayer({ response, remoteUrl });
    yield* defaultBranch(configured, true);
    assert.deepStrictEqual(requestedUrls(configured), [
      "https://api.test.local/2.0/repositories/proj/repo",
      "https://api.test.local/2.0/repositories/proj/repo/branching-model",
    ]);
  }),
);

it.effect(
  "prefers the Bitbucket branching model development branch as the default PR target",
  () => {
    const { execute, layer } = makeLayer({
      response: (request) =>
        Response.json(
          request.url.endsWith("/branching-model")
            ? {
                development: {
                  branch: { name: "develop" },
                  name: "develop",
                  use_mainbranch: false,
                },
              }
            : repositoryJson,
        ),
    });

    return Effect.gen(function* () {
      const bitbucket = yield* BitbucketApi.BitbucketApi;
      const defaultBranch = yield* bitbucket.getDefaultBranch({ cwd: "/repo" });

      assert.strictEqual(defaultBranch, "develop");
      assert.deepStrictEqual(
        execute.mock.calls.map((call) => call[0].url).toSorted(),
        [
          "https://api.test.local/2.0/repositories/pingdotgg/t3code",
          "https://api.test.local/2.0/repositories/pingdotgg/t3code/branching-model",
        ].toSorted(),
      );
    }).pipe(Effect.provide(layer));
  },
);

it.effect(
  "falls back to the repository main branch when the Bitbucket development branch is invalid",
  () => {
    const { layer } = makeLayer({
      response: (request) =>
        Response.json(
          request.url.endsWith("/branching-model")
            ? {
                development: {
                  name: "develop",
                  use_mainbranch: false,
                  is_valid: false,
                },
              }
            : repositoryJson,
        ),
    });

    return Effect.gen(function* () {
      const bitbucket = yield* BitbucketApi.BitbucketApi;
      const defaultBranch = yield* bitbucket.getDefaultBranch({ cwd: "/repo" });

      assert.strictEqual(defaultBranch, "main");
    }).pipe(Effect.provide(layer));
  },
);

it.effect("creates pull requests using the official REST payload shape", () => {
  const { execute, layer } = makeLayer({
    response: () => Response.json(bitbucketPullRequest),
  });

  return Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const bodyFile = yield* fileSystem.makeTempFileScoped({ prefix: "bitbucket-pr-body-" });
    yield* fileSystem.writeFileString(bodyFile, "PR body");

    const bitbucket = yield* BitbucketApi.BitbucketApi;
    yield* bitbucket.createPullRequest({
      cwd: "/repo",
      baseBranch: "main",
      headSelector: "owner:feature/provider",
      title: "Provider PR",
      bodyFile,
    });

    const request = execute.mock.calls[0]?.[0];
    assert.strictEqual(
      request?.url,
      "https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests",
    );
    assert.strictEqual(request?.method, "POST");
    assert.ok(request);
    const rawBody = (request.body as { readonly body?: Uint8Array }).body;
    assert.ok(rawBody);
    assert.deepStrictEqual(JSON.parse(new TextDecoder().decode(rawBody)), {
      title: "Provider PR",
      description: "PR body",
      source: {
        branch: { name: "feature/provider" },
        repository: { full_name: "owner/t3code" },
      },
      destination: {
        branch: { name: "main" },
      },
    });
  }).pipe(Effect.provide(layer), Effect.scoped);
});

it.effect("reports the account Bitbucket confirms for the configured credential", () => {
  const { layer } = makeLayer({
    response: () => Response.json({ username: "bitbucket-user" }),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const auth = yield* bitbucket.probeAuth;
    assert.strictEqual(auth.status, "authenticated");
    assert.deepStrictEqual(auth.account, Option.some("bitbucket-user"));
    assert.deepStrictEqual(auth.host, Option.some("bitbucket.org"));
  }).pipe(Effect.provide(layer));
});

it.effect("prefers credentials saved in settings over the environment, without a restart", () => {
  const { execute, layer } = makeLayer({
    response: () => Response.json({ username: "bitbucket-user" }),
  });
  const lastAuthorization = () => execute.mock.calls.at(-1)?.[0].headers.authorization;
  const basic = (user: string, password: string) => `Basic ${btoa(`${user}:${password}`)}`;

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const settings = yield* TestSourceControlHost.TestSourceControlHostSettings;

    yield* bitbucket.probeAuth;
    assert.strictEqual(lastAuthorization(), basic("user@example.com", "token"));

    yield* settings.update({
      sourceControlHosts: {
        bitbucket: { email: "saved@example.com", apiToken: "saved-api-token" },
      },
    });
    yield* bitbucket.probeAuth;
    assert.strictEqual(lastAuthorization(), basic("saved@example.com", "saved-api-token"));

    yield* settings.update({
      sourceControlHosts: { bitbucket: { accessToken: "saved-access-token" } },
    });
    yield* bitbucket.probeAuth;
    assert.strictEqual(lastAuthorization(), "Bearer saved-access-token");

    yield* settings.update({
      sourceControlHosts: { bitbucket: { accessToken: "", apiToken: "" } },
    });
    yield* bitbucket.probeAuth;
    assert.strictEqual(lastAuthorization(), basic("user@example.com", "token"));

    // A reference left in place by getWithSecrets is one its secret provider could not read.
    const requests = execute.mock.calls.length;
    yield* settings.update({
      sourceControlHosts: {
        bitbucket: {
          accessToken: { provider: SecretProviderId.make("vault"), reference: "bb#token" },
        },
      },
    });
    const auth = yield* bitbucket.probeAuth;
    assert.strictEqual(auth.status, "unauthenticated");
    assert.include(Option.getOrThrow(auth.detail), '"vault"');
    const error = yield* Effect.flip(
      bitbucket.listPullRequests({ cwd: "/repo", headSelector: "feature", state: "open" }),
    );
    assert.strictEqual(error._tag, "SettingsSecretUnresolvedError");
    assert.strictEqual(execute.mock.calls.length, requests);
  }).pipe(Effect.provide(layer));
});

it.effect("never puts a saved token that is unsafe for an HTTP header on the wire", () => {
  const { execute, layer } = makeLayer({
    response: () => Response.json({ username: "bitbucket-user" }),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const settings = yield* TestSourceControlHost.TestSourceControlHostSettings;

    // Fetch would reject this header with an error quoting the token, and that error reaches
    // clients. The unusable token is ignored, so the environment credential is used instead.
    yield* settings.update({
      sourceControlHosts: { bitbucket: { accessToken: "saved\ntoken" } },
    });
    yield* bitbucket.probeAuth;
    assert.strictEqual(
      execute.mock.calls.at(-1)?.[0].headers.authorization,
      `Basic ${btoa("user@example.com:token")}`,
    );
  }).pipe(Effect.provide(layer));
});

it.effect("reports saved credentials as configured when Bitbucket cannot confirm them", () => {
  const { execute, layer } = makeLayer({
    response: () => new Response(null, { status: 401 }),
    env: { T3CODE_BITBUCKET_API_BASE_URL: "https://api.test.local/2.0" },
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const settings = yield* TestSourceControlHost.TestSourceControlHostSettings;

    assert.strictEqual((yield* bitbucket.probeAuth).status, "unauthenticated");
    assert.strictEqual(execute.mock.calls.length, 0);

    yield* settings.update({
      sourceControlHosts: { bitbucket: { accessToken: "saved-access-token" } },
    });
    assert.deepStrictEqual(yield* bitbucket.probeAuth, {
      status: "unknown",
      account: Option.none(),
      host: Option.some("bitbucket.org"),
      detail: Option.some("An access token is configured."),
    });
  }).pipe(Effect.provide(layer));
});

it.effect("keeps Bitbucket response bodies out of checkout diagnostics", () => {
  const responseBody = '{"error":{"message":"credential=secret-value"}}';
  const { layer } = makeLayer({
    response: () => new Response(responseBody, { status: 403 }),
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const error = yield* bitbucket
      .checkoutPullRequest({ cwd: "/repo", reference: "42" })
      .pipe(Effect.flip);

    assert.instanceOf(error, BitbucketApi.BitbucketResponseError);
    assert.strictEqual(error.operation, "getPullRequest");
    assert.strictEqual(error.status, 403);
    assert.strictEqual(error.responseBodyLength, responseBody.length);
    assert.notProperty(error, "responseBody");
    assert.strictEqual(
      error.message,
      "Bitbucket API failed in getPullRequest: Bitbucket returned HTTP 403.",
    );
    assert.notInclude(error.message, "secret-value");
  }).pipe(Effect.provide(layer));
});

it.effect("checks out fork pull requests through an ensured fork remote", () => {
  const { git, layer } = makeLayer({
    response: (request) => {
      if (request.url.endsWith("/repositories/octocat/t3code")) {
        return Response.json({
          ...repositoryJson,
          full_name: "octocat/t3code",
          links: {
            html: { href: "https://bitbucket.org/octocat/t3code" },
            clone: [
              { name: "https", href: "https://bitbucket.org/octocat/t3code.git" },
              { name: "ssh", href: "git@bitbucket.org:octocat/t3code.git" },
            ],
          },
        });
      }
      return Response.json({
        ...bitbucketPullRequest,
        source: {
          branch: { name: "main" },
          repository: {
            full_name: "octocat/t3code",
            workspace: { slug: "octocat" },
          },
        },
      });
    },
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    yield* bitbucket.checkoutPullRequest({
      cwd: "/repo",
      reference: "42",
      force: true,
    });

    assert.deepStrictEqual(git.ensureRemote.mock.calls[0]?.[0], {
      cwd: "/repo",
      preferredName: "octocat",
      url: "git@bitbucket.org:octocat/t3code.git",
    });
    assert.deepStrictEqual(git.fetchRemoteBranch.mock.calls[0]?.[0], {
      cwd: "/repo",
      remoteName: "octocat",
      remoteBranch: "main",
      localBranch: "t3code/pr-42/main",
    });
    assert.deepStrictEqual(git.setBranchUpstream.mock.calls[0]?.[0], {
      cwd: "/repo",
      branch: "t3code/pr-42/main",
      remoteName: "octocat",
      remoteBranch: "main",
    });
    assert.deepStrictEqual(git.switchRef.mock.calls[0]?.[0], {
      cwd: "/repo",
      refName: "t3code/pr-42/main",
    });
  }).pipe(Effect.provide(layer));
});

it.effect("refuses a url that points away from the configured Bitbucket", () => {
  const { layer, execute } = makeLayer({ response: () => new Response("{}", { status: 200 }) });
  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;

    const error = yield* Effect.flip(
      bitbucket.request({ method: "GET", url: "https://attacker.example/2.0/repositories" }),
    );

    assert.strictEqual(error._tag, "BitbucketUntrustedUrlError");
    assert.strictEqual(execute.mock.calls.length, 0);
  }).pipe(Effect.provide(layer));
});

it.effect("keeps only the host of a url it refuses, never its query", () =>
  Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;

    const error = yield* Effect.flip(
      bitbucket.request({
        method: "GET",
        url: "https://attacker.example/asset?signature=secret-token",
      }),
    );

    assert.strictEqual(error._tag, "BitbucketUntrustedUrlError");
    assert.strictEqual(
      error._tag === "BitbucketUntrustedUrlError" ? error.host : "",
      "https://attacker.example",
    );
    assert.notInclude(error.message, "secret-token");
  }).pipe(Effect.provide(makeLayer({ response: () => new Response("{}", { status: 200 }) }).layer)),
);

it.effect("does not follow a redirect off the configured Bitbucket", () =>
  Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;

    const error = yield* Effect.flip(
      bitbucket.request({ method: "GET", url: "/repositories/acme/web/pullrequests/1/diff" }),
    );

    assert.strictEqual(error._tag, "BitbucketUntrustedUrlError");
  }).pipe(
    Effect.provide(
      makeLayer({
        response: () =>
          new Response(null, {
            status: 302,
            headers: { location: "https://attacker.example/stolen" },
          }),
      }).layer,
    ),
  ),
);

it.effect("follows a redirect that stays on the configured Bitbucket", () =>
  Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;

    const result = yield* bitbucket.request({
      method: "GET",
      url: "/repositories/acme/web/pullrequests/1/diff",
    });

    assert.strictEqual(result.body, "diff --git a/a.ts b/a.ts");
    assert.isFalse(result.truncated);
  }).pipe(
    Effect.provide(
      makeLayer({
        response: (request) =>
          request.url.endsWith("/pullrequests/1/diff")
            ? new Response(null, {
                status: 302,
                headers: { location: "https://api.test.local/2.0/repositories/acme/web/diff/abc" },
              })
            : new Response("diff --git a/a.ts b/a.ts", { status: 200 }),
      }).layer,
    ),
  ),
);

it.effect("cuts a response short rather than reading an unbounded diff into memory", () =>
  Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;

    const result = yield* bitbucket.request({
      method: "GET",
      url: "/repositories/acme/web/pullrequests/1/diff",
      maxBytes: 8,
    });

    assert.strictEqual(result.body, "12345678");
    assert.isTrue(result.truncated);
  }).pipe(
    Effect.provide(
      makeLayer({ response: () => new Response("1234567890", { status: 200 }) }).layer,
    ),
  ),
);

it.effect("pauses background reads after a 429 until Bitbucket's retry-after passes", () => {
  let answered = 0;
  const { execute, layer } = makeLayer({
    response: () => {
      answered += 1;
      return answered === 1
        ? new Response("Rate limit exceeded", { status: 429, headers: { "retry-after": "60" } })
        : Response.json({ values: [] });
    },
  });

  return Effect.gen(function* () {
    const bitbucket = yield* BitbucketApi.BitbucketApi;
    const lookup = bitbucket.listPullRequests({
      cwd: "/repo",
      headSelector: "feature/a",
      state: "all",
    });

    yield* Effect.flip(lookup);
    const paused = yield* Effect.flip(lookup);
    // Keyed by the repository host, where PullRequestService records its own backoff.
    assert.deepInclude(paused, {
      _tag: "SourceControlRateLimitPausedError",
      host: "bitbucket.org",
      retryAt: 60_000,
    });
    assert.strictEqual(execute.mock.calls.length, 1);

    // A user waiting on an answer is not held back by the background pause, and their success
    // does not end it early.
    yield* lookup.pipe(Effect.provideService(SourceControlRateLimit.Interactive, true));
    yield* bitbucket.request({
      method: "POST",
      url: "/repositories/acme/web/pullrequests/1/approve",
    });

    yield* TestClock.adjust("59 seconds");
    assert.strictEqual((yield* Effect.flip(lookup))._tag, "SourceControlRateLimitPausedError");

    yield* TestClock.adjust("1 second");
    yield* lookup;
  }).pipe(Effect.provide(layer));
});

it.effect("keeps a sweep over many branches to a few Bitbucket requests at a time", () =>
  Effect.gen(function* () {
    const started = yield* Queue.unbounded<void>();
    const release = yield* Deferred.make<void>();
    let inFlight = 0;
    let peak = 0;
    const { layer } = makeLayer({
      response: () => Response.json({ values: [] }),
      answer: (response) =>
        Effect.gen(function* () {
          inFlight += 1;
          peak = Math.max(peak, inFlight);
          yield* Queue.offer(started, undefined);
          yield* Deferred.await(release);
          inFlight -= 1;
          return response;
        }),
    });

    yield* Effect.gen(function* () {
      const bitbucket = yield* BitbucketApi.BitbucketApi;
      const sweep = yield* Effect.forEach(
        Array.from({ length: 12 }, (_, index) => `feature/${index}`),
        (branch) =>
          bitbucket.listPullRequests({ cwd: "/repo", headSelector: branch, state: "all" }),
        { concurrency: "unbounded", discard: true },
      ).pipe(Effect.forkChild);
      for (let index = 0; index < 4; index += 1) yield* Queue.take(started);
      yield* Deferred.succeed(release, undefined);
      yield* Fiber.join(sweep);
    }).pipe(Effect.provide(layer));

    assert.strictEqual(peak, 4);
  }),
);