path: root/packfile/ingest/ingest_test.go

package ingest_test

import (
	"bytes"
	"encoding/binary"
	"errors"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"codeberg.org/lindenii/furgit/internal/testgit"
	objectid "codeberg.org/lindenii/furgit/object/id"
	"codeberg.org/lindenii/furgit/packfile/ingest"
)

type noExtraReadReader struct {
	reader *bytes.Reader
}

func (r *noExtraReadReader) Read(p []byte) (int, error) {
	if r.reader.Len() == 0 {
		return 0, errors.New("unexpected extra read after pack trailer")
	}

	return r.reader.Read(p)
}

func beginAndContinue(
	src io.Reader,
	packRoot *os.Root,
	algo objectid.Algorithm,
	opts ingest.Options,
) (ingest.Result, error) {
	pending, err := ingest.Ingest(src, algo, opts)
	if err != nil {
		return ingest.Result{}, err
	}

	return pending.Continue(packRoot)
}

// fixturePath returns one fixture file path for the selected algorithm.
func fixturePath(t *testing.T, algo objectid.Algorithm, name string) string {
	t.Helper()

	dir := algo.String()
	if dir == "" {
		t.Fatalf("unsupported fixture algorithm: %v", algo)
	}

	return filepath.Join("testdata", "fixtures", dir, name)
}

// fixtureBytes reads one fixture file fully.
func fixtureBytes(t *testing.T, algo objectid.Algorithm, name string) []byte {
	t.Helper()

	path := fixturePath(t, algo, name)
	dir := filepath.Dir(path)
	base := filepath.Base(path)

	root, err := os.OpenRoot(dir)
	if err != nil {
		t.Fatalf("open fixture root %q: %v", dir, err)
	}

	defer func() {
		err := root.Close()
		if err != nil {
			t.Fatalf("close fixture root %q: %v", dir, err)
		}
	}()

	data, err := root.ReadFile(base)
	if err != nil {
		t.Fatalf("read fixture %q: %v", base, err)
	}

	return data
}

// fixtureMetadata parses key=value metadata for one algorithm fixture set.
func fixtureMetadata(t *testing.T, algo objectid.Algorithm) map[string]string {
	t.Helper()

	data := fixtureBytes(t, algo, "METADATA.txt")

	out := make(map[string]string)
	for line := range strings.SplitSeq(strings.TrimSpace(string(data)), "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		key, value, ok := strings.Cut(line, "=")
		if !ok {
			t.Fatalf("invalid fixture metadata line %q", line)
		}

		out[strings.TrimSpace(key)] = strings.TrimSpace(value)
	}

	return out
}

// fixtureOID returns one fixture metadata object ID value.
func fixtureOID(t *testing.T, algo objectid.Algorithm, key string) objectid.ObjectID {
	t.Helper()

	meta := fixtureMetadata(t, algo)

	hex, ok := meta[key]
	if !ok {
		t.Fatalf("missing fixture metadata key %q", key)
	}

	id, err := objectid.ParseHex(algo, hex)
	if err != nil {
		t.Fatalf("parse fixture metadata oid %q: %v", hex, err)
	}

	return id
}

// verifyReindexOracle regenerates idx/rev with upstream git index-pack and
// compares bytes with files produced by ingest.
func verifyReindexOracle(t *testing.T, repo *testgit.TestRepo, packName, idxName, revName string) {
	t.Helper()

	oracleDir := t.TempDir()
	oracleIdxPath := filepath.Join(oracleDir, "oracle.idx")
	_ = repo.Run(t, "index-pack", "--rev-index", "-o", oracleIdxPath, filepath.Join("objects", "pack", packName))
	oracleRevPath := strings.TrimSuffix(oracleIdxPath, ".idx") + ".rev"

	packRoot := repo.OpenPackRoot(t)

	gotIdx, err := packRoot.ReadFile(idxName)
	if err != nil {
		t.Fatalf("read idx: %v", err)
	}

	oracleRoot, err := os.OpenRoot(oracleDir)
	if err != nil {
		t.Fatalf("open oracle root: %v", err)
	}

	defer func() {
		err := oracleRoot.Close()
		if err != nil {
			t.Fatalf("close oracle root: %v", err)
		}
	}()

	wantIdx, err := oracleRoot.ReadFile(filepath.Base(oracleIdxPath))
	if err != nil {
		t.Fatalf("read oracle idx: %v", err)
	}

	if !bytes.Equal(gotIdx, wantIdx) {
		t.Fatal("idx bytes differ from git index-pack output")
	}

	gotRev, err := packRoot.ReadFile(revName)
	if err != nil {
		t.Fatalf("read rev: %v", err)
	}

	wantRev, err := oracleRoot.ReadFile(filepath.Base(oracleRevPath))
	if err != nil {
		t.Fatalf("read oracle rev: %v", err)
	}

	if !bytes.Equal(gotRev, wantRev) {
		t.Fatal("rev bytes differ from git index-pack output")
	}
}

func TestIngestNonThinPackWritesPackIdxRev(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		head := fixtureOID(t, algo, "head")
		packBytes := fixtureBytes(t, algo, "nonthin.pack")

		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

		packRoot := receiver.OpenPackRoot(t)

		result, err := beginAndContinue(bytes.NewReader(packBytes), packRoot, algo, ingest.Options{
			WriteRev:           true,
			RequireTrailingEOF: true,
		})
		if err != nil {
			t.Fatalf("Ingest: %v", err)
		}

		if result.ThinFixed {
			t.Fatalf("ThinFixed = true, want false")
		}

		if result.RevName == "" {
			t.Fatal("RevName is empty")
		}

		_, err = packRoot.Stat(result.PackName)
		if err != nil {
			t.Fatalf("stat pack: %v", err)
		}

		_, err = packRoot.Stat(result.IdxName)
		if err != nil {
			t.Fatalf("stat idx: %v", err)
		}

		_, err = packRoot.Stat(result.RevName)
		if err != nil {
			t.Fatalf("stat rev: %v", err)
		}

		_ = receiver.Run(t, "verify-pack", "-v", filepath.Join("objects", "pack", result.IdxName))
		verifyReindexOracle(t, receiver, result.PackName, result.IdxName, result.RevName)

		receiver.UpdateRef(t, "refs/heads/main", head)
		_ = receiver.Run(t, "fsck", "--full", "--strict", "--no-progress", "--no-dangling")
	})
}

func TestIngestThinPackWithoutFixReturnsUnresolved(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		thinPack := fixtureBytes(t, algo, "thin.pack")

		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
		packRoot := receiver.OpenPackRoot(t)

		_, err := beginAndContinue(bytes.NewReader(thinPack), packRoot, algo, ingest.Options{
			WriteRev:           true,
			RequireTrailingEOF: true,
		})
		if err == nil {
			t.Fatal("Ingest error = nil, want error")
		}

		if _, ok := errors.AsType[*ingest.ThinPackUnresolvedError](err); !ok {
			t.Fatalf("Ingest error type = %T (%v), want *ThinPackUnresolvedError", err, err)
		}

		entries, err := fs.ReadDir(packRoot.FS(), ".")
		if err != nil {
			t.Fatalf("ReadDir(pack): %v", err)
		}

		for _, entry := range entries {
			if strings.HasSuffix(entry.Name(), ".pack") {
				t.Fatalf("found finalized pack file after failure: %v", entry.Name())
			}
		}
	})
}

func TestIngestThinPackWithFixThin(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		head := fixtureOID(t, algo, "head")
		basePack := fixtureBytes(t, algo, "base.pack")
		thinPack := fixtureBytes(t, algo, "thin.pack")
		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})

		packRoot := receiver.OpenPackRoot(t)

		_, err := beginAndContinue(bytes.NewReader(basePack), packRoot, algo, ingest.Options{
			RequireTrailingEOF: true,
		})
		if err != nil {
			t.Fatalf("ingest base pack: %v", err)
		}

		receiverRepo := receiver.OpenRepository(t)

		result, err := beginAndContinue(bytes.NewReader(thinPack), packRoot, algo, ingest.Options{
			FixThin:            true,
			WriteRev:           true,
			Base:               receiverRepo.Objects(),
			RequireTrailingEOF: true,
		})
		if err != nil {
			t.Fatalf("Ingest(thin): %v", err)
		}

		if !result.ThinFixed {
			t.Fatal("ThinFixed = false, want true")
		}

		_ = receiver.Run(t, "verify-pack", "-v", filepath.Join("objects", "pack", result.IdxName))
		verifyReindexOracle(t, receiver, result.PackName, result.IdxName, result.RevName)
		receiver.UpdateRef(t, "refs/heads/main", head)
		_ = receiver.Run(t, "fsck", "--full", "--strict", "--no-progress", "--no-dangling")
	})
}

func TestIngestPackTrailerMismatch(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		packBytes := fixtureBytes(t, algo, "nonthin.pack")
		if len(packBytes) == 0 {
			t.Fatal("empty pack stream")
		}

		packBytes[len(packBytes)-1] ^= 0xff

		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
		packRoot := receiver.OpenPackRoot(t)

		_, err := beginAndContinue(bytes.NewReader(packBytes), packRoot, algo, ingest.Options{
			WriteRev:           true,
			RequireTrailingEOF: true,
		})
		if err == nil {
			t.Fatal("Ingest error = nil, want error")
		}

		if _, ok := errors.AsType[*ingest.PackTrailerMismatchError](err); !ok {
			t.Fatalf("Ingest error type = %T (%v), want *PackTrailerMismatchError", err, err)
		}

		entries, err := fs.ReadDir(packRoot.FS(), ".")
		if err != nil {
			t.Fatalf("ReadDir(pack): %v", err)
		}

		for _, entry := range entries {
			if strings.HasSuffix(entry.Name(), ".pack") {
				t.Fatalf("found finalized pack file after failure: %v", entry.Name())
			}
		}
	})
}

func zeroObjectPackBytes(t *testing.T, algo objectid.Algorithm) []byte {
	t.Helper()

	hashImpl, err := algo.New()
	if err != nil {
		t.Fatalf("algo.New: %v", err)
	}

	var header [12]byte
	copy(header[:4], []byte{'P', 'A', 'C', 'K'})
	binary.BigEndian.PutUint32(header[4:8], 2)
	binary.BigEndian.PutUint32(header[8:12], 0)

	_, _ = hashImpl.Write(header[:])

	return append(header[:], hashImpl.Sum(nil)...)
}

func TestIngestDiscardZeroObjectPack(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		packBytes := zeroObjectPackBytes(t, algo)

		pending, err := ingest.Ingest(bytes.NewReader(packBytes), algo, ingest.Options{
			RequireTrailingEOF: true,
		})
		if err != nil {
			t.Fatalf("Ingest: %v", err)
		}

		if pending.Header().ObjectCount != 0 {
			t.Fatalf("ObjectCount = %d, want 0", pending.Header().ObjectCount)
		}

		discarded, err := pending.Discard()
		if err != nil {
			t.Fatalf("Discard: %v", err)
		}

		if discarded.ObjectCount != 0 {
			t.Fatalf("Discard.ObjectCount = %d, want 0", discarded.ObjectCount)
		}
	})
}

func TestIngestContinueRejectsZeroObjectPack(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		packBytes := zeroObjectPackBytes(t, algo)
		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
		packRoot := receiver.OpenPackRoot(t)

		pending, err := ingest.Ingest(bytes.NewReader(packBytes), algo, ingest.Options{
			RequireTrailingEOF: true,
		})
		if err != nil {
			t.Fatalf("Ingest: %v", err)
		}

		_, err = pending.Continue(packRoot)
		if !errors.Is(err, ingest.ErrZeroObjectContinue) {
			t.Fatalf("Continue error = %v, want ErrZeroObjectContinue", err)
		}
	})
}

func TestIngestCanFinishWithoutTrailingEOF(t *testing.T) {
	t.Parallel()

	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
		head := fixtureOID(t, algo, "head")
		packBytes := fixtureBytes(t, algo, "nonthin.pack")

		receiver := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
		packRoot := receiver.OpenPackRoot(t)

		result, err := beginAndContinue(&noExtraReadReader{reader: bytes.NewReader(packBytes)}, packRoot, algo, ingest.Options{
			WriteRev: true,
		})
		if err != nil {
			t.Fatalf("Ingest without trailing EOF: %v", err)
		}

		receiver.UpdateRef(t, "refs/heads/main", head)
		_ = receiver.Run(t, "verify-pack", "-v", filepath.Join("objects", "pack", result.IdxName))
		_ = receiver.Run(t, "fsck", "--full", "--strict", "--no-progress", "--no-dangling")
	})
}