Files
knowledge-governance/internal/librarysnapshot/usage_test.go
T
2026-10-27 23:44:12 +08:00

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")
}
}