sailfork / t3code-github / packages/ source-control-gitcafe/ src/ server/ GitCafeCredentials.test.ts

import { assert, describe, it } from "@effect/vitest";
import { SecretProviderId } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import * as HostProcess from "@t3tools/shared/HostProcess";
import type * as SourceControlHost from "@t3tools/source-control-core/server/SourceControlHost";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";

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

const processOutput = TestSourceControlHost.processOutput;

function harness(
  run: SourceControlHost.SourceControlHost["Service"]["process"]["run"],
  env: NodeJS.ProcessEnv = {},
) {
  const calls: Array<SourceControlHost.SourceControlProcessInput> = [];
  const layer = GitCafeCredentials.layer.pipe(
    Layer.provide(
      TestSourceControlHost.layer({
        process: {
          run: (input) => {
            calls.push(input);
            return run(input);
          },
        },
      }),
    ),
    Layer.provide(Layer.succeed(HostProcess.Environment, env)),
    Layer.provide(Layer.succeed(HostProcess.WorkingDirectory, "/server")),
  );
  return { layer, calls };
}

describe("GitCafeCredentials", () => {
  it("hands CAFE_TOKEN only to the host cafe itself targets", () => {
    const token = { CAFE_TOKEN: "env-token" };
    assert.strictEqual(GitCafeCredentials.environmentToken("git.cafe", token), "env-token");
    assert.isNull(GitCafeCredentials.environmentToken("staging.git.cafe", token));
    for (const CAFE_HOST of ["https://staging.git.cafe/api", "staging.git.cafe"]) {
      const staging = { ...token, CAFE_HOST };
      assert.strictEqual(
        GitCafeCredentials.environmentToken("staging.git.cafe", staging),
        "env-token",
      );
      assert.isNull(GitCafeCredentials.environmentToken("git.cafe", staging));
    }
    assert.isNull(GitCafeCredentials.environmentToken("git.cafe", { CAFE_TOKEN: " " }));
  });

  it.effect("prefers CAFE_TOKEN without running cafe", () => {
    const { layer, calls } = harness(() => Effect.die("cafe must not run"), {
      CAFE_TOKEN: "env-token",
    });
    return Effect.gen(function* () {
      const credentials = yield* GitCafeCredentials.GitCafeCredentials;
      const credential = yield* credentials.get("git.cafe");
      assert.strictEqual(Redacted.value(credential.token), "env-token");
      assert.strictEqual(credential.source, "env");
      assert.deepStrictEqual(calls, []);
    }).pipe(Effect.provide(layer));
  });

  it.effect("uses a token saved in Settings for git.cafe only, ahead of CAFE_TOKEN", () => {
    const calls: Array<SourceControlHost.SourceControlProcessInput> = [];
    const layer = GitCafeCredentials.layer.pipe(
      Layer.provideMerge(
        TestSourceControlHost.layer({
          process: {
            run: (input) => {
              calls.push(input);
              return Effect.succeed(processOutput("password=gct_staging\n"));
            },
          },
        }),
      ),
      Layer.provide(Layer.succeed(HostProcess.Environment, { CAFE_TOKEN: "env-token" })),
      Layer.provide(Layer.succeed(HostProcess.WorkingDirectory, "/server")),
    );
    return Effect.gen(function* () {
      const credentials = yield* GitCafeCredentials.GitCafeCredentials;
      const settings = yield* TestSourceControlHost.TestSourceControlHostSettings;
      yield* settings.update({ sourceControlHosts: { gitcafe: { token: "saved-token" } } });

      const saved = yield* credentials.get("git.cafe");
      assert.strictEqual(Redacted.value(saved.token), "saved-token");
      assert.strictEqual(saved.source, "settings");
      assert.deepStrictEqual(yield* credentials.cliEnv("git.cafe"), { CAFE_TOKEN: "saved-token" });
      assert.deepStrictEqual(yield* credentials.cliEnv("staging.git.cafe"), {});
      assert.strictEqual(
        Redacted.value((yield* credentials.get("staging.git.cafe")).token),
        "gct_staging",
      );

      yield* settings.update({ sourceControlHosts: { gitcafe: { token: "" } } });
      assert.strictEqual((yield* credentials.get("git.cafe")).source, "env");

      // A reference left in place by getWithSecrets is one its secret provider could not read,
      // here one naming a removed provider whose id is also an Object.prototype key.
      yield* settings.update({
        sourceControlHosts: {
          gitcafe: {
            token: { provider: SecretProviderId.make("constructor"), reference: "cafe#token" },
          },
        },
      });
      const error = yield* Effect.flip(credentials.get("git.cafe"));
      assert.strictEqual(error._tag, "SettingsSecretUnresolvedError");
      assert.include(error.message, '"constructor"');
      assert.strictEqual(
        (yield* Effect.flip(credentials.cliEnv("git.cafe")))._tag,
        "SettingsSecretUnresolvedError",
      );
      assert.strictEqual(calls.length, 1);
    }).pipe(Effect.provide(layer));
  });

  it.effect("asks cafe's Git credential helper over stdin and reuses the token", () => {
    const { layer, calls } = harness(() =>
      Effect.succeed(
        processOutput("protocol=https\nhost=staging.git.cafe\nusername=alice\npassword=gct_1\n"),
      ),
    );
    return Effect.gen(function* () {
      const credentials = yield* GitCafeCredentials.GitCafeCredentials;
      const credential = yield* credentials.get("Staging.Git.Cafe");
      assert.strictEqual(Redacted.value(credential.token), "gct_1");
      assert.strictEqual(credential.source, "cafe");
      yield* credentials.get("staging.git.cafe");
      assert.strictEqual(calls.length, 1);
      assert.strictEqual(calls[0]?.command, "cafe");
      assert.deepStrictEqual(calls[0]?.args, [
        "auth",
        "http",
        "credential",
        "--host",
        "https://staging.git.cafe/api",
        "get",
      ]);
      assert.strictEqual(calls[0]?.stdin, "protocol=https\nhost=staging.git.cafe\n\n");
      yield* credentials.invalidate("staging.git.cafe");
      yield* credentials.get("staging.git.cafe");
      assert.strictEqual(calls.length, 2);
    }).pipe(Effect.provide(layer));
  });
});