aboutsummaryrefslogtreecommitdiff
path: root/object/store/packed/read_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'object/store/packed/read_test.go')
-rw-r--r--object/store/packed/read_test.go301
1 files changed, 301 insertions, 0 deletions
diff --git a/object/store/packed/read_test.go b/object/store/packed/read_test.go
new file mode 100644
index 00000000..e690a8fd
--- /dev/null
+++ b/object/store/packed/read_test.go
@@ -0,0 +1,301 @@
+package packed_test
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "io/fs"
+ "strconv"
+ "strings"
+ "testing"
+
+ "codeberg.org/lindenii/furgit/internal/testgit"
+ objectid "codeberg.org/lindenii/furgit/object/id"
+ "codeberg.org/lindenii/furgit/object/store"
+ "codeberg.org/lindenii/furgit/object/store/packed"
+)
+
+func TestPackedStoreReadAgainstGit(t *testing.T) {
+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+ testRepo, ids := createPackedFixtureRepo(t, algo)
+ store := openPackedStore(t, testRepo, algo)
+
+ for _, id := range ids {
+ t.Run(id.String(), func(t *testing.T) {
+ wantType, wantBody, wantRaw := expectedRawObject(t, testRepo, id)
+
+ gotHeaderType, gotHeaderSize, err := store.ReadHeader(id)
+ if err != nil {
+ t.Fatalf("ReadHeader: %v", err)
+ }
+
+ if gotHeaderType != wantType {
+ t.Fatalf("ReadHeader type = %v, want %v", gotHeaderType, wantType)
+ }
+
+ if gotHeaderSize != int64(len(wantBody)) {
+ t.Fatalf("ReadHeader size = %d, want %d", gotHeaderSize, len(wantBody))
+ }
+
+ gotSize, err := store.ReadSize(id)
+ if err != nil {
+ t.Fatalf("ReadSize: %v", err)
+ }
+
+ if gotSize != int64(len(wantBody)) {
+ t.Fatalf("ReadSize = %d, want %d", gotSize, len(wantBody))
+ }
+
+ gotRaw, err := store.ReadBytesFull(id)
+ if err != nil {
+ t.Fatalf("ReadBytesFull: %v", err)
+ }
+
+ if !bytes.Equal(gotRaw, wantRaw) {
+ t.Fatalf("ReadBytesFull mismatch")
+ }
+
+ gotType, gotBody, err := store.ReadBytesContent(id)
+ if err != nil {
+ t.Fatalf("ReadBytesContent: %v", err)
+ }
+
+ if gotType != wantType {
+ t.Fatalf("ReadBytesContent type = %v, want %v", gotType, wantType)
+ }
+
+ if !bytes.Equal(gotBody, wantBody) {
+ t.Fatalf("ReadBytesContent mismatch")
+ }
+
+ fullReader, err := store.ReadReaderFull(id)
+ if err != nil {
+ t.Fatalf("ReadReaderFull: %v", err)
+ }
+
+ got := mustReadAllAndClose(t, fullReader)
+ if !bytes.Equal(got, wantRaw) {
+ t.Fatalf("ReadReaderFull mismatch")
+ }
+
+ contentType, contentSize, contentReader, err := store.ReadReaderContent(id)
+ if err != nil {
+ t.Fatalf("ReadReaderContent: %v", err)
+ }
+
+ if contentType != wantType {
+ t.Fatalf("ReadReaderContent type = %v, want %v", contentType, wantType)
+ }
+
+ if contentSize != int64(len(wantBody)) {
+ t.Fatalf("ReadReaderContent size = %d, want %d", contentSize, len(wantBody))
+ }
+
+ got = mustReadAllAndClose(t, contentReader)
+ if !bytes.Equal(got, wantBody) {
+ t.Fatalf("ReadReaderContent mismatch")
+ }
+ })
+ }
+ })
+}
+
+func TestPackedStoreErrors(t *testing.T) {
+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+ testRepo, _ := createPackedFixtureRepo(t, algo)
+ store := openPackedStore(t, testRepo, algo)
+
+ notFoundID, err := objectid.ParseHex(algo, strings.Repeat("0", algo.HexLen()))
+ if err != nil {
+ t.Fatalf("ParseHex(notFound): %v", err)
+ }
+
+ _, err = store.ReadBytesFull(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadBytesFull not-found error = %v", err)
+ }
+
+ _, _, err = store.ReadBytesContent(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadBytesContent not-found error = %v", err)
+ }
+
+ _, err = store.ReadReaderFull(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadReaderFull not-found error = %v", err)
+ }
+
+ _, _, _, err = store.ReadReaderContent(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadReaderContent not-found error = %v", err)
+ }
+
+ _, _, err = store.ReadHeader(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadHeader not-found error = %v", err)
+ }
+
+ _, err = store.ReadSize(notFoundID)
+ if !errors.Is(err, objectstore.ErrObjectNotFound) {
+ t.Fatalf("ReadSize not-found error = %v", err)
+ }
+
+ var otherAlgo objectid.Algorithm
+
+ for _, candidate := range objectid.SupportedAlgorithms() {
+ if candidate != algo {
+ otherAlgo = candidate
+
+ break
+ }
+ }
+
+ if otherAlgo != objectid.AlgorithmUnknown {
+ mismatchID, err := objectid.ParseHex(otherAlgo, strings.Repeat("0", otherAlgo.HexLen()))
+ if err != nil {
+ t.Fatalf("ParseHex(mismatch): %v", err)
+ }
+
+ _, err = store.ReadBytesFull(mismatchID)
+ if err == nil || !strings.Contains(err.Error(), "algorithm mismatch") {
+ t.Fatalf("ReadBytesFull algorithm-mismatch error = %v", err)
+ }
+ }
+ })
+}
+
+func TestPackedStoreNewValidation(t *testing.T) {
+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+ testRepo, _ := createPackedFixtureRepo(t, algo)
+
+ store := openPackedStore(t, testRepo, algo)
+
+ err := store.Close()
+ if err != nil {
+ t.Fatalf("Close: %v", err)
+ }
+ })
+}
+
+func TestPackedStoreInvalidAlgorithm(t *testing.T) {
+ t.Parallel()
+ testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: objectid.AlgorithmSHA1, Bare: true})
+
+ root := testRepo.OpenPackRoot(t)
+
+ _, err := packed.New(root, objectid.AlgorithmUnknown, packed.Options{})
+ if !errors.Is(err, objectid.ErrInvalidAlgorithm) {
+ t.Fatalf("packed.New invalid algorithm error = %v", err)
+ }
+}
+
+func TestPackedStoreReadHeaderUsesResolvedObjectSizeForDelta(t *testing.T) {
+ t.Parallel()
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+ testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
+
+ var parent objectid.ObjectID
+
+ for i := range 96 {
+ content := strings.Repeat("common-line-"+strconv.Itoa(i%7)+"\n", 384) + fmt.Sprintf("tail-%03d\n", i)
+
+ _, treeID := testRepo.MakeSingleFileTree(t, "file.txt", []byte(content))
+ if i == 0 {
+ parent = testRepo.CommitTree(t, treeID, "delta-header-size-0")
+
+ continue
+ }
+
+ parent = testRepo.CommitTree(t, treeID, fmt.Sprintf("delta-header-size-%03d", i), parent)
+ }
+
+ testRepo.UpdateRef(t, "refs/heads/main", parent)
+ testRepo.Repack(t, "-a", "-d", "-f", "--window=128", "--depth=128")
+
+ deltaID, wantResolvedSize := findDeltaObjectWithResolvedSizeMismatch(t, testRepo, algo)
+ store := openPackedStore(t, testRepo, algo)
+
+ _, gotSize, err := store.ReadHeader(deltaID)
+ if err != nil {
+ t.Fatalf("ReadHeader(%s): %v", deltaID, err)
+ }
+
+ if gotSize != wantResolvedSize {
+ t.Fatalf("ReadHeader(%s) size = %d, want resolved size %d", deltaID, gotSize, wantResolvedSize)
+ }
+
+ gotReadSize, err := store.ReadSize(deltaID)
+ if err != nil {
+ t.Fatalf("ReadSize(%s): %v", deltaID, err)
+ }
+
+ if gotReadSize != wantResolvedSize {
+ t.Fatalf("ReadSize(%s) = %d, want resolved size %d", deltaID, gotReadSize, wantResolvedSize)
+ }
+ })
+}
+
+func findDeltaObjectWithResolvedSizeMismatch(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) (objectid.ObjectID, int64) {
+ t.Helper()
+
+ packRoot := testRepo.OpenPackRoot(t)
+
+ entries, err := fs.ReadDir(packRoot.FS(), ".")
+ if err != nil {
+ t.Fatalf("ReadDir(pack): %v", err)
+ }
+
+ var idxName string
+
+ for _, entry := range entries {
+ if strings.HasSuffix(entry.Name(), ".idx") {
+ idxName = entry.Name()
+
+ break
+ }
+ }
+
+ if idxName == "" {
+ t.Fatalf("no idx files found")
+ }
+
+ verifyOut := testRepo.Run(t, "verify-pack", "-v", "objects/pack/"+idxName)
+ for line := range strings.SplitSeq(strings.TrimSpace(verifyOut), "\n") {
+ fields := strings.Fields(line)
+ if len(fields) < 7 {
+ continue
+ }
+
+ idHex := fields[0]
+
+ deltaStreamSize, err := strconv.ParseInt(fields[2], 10, 64)
+ if err != nil {
+ continue
+ }
+
+ resolvedSizeStr := testRepo.Run(t, "cat-file", "-s", idHex)
+
+ resolvedSize, err := strconv.ParseInt(strings.TrimSpace(resolvedSizeStr), 10, 64)
+ if err != nil {
+ t.Fatalf("parse cat-file size for %s: %v", idHex, err)
+ }
+
+ if deltaStreamSize == resolvedSize {
+ continue
+ }
+
+ id, err := objectid.ParseHex(algo, idHex)
+ if err != nil {
+ t.Fatalf("ParseHex(%s): %v", idHex, err)
+ }
+
+ return id, resolvedSize
+ }
+
+ t.Fatalf("did not find a delta object with mismatched stream/resolved size")
+
+ return objectid.ObjectID{}, 0
+}
generated by cgit v1.3.1-10-gc9f91 (git 2.54.0) at 2026-05-25 15:03:40 +0000