odb_test.go

package git

import (
"bytes"
"errors"
"fmt"
"io"
"io/ioutil"
"os"
"path"
"testing"
)

funcTestOdbRead(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)
odb, err:=repo.Odb()
iferr!=nil {
t.Fatalf("Odb: %v", err)
 }
data:= []byte("hello")
id, err:=odb.Write(data, ObjectBlob)
iferr!=nil {
t.Fatalf("odb.Write: %v", err)
 }

sz, typ, err:=odb.ReadHeader(id)
iferr!=nil {
t.Fatalf("ReadHeader: %v", err)
 }

ifsz!=uint64(len(data)) {
t.Errorf("ReadHeader got size %d, want %d", sz, len(data))
 }
iftyp!=ObjectBlob {
t.Errorf("ReadHeader got object type %s", typ)
 }

obj, err:=odb.Read(id)
iferr!=nil {
t.Fatalf("Read: %v", err)
 }
if!bytes.Equal(obj.Data(), data) {
t.Errorf("Read got wrong data")
 }
ifsz:=obj.Len(); sz!=uint64(len(data)) {
t.Errorf("Read got size %d, want %d", sz, len(data))
 }
iftyp:=obj.Type(); typ!=ObjectBlob {
t.Errorf("Read got object type %s", typ)
 }
}

funcTestOdbStream(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)

odb, err:=repo.Odb()
checkFatal(t, err)

str:="hello, world!"

writeStream, err:=odb.NewWriteStream(int64(len(str)), ObjectBlob)
checkFatal(t, err)
n, err:=io.WriteString(writeStream, str)
checkFatal(t, err)
ifn!=len(str) {
t.Fatalf("Bad write length %v != %v", n, len(str))
 }

err=writeStream.Close()
checkFatal(t, err)

expectedId, err:=NewOid("30f51a3fba5274d53522d0f19748456974647b4f")
checkFatal(t, err)
ifwriteStream.Id.Cmp(expectedId) !=0 {
t.Fatal("Wrong data written")
 }

readStream, err:=odb.NewReadStream(&writeStream.Id)
checkFatal(t, err)
data, err:=ioutil.ReadAll(readStream)
ifstr!=string(data) {
t.Fatalf("Wrong data read %v != %v", str, string(data))
 }
}

funcTestOdbHash(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)

odb, err:=repo.Odb()
checkFatal(t, err)

str:=`tree 115fcae49287c82eb55bb275cbbd4556fbed72b7
parent 66e1c476199ebcd3e304659992233132c5a52c6c
author John Doe <john@doe.com> 1390682018 +0000
committer John Doe <john@doe.com> 1390682018 +0000

Initial commit.`

for_, data:=range [][]byte{[]byte(str), doublePointerBytes()} {
oid, err:=odb.Hash(data, ObjectCommit)
checkFatal(t, err)

coid, err:=odb.Write(data, ObjectCommit)
checkFatal(t, err)

ifoid.Cmp(coid) !=0 {
t.Fatal("Hash and write Oids are different")
 }
 }
}

funcTestOdbForeach(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)

odb, err:=repo.Odb()
checkFatal(t, err)

expect:=3
count:=0
err=odb.ForEach(func(id*Oid) error {
count++
returnnil
 })

checkFatal(t, err)
ifcount!=expect {
t.Fatalf("Expected %v objects, got %v", expect, count)
 }

expect=1
count=0
to_return:=errors.New("not really an error")
err=odb.ForEach(func(id*Oid) error {
count++
returnto_return
 })

iferr!=to_return {
t.Fatalf("Odb.ForEach() did not return the expected error, got %v", err)
 }
}

funcTestOdbWritepack(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)

odb, err:=repo.Odb()
checkFatal(t, err)

varfinalStatsTransferProgress
writepack, err:=odb.NewWritePack(func(statsTransferProgress) error {
finalStats=stats
returnnil
 })
checkFatal(t, err)
deferwritepack.Free()

_, err=writepack.Write(outOfOrderPack)
checkFatal(t, err)
err=writepack.Commit()
checkFatal(t, err)

iffinalStats.TotalObjects!=3 {
t.Errorf("mismatched transferred objects, expected 3, got %v", finalStats.TotalObjects)
 }
iffinalStats.ReceivedObjects!=3 {
t.Errorf("mismatched received objects, expected 3, got %v", finalStats.ReceivedObjects)
 }
iffinalStats.IndexedObjects!=3 {
t.Errorf("mismatched indexed objects, expected 3, got %v", finalStats.IndexedObjects)
 }
}

funcTestOdbBackendLoose(t*testing.T) {
t.Parallel()
repo:=createTestRepo(t)
defercleanupTestRepo(t, repo)

_, _=seedTestRepo(t, repo)

odb, err:=repo.Odb()
checkFatal(t, err)

looseObjectsDir, err:=ioutil.TempDir("", fmt.Sprintf("loose_objects_%s", path.Base(repo.Path())))
checkFatal(t, err)
deferos.RemoveAll(looseObjectsDir)

looseObjectsBackend, err:=NewOdbBackendLoose(looseObjectsDir, -1, false, 0, 0)
checkFatal(t, err)
iferr:=odb.AddBackend(looseObjectsBackend, 999); err!=nil {
looseObjectsBackend.Free()
checkFatal(t, err)
 }

str:="hello, world!"

writeStream, err:=odb.NewWriteStream(int64(len(str)), ObjectBlob)
checkFatal(t, err)
n, err:=io.WriteString(writeStream, str)
checkFatal(t, err)
ifn!=len(str) {
t.Fatalf("Bad write length %v != %v", n, len(str))
 }

err=writeStream.Close()
checkFatal(t, err)

expectedId, err:=NewOid("30f51a3fba5274d53522d0f19748456974647b4f")
checkFatal(t, err)
if!writeStream.Id.Equal(expectedId) {
t.Fatalf("writeStream.id = %v; want %v", writeStream.Id, expectedId)
 }

_, err=os.Stat(path.Join(looseObjectsDir, expectedId.String()[:2], expectedId.String()[2:]))
checkFatal(t, err)
}