Git designed for AI agents.
package localrepo
import (
"bytes"
"context"
"errors"
"os"
"path/filepath"
"sort"
"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/helper/text"
"github.com/feder-cr/git-ai/internal/structerr"
"github.com/feder-cr/git-ai/internal/testhelper"
"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
"github.com/stretchr/testify/require"
)
func TestTreeEntry_Write(t *testing.T) {
cfg := testcfg.Build(t)
ctx := testhelper.Context(t)
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
differentContentBlobID := gittest.WriteBlob(t, cfg, repoPath, []byte("different content"))
blobID := gittest.WriteBlob(t, cfg, repoPath, []byte("foobar\n"))
tree := &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "file",
},
},
}
require.NoError(t, tree.Write(ctx, repo))
treeID := tree.OID
nonExistentBlobID := gittest.WriteBlob(t, cfg, repoPath, []byte("content"))
nonExistentBlobPath := filepath.Join(repoPath, "objects", string(nonExistentBlobID)[0:2], string(nonExistentBlobID)[2:])
require.NoError(t, os.Remove(nonExistentBlobPath))
for _, tc := range []struct {
desc string
entries []*TreeEntry
expectedEntries []TreeEntry
expectedErrString string
}{
{
desc: "entry with blob OID",
entries: []*TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "file",
},
},
expectedEntries: []TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "file",
},
},
},
{
desc: "entry with tree OID",
entries: []*TreeEntry{
{
OID: treeID,
Mode: "040000",
Path: "dir",
},
},
expectedEntries: []TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "dir/file",
},
},
},
{
desc: "mixed tree and blob entries",
entries: []*TreeEntry{
{
OID: treeID,
Mode: "040000",
Path: "dir",
},
{
OID: blobID,
Mode: "100644",
Path: "file1",
},
{
OID: differentContentBlobID,
Mode: "100644",
Path: "file2",
},
},
expectedEntries: []TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "dir/file",
},
{
OID: blobID,
Mode: "100644",
Path: "file1",
},
{
OID: differentContentBlobID,
Mode: "100644",
Path: "file2",
},
},
},
{
desc: "entry with nonexistent object",
entries: []*TreeEntry{
{
OID: nonExistentBlobID,
Mode: "100644",
Path: "file",
},
},
expectedEntries: []TreeEntry{
{
OID: nonExistentBlobID,
Mode: "100644",
Path: "file",
},
},
},
{
desc: "entry with duplicate file",
entries: []*TreeEntry{
{
OID: blobID,
Mode: "100644",
Path: "file",
},
{
OID: nonExistentBlobID,
Mode: "100644",
Path: "file",
},
},
expectedErrString: "duplicateEntries: contains duplicate file entries",
},
{
desc: "entry with malformed mode",
entries: []*TreeEntry{
{
OID: blobID,
Mode: "1006442",
Path: "file",
},
},
expectedErrString: "badFilemode: contains bad file modes",
},
{
desc: "tries to write .git file",
entries: []*TreeEntry{
{
OID: blobID,
Mode: "040000",
Path: ".git",
},
},
expectedErrString: "hasDotgit: contains '.git'",
},
} {
t.Run(tc.desc, func(t *testing.T) {
t.Parallel()
tree := &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: tc.entries,
}
err := tree.Write(ctx, repo)
oid := tree.OID
if tc.expectedErrString != "" {
var structErr structerr.Error
if errors.As(err, &structErr) {
stderr := structErr.Metadata()["stderr"].(string)
strings.Contains(stderr, tc.expectedErrString)
} else {
strings.Contains(err.Error(), tc.expectedErrString)
}
return
}
require.NoError(t, err)
output := text.ChompBytes(gittest.Exec(t, cfg, "-C", repoPath, "ls-tree", "-r", string(oid)))
if len(output) > 0 {
var actualEntries []TreeEntry
for _, line := range bytes.Split([]byte(output), []byte("\n")) {
// Format: <mode> SP <type> SP <object> TAB <file>
tabSplit := bytes.Split(line, []byte("\t"))
require.Len(t, tabSplit, 2)
spaceSplit := bytes.Split(tabSplit[0], []byte(" "))
require.Len(t, spaceSplit, 3)
path := string(tabSplit[1])
objectHash, err := repo.ObjectHash(ctx)
require.NoError(t, err)
objectID, err := objectHash.FromHex(text.ChompBytes(spaceSplit[2]))
require.NoError(t, err)
actualEntries = append(actualEntries, TreeEntry{
OID: objectID,
Mode: string(spaceSplit[0]),
Path: path,
})
}
require.Equal(t, tc.expectedEntries, actualEntries)
return
}
require.Nil(t, tc.expectedEntries)
})
}
}
func TestTreeEntryByPath(t *testing.T) {
t.Parallel()
testCases := []struct {
desc string
input []*TreeEntry
expected []*TreeEntry
}{
{
desc: "all blobs",
input: []*TreeEntry{
{
Type: Blob,
Path: "abc",
},
{
Type: Blob,
Path: "ab",
},
{
Type: Blob,
Path: "a",
},
},
expected: []*TreeEntry{
{
Type: Blob,
Path: "a",
},
{
Type: Blob,
Path: "ab",
},
{
Type: Blob,
Path: "abc",
},
},
},
{
desc: "blobs and trees",
input: []*TreeEntry{
{
Type: Blob,
Path: "abc",
},
{
Type: Tree,
Path: "ab",
},
{
Type: Blob,
Path: "a",
},
},
expected: []*TreeEntry{
{
Type: Blob,
Path: "a",
},
{
Type: Tree,
Path: "ab",
},
{
Type: Blob,
Path: "abc",
},
},
},
{
desc: "trees get sorted with / appended",
input: []*TreeEntry{
{
Type: Tree,
Path: "a",
},
{
Type: Blob,
Path: "a+",
},
},
expected: []*TreeEntry{
{
Type: Blob,
Path: "a+",
},
{
Type: Tree,
Path: "a",
},
},
},
{
desc: "blobs get sorted without / appended",
input: []*TreeEntry{
{
Type: Blob,
Path: "a",
},
{
Type: Blob,
Path: "a+",
},
},
expected: []*TreeEntry{
{
Type: Blob,
Path: "a",
},
{
Type: Blob,
Path: "a+",
},
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
sort.Stable(TreeEntriesByPath(tc.input))
require.Equal(
t,
tc.expected,
tc.input,
)
})
}
}
func TestReadTree(t *testing.T) {
t.Parallel()
cfg := testcfg.Build(t)
ctx := testhelper.Context(t)
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
blobID := gittest.WriteBlob(t, cfg, repoPath, []byte("blob contents"))
emptyTreeID := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{})
treeWithBlob := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{OID: blobID, Mode: "100644", Path: "nonexecutable"},
{OID: blobID, Mode: "100755", Path: "executable"},
})
treeWithSubtree := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{OID: emptyTreeID, Mode: "040000", Path: "subdir"},
})
treeWithNestedSubtrees := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{OID: treeWithSubtree, Mode: "040000", Path: "nested-subdir"},
})
treeWithSubtreeAndBlob := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{OID: treeWithSubtree, Mode: "040000", Path: "subdir"},
{OID: blobID, Mode: "100644", Path: "blob"},
})
treeWithSubtreeContainingBlob := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{OID: treeWithSubtreeAndBlob, Mode: "040000", Path: "subdir"},
})
_, submoduleRepoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
submodule := gittest.WriteCommit(t, cfg, submoduleRepoPath)
treeWithSubmodule := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{Path: "submodule", Mode: "160000", OID: submodule},
})
for _, tc := range []struct {
desc string
treeish git.Revision
options []ReadTreeOption
cfg *readTreeConfig
expectedTree TreeEntry
expectedErr error
}{
{
desc: "empty tree",
treeish: emptyTreeID.Revision(),
expectedTree: TreeEntry{
OID: emptyTreeID,
Type: Tree,
Mode: "040000",
},
},
{
desc: "tree with blob",
treeish: treeWithBlob.Revision(),
expectedTree: TreeEntry{
OID: treeWithBlob,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "100755", Type: Blob, OID: blobID, Path: "executable"},
{Mode: "100644", Type: Blob, OID: blobID, Path: "nonexecutable"},
},
},
},
{
desc: "tree with subtree",
treeish: treeWithSubtree.Revision(),
expectedTree: TreeEntry{
OID: treeWithSubtree,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "040000", Type: Tree, OID: emptyTreeID, Path: "subdir"},
},
},
},
{
desc: "nested trees",
treeish: treeWithNestedSubtrees.Revision(),
expectedTree: TreeEntry{
OID: treeWithNestedSubtrees,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "040000", Type: Tree, OID: treeWithSubtree, Path: "nested-subdir"},
},
},
},
{
desc: "recursive nested trees",
treeish: treeWithNestedSubtrees.Revision(),
options: []ReadTreeOption{WithRecursive()},
expectedTree: TreeEntry{
OID: treeWithNestedSubtrees,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
Mode: "040000",
Type: Tree,
OID: treeWithSubtree,
Path: "nested-subdir",
Entries: []*TreeEntry{
{
Mode: "040000",
Type: Tree,
OID: emptyTreeID,
Path: "subdir",
},
},
},
},
},
},
{
desc: "nested subtree",
treeish: treeWithNestedSubtrees.Revision(),
options: []ReadTreeOption{WithRelativePath("nested-subdir")},
expectedTree: TreeEntry{
OID: treeWithSubtree,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "040000", Type: Tree, OID: emptyTreeID, Path: "subdir"},
},
},
},
{
desc: "nested recursive subtree",
treeish: treeWithSubtreeContainingBlob.Revision(),
options: []ReadTreeOption{
WithRelativePath("subdir"),
WithRecursive(),
},
expectedTree: TreeEntry{
OID: treeWithSubtreeAndBlob,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "100644", Type: Blob, OID: blobID, Path: "blob"},
{
Mode: "040000",
Type: Tree,
OID: treeWithSubtree,
Path: "subdir",
Entries: []*TreeEntry{
{
Mode: "040000",
Type: Tree,
OID: emptyTreeID,
Path: "subdir",
},
},
},
},
},
},
{
desc: "recursive nested trees and blobs",
treeish: treeWithSubtreeAndBlob.Revision(),
options: []ReadTreeOption{
WithRecursive(),
},
expectedTree: TreeEntry{
OID: treeWithSubtreeAndBlob,
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{Mode: "100644", Type: Blob, OID: blobID, Path: "blob"},
{
Mode: "040000",
Type: Tree,
OID: treeWithSubtree,
Path: "subdir",
Entries: []*TreeEntry{
{
Mode: "040000",
Type: Tree,
OID: emptyTreeID,
Path: "subdir",
},
},
},
},
},
},
{
desc: "listing blob fails",
treeish: blobID.Revision(),
// We get a NotExist error here because it's invalid to suffix an object ID
// which resolves to a blob with a colon (":") given that it's not possible
// to resolve a subpath.
expectedErr: git.ErrReferenceNotFound,
},
{
desc: "valid revision with invalid path",
treeish: treeWithSubtree.Revision(),
options: []ReadTreeOption{
WithRelativePath("does-not-exist"),
},
expectedErr: git.ErrReferenceNotFound,
},
{
desc: "valid revision with path pointing to blob",
treeish: treeWithSubtreeAndBlob.Revision(),
options: []ReadTreeOption{
WithRelativePath("blob"),
},
expectedErr: ErrNotTreeish,
},
{
desc: "listing nonexistent object fails",
treeish: "does-not-exist",
expectedErr: git.ErrReferenceNotFound,
},
{
desc: "path to submodule",
treeish: treeWithSubmodule.Revision(),
options: []ReadTreeOption{
WithRelativePath("submodule"),
},
expectedErr: ErrTreeNotExist,
},
{
desc: "path inside submodule",
treeish: treeWithSubmodule.Revision(),
options: []ReadTreeOption{
WithRelativePath("submodule/foo"),
},
expectedErr: git.ErrReferenceNotFound,
},
} {
t.Run(tc.desc, func(t *testing.T) {
t.Parallel()
tree, err := repo.ReadTree(ctx, tc.treeish, tc.options...)
if tc.expectedErr != nil {
require.ErrorIs(t, err, tc.expectedErr)
return
}
require.Equal(t, tc.expectedTree, *tree)
})
}
}
func TestWriteTreeRecursively(t *testing.T) {
cfg := testcfg.Build(t)
testCases := []struct {
desc string
setupTree func(*testing.T, string) *TreeEntry
}{
{
desc: "every level has a new tree",
setupTree: func(t *testing.T, repoPath string) *TreeEntry {
blobA := gittest.WriteBlob(t, cfg, repoPath, []byte("a"))
return &TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: blobA,
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
}
},
},
{
desc: "only some new trees",
setupTree: func(t *testing.T, repoPath string) *TreeEntry {
blobA := gittest.WriteBlob(t, cfg, repoPath, []byte("a"))
blobB := gittest.WriteBlob(t, cfg, repoPath, []byte("b"))
blobC := gittest.WriteBlob(t, cfg, repoPath, []byte("c"))
blobD := gittest.WriteBlob(t, cfg, repoPath, []byte("d"))
dirDTree := gittest.WriteTree(
t,
cfg,
repoPath,
[]gittest.TreeEntry{
{
OID: blobC,
Mode: "100644",
Path: "file3",
},
{
OID: blobD,
Mode: "100644",
Path: "file4",
},
})
dirCTree := gittest.WriteTree(
t,
cfg,
repoPath,
[]gittest.TreeEntry{
{
OID: dirDTree,
Mode: "040000",
Path: "dirD",
},
},
)
return &TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: blobA,
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: blobB,
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
{
OID: dirCTree,
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: dirDTree,
Mode: "040000",
Type: Tree,
Path: "dirD",
Entries: []*TreeEntry{
{
OID: blobC,
Type: Blob,
Mode: "100644",
Path: "file3",
},
{
OID: blobD,
Type: Blob,
Mode: "100644",
Path: "file4",
},
},
},
},
},
},
}
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
t.Parallel()
ctx := testhelper.Context(t)
repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg, gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
treeEntry := tc.setupTree(t, repoPath)
require.NoError(t, treeEntry.Write(
ctx,
repo,
))
requireTreeEquals(t, ctx, repo, treeEntry.OID, treeEntry)
})
}
}
func requireTreeEquals(
t *testing.T,
ctx context.Context,
repo *Repo,
treeOID git.ObjectID,
expect *TreeEntry,
) {
tree, err := repo.ReadTree(ctx, git.Revision(treeOID))
require.NoError(t, err)
for i, entry := range tree.Entries {
if tree.Entries[i].OID != "" {
require.Equal(t, expect.Entries[i].Mode, entry.Mode)
require.Equal(t, expect.Entries[i].Type, entry.Type)
require.Equal(t, expect.Entries[i].OID, entry.OID)
require.Equal(t, expect.Entries[i].Path, entry.Path)
} else {
objectInfo, err := repo.ReadObjectInfo(
ctx,
git.Revision(entry.OID),
)
require.NoError(t, err)
require.Equal(t, expect.Entries[i].Type, ObjectTypeFromString(objectInfo.Type))
}
if entry.Type == Tree {
requireTreeEquals(t, ctx, repo, entry.OID, expect.Entries[i])
}
}
}
func TestReadTree_WithRecursive(t *testing.T) {
t.Parallel()
cfg := testcfg.Build(t)
ctx := testhelper.Context(t)
testCases := []struct {
desc string
setupTree func(t *testing.T, repoPath string) (git.ObjectID, TreeEntry)
expectedErr error
}{
{
desc: "flat tree",
setupTree: func(t *testing.T, repoPath string) (git.ObjectID, TreeEntry) {
blobA := gittest.WriteBlob(t, cfg, repoPath, []byte("a"))
blobB := gittest.WriteBlob(t, cfg, repoPath, []byte("b"))
treeID := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{
Mode: "100644",
Path: "fileA",
OID: blobA,
},
{
Mode: "100644",
Path: "fileB",
OID: blobB,
},
})
return gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("master"),
gittest.WithTree(treeID)),
TreeEntry{
OID: treeID,
Mode: "040000",
Type: Tree,
Entries: []*TreeEntry{
{
Mode: "100644",
Path: "fileA",
OID: blobA,
Type: Blob,
},
{
Mode: "100644",
Path: "fileB",
OID: blobB,
Type: Blob,
},
},
}
},
},
{
desc: "nested tree",
setupTree: func(t *testing.T, repoPath string) (git.ObjectID, TreeEntry) {
blobA := gittest.WriteBlob(t, cfg, repoPath, []byte("a"))
blobB := gittest.WriteBlob(t, cfg, repoPath, []byte("b"))
blobC := gittest.WriteBlob(t, cfg, repoPath, []byte("c"))
dirATree := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{
Mode: "100644",
Path: "file1InDirA",
OID: blobA,
},
})
treeID := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
{
Mode: "100644",
Path: "fileB",
OID: blobB,
},
{
Mode: "100644",
Path: "fileC",
OID: blobC,
},
{
Mode: "040000",
Path: "dirA",
OID: dirATree,
},
})
return gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("master"),
gittest.WithTree(treeID)),
TreeEntry{
OID: treeID,
Mode: "040000",
Type: Tree,
Entries: []*TreeEntry{
{
Mode: "040000",
Path: "dirA",
Type: Tree,
OID: dirATree,
Entries: []*TreeEntry{
{
Mode: "100644",
Path: "file1InDirA",
OID: blobA,
Type: Blob,
},
},
},
{
Mode: "100644",
Path: "fileB",
OID: blobB,
Type: Blob,
},
{
Mode: "100644",
Path: "fileC",
OID: blobC,
Type: Blob,
},
},
}
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
t.Parallel()
repoProto, repoPath := gittest.CreateRepository(
t,
ctx,
cfg,
gittest.CreateRepositoryConfig{
SkipCreationViaService: true,
})
repo := NewTestRepo(t, cfg, repoProto)
commitID, expectedTree := tc.setupTree(t, repoPath)
tree, err := repo.ReadTree(
ctx,
git.Revision(commitID),
WithRecursive(),
)
require.NoError(t, err)
require.Equal(t, expectedTree, *tree)
})
}
}
func TestTreeEntry_Modify(t *testing.T) {
testCases := []struct {
desc string
tree *TreeEntry
pathToModify string
modifyEntryFunc func(*TreeEntry) error
expectedTree TreeEntry
expectedErr error
}{
{
desc: "flat tree",
tree: &TreeEntry{
OID: "abcd",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
pathToModify: "file2",
modifyEntryFunc: func(t *TreeEntry) error {
t.OID = "deadbeef"
t.Mode = "100755"
t.Path = "new-file-name"
return nil
},
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "deadbeef",
Type: Blob,
Mode: "100755",
Path: "new-file-name",
},
},
},
},
{
desc: "nested tree",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
pathToModify: "dirA/dirB/file1",
modifyEntryFunc: func(t *TreeEntry) error {
t.OID = "deadbeef"
t.Mode = "100755"
t.Path = "new-file-name"
return nil
},
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "deadbeef",
Type: Blob,
Mode: "100755",
Path: "new-file-name",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
},
{
desc: "nested tree with duplicate file",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
{
OID: "feedface",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
pathToModify: "dirA/dirB/file1",
modifyEntryFunc: func(t *TreeEntry) error {
t.OID = "deadbeef"
t.Mode = "100755"
t.Path = "new-file-name"
return nil
},
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "deadbeef",
Type: Blob,
Mode: "100755",
Path: "new-file-name",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
{
OID: "feedface",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
{
desc: "entry does not exist",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
pathToModify: "file3",
modifyEntryFunc: func(t *TreeEntry) error {
t.OID = "deadbeef"
t.Mode = "100755"
t.Path = "new-file-name"
return nil
},
expectedErr: ErrEntryNotFound,
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
err := tc.tree.Modify(
tc.pathToModify,
tc.modifyEntryFunc,
)
require.Equal(t, tc.expectedErr, err)
if tc.expectedErr != nil {
return
}
require.Equal(t, tc.expectedTree, *tc.tree)
})
}
}
func TestTreeEntry_Delete(t *testing.T) {
testCases := []struct {
desc string
tree *TreeEntry
pathToDelete string
expectedTree TreeEntry
expectedErr error
}{
{
desc: "flat tree",
tree: &TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
pathToDelete: "file2",
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
{
desc: "flat tree, single entry",
tree: &TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
pathToDelete: "file1",
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{},
},
},
{
desc: "nested tree",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "defg",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
pathToDelete: "dirA/dirB/file1",
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
},
{
desc: "nested tree with only single child",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
},
},
},
pathToDelete: "dirA/dirB/dirC/file1",
expectedTree: TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{},
},
},
{
desc: "entry does not exist",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
pathToDelete: "file3",
expectedErr: ErrEntryNotFound,
},
{
desc: "path contains traversal",
tree: &TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
pathToDelete: "a/../../something",
expectedErr: ErrPathTraversal,
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
err := tc.tree.Delete(
tc.pathToDelete,
)
require.Equal(t, tc.expectedErr, err)
if tc.expectedErr != nil {
return
}
require.Equal(t, tc.expectedTree, *tc.tree)
})
}
}
func TestTreeEntry_Add(t *testing.T) {
testCases := []struct {
desc string
tree TreeEntry
pathToAdd string
entryToAdd TreeEntry
expectedTree TreeEntry
addTreeOptions []AddTreeEntryOption
expectedErr error
}{
{
desc: "empty tree",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
},
pathToAdd: "dirA/dirB/file1",
entryToAdd: TreeEntry{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
expectedTree: TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
},
},
{
desc: "cannot add entry into existing tree",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "gab",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
},
pathToAdd: "dirA/dirB/file1",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedErr: ErrEntryExists,
},
{
desc: "add entry into existing tree",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "gab",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
},
pathToAdd: "dirA/dirB/file2",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedTree: TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Mode: "040000",
Type: Tree,
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
},
{
desc: "overwrite file",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
pathToAdd: "file1",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedTree: TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
addTreeOptions: []AddTreeEntryOption{
WithOverwriteFile(),
},
},
{
desc: "cannot overwrite file",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
pathToAdd: "file1",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedErr: ErrEntryExists,
},
{
desc: "overwrite directory",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirA",
},
},
},
pathToAdd: "dirA",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedTree: TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
addTreeOptions: []AddTreeEntryOption{
WithOverwriteDirectory(),
},
},
{
desc: "cannot overwrite directory",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "def",
Type: Tree,
Mode: "040000",
Path: "dirA",
},
},
},
pathToAdd: "dirA",
entryToAdd: TreeEntry{
OID: "e1",
Type: Blob,
Mode: "100644",
Path: "file2",
},
expectedErr: ErrEntryExists,
},
{
desc: "add nested directory with same name",
tree: TreeEntry{
OID: "abc",
Type: Tree,
Mode: "040000",
},
pathToAdd: "dirA/file1/dirA/file1",
entryToAdd: TreeEntry{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
expectedTree: TreeEntry{
OID: "",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Mode: "040000",
Type: Tree,
Path: "file1",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "d1",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
},
},
},
},
},
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
err := tc.tree.Add(
tc.pathToAdd,
tc.entryToAdd,
tc.addTreeOptions...,
)
require.Equal(t, tc.expectedErr, err)
if tc.expectedErr != nil {
return
}
require.Equal(t, tc.expectedTree, tc.tree)
})
}
}
func TestTreeEntry_Get(t *testing.T) {
testCases := []struct {
desc string
tree *TreeEntry
path string
expectedEntry TreeEntry
expectedErr error
}{
{
desc: "flat tree",
tree: &TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
path: "file2",
expectedEntry: TreeEntry{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
{
desc: "get root",
tree: &TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
path: "",
expectedEntry: TreeEntry{
OID: "def",
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
{
desc: "nested tree",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirA",
Entries: []*TreeEntry{
{
OID: "",
Type: Tree,
Mode: "040000",
Path: "dirB",
Entries: []*TreeEntry{
{
OID: "defg",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
},
{
OID: "aa123",
Type: Tree,
Mode: "040000",
Path: "dirC",
Entries: []*TreeEntry{
{
OID: "abcd",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
},
},
},
},
path: "dirA/dirB/file1",
expectedEntry: TreeEntry{
OID: "defg",
Type: Blob,
Mode: "100644",
Path: "file1",
},
},
{
desc: "entry does not exist",
tree: &TreeEntry{
Type: Tree,
Mode: "040000",
Entries: []*TreeEntry{
{
OID: "abc",
Type: Blob,
Mode: "100644",
Path: "file1",
},
{
OID: "cba",
Type: Blob,
Mode: "100644",
Path: "file2",
},
},
},
path: "file3",
expectedErr: ErrEntryNotFound,
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
entry, err := tc.tree.Get(
tc.path,
)
require.Equal(t, tc.expectedErr, err)
if tc.expectedErr != nil {
return
}
require.Equal(t, tc.expectedEntry, *entry)
})
}
}
func TestValidatePath(t *testing.T) {
testCases := []struct {
desc string
path string
expectedPath string
expectedErr error
}{
{
desc: "normal path",
path: "a/b/c/d/e/f/g",
expectedPath: "a/b/c/d/e/f/g",
expectedErr: nil,
},
{
desc: "weird path",
path: "a/b..c/d..e/f/g",
expectedPath: "a/b..c/d..e/f/g",
expectedErr: nil,
},
{
desc: "starts with traversal",
path: "../../a",
expectedErr: ErrPathTraversal,
},
{
desc: "contains traversal",
path: "a/../../../b",
expectedErr: ErrPathTraversal,
},
{
desc: "does not contain traversal",
path: "a/b/../c",
expectedPath: "a/c",
expectedErr: nil,
},
{
desc: "absolute path",
path: "/a/b/c",
expectedErr: ErrAbsolutePath,
},
{
desc: "empty path",
path: "",
expectedErr: ErrEmptyPath,
},
{
desc: "empty path",
path: ".",
expectedErr: ErrEmptyPath,
},
{
desc: "contains .git",
path: ".git/objects/info",
expectedErr: ErrDisallowedPath,
},
{
desc: "contains .git but not the git directory",
path: ".gitsomefile",
expectedPath: ".gitsomefile",
expectedErr: nil,
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
path, err := validateFileCreationPath(tc.path)
require.Equal(
t,
tc.expectedPath,
path,
)
require.Equal(
t,
tc.expectedErr,
err,
)
})
}
}