aboutsummaryrefslogtreecommitdiff
path: root/object/storer/packed/read_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'object/storer/packed/read_test.go')
-rw-r--r--object/storer/packed/read_test.go301
1 files changed, 0 insertions, 301 deletions
diff --git a/object/storer/packed/read_test.go b/object/storer/packed/read_test.go
deleted file mode 100644
index 841019fe..00000000
--- a/object/storer/packed/read_test.go
+++ /dev/null
@@ -1,301 +0,0 @@
-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"
- objectstorer "codeberg.org/lindenii/furgit/object/storer"
- "codeberg.org/lindenii/furgit/object/storer/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, objectstorer.ErrObjectNotFound) {
- t.Fatalf("ReadBytesFull not-found error = %v", err)
- }
-
- _, _, err = store.ReadBytesContent(notFoundID)
- if !errors.Is(err, objectstorer.ErrObjectNotFound) {
- t.Fatalf("ReadBytesContent not-found error = %v", err)
- }
-
- _, err = store.ReadReaderFull(notFoundID)
- if !errors.Is(err, objectstorer.ErrObjectNotFound) {
- t.Fatalf("ReadReaderFull not-found error = %v", err)
- }
-
- _, _, _, err = store.ReadReaderContent(notFoundID)
- if !errors.Is(err, objectstorer.ErrObjectNotFound) {
- t.Fatalf("ReadReaderContent not-found error = %v", err)
- }
-
- _, _, err = store.ReadHeader(notFoundID)
- if !errors.Is(err, objectstorer.ErrObjectNotFound) {
- t.Fatalf("ReadHeader not-found error = %v", err)
- }
-
- _, err = store.ReadSize(notFoundID)
- if !errors.Is(err, objectstorer.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 13:54:14 +0000