From f23c6a801eef4e7d115b568d7fa905596cd1b253 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Mon, 30 Mar 2026 13:21:59 +0000 Subject: object/store/memory: Remove AddObject, fix lints --- commitquery/queries_is_ancestor_unit_test.go | 74 +++++++-- commitquery/queries_merge_bases_unit_test.go | 230 ++++++++++++++++++++++----- object/store/memory/add.go | 18 --- object/store/memory/write_test.go | 50 ++++-- reachability/unit_test.go | 168 +++++++++++++++---- 5 files changed, 424 insertions(+), 116 deletions(-) delete mode 100644 object/store/memory/add.go diff --git a/commitquery/queries_is_ancestor_unit_test.go b/commitquery/queries_is_ancestor_unit_test.go index bc8fb995..002c49ae 100644 --- a/commitquery/queries_is_ancestor_unit_test.go +++ b/commitquery/queries_is_ancestor_unit_test.go @@ -55,22 +55,54 @@ func TestIs(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ Mode: objecttree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - c1 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree)) - c2 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree, c1)) - otherBlob := store.AddObject(objecttype.TypeBlob, []byte("other-blob\n")) - otherTree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + c1, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree)) + if err != nil { + t.Fatal(err) + } + + c2, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree, c1)) + if err != nil { + t.Fatal(err) + } + + otherBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("other-blob\n")) + if err != nil { + t.Fatal(err) + } + + otherTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ Mode: objecttree.FileModeRegular, Name: []byte("g"), ID: otherBlob, }}})) - c3 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(otherTree)) - tag := store.AddObject(objecttype.TypeTag, ancestorTagBody(c2, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } + + c3, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(otherTree)) + if err != nil { + t.Fatal(err) + } + + tag, err := store.WriteBytesContent(objecttype.TypeTag, ancestorTagBody(c2, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } ok, err := commitquery.New(fetch.New(store), nil).IsAncestor(c1, tag) if err != nil { @@ -97,16 +129,32 @@ func TestIsRejectsNonCommitAfterPeel(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeAncestorTree(t, &objecttree.Tree{Entries: []objecttree.TreeEntry{{ Mode: objecttree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - commit := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree)) - tagToTree := store.AddObject(objecttype.TypeTag, ancestorTagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } + + commit, err := store.WriteBytesContent(objecttype.TypeCommit, ancestorCommitBody(tree)) + if err != nil { + t.Fatal(err) + } + + tagToTree, err := store.WriteBytesContent(objecttype.TypeTag, ancestorTagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } - _, err := commitquery.New(fetch.New(store), nil).IsAncestor(commit, tagToTree) + _, err = commitquery.New(fetch.New(store), nil).IsAncestor(commit, tagToTree) if err == nil { t.Fatal("expected error") } diff --git a/commitquery/queries_merge_bases_unit_test.go b/commitquery/queries_merge_bases_unit_test.go index 596a5edc..3e302536 100644 --- a/commitquery/queries_merge_bases_unit_test.go +++ b/commitquery/queries_merge_bases_unit_test.go @@ -74,15 +74,35 @@ func TestQueryLinearHistory(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - base := store.AddObject(objecttype.TypeCommit, commitBody(tree)) - left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base)) - right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left)) + if err != nil { + t.Fatal(err) + } + + base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, base)) + if err != nil { + t.Fatal(err) + } + + right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, left)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) @@ -115,21 +135,49 @@ func TestQueryPeelsAnnotatedTags(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("left"), ID: blob, }}})) - rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("right"), ID: blob, }}})) - base := store.AddObject(objecttype.TypeCommit, commitBody(leftTree)) - left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree, base)) - right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base)) - tag := store.AddObject(objecttype.TypeTag, tagBody(right, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } + + base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree)) + if err != nil { + t.Fatal(err) + } + + left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree, base)) + if err != nil { + t.Fatal(err) + } + + right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree, base)) + if err != nil { + t.Fatal(err) + } + + tag, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(right, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) @@ -149,37 +197,81 @@ func TestQueryCrissCrossReturnsAllBestCommonAncestors(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - rootTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + rootTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("root"), ID: blob, }}})) - base1Tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + base1Tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("base1"), ID: blob, }}})) - base2Tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + base2Tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("base2"), ID: blob, }}})) - leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("left"), ID: blob, }}})) - rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("right"), ID: blob, }}})) - root := store.AddObject(objecttype.TypeCommit, commitBody(rootTree)) - base1 := store.AddObject(objecttype.TypeCommit, commitBody(base1Tree, root)) - base2 := store.AddObject(objecttype.TypeCommit, commitBody(base2Tree, root)) - left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree, base1, base2)) - right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base2, base1)) + if err != nil { + t.Fatal(err) + } + + root, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rootTree)) + if err != nil { + t.Fatal(err) + } + + base1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(base1Tree, root)) + if err != nil { + t.Fatal(err) + } + + base2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(base2Tree, root)) + if err != nil { + t.Fatal(err) + } + + left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree, base1, base2)) + if err != nil { + t.Fatal(err) + } + + right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree, base2, base1)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) @@ -215,20 +307,44 @@ func TestQueryReturnsNoResultWhenNoCommonAncestorExists(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - leftBlob := store.AddObject(objecttype.TypeBlob, []byte("left\n")) - leftTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + leftBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("left\n")) + if err != nil { + t.Fatal(err) + } + + leftTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("left"), ID: leftBlob, }}})) - rightBlob := store.AddObject(objecttype.TypeBlob, []byte("right\n")) - rightTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + if err != nil { + t.Fatal(err) + } + + rightBlob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("right\n")) + if err != nil { + t.Fatal(err) + } + + rightTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("right"), ID: rightBlob, }}})) - left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree)) - right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree)) + if err != nil { + t.Fatal(err) + } + + left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(leftTree)) + if err != nil { + t.Fatal(err) + } + + right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rightTree)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) @@ -257,18 +373,34 @@ func TestQueryRejectsNonCommitAfterPeel(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - commit := store.AddObject(objecttype.TypeCommit, commitBody(tree)) - tagToTree := store.AddObject(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } + + commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + tagToTree, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) - _, err := query.MergeBases(commit, tagToTree) + _, err = query.MergeBases(commit, tagToTree) if err == nil { t.Fatal("expected error") } @@ -289,15 +421,35 @@ func TestQueryAllIsRepeatable(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := memory.New(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - base := store.AddObject(objecttype.TypeCommit, commitBody(tree)) - left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base)) - right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left)) + if err != nil { + t.Fatal(err) + } + + base, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + left, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, base)) + if err != nil { + t.Fatal(err) + } + + right, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, left)) + if err != nil { + t.Fatal(err) + } query := commitquery.New(fetch.New(store), nil) diff --git a/object/store/memory/add.go b/object/store/memory/add.go deleted file mode 100644 index 3946c89e..00000000 --- a/object/store/memory/add.go +++ /dev/null @@ -1,18 +0,0 @@ -package memory - -import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" -) - -// AddObject stores one object body and returns its object ID. -// -//go:fix inline -func (store *Store) AddObject(ty objecttype.Type, body []byte) objectid.ObjectID { - id, err := store.WriteBytesContent(ty, body) - if err != nil { - panic(err) - } - - return id -} diff --git a/object/store/memory/write_test.go b/object/store/memory/write_test.go index 5fe5f893..9f38a14b 100644 --- a/object/store/memory/write_test.go +++ b/object/store/memory/write_test.go @@ -1,4 +1,4 @@ -package memory +package memory_test import ( "bytes" @@ -7,13 +7,14 @@ import ( "codeberg.org/lindenii/furgit/internal/testgit" objectheader "codeberg.org/lindenii/furgit/object/header" objectid "codeberg.org/lindenii/furgit/object/id" + "codeberg.org/lindenii/furgit/object/store/memory" objecttype "codeberg.org/lindenii/furgit/object/type" ) func TestStoreWriteReaderContent(t *testing.T) { t.Parallel() testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper - store := New(algo) + store := memory.New(algo) content := []byte("memory-content\n") gotID, err := store.WriteReaderContent(objecttype.TypeBlob, int64(len(content)), bytes.NewReader(content)) @@ -21,7 +22,7 @@ func TestStoreWriteReaderContent(t *testing.T) { t.Fatalf("WriteReaderContent: %v", err) } - wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content)) + wantID := algo.Sum(buildRawObject(t, objecttype.TypeBlob, content)) if gotID != wantID { t.Fatalf("WriteReaderContent id = %s, want %s", gotID, wantID) } @@ -44,9 +45,9 @@ func TestStoreWriteReaderContent(t *testing.T) { func TestStoreWriteReaderFull(t *testing.T) { t.Parallel() testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper - store := New(algo) + store := memory.New(algo) content := []byte("memory-full\n") - raw := buildRawObject(objecttype.TypeBlob, content) + raw := buildRawObject(t, objecttype.TypeBlob, content) gotID, err := store.WriteReaderFull(bytes.NewReader(raw)) if err != nil { @@ -72,7 +73,7 @@ func TestStoreWriteReaderFull(t *testing.T) { func TestStoreWriteBytes(t *testing.T) { t.Parallel() testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper - store := New(algo) + store := memory.New(algo) content := []byte("memory-bytes\n") gotID, err := store.WriteBytesContent(objecttype.TypeBlob, content) @@ -80,12 +81,12 @@ func TestStoreWriteBytes(t *testing.T) { t.Fatalf("WriteBytesContent: %v", err) } - wantID := algo.Sum(buildRawObject(objecttype.TypeBlob, content)) + wantID := algo.Sum(buildRawObject(t, objecttype.TypeBlob, content)) if gotID != wantID { t.Fatalf("WriteBytesContent id = %s, want %s", gotID, wantID) } - raw := buildRawObject(objecttype.TypeBlob, content) + raw := buildRawObject(t, objecttype.TypeBlob, content) gotID2, err := store.WriteBytesFull(raw) if err != nil { @@ -103,7 +104,8 @@ func TestStoreWriteReaderValidationErrors(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper t.Run("content overflow", func(t *testing.T) { t.Parallel() - store := New(algo) + + store := memory.New(algo) _, err := store.WriteReaderContent(objecttype.TypeBlob, 1, bytes.NewReader([]byte("hello"))) if err == nil { @@ -113,7 +115,8 @@ func TestStoreWriteReaderValidationErrors(t *testing.T) { t.Run("content short", func(t *testing.T) { t.Parallel() - store := New(algo) + + store := memory.New(algo) _, err := store.WriteReaderContent(objecttype.TypeBlob, 5, bytes.NewReader([]byte("x"))) if err == nil { @@ -123,7 +126,8 @@ func TestStoreWriteReaderValidationErrors(t *testing.T) { t.Run("full malformed header", func(t *testing.T) { t.Parallel() - store := New(algo) + + store := memory.New(algo) _, err := store.WriteReaderFull(bytes.NewReader([]byte("not-a-header"))) if err == nil { @@ -133,7 +137,8 @@ func TestStoreWriteReaderValidationErrors(t *testing.T) { t.Run("full size mismatch", func(t *testing.T) { t.Parallel() - store := New(algo) + + store := memory.New(algo) _, err := store.WriteReaderFull(bytes.NewReader([]byte("blob 1\x00hello"))) if err == nil { @@ -143,7 +148,8 @@ func TestStoreWriteReaderValidationErrors(t *testing.T) { t.Run("bytes malformed header", func(t *testing.T) { t.Parallel() - store := New(algo) + + store := memory.New(algo) _, err := store.WriteBytesFull([]byte("not-a-header")) if err == nil { @@ -157,7 +163,8 @@ func TestBuildRawObjectMatchesObjectHeaderEncode(t *testing.T) { t.Parallel() content := []byte("body") - raw := buildRawObject(objecttype.TypeBlob, content) + raw := buildRawObject(t, objecttype.TypeBlob, content) + header, ok := objectheader.Encode(objecttype.TypeBlob, int64(len(content))) if !ok { t.Fatalf("objectheader.Encode failed") @@ -168,3 +175,18 @@ func TestBuildRawObjectMatchesObjectHeaderEncode(t *testing.T) { t.Fatalf("buildRawObject mismatch") } } + +func buildRawObject(tb testing.TB, ty objecttype.Type, body []byte) []byte { //nolint:unparam + tb.Helper() + + header, ok := objectheader.Encode(ty, int64(len(body))) + if !ok { + tb.Fatalf("objectheader.Encode(%v, %d) failed", ty, len(body)) + } + + raw := make([]byte, len(header)+len(body)) + copy(raw, header) + copy(raw[len(header):], body) + + return raw +} diff --git a/reachability/unit_test.go b/reachability/unit_test.go index a06df9da..e5517a66 100644 --- a/reachability/unit_test.go +++ b/reachability/unit_test.go @@ -83,23 +83,47 @@ func TestWalkDomainCommitsIncludesTagNodes(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - commit1 := store.AddObject(objecttype.TypeCommit, commitBody(tree)) - commit2 := store.AddObject(objecttype.TypeCommit, commitBody(tree, commit1)) - tag1 := store.AddObject(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit)) - tag2 := store.AddObject(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag)) + if err != nil { + t.Fatal(err) + } + + commit1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + commit2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, commit1)) + if err != nil { + t.Fatal(err) + } + + tag1, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } + + tag2, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) walk := r.Walk(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{tag2: {}}) got := collectSeq(walk.Seq()) - err := walk.Err() + err = walk.Err() if err != nil { t.Fatalf("walk.Err(): %v", err) } @@ -118,20 +142,32 @@ func TestWalkExcludesHavesCompletely(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - commit := store.AddObject(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) walk := r.Walk(reachability.DomainCommits, map[objectid.ObjectID]struct{}{commit: {}}, map[objectid.ObjectID]struct{}{commit: {}}) got := collectSeq(walk.Seq()) - err := walk.Err() + err = walk.Err() if err != nil { t.Fatalf("walk.Err(): %v", err) } @@ -147,19 +183,31 @@ func TestWalkDomainCommitsRejectsNonCommitRootAfterPeel(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - tag := store.AddObject(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } + + tag, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) walk := r.Walk(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{tag: {}}) _ = collectSeq(walk.Seq()) - err := walk.Err() + err = walk.Err() if err == nil { t.Fatal("expected error") } @@ -180,16 +228,40 @@ func TestWalkDomainCommitsHaveTagStopsTraversal(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) - commit1 := store.AddObject(objecttype.TypeCommit, commitBody(tree)) - commit2 := store.AddObject(objecttype.TypeCommit, commitBody(tree, commit1)) - tag1 := store.AddObject(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit)) - tag2 := store.AddObject(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag)) + if err != nil { + t.Fatal(err) + } + + commit1, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree)) + if err != nil { + t.Fatal(err) + } + + commit2, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, commit1)) + if err != nil { + t.Fatal(err) + } + + tag1, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(commit2, objecttype.TypeCommit)) + if err != nil { + t.Fatal(err) + } + + tag2, err := store.WriteBytesContent(objecttype.TypeTag, tagBody(tag1, objecttype.TypeTag)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) walk := r.Walk( @@ -200,7 +272,7 @@ func TestWalkDomainCommitsHaveTagStopsTraversal(t *testing.T) { got := collectSeq(walk.Seq()) - err := walk.Err() + err = walk.Err() if err != nil { t.Fatalf("walk.Err(): %v", err) } @@ -220,28 +292,47 @@ func TestWalkDomainObjectsRecursesTreesAndSkipsBlobContentReads(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob1 := store.AddObject(objecttype.TypeBlob, []byte("b1\n")) - blob2 := store.AddObject(objecttype.TypeBlob, []byte("b2\n")) + blob1, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("b1\n")) + if err != nil { + t.Fatal(err) + } + + blob2, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("b2\n")) + if err != nil { + t.Fatal(err) + } + gitlinkTarget := store.Algorithm().Sum([]byte("external-submodule")) - subtree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + subtree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("nested"), ID: blob2, }}})) - rootTree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{ + if err != nil { + t.Fatal(err) + } + + rootTree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{ {Mode: tree.FileModeRegular, Name: []byte("a"), ID: blob1}, {Mode: tree.FileModeDir, Name: []byte("dir"), ID: subtree}, {Mode: tree.FileModeGitlink, Name: []byte("submodule"), ID: gitlinkTarget}, }})) - commit := store.AddObject(objecttype.TypeCommit, commitBody(rootTree)) + if err != nil { + t.Fatal(err) + } + + commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(rootTree)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) walk := r.Walk(reachability.DomainObjects, nil, map[objectid.ObjectID]struct{}{commit: {}}) got := collectSeq(walk.Seq()) - err := walk.Err() + err = walk.Err() if err != nil { t.Fatalf("walk.Err(): %v", err) } @@ -264,18 +355,31 @@ func TestCheckConnectedReturnsConcreteMissingObject(t *testing.T) { testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper store := newCountingMemStore(algo) - blob := store.AddObject(objecttype.TypeBlob, []byte("blob\n")) - tree := store.AddObject(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ + + blob, err := store.WriteBytesContent(objecttype.TypeBlob, []byte("blob\n")) + if err != nil { + t.Fatal(err) + } + + tree, err := store.WriteBytesContent(objecttype.TypeTree, mustSerializeTree(t, &tree.Tree{Entries: []tree.TreeEntry{{ Mode: tree.FileModeRegular, Name: []byte("f"), ID: blob, }}})) + if err != nil { + t.Fatal(err) + } + missingParent := store.Algorithm().Sum([]byte("missing-parent")) - commit := store.AddObject(objecttype.TypeCommit, commitBody(tree, missingParent)) + + commit, err := store.WriteBytesContent(objecttype.TypeCommit, commitBody(tree, missingParent)) + if err != nil { + t.Fatal(err) + } r := reachability.New(store, nil) - err := r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}}) + err = r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}}) if err == nil { t.Fatal("expected error") } -- cgit v1.3.1-10-gc9f91