import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import { symlinksSupported } from "@t3tools/shared/testing/symlinks";
import * as SourceControlHost from "@t3tools/source-control-core/server/SourceControlHost";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
import * as GitHubChangeRequestTemplate from "./gitHubChangeRequestTemplate.ts";
const TEMPLATE_DIRECTORIES = [
".github/PULL_REQUEST_TEMPLATE",
"PULL_REQUEST_TEMPLATE",
"docs/PULL_REQUEST_TEMPLATE",
] as const;
const layerPrTemplateDetectionTest = Layer.merge(
TestSourceControlHost.layerWithRealGit(),
NodeServices.layer,
);
const runGit = (cwd: string, args: ReadonlyArray<string>) =>
Effect.gen(function* () {
const { git } = yield* SourceControlHost.SourceControlHost;
return yield* git.execute({
operation: "PrTemplateDetection.test.runGit",
cwd,
args,
});
});
const runWithTempDirectory = <A, E, R>(
test: (cwd: string) => Effect.Effect<A, E, R | FileSystem.FileSystem | Path.Path>,
) =>
Effect.scoped(
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const cwd = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-pr-template-" });
yield* runGit(cwd, ["init", "--initial-branch=main"]);
yield* runGit(cwd, ["config", "user.email", "test@example.com"]);
yield* runGit(cwd, ["config", "user.name", "Test User"]);
return yield* test(cwd);
}),
).pipe(Effect.provide(layerPrTemplateDetectionTest));
const writeTemplate = (cwd: string, relativePath: string, contents: string) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const templatePath = path.join(cwd, relativePath);
yield* fileSystem.makeDirectory(path.dirname(templatePath), { recursive: true });
yield* fileSystem.writeFileString(templatePath, contents);
return templatePath;
});
const commitTemplates = (cwd: string) =>
Effect.gen(function* () {
yield* runGit(cwd, ["add", "-A"]);
yield* runGit(cwd, ["commit", "--allow-empty", "-m", "Add pull request templates"]);
});
const detectTemplate = (cwd: string, treeish = "HEAD") =>
Effect.gen(function* () {
const { git } = yield* SourceControlHost.SourceControlHost;
return yield* GitHubChangeRequestTemplate.detect(cwd, treeish, git.execute);
});
it.effect("reads templates from the requested base tree", () =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
yield* writeTemplate(cwd, "README.md", "initial\n");
yield* commitTemplates(cwd);
yield* runGit(cwd, ["branch", "feature"]);
yield* writeTemplate(cwd, ".github/pull_request_template.md", "base template");
yield* commitTemplates(cwd);
yield* runGit(cwd, ["checkout", "feature"]);
assert.isTrue(Option.isNone(yield* detectTemplate(cwd)));
assert.strictEqual(
Option.getOrUndefined(yield* detectTemplate(cwd, "main")),
"base template",
);
}),
),
);
it.effect("uses the first non-empty template in the configured path order", () =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
yield* writeTemplate(cwd, ".github/pull_request_template.md", " \n");
yield* writeTemplate(cwd, ".github/PULL_REQUEST_TEMPLATE.md", " ## Preferred template \n");
yield* writeTemplate(cwd, "pull_request_template.md", "## Later template");
yield* commitTemplates(cwd);
const template = yield* detectTemplate(cwd);
assert.strictEqual(Option.getOrUndefined(template), "## Preferred template");
}),
),
);
it.effect.each(TEMPLATE_DIRECTORIES)("recognizes the $0 directory", (relativeDirectory) =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
yield* writeTemplate(cwd, `${relativeDirectory}/template.MD`, "directory template");
yield* commitTemplates(cwd);
const template = yield* detectTemplate(cwd);
assert.strictEqual(Option.getOrUndefined(template), "directory template");
}),
),
);
it.effect.skipIf(!symlinksSupported)(
"skips unusable directory entries and uses the one valid template",
() =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const templateDirectory = path.join(cwd, ".github", "PULL_REQUEST_TEMPLATE");
yield* fileSystem.makeDirectory(path.join(templateDirectory, "b-directory.md"), {
recursive: true,
});
yield* fileSystem.writeFileString(path.join(templateDirectory, "a-empty.md"), " \n");
yield* fileSystem.symlink(
path.join(templateDirectory, "missing.md"),
path.join(templateDirectory, "c-broken.md"),
);
yield* fileSystem.writeFileString(path.join(templateDirectory, "z-valid.md"), "valid");
yield* commitTemplates(cwd);
const template = yield* detectTemplate(cwd);
assert.strictEqual(Option.getOrUndefined(template), "valid");
}),
),
);
it.effect("does not guess between multiple directory templates", () =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
yield* writeTemplate(cwd, ".github/PULL_REQUEST_TEMPLATE/a.md", "first");
yield* writeTemplate(cwd, ".github/PULL_REQUEST_TEMPLATE/b.md", "second");
yield* writeTemplate(cwd, "PULL_REQUEST_TEMPLATE/fallback.md", "fallback");
yield* commitTemplates(cwd);
const template = yield* detectTemplate(cwd);
assert.isTrue(Option.isNone(template));
}),
),
);
it.effect.skipIf(!symlinksSupported)(
"rejects a committed template symlink escaping the repository",
() =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const outsideDirectory = yield* fileSystem.makeTempDirectoryScoped({
prefix: "t3-pr-template-outside-",
});
const outsideTemplate = path.join(outsideDirectory, "secret.md");
yield* fileSystem.writeFileString(outsideTemplate, "LOCAL_SECRET_SENTINEL");
const escapedTemplatePath = path.join(cwd, ".github", "pull_request_template.md");
yield* fileSystem.makeDirectory(path.dirname(escapedTemplatePath), { recursive: true });
yield* fileSystem.symlink(outsideTemplate, escapedTemplatePath);
yield* writeTemplate(cwd, "pull_request_template.md", "safe template");
yield* commitTemplates(cwd);
const template = yield* detectTemplate(cwd);
assert.strictEqual(Option.getOrUndefined(template), "safe template");
assert.notInclude(
Option.getOrElse(template, () => ""),
"LOCAL_SECRET_SENTINEL",
);
}),
),
);
it.effect.skipIf(!symlinksSupported)(
"reads the committed template when a worktree parent is replaced",
() =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const outsideDirectory = yield* fileSystem.makeTempDirectoryScoped({
prefix: "t3-pr-template-outside-",
});
const templatePath = yield* writeTemplate(
cwd,
".github/pull_request_template.md",
"committed template",
);
yield* commitTemplates(cwd);
yield* writeTemplate(outsideDirectory, "pull_request_template.md", "LOCAL_SECRET_SENTINEL");
const templateDirectory = path.dirname(templatePath);
yield* fileSystem.rename(templateDirectory, path.join(cwd, ".github-original"));
yield* fileSystem.symlink(outsideDirectory, templateDirectory);
const template = yield* detectTemplate(cwd);
assert.strictEqual(Option.getOrUndefined(template), "committed template");
assert.notInclude(
Option.getOrElse(template, () => ""),
"LOCAL_SECRET_SENTINEL",
);
}),
),
);
it.effect("bounds template reads and marks truncated content", () =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
const prefix = "a".repeat(8_000);
yield* writeTemplate(cwd, ".github/pull_request_template.md", `${prefix}SECRET_SENTINEL`);
yield* commitTemplates(cwd);
const template = Option.getOrThrow(yield* detectTemplate(cwd));
assert.strictEqual(template, `${prefix}\n\n[truncated]`);
assert.lengthOf(template.match(/\[truncated\]/g) ?? [], 1);
assert.notInclude(template, "SECRET_SENTINEL");
}),
),
);
it.effect.each([
".github/pull_request_template.txt",
"PULL_REQUEST_TEMPLATE.TXT",
"docs/PuLl_ReQuEsT_TeMpLaTe.Md",
".github/PULL_REQUEST_TEMPLATE/template.TxT",
])("reads committed text and mixed-case template $0 from a subdirectory", (relativePath) =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
const path = yield* Path.Path;
yield* runGit(cwd, ["config", "grep.patternType", "fixed"]);
yield* runGit(cwd, ["config", "color.grep", "always"]);
yield* writeTemplate(cwd, relativePath, "committed template");
yield* writeTemplate(cwd, "nested/README.md", "project");
for (let index = 0; index < 600; index += 1) {
yield* writeTemplate(cwd, `docs/${index}-${"a".repeat(180)}.md`, "guide");
}
yield* commitTemplates(cwd);
yield* writeTemplate(cwd, relativePath, "uncommitted template");
assert.strictEqual(
Option.getOrUndefined(yield* detectTemplate(path.join(cwd, "nested"))),
"committed template",
);
}),
),
);
it.effect("does not guess between Markdown and text directory templates", () =>
runWithTempDirectory((cwd) =>
Effect.gen(function* () {
yield* writeTemplate(cwd, ".github/PULL_REQUEST_TEMPLATE/a.md", "markdown");
yield* writeTemplate(cwd, ".github/PULL_REQUEST_TEMPLATE/b.TXT", "text");
yield* commitTemplates(cwd);
assert.isTrue(Option.isNone(yield* detectTemplate(cwd)));
}),
),
);