Skip to content

Git designed for AI agents.

20.3 KB
Raw Blame
package gitops_test

import (
	"bytes"
	"context"
	"crypto/sha256"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/feder-cr/git-ai/internal/git"
	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/git/localrepo"
	"github.com/feder-cr/git-ai/internal/git/updateref"
	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/graft/corestore"
	"github.com/feder-cr/git-ai/internal/graft/corestore/gitops"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
	"github.com/stretchr/testify/require"
)

// objectFormats are the object formats every git operation is tested with.
var objectFormats = []string{"sha1", "sha256"}

// fixture is a fresh repository together with its local helper objects.
type fixture struct {
	ctx  context.Context
	cfg  config.Cfg
	repo *localrepo.Repo
	path string
	hash git.ObjectHash
}

func newFixture(t *testing.T, format string) fixture {
	t.Helper()

	ctx := testhelper.Context(t)
	cfg := testcfg.Build(t)

	protoRepo, path := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
		ObjectFormat:           format,
		SkipCreationViaService: true,
	})

	hash, err := git.ObjectHashByFormat(format)
	require.NoError(t, err)

	return fixture{
		ctx:  ctx,
		cfg:  cfg,
		repo: localrepo.NewTestRepo(t, cfg, protoRepo),
		path: path,
		hash: hash,
	}
}

// commit writes a commit with one file of the given content and the given
// parents. The commit is not referenced. gittest.WriteCommit is not used
// because it hashes with the default object format only.
func (f fixture) commit(t *testing.T, parents []git.ObjectID, content string) git.ObjectID {
	t.Helper()

	blob := gittest.WriteBlob(t, f.cfg, f.path, []byte(content))

	mktree := gittest.NewCommand(t, f.cfg, "-C", f.path, "mktree")
	mktree.Stdin = strings.NewReader(fmt.Sprintf("100644 blob %s\tfile\n", blob))
	tree, err := mktree.Output()
	require.NoError(t, err)

	args := []string{"-C", f.path, "commit-tree", strings.TrimSpace(string(tree)), "-m", "commit " + content}
	for _, parent := range parents {
		args = append(args, "-p", parent.String())
	}

	out, err := gittest.NewCommand(t, f.cfg, args...).Output()
	require.NoError(t, err)

	return git.ObjectID(strings.TrimSpace(string(out)))
}

func (f fixture) git(t *testing.T, args ...string) string {
	t.Helper()

	return strings.TrimSpace(string(gittest.Exec(t, f.cfg, append([]string{"-C", f.path}, args...)...)))
}

func readPack(t *testing.T, p gitops.Pack) []byte {
	t.Helper()

	r, err := p.Open()
	require.NoError(t, err)
	defer func() { require.NoError(t, r.Close()) }()

	data, err := io.ReadAll(r)
	require.NoError(t, err)

	sum := sha256.Sum256(data)
	require.Equal(t, sum, p.SHA256, "pack hash must match its bytes")
	require.Equal(t, int64(len(data)), p.Size, "pack size must match its bytes")

	return data
}

func countEntries(t *testing.T, dir string) int {
	t.Helper()

	entries, err := os.ReadDir(dir)
	require.NoError(t, err)
	return len(entries)
}

func TestBuildPackOnlyNewObjects(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			f := newFixture(t, format)
			c1 := f.commit(t, nil, "old")
			gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)
			c2 := f.commit(t, []git.ObjectID{c1}, "new")

			tmpDir := t.TempDir()
			pack, err := gitops.BuildPack(f.ctx, f.repo, []git.ObjectID{c2}, tmpDir)
			require.NoError(t, err)
			require.False(t, pack.Empty())
			require.Equal(t, 3, pack.Objects, "commit, tree and blob of c2 only")
			require.Positive(t, pack.Walk, "the walk of the objects is timed")
			require.Equal(t, 1, countEntries(t, tmpDir))
			require.True(t, strings.HasPrefix(filepath.Base(pack.Path), "graft-pack-"))
			readPack(t, pack)
			require.NoError(t, pack.Remove())
			require.Equal(t, 0, countEntries(t, tmpDir))
		})
	}
}

func TestBuildPackIndexesIntoEmptyRepository(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			source := newFixture(t, format)
			c1 := source.commit(t, nil, "old")
			gittest.WriteRef(t, source.cfg, source.path, "refs/heads/main", c1)
			c2 := source.commit(t, []git.ObjectID{c1}, "new")

			tmpDir := t.TempDir()
			full, err := gitops.BuildFullPack(source.ctx, source.repo, tmpDir)
			require.NoError(t, err)
			fullData := readPack(t, full)
			require.Equal(t, 3, full.Objects)

			incremental, err := gitops.BuildPack(source.ctx, source.repo, []git.ObjectID{c2}, tmpDir)
			require.NoError(t, err)
			incrementalData := readPack(t, incremental)

			target := newFixture(t, format)
			require.NoError(t, gitops.IndexPack(target.ctx, target.repo, bytes.NewReader(fullData)))
			require.NoError(t, gitops.IndexPack(target.ctx, target.repo, bytes.NewReader(incrementalData)))

			require.NoError(t, gitops.ApplyRefs(target.ctx, target.repo, map[string]corestore.Target{
				"refs/heads/main": corestore.Target(c2.String()),
			}))

			// Both packs together make the history of c2 complete.
			gittest.Exec(t, target.cfg, "-C", target.path, "fsck", "--connectivity-only")
			require.Equal(t, c2.String(), target.git(t, "rev-parse", "refs/heads/main"))
		})
	}
}

func TestBuildPackEmpty(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			f := newFixture(t, format)
			tmpDir := t.TempDir()

			// A repository without references has nothing to pack.
			full, err := gitops.BuildFullPack(f.ctx, f.repo, tmpDir)
			require.NoError(t, err)
			require.True(t, full.Empty())
			require.NoError(t, full.Remove())

			c1 := f.commit(t, nil, "old")
			gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)

			// Every object of the tip is already reachable from a reference.
			pack, err := gitops.BuildPack(f.ctx, f.repo, []git.ObjectID{c1}, tmpDir)
			require.NoError(t, err)
			require.True(t, pack.Empty())
			require.Equal(t, 0, pack.Objects)
			require.Positive(t, pack.Walk, "an empty walk is timed too")

			pack, err = gitops.BuildPack(f.ctx, f.repo, nil, tmpDir)
			require.NoError(t, err)
			require.True(t, pack.Empty())
			require.Zero(t, pack.Walk, "without a tip there is no walk")

			pack, err = gitops.BuildPack(f.ctx, f.repo, []git.ObjectID{f.hash.ZeroOID}, tmpDir)
			require.NoError(t, err)
			require.True(t, pack.Empty())

			require.Equal(t, 0, countEntries(t, tmpDir), "an empty result writes no file")
		})
	}
}

func TestBuildPackRejectsInvalidTip(t *testing.T) {
	t.Parallel()

	f := newFixture(t, "sha1")
	tmpDir := t.TempDir()

	_, err := gitops.BuildPack(f.ctx, f.repo, []git.ObjectID{"not-an-object-id"}, tmpDir)
	require.Error(t, err)
	require.Equal(t, 0, countEntries(t, tmpDir))
}

func TestPackOpenAndRemove(t *testing.T) {
	t.Parallel()

	require.True(t, gitops.Pack{}.Empty())
	require.NoError(t, gitops.Pack{}.Remove())

	_, err := gitops.Pack{}.Open()
	require.Error(t, err)

	f := newFixture(t, "sha1")
	c1 := f.commit(t, nil, "content")
	gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)

	pack, err := gitops.BuildFullPack(f.ctx, f.repo, t.TempDir())
	require.NoError(t, err)
	require.False(t, pack.Empty())
	readPack(t, pack)

	require.NoError(t, pack.Remove())
	_, err = os.Stat(pack.Path)
	require.ErrorIs(t, err, os.ErrNotExist)
	require.NoError(t, pack.Remove(), "removing a missing pack is not an error")
}

func TestReadRefs(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			f := newFixture(t, format)

			// An unborn HEAD is a symbolic reference like any other.
			refs, err := gitops.ReadRefs(f.ctx, f.repo)
			require.NoError(t, err)
			require.Equal(t, map[string]corestore.Target{
				"HEAD": corestore.SymbolicTarget("refs/heads/main"),
			}, refs)

			c1 := f.commit(t, nil, "one")
			c2 := f.commit(t, []git.ObjectID{c1}, "two")
			gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)
			gittest.WriteRef(t, f.cfg, f.path, "refs/heads/other", c2)
			f.git(t, "tag", "v1", c1.String())
			f.git(t, "symbolic-ref", "refs/heads/alias", "refs/heads/main")

			refs, err = gitops.ReadRefs(f.ctx, f.repo)
			require.NoError(t, err)
			require.Equal(t, map[string]corestore.Target{
				"HEAD":             corestore.SymbolicTarget("refs/heads/main"),
				"refs/heads/main":  corestore.Target(c1.String()),
				"refs/heads/other": corestore.Target(c2.String()),
				"refs/heads/alias": corestore.SymbolicTarget("refs/heads/main"),
				"refs/tags/v1":     corestore.Target(c1.String()),
			}, refs)

			// A detached HEAD holds the object ID.
			f.git(t, "update-ref", "--no-deref", "HEAD", c2.String())
			refs, err = gitops.ReadRefs(f.ctx, f.repo)
			require.NoError(t, err)
			require.Equal(t, corestore.Target(c2.String()), refs["HEAD"])
		})
	}
}

func TestReadRefValues(t *testing.T) {
	t.Parallel()

	f := newFixture(t, "sha1")
	c1 := f.commit(t, nil, "one")
	gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)

	values, err := gitops.ReadRefValues(f.ctx, f.repo, nil)
	require.NoError(t, err)
	require.Empty(t, values)

	values, err = gitops.ReadRefValues(f.ctx, f.repo, []string{"HEAD", "refs/heads/main", "refs/heads/missing"})
	require.NoError(t, err)
	require.Equal(t, map[string]corestore.Target{
		"HEAD":            corestore.SymbolicTarget("refs/heads/main"),
		"refs/heads/main": corestore.Target(c1.String()),
	}, values)

	f.git(t, "update-ref", "--no-deref", "HEAD", c1.String())
	values, err = gitops.ReadRefValues(f.ctx, f.repo, []string{"HEAD"})
	require.NoError(t, err)
	require.Equal(t, map[string]corestore.Target{"HEAD": corestore.Target(c1.String())}, values)
}

func TestApplyRefs(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			t.Run("sets and deletes", func(t *testing.T) {
				f := newFixture(t, format)
				c1 := f.commit(t, nil, "one")
				c2 := f.commit(t, []git.ObjectID{c1}, "two")
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/a", c1)
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/b", c1)

				require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
					"refs/heads/a": corestore.Target(c2.String()),
					"refs/heads/b": "",
					"refs/heads/c": corestore.Target(c1.String()),
				}))

				refs, err := gitops.ReadRefValues(f.ctx, f.repo, []string{"refs/heads/a", "refs/heads/b", "refs/heads/c"})
				require.NoError(t, err)
				require.Equal(t, map[string]corestore.Target{
					"refs/heads/a": corestore.Target(c2.String()),
					"refs/heads/c": corestore.Target(c1.String()),
				}, refs)
			})

			t.Run("symbolic HEAD", func(t *testing.T) {
				f := newFixture(t, format)
				c1 := f.commit(t, nil, "one")
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/feature", c1)

				require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
					"HEAD": corestore.SymbolicTarget("refs/heads/feature"),
				}))
				require.Equal(t, "refs/heads/feature", f.git(t, "symbolic-ref", "HEAD"))
			})

			t.Run("detached HEAD", func(t *testing.T) {
				f := newFixture(t, format)
				c1 := f.commit(t, nil, "one")
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)

				require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
					"HEAD": corestore.Target(c1.String()),
				}))

				refs, err := gitops.ReadRefs(f.ctx, f.repo)
				require.NoError(t, err)
				require.Equal(t, corestore.Target(c1.String()), refs["HEAD"])
			})

			t.Run("file directory conflict", func(t *testing.T) {
				f := newFixture(t, format)
				c1 := f.commit(t, nil, "one")
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/d", c1)

				require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
					"refs/heads/d":   "",
					"refs/heads/d/e": corestore.Target(c1.String()),
				}))

				refs, err := gitops.ReadRefValues(f.ctx, f.repo, []string{"refs/heads/d", "refs/heads/d/e"})
				require.NoError(t, err)
				require.Equal(t, map[string]corestore.Target{
					"refs/heads/d/e": corestore.Target(c1.String()),
				}, refs)
			})

			t.Run("invalid input changes nothing", func(t *testing.T) {
				f := newFixture(t, format)
				c1 := f.commit(t, nil, "one")
				gittest.WriteRef(t, f.cfg, f.path, "refs/heads/main", c1)

				valid := corestore.Target(c1.String())
				for _, tc := range []struct {
					desc string
					refs map[string]corestore.Target
				}{
					{desc: "dot dot name", refs: map[string]corestore.Target{"refs/../x": valid}},
					{desc: "HEAD with a path", refs: map[string]corestore.Target{"HEAD:x": valid}},
					{desc: "name with a space", refs: map[string]corestore.Target{"refs/heads/with space": valid}},
					{desc: "name with a newline", refs: map[string]corestore.Target{"refs/heads/nl\n": valid}},
					{desc: "not fully qualified", refs: map[string]corestore.Target{"main": valid}},
					{desc: "non hex object ID", refs: map[string]corestore.Target{"refs/heads/x": "zz"}},
					{desc: "uppercase object ID", refs: map[string]corestore.Target{"refs/heads/x": corestore.Target(strings.ToUpper(c1.String()))}},
					{desc: "short object ID", refs: map[string]corestore.Target{"refs/heads/x": "abc"}},
					{desc: "invalid symbolic target", refs: map[string]corestore.Target{"refs/heads/x": "ref:refs/../x"}},
				} {
					t.Run(tc.desc, func(t *testing.T) {
						refs := map[string]corestore.Target{"refs/heads/valid": valid}
						for name, target := range tc.refs {
							refs[name] = target
						}

						require.Error(t, gitops.ApplyRefs(f.ctx, f.repo, refs))

						current, err := gitops.ReadRefs(f.ctx, f.repo)
						require.NoError(t, err)
						require.Equal(t, map[string]corestore.Target{
							"HEAD":            corestore.SymbolicTarget("refs/heads/main"),
							"refs/heads/main": valid,
						}, current)
					})
				}
			})

			t.Run("empty map", func(t *testing.T) {
				f := newFixture(t, format)
				require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, nil))
			})
		})
	}
}

func TestApplyRefsLockContention(t *testing.T) {
	t.Parallel()

	f := newFixture(t, "sha1")
	testhelper.SkipWithReftable(t, "the reference lock is a file in the files backend")

	c1 := f.commit(t, nil, "one")
	lock := filepath.Join(f.path, "refs", "heads", "locked.lock")
	require.NoError(t, os.WriteFile(lock, nil, 0o600))

	err := gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
		"refs/heads/locked": corestore.Target(c1.String()),
	})
	require.Error(t, err)
	require.True(t, gitops.IsLockError(err), "error: %v", err)

	require.NoError(t, os.Remove(lock))
	require.NoError(t, gitops.ApplyRefs(f.ctx, f.repo, map[string]corestore.Target{
		"refs/heads/locked": corestore.Target(c1.String()),
	}))
	require.Equal(t, c1.String(), f.git(t, "rev-parse", "refs/heads/locked"))
}

func TestIsLockError(t *testing.T) {
	t.Parallel()

	require.True(t, gitops.IsLockError(updateref.AlreadyLockedError{ReferenceName: "refs/heads/x"}))
	require.True(t, gitops.IsLockError(updateref.AlreadyLockedError{}))
	require.True(t, gitops.IsLockError(updateref.ErrPackedRefsLocked))
	require.False(t, gitops.IsLockError(errors.New("boom")))
	require.False(t, gitops.IsLockError(nil))
}

func TestInitBare(t *testing.T) {
	t.Parallel()

	for _, format := range objectFormats {
		t.Run(format, func(t *testing.T) {
			t.Parallel()

			ctx := testhelper.Context(t)
			cfg := testcfg.Build(t)
			factory := gittest.NewCommandFactory(t, cfg)

			path := filepath.Join(t.TempDir(), "repo.git")
			require.NoError(t, gitops.InitBare(ctx, factory, path, format))

			out := gittest.Exec(t, cfg, "-C", path, "rev-parse", "--show-ref-format")
			require.Equal(t, "reftable", strings.TrimSpace(string(out)))

			out = gittest.Exec(t, cfg, "-C", path, "rev-parse", "--show-object-format")
			require.Equal(t, format, strings.TrimSpace(string(out)))

			require.Error(t, gitops.InitBare(ctx, factory, path, format), "an existing path is not reused")
		})
	}

	t.Run("unknown object format", func(t *testing.T) {
		t.Parallel()

		ctx := testhelper.Context(t)
		cfg := testcfg.Build(t)
		path := filepath.Join(t.TempDir(), "repo.git")
		require.Error(t, gitops.InitBare(ctx, gittest.NewCommandFactory(t, cfg), path, "md5"))

		_, err := os.Lstat(path)
		require.ErrorIs(t, err, os.ErrNotExist)
	})
}

func TestWatermarkRoundTrip(t *testing.T) {
	t.Parallel()

	repoPath := t.TempDir()

	w, ok, err := gitops.ReadWatermark(repoPath)
	require.NoError(t, err)
	require.False(t, ok)
	require.Equal(t, corestore.Watermark{}, w)

	require.Equal(t, filepath.Join(repoPath, "graft", "storage", "applied"), gitops.WatermarkPath(repoPath))

	require.NoError(t, gitops.WriteWatermark(repoPath, corestore.Watermark{RepoID: 7, Seq: 42}))
	w, ok, err = gitops.ReadWatermark(repoPath)
	require.NoError(t, err)
	require.True(t, ok)
	require.Equal(t, corestore.Watermark{RepoID: 7, Seq: 42}, w)

	require.NoError(t, gitops.WriteWatermark(repoPath, corestore.Watermark{RepoID: 7, Seq: 43}))
	w, ok, err = gitops.ReadWatermark(repoPath)
	require.NoError(t, err)
	require.True(t, ok)
	require.Equal(t, uint64(43), w.Seq)

	// The temporary files of the atomic write do not remain.
	entries, err := os.ReadDir(filepath.Dir(gitops.WatermarkPath(repoPath)))
	require.NoError(t, err)
	require.Len(t, entries, 1)
	require.Equal(t, "applied", entries[0].Name())
}

// TestWriteWatermarkWithoutSync checks that the watermark written without fsync
// reads back, leaves no temporary file, and is written as WriteWatermark does
// when its directory is missing.
func TestWriteWatermarkWithoutSync(t *testing.T) {
	t.Parallel()

	repoPath := t.TempDir()
	// Without its directory the watermark is written as WriteWatermark does.
	require.NoError(t, gitops.WriteWatermarkWithoutSync(repoPath, corestore.Watermark{RepoID: 7, Seq: 1}))
	require.FileExists(t, gitops.WatermarkPath(repoPath))

	require.NoError(t, gitops.WriteWatermarkWithoutSync(repoPath, corestore.Watermark{RepoID: 7, Seq: 2}))
	w, ok, err := gitops.ReadWatermark(repoPath)
	require.NoError(t, err)
	require.True(t, ok)
	require.Equal(t, corestore.Watermark{RepoID: 7, Seq: 2}, w)

	entries, err := os.ReadDir(filepath.Dir(gitops.WatermarkPath(repoPath)))
	require.NoError(t, err)
	require.Len(t, entries, 1)
}

func TestWatermarkCorrupt(t *testing.T) {
	t.Parallel()

	repoPath := t.TempDir()
	require.NoError(t, gitops.WriteWatermark(repoPath, corestore.Watermark{RepoID: 1, Seq: 1}))
	require.NoError(t, os.WriteFile(gitops.WatermarkPath(repoPath), []byte("{not json"), 0o600))

	_, _, err := gitops.ReadWatermark(repoPath)
	require.Error(t, err)
}

func TestValidateName(t *testing.T) {
	t.Parallel()

	for _, tc := range []struct {
		name  string
		valid bool
	}{
		{name: "HEAD", valid: true},
		{name: "refs/heads/main", valid: true},
		{name: "refs/tags/v1.0", valid: true},
		{name: "main", valid: false},
		{name: "", valid: false},
		{name: "refs/", valid: false},
		{name: "refs/../x", valid: false},
		{name: "refs/heads/a b", valid: false},
		{name: "refs/heads/a..b", valid: false},
		{name: "refs/heads/a\nb", valid: false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			err := gitops.ValidateName(tc.name)
			if tc.valid {
				require.NoError(t, err)
			} else {
				require.Error(t, err)
			}
		})
	}
}

func TestValidateTarget(t *testing.T) {
	t.Parallel()

	sha1 := git.ObjectHashSHA1
	sha256Hash := git.ObjectHashSHA256
	sha1OID := strings.Repeat("a", 40)
	sha256OID := strings.Repeat("b", 64)

	for _, tc := range []struct {
		desc   string
		target corestore.Target
		hash   git.ObjectHash
		valid  bool
	}{
		{desc: "absent", target: "", hash: sha1, valid: true},
		{desc: "sha1 object", target: corestore.Target(sha1OID), hash: sha1, valid: true},
		{desc: "sha256 object", target: corestore.Target(sha256OID), hash: sha256Hash, valid: true},
		{desc: "sha256 object in a sha1 repository", target: corestore.Target(sha256OID), hash: sha1, valid: false},
		{desc: "sha1 object in a sha256 repository", target: corestore.Target(sha1OID), hash: sha256Hash, valid: false},
		{desc: "uppercase", target: corestore.Target(strings.ToUpper(sha1OID)), hash: sha1, valid: false},
		{desc: "symbolic", target: corestore.SymbolicTarget("refs/heads/main"), hash: sha1, valid: true},
		{desc: "symbolic to HEAD", target: corestore.SymbolicTarget("HEAD"), hash: sha1, valid: false},
		{desc: "symbolic to an invalid name", target: corestore.SymbolicTarget("main"), hash: sha1, valid: false},
		{desc: "symbolic without name", target: corestore.Target("ref:"), hash: sha1, valid: false},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			err := gitops.ValidateTarget(tc.target, tc.hash)
			if tc.valid {
				require.NoError(t, err)
			} else {
				require.Error(t, err)
			}
		})
	}
}