93 lines
3.5 KiB
Go
93 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/declaration"
|
|
"github.com/novox/mesh-host/internal/link"
|
|
)
|
|
|
|
// aFilesLink is a link that serves objects by name.
|
|
type aFilesLink struct{ objects map[string][]byte }
|
|
|
|
func (a aFilesLink) FileObject(_ context.Context, name string, _ int64) ([]byte, error) {
|
|
if b, ok := a.objects[name]; ok {
|
|
return b, nil
|
|
}
|
|
return nil, os.ErrNotExist
|
|
}
|
|
|
|
func referenceDeclaration(path string, body []byte) []byte {
|
|
return []byte(`{"declaration":1,"resources":[{"id":"m.big","type":"file","path":"` + path + `","digest":"` +
|
|
declaration.DigestOf(body) + `","size":` + strconv.Itoa(len(body)) + `}]}`)
|
|
}
|
|
|
|
// 1695/AC1 and AC2, through the whole apply: a reference is fetched, verified and written; a differing object
|
|
// refuses the declaration whole and writes nothing.
|
|
func TestADeclarationWithAFileByDigestAppliesFromTheObject(t *testing.T) {
|
|
unansweringPacman(t)
|
|
body := []byte(strings.Repeat("a line of a big file\n", 4000))
|
|
name, _ := declaration.ObjectName(declaration.DigestOf(body))
|
|
dir := t.TempDir()
|
|
target := filepath.Join(dir, "big")
|
|
opts := options{state: filepath.Join(dir, "state.json"), out: &strings.Builder{}}
|
|
raw := referenceDeclaration(target, body)
|
|
|
|
bad := append([]byte(nil), body...)
|
|
bad[10] ^= 1
|
|
ctx := link.WithFiles(context.Background(), aFilesLink{map[string][]byte{name: bad}})
|
|
report := applyAndKeep(ctx, opts, raw, nil, nil, nil)
|
|
if report.Refused == "" || !strings.Contains(report.Refused, "m.big") {
|
|
t.Errorf("1695/AC2: a differing object did not refuse the declaration: %+v", report)
|
|
}
|
|
if _, err := os.Stat(target); err == nil {
|
|
t.Error("1695/AC2: a file was written from an object that differs")
|
|
}
|
|
|
|
ctx = link.WithFiles(context.Background(), aFilesLink{map[string][]byte{name: body}})
|
|
report = applyAndKeep(ctx, opts, raw, nil, nil, nil)
|
|
if report.Refused != "" {
|
|
t.Fatalf("1695/AC1: refused: %s", report.Refused)
|
|
}
|
|
got, err := os.ReadFile(target)
|
|
if err != nil || string(got) != string(body) {
|
|
t.Errorf("1695/AC1: the file holds %d bytes (%v), want %d", len(got), err, len(body))
|
|
}
|
|
}
|
|
|
|
// 1695/AC8: the hand-run `apply <file>` and `reconcile` have no bus: a reference whose file here verifies is applied
|
|
// as it is, any other refuses and writes nothing — never an empty file.
|
|
func TestTheHandApplyNeverWritesAReferenceEmpty(t *testing.T) {
|
|
unansweringPacman(t)
|
|
body := []byte(strings.Repeat("a line of a big file\n", 4000))
|
|
dir := t.TempDir()
|
|
target := filepath.Join(dir, "big")
|
|
opts := options{state: filepath.Join(dir, "state.json"), out: &strings.Builder{}}
|
|
raw := referenceDeclaration(target, body)
|
|
d, err := declaration.ParseFileTrusted(raw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := runApply(context.Background(), opts, d, raw, fromFile); err == nil || !strings.Contains(err.Error(), "digest") {
|
|
t.Errorf("1695/AC8: a reference with no file and no bus was not refused: %v", err)
|
|
}
|
|
if _, err := os.Stat(target); err == nil {
|
|
t.Error("1695/AC8: a file was written for a reference that could not be had")
|
|
}
|
|
if err := os.WriteFile(target, body, 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, _ = declaration.ParseFileTrusted(raw)
|
|
if err := runApply(context.Background(), opts, d, raw, fromFile); err != nil && !strings.Contains(err.Error(), "applied only in part") {
|
|
t.Fatalf("1695/AC8: %v", err)
|
|
}
|
|
if got, _ := os.ReadFile(target); string(got) != string(body) {
|
|
t.Errorf("1695/AC8: the file holds %d bytes, want %d", len(got), len(body))
|
|
}
|
|
}
|