object/store/memory: Remove AddObject, fix lints v0.1.158

5 files changed, 424 insertions, 116 deletions

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")
 		}