using Forge.Git; using Forge.Tests.Support; using Microsoft.Extensions.Options; namespace Forge.Tests; /// /// A real repository in a temp directory with the awkward cases in it: a branch with a slash, /// annotated and lightweight tags, a binary file, a file with a space in its name, and a rename. /// public sealed class GitRepoFixture : IAsyncLifetime { private readonly TempDir _temp = new(); public GitCli Cli { get; private set; } = null!; public GitRepo Repo { get; private set; } = null!; public RefResolver Resolver { get; private set; } = null!; public string DataPath { get; private set; } = ""; /// The .git directory of the working repository; the git layer only needs a git dir. public string RepoPath { get; private set; } = ""; public string FirstSha { get; private set; } = ""; public string SecondSha { get; private set; } = ""; public string FeatureSha { get; private set; } = ""; public async Task InitializeAsync() { DataPath = _temp.Sub("data"); var options = Options.Create(new ForgeOptions { DataPath = DataPath, GitPath = TestGit.Executable }); Cli = new GitCli(options); Repo = new GitRepo(Cli); Resolver = new RefResolver(Repo); var git = new TestGit(_temp.Sub("home")); var work = _temp.Sub("work"); await git.MustAsync(work, "init", "--initial-branch=main", "."); Directory.CreateDirectory(Path.Combine(work, "src")); await File.WriteAllTextAsync(Path.Combine(work, "README.md"), "# Fixture\n"); await File.WriteAllTextAsync(Path.Combine(work, "src", "a.cs"), "line one\nline two\nline three\n"); await File.WriteAllTextAsync(Path.Combine(work, "file with space.txt"), "spaced\n"); await File.WriteAllTextAsync(Path.Combine(work, "old.txt"), "this file will be renamed\nwithout changes\n"); await File.WriteAllBytesAsync(Path.Combine(work, "binary.bin"), [1, 2, 0, 3, 4, 0, 255]); await git.MustAsync(work, "add", "-A"); await git.MustAsync(work, "commit", "-m", "First commit", "-m", "With a body.\nOn two lines."); FirstSha = await git.MustAsync(work, "rev-parse", "HEAD"); await File.WriteAllTextAsync(Path.Combine(work, "src", "a.cs"), "line one\nline 2\nline three\nline four\n"); await git.MustAsync(work, "mv", "old.txt", "new.txt"); await git.MustAsync(work, "add", "-A"); await git.MustAsync(work, "commit", "-m", "Second commit"); SecondSha = await git.MustAsync(work, "rev-parse", "HEAD"); await git.MustAsync(work, "tag", "-a", "v1.0", "-m", "Release 1.0"); await git.MustAsync(work, "tag", "light"); await git.MustAsync(work, "checkout", "-b", "feature/x"); await File.WriteAllTextAsync(Path.Combine(work, "src", "feature.txt"), "feature\n"); await git.MustAsync(work, "add", "-A"); await git.MustAsync(work, "commit", "-m", "Feature commit"); FeatureSha = await git.MustAsync(work, "rev-parse", "HEAD"); await git.MustAsync(work, "checkout", "main"); RepoPath = Path.Combine(work, ".git"); } public Task DisposeAsync() { _temp.Dispose(); return Task.CompletedTask; } } public class GitLayerTests(GitRepoFixture fx) : IClassFixture { [Fact] public async Task Version_is_reported() { var version = await fx.Cli.GetVersionAsync(); Assert.True(version >= ForgeApp.MinimumGitVersion, $"git {version} is older than {ForgeApp.MinimumGitVersion}"); } [Fact] public async Task Missing_git_gives_a_clear_error() { var cli = new GitCli(Options.Create(new ForgeOptions { DataPath = fx.DataPath, GitPath = "git-that-does-not-exist" })); var ex = await Assert.ThrowsAsync(() => cli.GetVersionAsync()); Assert.Contains("git-that-does-not-exist", ex.Message); } [Fact] public async Task Refs_list_branches_and_tags() { var refs = await fx.Repo.ListRefsAsync(fx.RepoPath); var main = Assert.Single(refs, r => r is { Kind: RefKind.Branch, Name: "main" }); Assert.Equal(fx.SecondSha, main.Sha); Assert.Equal("Second commit", main.Subject); Assert.NotNull(main.Date); var feature = Assert.Single(refs, r => r is { Kind: RefKind.Branch, Name: "feature/x" }); Assert.Equal(fx.FeatureSha, feature.TargetSha); var annotated = Assert.Single(refs, r => r is { Kind: RefKind.Tag, Name: "v1.0" }); Assert.Equal("tag", annotated.ObjectType); Assert.NotEqual(fx.SecondSha, annotated.Sha); Assert.Equal(fx.SecondSha, annotated.TargetSha); Assert.Equal("Release 1.0", annotated.Subject); var light = Assert.Single(refs, r => r is { Kind: RefKind.Tag, Name: "light" }); Assert.Equal(fx.SecondSha, light.Sha); Assert.Null(light.PeeledSha); } [Fact] public async Task Tree_lists_root_and_subdirectory() { var rootSha = await fx.Repo.GetRootTreeShaAsync(fx.RepoPath, fx.SecondSha); Assert.NotNull(rootSha); var root = await fx.Repo.ListTreeAsync(fx.RepoPath, rootSha); Assert.Equal( ["README.md", "binary.bin", "file with space.txt", "new.txt", "src"], root.Select(e => e.Name).Order(StringComparer.Ordinal)); Assert.True(root.Single(e => e.Name == "src").IsTree); Assert.Equal(7, root.Single(e => e.Name == "binary.bin").Size); var src = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src"); Assert.True(src is { IsTree: true }); var children = await fx.Repo.ListTreeAsync(fx.RepoPath, src.Sha); Assert.Equal("a.cs", Assert.Single(children).Name); } [Fact] public async Task Entry_lookup_handles_spaces_and_missing_paths() { var spaced = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "file with space.txt"); Assert.True(spaced is { IsBlob: true, Name: "file with space.txt" }); var nested = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src/a.cs"); Assert.Equal("a.cs", nested?.Name); Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "nope.txt")); // Pathspec magic and option-like paths are plain (missing) file names. Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, ":(glob)**")); Assert.Null(await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "--name-only")); } [Fact] public async Task Blob_is_read_with_size_and_cap() { var entry = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "src/a.cs"); Assert.NotNull(entry); Assert.Equal(entry.Size, await fx.Repo.GetBlobSizeAsync(fx.RepoPath, entry.Sha)); var blob = await fx.Repo.ReadBlobAsync(fx.RepoPath, entry.Sha, 1024); Assert.False(blob.Truncated); Assert.False(blob.IsBinary); Assert.Equal("line one\nline 2\nline three\nline four\n", blob.Text); var capped = await fx.Repo.ReadBlobAsync(fx.RepoPath, entry.Sha, 8); Assert.True(capped.Truncated); Assert.Equal("line one", capped.Text); var binary = await fx.Repo.GetEntryAsync(fx.RepoPath, fx.SecondSha, "binary.bin"); Assert.True((await fx.Repo.ReadBlobAsync(fx.RepoPath, binary!.Sha, 1024)).IsBinary); } [Fact] public async Task Log_pages_and_filters_by_path() { var all = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha); Assert.Equal([fx.SecondSha, fx.FirstSha], all.Select(c => c.Sha)); Assert.Equal("First commit", all[1].Subject); Assert.Equal("With a body.\nOn two lines.", all[1].Body); Assert.Equal("Test Author", all[1].AuthorName); Assert.Equal("author@example.com", all[1].AuthorEmail); Assert.Equal([fx.FirstSha], all[0].Parents); var second = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha, skip: 1, take: 1); Assert.Equal(fx.FirstSha, Assert.Single(second).Sha); var readme = await fx.Repo.LogAsync(fx.RepoPath, fx.SecondSha, "README.md"); Assert.Equal(fx.FirstSha, Assert.Single(readme).Sha); var range = await fx.Repo.LogRangeAsync(fx.RepoPath, fx.FirstSha, fx.FeatureSha, 20); Assert.Equal([fx.FeatureSha, fx.SecondSha], range.Select(c => c.Sha)); } [Fact] public async Task Commit_diff_has_stats_hunks_and_renames() { var commit = await fx.Repo.GetCommitAsync(fx.RepoPath, fx.SecondSha); Assert.Equal("Second commit", commit?.Subject); var diff = await fx.Repo.GetDiffAsync(fx.RepoPath, fx.SecondSha); var stat = Assert.Single(diff.Stats, s => s.Path == "src/a.cs"); Assert.Equal((2, 1), (stat.Added, stat.Deleted)); var renameStat = Assert.Single(diff.Stats, s => s.Path == "new.txt"); Assert.Equal("old.txt", renameStat.OldPath); var modified = Assert.Single(diff.Patch.Files, f => f.NewPath == "src/a.cs"); Assert.Equal(FileChange.Modified, modified.Change); var lines = modified.Hunks.SelectMany(h => h.Lines).ToList(); Assert.Contains(new DiffLine(DiffLineKind.Deleted, 2, null, "line two"), lines); Assert.Contains(new DiffLine(DiffLineKind.Added, null, 2, "line 2"), lines); Assert.Contains(new DiffLine(DiffLineKind.Added, null, 4, "line four"), lines); var renamed = Assert.Single(diff.Patch.Files, f => f.Change == FileChange.Renamed); Assert.Equal(("old.txt", "new.txt"), (renamed.OldPath, renamed.NewPath)); } [Fact] public async Task Root_commit_diff_marks_binary_files_and_reads_names_with_spaces() { var diff = await fx.Repo.GetDiffAsync(fx.RepoPath, fx.FirstSha); Assert.True(Assert.Single(diff.Stats, s => s.Path == "binary.bin").IsBinary); var binary = Assert.Single(diff.Patch.Files, f => f.NewPath == "binary.bin"); Assert.True(binary.IsBinary); Assert.Equal(FileChange.Added, binary.Change); var spaced = Assert.Single(diff.Patch.Files, f => f.NewPath == "file with space.txt"); Assert.Equal(FileChange.Added, spaced.Change); Assert.Equal(1, spaced.Added); } [Fact] public async Task Ahead_behind_counts_both_sides() { Assert.Equal((1, 0), await fx.Repo.AheadBehindAsync(fx.RepoPath, fx.SecondSha, fx.FeatureSha)); Assert.Equal((0, 2), await fx.Repo.AheadBehindAsync(fx.RepoPath, fx.FeatureSha, fx.FirstSha)); } [Fact] public async Task Resolver_handles_slashes_tags_shas_and_hostile_input() { var branch = await fx.Resolver.ResolveAsync(fx.RepoPath, "feature/x/src/feature.txt"); Assert.Equal(new ResolvedRef("feature/x", ResolvedKind.Branch, fx.FeatureSha, "src/feature.txt"), branch); var tag = await fx.Resolver.ResolveAsync(fx.RepoPath, "v1.0/src"); Assert.Equal(new ResolvedRef("v1.0", ResolvedKind.Tag, fx.SecondSha, "src"), tag); var sha = await fx.Resolver.ResolveAsync(fx.RepoPath, fx.FirstSha + "/README.md"); Assert.Equal(new ResolvedRef(fx.FirstSha, ResolvedKind.Commit, fx.FirstSha, "README.md"), sha); Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, new string('0', 40))); Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, "missing/README.md")); // The checklist case: a "ref" shaped like an option must resolve to nothing and run nothing. var marker = Path.Combine(fx.DataPath, "pwned"); Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, $"--upload-pack=touch {marker}")); Assert.Null(await fx.Resolver.ResolveAsync(fx.RepoPath, "--output=" + marker)); Assert.False(File.Exists(marker)); } [Fact] public async Task Commit_lookup_accepts_hex_only() { Assert.Equal(fx.SecondSha, await fx.Repo.ResolveCommitAsync(fx.RepoPath, fx.SecondSha[..10])); Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "main")); Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "--all")); Assert.Null(await fx.Repo.ResolveCommitAsync(fx.RepoPath, "HEAD~1")); } [Fact] public async Task Init_creates_a_bare_repository_on_main_with_fsck_enabled() { var path = Path.Combine(fx.DataPath, "repos", "77.git"); Directory.CreateDirectory(Path.GetDirectoryName(path)!); await fx.Repo.InitBareAsync(path); Assert.True(File.Exists(Path.Combine(path, "HEAD"))); Assert.Equal("main", await fx.Repo.GetHeadBranchAsync(path)); Assert.Empty(await fx.Repo.ListRefsAsync(path)); var config = await fx.Cli.RunAsync(path, ["config", "--get", "receive.fsckObjects"]); Assert.Equal("true", config.Text.Trim()); var bare = await fx.Cli.RunAsync(path, ["rev-parse", "--is-bare-repository"]); Assert.Equal("true", bare.Text.Trim()); } [Fact] public async Task Timeout_kills_the_process() { // cat-file --batch waits for stdin forever; a stream that never ends keeps it alive. await using var never = new NeverEndingStream(); await Assert.ThrowsAsync(() => fx.Cli.RunAsync(fx.RepoPath, ["cat-file", "--batch"], stdin: never, timeout: TimeSpan.FromMilliseconds(500))); } [Fact] public async Task Cancellation_kills_the_process() { await using var never = new NeverEndingStream(); using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(300)); await Assert.ThrowsAnyAsync(() => fx.Cli.RunAsync(fx.RepoPath, ["cat-file", "--batch"], stdin: never, ct: cts.Token)); } private sealed class NeverEndingStream : Stream { public override async ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) { await Task.Delay(Timeout.Infinite, cancellationToken); return 0; } public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) => ReadAsync(buffer.AsMemory(offset, count), cancellationToken).AsTask(); public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); public override bool CanRead => true; public override bool CanSeek => false; public override bool CanWrite => false; public override long Length => throw new NotSupportedException(); public override long Position { get => 0; set => throw new NotSupportedException(); } public override void Flush() { } public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); public override void SetLength(long value) => throw new NotSupportedException(); public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException(); } }