import { SourceControlProviderKind } from "@t3tools/contracts";
import { assert, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
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 Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PlatformError from "effect/PlatformError";
import * as PubSub from "effect/PubSub";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as TestClock from "effect/testing/TestClock";
import {
DEFAULT_SERVER_SETTINGS,
VcsProcessSpawnError,
VcsProcessTimeoutError,
} from "@t3tools/contracts";
import type {
SourceControlCliDiscoverySpec,
SourceControlManagedCliDiscoverySpec,
SourceControlProviderDiscoverySpec,
} from "@t3tools/source-control-core/server/discovery";
import type * as SourceControlHost from "@t3tools/source-control-core/server/SourceControlHost";
import { fakeSourceControlProvider } from "@t3tools/source-control-testing/fakeSourceControlDriver";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
import * as ServerSettings from "../serverSettings.ts";
import * as ServerConfig from "../config.ts";
import type * as VcsDriver from "../vcs/VcsDriver.ts";
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
const kind = SourceControlProviderKind.make;
class NotAnswered extends Schema.TaggedError<NotAnswered>()("NotAnswered", {}) {}
const linkSubject = (host: string) => () =>
Effect.succeed({ title: `${host} subject`, body: null });
/** Only GitHub and GitLab read linked subjects, as in production. */
const PROVIDERS = [
fakeSourceControlProvider("github", { resolveLink: linkSubject("github") }),
fakeSourceControlProvider("gitlab", { resolveLink: linkSubject("gitlab") }),
fakeSourceControlProvider("forgejo"),
fakeSourceControlProvider("bitbucket"),
fakeSourceControlProvider("azure-devops"),
];
/** A host CLI that claims every server it is signed in to, as `glab` does. */
const claimingCli = (claims: string): SourceControlCliDiscoverySpec => ({
type: "cli",
kind: kind(claims),
label: claims,
installHint: `Install ${claims}.`,
executable: `${claims}-cli`,
versionArgs: ["--version"],
authArgs: ["auth", "status"],
remoteRefinementArgs: ({ provider }) => ["auth", "status", "--hostname", provider.name],
parseAuth: () => ({
status: "unknown",
account: Option.none(),
host: Option.none(),
detail: Option.none(),
}),
refineUnknownRemote: ({ context, auth }) =>
auth.stdout.includes(`Logged in to ${context.provider.name}`)
? { kind: kind(claims), name: `${claims} Self-Hosted`, baseUrl: context.provider.baseUrl }
: null,
});
const managedCli = (
claims: string,
refine: SourceControlManagedCliDiscoverySpec["refineUnknownRemote"],
): SourceControlManagedCliDiscoverySpec => ({
type: "managed-cli",
kind: kind(claims),
label: claims,
installHint: `Install ${claims}.`,
probe: () => Effect.die("unused"),
refineUnknownRemote: refine,
});
function makeRegistry(input: {
readonly remotes: ReadonlyArray<{
readonly name: string;
readonly url: string;
}>;
readonly discovery?: ReadonlyArray<SourceControlProviderDiscoverySpec>;
readonly run?: SourceControlHost.SourceControlHost["Service"]["process"]["run"];
readonly settings?: Partial<ServerSettings.ServerSettingsService["Service"]>;
}) {
const driver = {
listRemotes: () =>
Effect.succeed({
remotes: input.remotes.map((remote) => ({
...remote,
pushUrl: Option.none(),
isPrimary: remote.name === "origin",
})),
freshness: {
source: "live-local" as const,
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
}),
} satisfies Partial<VcsDriver.VcsDriver["Service"]>;
const discovery = input.discovery ?? [claimingCli("gitlab")];
return SourceControlProviderRegistry.makeWithProviders(
PROVIDERS.map((provider) => ({
kind: provider.kind,
provider,
discovery: discovery.find((spec) => spec.kind === provider.kind) ?? {
type: "api",
kind: provider.kind,
label: provider.kind,
installHint: "unused",
probeAuth: Effect.succeed({
status: "unknown",
account: Option.none(),
host: Option.none(),
detail: Option.none(),
}),
},
})),
).pipe(
Effect.provide(
Layer.mergeAll(
Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
resolve: () =>
Effect.succeed({
kind: "git",
repository: {
kind: "git",
rootPath: "/repo",
metadataPath: null,
freshness: {
source: "live-local" as const,
observedAt: TEST_EPOCH,
expiresAt: Option.none(),
},
},
driver: driver as unknown as VcsDriver.VcsDriver["Service"],
}),
}),
TestSourceControlHost.layer({
process: {
run: input.run ?? (() => Effect.succeed(TestSourceControlHost.processOutput(""))),
},
}),
input.settings
? Layer.mock(ServerSettings.ServerSettingsService)(input.settings)
: ServerSettings.ServerSettingsService.layerTest(),
ServerConfig.layerTest(process.cwd(), {
prefix: "t3-source-control-registry-test-",
}).pipe(Layer.provide(NodeServices.layer)),
),
),
);
}
const signedIn = (host: string) => () =>
Effect.succeed(TestSourceControlHost.processOutput(` ✓ Logged in to ${host} as user\n`));
it.effect("routes an unknown remote to the integration that claims its server", () =>
Effect.gen(function* () {
const asked: Array<string> = [];
const registry = yield* makeRegistry({
remotes: [{ name: "origin", url: "git@self-hosted.example.test:group/project.git" }],
run: (input) => {
asked.push([input.command, ...input.args].join(" "));
return signedIn("self-hosted.example.test")();
},
});
const handle = yield* registry.resolveHandle({ cwd: "/repo" });
assert.strictEqual(handle.provider.kind, "gitlab");
assert.deepStrictEqual(handle.context?.provider, {
kind: kind("gitlab"),
name: "gitlab Self-Hosted",
baseUrl: "https://self-hosted.example.test",
});
assert.deepStrictEqual(asked, ["gitlab-cli auth status --hostname self-hosted.example.test"]);
}),
);
it.effect("leaves a remote no integration claims unknown, with its server's address", () =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
remotes: [{ name: "origin", url: "git@code.example.test:team/project.git" }],
});
const handle = yield* registry.resolveHandle({ cwd: "/repo" });
assert.strictEqual(handle.provider.kind, kind("unknown"));
assert.strictEqual(handle.context?.provider.baseUrl, "https://code.example.test");
}),
);
it.effect.each([
["github.com:team/project.git", "github"],
["gitlab.com:team/project.git", "gitlab"],
["bitbucket.org:team/project.git", "bitbucket"],
["code.example.test:team/project.git", "unknown"],
] as const)(
"reads the host of an SSH remote that leaves its user to ssh config: %s",
([url, expected]) =>
Effect.gen(function* () {
const registry = yield* makeRegistry({ remotes: [{ name: "origin", url }] });
const handle = yield* registry.resolveHandle({ cwd: "/repo" });
assert.strictEqual(handle.provider.kind, kind(expected));
assert.strictEqual(handle.context?.remoteUrl, url);
}),
);
it.effect("refines the caller-selected remote instead of choosing another configured remote", () =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
remotes: [{ name: "origin", url: "git@github.com:fork/project.git" }],
run: signedIn("self-hosted.example.test"),
});
const handle = yield* registry.resolveHandle({
cwd: "/repo",
context: {
provider: {
kind: kind("unknown"),
name: "self-hosted.example.test",
baseUrl: "https://self-hosted.example.test",
},
remoteName: "upstream",
remoteUrl: "https://self-hosted.example.test/group/project.git",
},
});
assert.strictEqual(handle.context?.provider.kind, "gitlab");
assert.strictEqual(handle.context?.remoteName, "upstream");
}),
);
it.effect("falls back to a non-origin remote when origin is not configured", () =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
remotes: [{ name: "upstream", url: "https://dev.azure.com/acme/project/_git/repo" }],
});
const provider = yield* registry.resolve({ cwd: "/repo" });
assert.strictEqual(provider.kind, "azure-devops");
}),
);
it.effect(
"routes linked subjects to the host that serves them, independently of the checkout",
() =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
remotes: [{ name: "origin", url: "https://github.com/unrelated/checkout.git" }],
});
for (const [url, host] of [
["https://github.com/team/project/issues/1", "github"],
["https://gitlab.com/team/sub/project/-/merge_requests/2", "gitlab"],
] as const) {
const lookup = registry.resolveLink({ cwd: "/unrelated", url: new URL(url) });
assert.ok(lookup);
assert.deepStrictEqual(yield* lookup, { title: `${host} subject`, body: null });
}
for (const url of [
"https://example.test/team/project/issues/1",
"https://codeberg.org/team/project/issues/1",
"https://bitbucket.org/team/project/pull-requests/1",
"https://dev.azure.com/org/project/_git/repo/pullrequest/1",
"http://github.com/team/project/issues/1",
"https://user:secret@github.com/team/project/issues/1",
]) {
assert.strictEqual(
registry.resolveLink({ cwd: "/unrelated", url: new URL(url) }),
undefined,
url,
);
}
}).pipe(Effect.scoped),
);
it.effect("does not refine a context whose server address is empty", () =>
Effect.gen(function* () {
let asked = 0;
const remoteUrl = "git@githubenterprise.dev.example.com:team/workspace.git";
const registry = yield* makeRegistry({
remotes: [{ name: "origin", url: remoteUrl }],
discovery: [
managedCli("github", ({ context }) => {
asked += 1;
return Effect.succeed(
context.provider.baseUrl === ""
? null
: { kind: kind("github"), name: "GitHub", baseUrl: context.provider.baseUrl },
);
}),
],
});
const context = {
provider: { kind: kind("unknown"), name: "Unknown", baseUrl: "" },
remoteName: "origin",
remoteUrl,
};
assert.deepStrictEqual(
(yield* registry.resolveHandle({ cwd: "/repo", context })).context,
context,
);
const resolved = yield* registry.resolveHandle({ cwd: "/repo" });
assert.strictEqual(resolved.provider.kind, "github");
assert.strictEqual(
resolved.context?.provider.baseUrl,
"https://githubenterprise.dev.example.com",
);
assert.strictEqual(asked, 2);
}),
);
const notFound = (command: string, cwd: string) =>
new VcsProcessSpawnError({
operation: "test",
command,
cwd,
cause: PlatformError.systemError({ _tag: "NotFound", module: "ChildProcess", method: "spawn" }),
});
const resolveUnknown = (
registry: SourceControlProviderRegistry.SourceControlProviderRegistry["Service"],
repository: string,
) =>
registry.resolveHandle({
cwd: `/${repository}`,
context: {
provider: {
kind: kind("unknown"),
name: "git.example.internal",
baseUrl: "https://git.example.internal",
},
remoteName: "origin",
remoteUrl: `git@Git.Example.Internal:team/${repository}.git`,
},
});
it.effect("asks once for every checkout of a server no integration claims", () =>
Effect.gen(function* () {
const asked: Array<string> = [];
const release = yield* Deferred.make<void>();
const registry = yield* makeRegistry({
remotes: [],
discovery: [
claimingCli("gitlab"),
managedCli("github", ({ context }) => {
asked.push(`managed ${context.provider.name}`);
return Effect.succeed(null);
}),
],
run: ({ command, args, cwd }) => {
asked.push([command, ...args].join(" "));
return Deferred.await(release).pipe(Effect.andThen(Effect.fail(notFound(command, cwd))));
},
});
const started = yield* Effect.forEach(["a", "b", "c"], () => Deferred.make<void>());
const callers = yield* Effect.forEach(
["a", "b", "c"],
(repository, index) =>
Deferred.succeed(started[index]!, undefined).pipe(
Effect.andThen(resolveUnknown(registry, repository)),
),
{ concurrency: "unbounded" },
).pipe(Effect.forkChild);
yield* Effect.forEach(started, Deferred.await);
yield* Deferred.succeed(release, undefined);
const handles = yield* Fiber.join(callers);
yield* resolveUnknown(registry, "d");
assert.deepStrictEqual(
handles.map((handle) => handle.provider.kind),
["unknown", "unknown", "unknown"],
);
const once = asked.slice();
assert.sameMembers(once, [
"managed git.example.internal",
"gitlab-cli auth status --hostname git.example.internal",
]);
yield* TestClock.adjust("5 minutes");
yield* resolveUnknown(registry, "a");
assert.deepStrictEqual(asked, [...once, ...once]);
}),
);
it.effect("asks again after a check that could not answer", () =>
Effect.gen(function* () {
let asks = 0;
let managedAsks = 0;
const registry = yield* makeRegistry({
remotes: [],
discovery: [
claimingCli("gitlab"),
managedCli("github", () => {
managedAsks += 1;
return Effect.fail(new NotAnswered());
}),
],
run: ({ command, cwd }) => {
asks += 1;
return Effect.fail(
new VcsProcessTimeoutError({ operation: "test", command, cwd, timeoutMs: 1 }),
);
},
});
yield* resolveUnknown(registry, "a");
yield* resolveUnknown(registry, "b");
assert.strictEqual(asks, 2);
assert.strictEqual(managedAsks, 2);
}),
);
it.effect("asks again once Settings change", () =>
Effect.gen(function* () {
const changes = yield* PubSub.unbounded<typeof DEFAULT_SERVER_SETTINGS>();
const handled = yield* Deferred.make<void>();
let claims = false;
const registry = yield* makeRegistry({
remotes: [],
settings: {
subscribeChanges: PubSub.subscribe(changes).pipe(
Effect.map((subscription) =>
Stream.fromSubscription(subscription).pipe(
Stream.flatMap((settings) =>
Stream.concat(
Stream.make(settings),
Stream.fromEffectDrain(Deferred.succeed(handled, undefined)),
),
),
),
),
),
},
discovery: [
managedCli("github", ({ context }) =>
Effect.succeed(
claims
? { kind: kind("github"), name: "GitHub", baseUrl: context.provider.baseUrl }
: null,
),
),
],
});
assert.strictEqual((yield* resolveUnknown(registry, "a")).provider.kind, "unknown");
claims = true;
assert.strictEqual((yield* resolveUnknown(registry, "b")).provider.kind, "unknown");
yield* PubSub.publish(changes, DEFAULT_SERVER_SETTINGS);
yield* Deferred.await(handled);
assert.strictEqual((yield* resolveUnknown(registry, "c")).provider.kind, "github");
}),
);
it.effect("answers discovery without waiting on a hosting API that stalls", () =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
remotes: [],
discovery: [
claimingCli("gitlab"),
{
type: "api",
kind: kind("bitbucket"),
label: "Bitbucket",
installHint: "unused",
probeAuth: Effect.never,
},
],
});
const discovering = yield* registry.discover.pipe(Effect.forkChild);
yield* TestClock.adjust("3 seconds");
const items = yield* Fiber.join(discovering);
const bitbucket = items.find((item) => item.kind === "bitbucket");
assert.strictEqual(bitbucket?.status, "available");
assert.strictEqual(bitbucket?.auth.status, "unknown");
assert.strictEqual(items.find((item) => item.kind === "gitlab")?.status, "available");
}),
);