ref: 0587025b7d48bae29b0843c2c4ab691b99f82752
dir: /objects_test.go/
package furgit
import (
"bytes"
"fmt"
"path/filepath"
"strings"
"testing"
)
func mustHash(t *testing.T, hex string) Hash {
id, err := ParseHash(hex)
if err != nil {
t.Fatalf("ParseHash failed: %v", err)
}
return id
}
func hashWithByte(fill byte) Hash {
var h Hash
for i := range h {
h[i] = fill
fill++
}
return h
}
func TestLoosePathUsesExpectedLayout(t *testing.T) {
id := mustHash(t, "0123456789abcdef0123456789abcdef01234567")
expect := filepath.Join("objects", "01", "23456789abcdef0123456789abcdef01234567")
if got := loosePath(id); got != expect {
t.Fatalf("unexpected loose path: %q", got)
}
}
func TestParseBlobAndSerialize(t *testing.T) {
data := []byte("blob payload")
id := hashWithByte(0x10)
blob, err := parseBlob(id, data)
if err != nil {
t.Fatalf("parseBlob error: %v", err)
}
if !bytes.Equal(blob.Data, data) {
t.Fatalf("blob data mismatch: %q", blob.Data)
}
if blob.Hash != id {
t.Fatalf("blob hash mismatch: %v", blob.Hash)
}
raw, err := blob.Serialize()
if err != nil {
t.Fatalf("Serialize error: %v", err)
}
header, err := headerForType(ObjBlob, data)
if err != nil {
t.Fatalf("headerForType: %v", err)
}
want := append(append([]byte(nil), header...), data...)
if !bytes.Equal(raw, want) {
t.Fatalf("serialized blob mismatch")
}
}
func TestParseTreeAndSerialize(t *testing.T) {
entries := []TreeEntry{
{Mode: 0100644, Name: []byte("file.txt"), ID: hashWithByte(0x20)},
{Mode: 040000, Name: []byte("subdir"), ID: hashWithByte(0x30)},
}
body := treeBody(&Tree{Entries: entries})
id := hashWithByte(0x40)
tree, err := parseTree(id, body)
if err != nil {
t.Fatalf("parseTree error: %v", err)
}
if len(tree.Entries) != len(entries) {
t.Fatalf("expected %d entries, got %d", len(entries), len(tree.Entries))
}
for i := range entries {
if tree.Entries[i].Mode != entries[i].Mode || !bytes.Equal(tree.Entries[i].Name, entries[i].Name) || tree.Entries[i].ID != entries[i].ID {
t.Fatalf("entry %d mismatch", i)
}
}
serialized, err := (&Tree{Entries: entries}).Serialize()
if err != nil {
t.Fatalf("Serialize error: %v", err)
}
header, _ := headerForType(ObjTree, body)
want := append(append([]byte(nil), header...), body...)
if !bytes.Equal(serialized, want) {
t.Fatalf("serialized tree mismatch")
}
}
func TestParseCommitWithExtraHeader(t *testing.T) {
treeID := hashWithByte(0x50)
parent := hashWithByte(0x60)
ident := Ident{
Name: []byte("Alice"),
Email: []byte("alice@example.com"),
WhenUnix: 1700000000,
OffsetMinutes: -420,
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "tree %s\n", treeID.String())
fmt.Fprintf(&buf, "parent %s\n", parent.String())
buf.WriteString("author ")
buf.Write(ident.Serialize())
buf.WriteByte('\n')
buf.WriteString("committer ")
buf.Write(ident.Serialize())
buf.WriteByte('\n')
buf.WriteString("extra data\n\nMessage body\n")
commit, err := parseCommit(hashWithByte(0x70), buf.Bytes())
if err != nil {
t.Fatalf("parseCommit error: %v", err)
}
if commit.Tree != treeID {
t.Fatalf("tree mismatch")
}
if len(commit.Parents) != 1 || commit.Parents[0] != parent {
t.Fatalf("parent mismatch: %+v", commit.Parents)
}
if string(commit.Message) != "Message body\n" {
t.Fatalf("message mismatch: %q", commit.Message)
}
if len(commit.ExtraHeaders) != 1 || commit.ExtraHeaders[0].Key != "extra" || !bytes.Equal(commit.ExtraHeaders[0].Value, []byte("data")) {
t.Fatalf("extra headers mismatch: %+v", commit.ExtraHeaders)
}
roundTrip := &Commit{
Tree: treeID,
Parents: []Hash{parent},
Author: ident,
Committer: ident,
Message: []byte("Message body\n"),
}
raw, err := roundTrip.Serialize()
if err != nil {
t.Fatalf("Serialize error: %v", err)
}
if !strings.Contains(string(raw), "tree "+treeID.String()) {
t.Fatalf("serialized commit missing tree header")
}
}
func TestParseTagAndSerialize(t *testing.T) {
target := hashWithByte(0x80)
tagger := &Ident{
Name: []byte("Tagger"),
Email: []byte("tagger@example.com"),
WhenUnix: 1234,
OffsetMinutes: 0,
}
var buf bytes.Buffer
buf.WriteString("object ")
buf.WriteString(target.String())
buf.WriteByte('\n')
buf.WriteString("type commit\n")
buf.WriteString("tag v1.0\n")
buf.WriteString("tagger ")
buf.Write(tagger.Serialize())
buf.WriteString("\n\nannotated tag\n")
body := append([]byte(nil), buf.Bytes()...)
tag, err := parseTag(hashWithByte(0x90), body)
if err != nil {
t.Fatalf("parseTag error: %v", err)
}
if tag.Target != target || tag.TargetType != ObjCommit {
t.Fatalf("tag target mismatch")
}
if tag.Tagger == nil {
t.Fatalf("tagger missing in body %q", string(body))
}
if !bytes.Contains(tag.Tagger.Name, []byte("Tagger")) {
t.Fatalf("tagger name mismatch: %q", tag.Tagger.Name)
}
if string(tag.Name) != "v1.0" {
t.Fatalf("tag name mismatch: %q", tag.Name)
}
serialized, err := tag.Serialize()
if err != nil {
t.Fatalf("Serialize error: %v", err)
}
if !strings.Contains(string(serialized), "tag v1.0") {
t.Fatalf("serialized tag missing name header")
}
}