139 lines
2.9 KiB
Go
139 lines
2.9 KiB
Go
package librarysnapshot
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestArchiveRecoveryIndependentOfSourceAndUsageByReferences(t *testing.T) {
|
|
root := t.TempDir()
|
|
_ = os.Chmod(root, 0700)
|
|
a, err := Open(root, 1024)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer a.Close()
|
|
source := filepath.Join(t.TempDir(), "source")
|
|
if err := os.WriteFile(source, []byte("first"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f, err := os.Open(source)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
blob, err := a.Put(f)
|
|
f.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = os.Remove(source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reader, err := a.OpenPart(blob)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
restored, err := io.ReadAll(reader)
|
|
reader.Close()
|
|
if err != nil || string(restored) != "first" {
|
|
t.Fatal("restore still depends on source")
|
|
}
|
|
empty, err := a.Put(bytes.NewBufferString("[]"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := testManifest(empty)
|
|
first, err := a.Seal(m)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m.CreatedAt = m.CreatedAt.Add(time.Second)
|
|
second, err := a.Seal(m)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := a.Usage()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 {
|
|
t.Fatalf("versions=%d", len(got))
|
|
}
|
|
for _, u := range got {
|
|
if u.VersionID != first && u.VersionID != second {
|
|
t.Fatal("unexpected version")
|
|
}
|
|
if u.LogicalBytes != 22 || u.UniqueBytes != 2 || u.SharedBytes != 2 || u.ExclusiveBytes != 0 {
|
|
t.Fatalf("bad shared accounting: %+v", u)
|
|
}
|
|
}
|
|
// A digest with no manifest reference must not inflate either version.
|
|
if len(restored) != 5 {
|
|
t.Fatal("fixture unexpected")
|
|
}
|
|
}
|
|
|
|
func TestArchiveConcurrentWritersAndReadSafety(t *testing.T) {
|
|
root := t.TempDir()
|
|
_ = os.Chmod(root, 0700)
|
|
a, err := Open(root, 16)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer a.Close()
|
|
b, err := Open(root, 16)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer b.Close()
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 12; i++ {
|
|
wg.Add(1)
|
|
go func(i int) {
|
|
defer wg.Done()
|
|
archive := a
|
|
if i%2 == 0 {
|
|
archive = b
|
|
}
|
|
p, err := archive.Put(bytes.NewBufferString("[]"))
|
|
if err != nil {
|
|
t.Error(err)
|
|
return
|
|
}
|
|
if _, err = archive.Seal(testManifest(p)); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}(i)
|
|
}
|
|
wg.Wait()
|
|
got, err := a.Usage()
|
|
if err != nil || len(got) != 1 {
|
|
t.Fatalf("concurrent publication: err=%v versions=%d", err, len(got))
|
|
}
|
|
if _, err = a.Put(bytes.NewBufferString("this is more than sixteen bytes")); err == nil {
|
|
t.Fatal("oversized blob accepted")
|
|
}
|
|
p, err := a.Put(bytes.NewBufferString("[]"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
target := filepath.Join(root, "blobs", p.SHA256)
|
|
if err = os.Remove(target); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = os.Symlink(filepath.Join(t.TempDir(), "outside"), target); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = a.OpenPart(p); err == nil {
|
|
t.Fatal("symlink followed")
|
|
}
|
|
if _, err = a.Usage(); err == nil {
|
|
t.Fatal("corrupt dependency reported as safe usage")
|
|
}
|
|
}
|