sailfork / t3code-github / packages/ source-control-github/ src/ server/ GitHubPullRequestProvider.credential.test.ts

import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import { HttpClient, HttpClientResponse } from "effect/http";
import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";

import * as GitHubCredentials from "./GitHubCredentials.ts";
import * as GitHubPullRequestApi from "./GitHubPullRequestApi.ts";
import * as GitHubPullRequestProvider from "./GitHubPullRequestProvider.ts";
import * as GitHubQuota from "./GitHubQuota.ts";
import * as GitHubRest from "./GitHubRest.ts";
import * as GitHubAppAccess from "./GitHubAppAccess.ts";
import * as GitHubAppSignIn from "./GitHubAppSignIn.ts";

const appSignedOut = Layer.mock(GitHubAppSignIn.GitHubAppSignIn)({
  enabled: false,
  token: () => Effect.succeedNone,
  invalidate: () => Effect.void,
});

it.effect("keeps branch deletion on the credential that passed source repository permissions", () =>
  Effect.gen(function* () {
    let activeToken = "account-a";
    const requests: Array<{ operation: string; authorization: string | undefined }> = [];
    const credentials = Layer.succeed(
      GitHubCredentials.GitHubCredentials,
      GitHubCredentials.GitHubCredentials.of({
        get: (host) =>
          Effect.sync(() => ({
            host,
            token: Redacted.make(activeToken),
            source: "gh" as const,
            fingerprint: `${host}:${activeToken}`,
          })),
        saved: () => Effect.succeedNone,
        fingerprint: (host, token) => Effect.succeed(`${host}:${token}`),
        invalidate: () => Effect.void,
      }),
    );
    const http = Layer.succeed(
      HttpClient.HttpClient,
      HttpClient.make((request) =>
        Effect.sync(() => {
          const operation = request.url.endsWith("/user")
            ? "user"
            : request.body._tag === "Uint8Array"
              ? new TextDecoder().decode(request.body.body)
              : "";
          requests.push({ operation, authorization: request.headers["authorization"] });
          let body;
          if (operation === "user") {
            body = { id: activeToken === "account-a" ? 101 : 202, login: activeToken };
          } else if (operation.includes("query PullRequestBranchToDelete")) {
            body = {
              data: {
                repository: {
                  pullRequest: {
                    state: "MERGED",
                    headRefName: "feature",
                    baseRefName: "main",
                    headRefOid: "abc123",
                    headRepository: { id: "FORK_REPO" },
                  },
                },
              },
            };
          } else if (operation.includes("query PullRequestSourceBranch")) {
            body = {
              data: {
                node: {
                  __typename: "Repository",
                  defaultBranchRef: { name: "main" },
                  ref: { target: { __typename: "Commit", oid: "abc123" } },
                },
              },
            };
          } else if (operation.includes("updateRefs(")) {
            body = { data: { updateRefs: { clientMutationId: null } } };
          } else {
            // The credential rotates the moment the permission read is answered.
            activeToken = "account-b";
            body = {
              data: {
                repository: {
                  mergeCommitAllowed: true,
                  squashMergeAllowed: true,
                  rebaseMergeAllowed: true,
                  autoMergeAllowed: true,
                  viewerPermission: "READ",
                  pullRequest: {
                    viewerCanUpdate: false,
                    viewerDidAuthor: false,
                    headRepository: { viewerPermission: "WRITE" },
                  },
                },
              },
            };
          }
          return HttpClientResponse.fromWeb(
            request,
            new Response(JSON.stringify(body), {
              headers: { "content-type": "application/json" },
            }),
          );
        }),
      ),
    );
    const provider = yield* GitHubPullRequestProvider.make.pipe(
      Effect.provide(
        GitHubPullRequestApi.layer.pipe(
          Layer.provideMerge(GitHubAppAccess.layer),
          // GraphQL reads go over `http` too, through the same credential and quota as REST.
          Layer.provide(
            GitHubRest.layer.pipe(
              Layer.provideMerge(Layer.mergeAll(credentials, http, appSignedOut)),
              Layer.provideMerge(GitHubQuota.layer),
              Layer.provideMerge(SourceControlRateLimit.layer),
            ),
          ),
          Layer.provide(TestSourceControlHost.layer()),
          Layer.provide(NodeServices.layer),
        ),
      ),
    );
    const reference = { cwd: "/a", repository: "acme/web", host: "github.com", number: 1 };
    assert.isDefined(provider.withVerifiedCredential);
    yield* provider.withVerifiedCredential!({ cwd: "/a", host: "github.com" }, () =>
      Effect.gen(function* () {
        const permissions = yield* provider.getViewerPermissions({
          ...reference,
          includeUpdateBranch: false,
        });
        assert.include(permissions.actions, "delete-branch");
        yield* provider.runAction({ ...reference, action: "delete-branch" });
      }),
    );

    assert.strictEqual(activeToken, "account-b");
    assert.strictEqual(
      requests.filter(({ operation }) => operation.includes("updateRefs(")).length,
      1,
    );
    assert.deepStrictEqual(
      requests.map(({ authorization }) => authorization),
      [
        "Bearer account-a",
        "Bearer account-a",
        "Bearer account-a",
        "Bearer account-a",
        "Bearer account-a",
      ],
    );
  }),
);