97 lines
3.9 KiB
Go
97 lines
3.9 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
meshasker "git.novox.be/novox/mesh-sdk/go/asker"
|
|
"git.novox.be/novox/mesh-sdk/go/asks"
|
|
"git.novox.be/novox/mesh-sdk/go/declaration"
|
|
"github.com/novox/mesh-host/internal/apply"
|
|
"github.com/novox/mesh-host/internal/link"
|
|
)
|
|
|
|
// A library whose root holds data never taken is said waiting with one access wait: the access `library:<name>`, the
|
|
// part its name, words with no path, the filesystem's name, and reason keep (novox/hq ADR 0328 §8); one whose root
|
|
// is absent waits with reason disk (§9). Neither carries a module.
|
|
func TestALibrarySaysItsWaitWithoutWordsToParse(t *testing.T) {
|
|
was := apply.Libraries
|
|
apply.Libraries = apply.NewLibraryMemory()
|
|
defer func() { apply.Libraries = was }()
|
|
dir := t.TempDir()
|
|
root := filepath.Join(dir, "media")
|
|
if err := os.MkdirAll(filepath.Join(root, "a film"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, err := declaration.Parse([]byte(`{"declaration":1,"groups":[{"name":"mesh-media","gid":62000},` +
|
|
`{"name":"mesh-books","gid":62001}],"libraries":[` +
|
|
`{"library":"media","root":"` + root + `","group":"mesh-media","gid":62000,"home":true},` +
|
|
`{"library":"books","root":"` + filepath.Join(dir, "books") + `","group":"mesh-books","gid":62001,"home":true}],` +
|
|
`"owns_nothing":true,"resources":[]}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j := newLibraryJudge()
|
|
j.set(d, nil)
|
|
vs, _ := j.look(time.Now())
|
|
if len(vs) != 2 {
|
|
t.Fatalf("the libraries are not said: %+v", vs)
|
|
}
|
|
books, media := vs[0], vs[1]
|
|
if media.Kind != link.KindLibrary || media.Resource != "library:media" || media.Module != "" ||
|
|
media.State != link.StateWaiting || len(media.AccessWaits) != 1 {
|
|
t.Fatalf("a library holding data is not said waiting: %+v", media)
|
|
}
|
|
raw, _ := json.Marshal(media.AccessWaits[0])
|
|
want := `{"kind":"access","access":"library:media","part":"media","what":"let the mesh keep the library media",` +
|
|
`"placed":"` + media.AccessWaits[0].Placed + `","reason":"keep"}`
|
|
if string(raw) != want || !strings.HasPrefix(media.AccessWaits[0].Placed, "fs-") {
|
|
t.Fatalf("the wait reads %s", raw)
|
|
}
|
|
if strings.Contains(media.Reason, dir) || len(books.AccessWaits) != 1 || books.AccessWaits[0].Reason != link.WaitDisk {
|
|
t.Fatalf("a missing root does not wait for its disk, or a reason names a path: %+v %+v", books, media)
|
|
}
|
|
// 774 (ADR 0563 §4): the library's home engine asks its take of the operator itself, once: no second ask while one is
|
|
// open, nor after it ended; and a library waiting for its disk is not asked.
|
|
t.Run("the home engine asks the take once", func(t *testing.T) {
|
|
var asked []asks.Ask
|
|
state := &link.MemState{}
|
|
h := &link.HandActs{Node: "n1", State: state,
|
|
JudgeAccess: func(act, access string) (link.Judged, error) {
|
|
return link.Judged{Subject: access, Path: root, Sets: "the group mesh-media", Disk: "0:0 755"}, nil
|
|
},
|
|
AccessAct: func(link.AccessAct) (string, error) { return "taken", nil }}
|
|
h.Asker = &meshasker.Client{Module: asks.EngineAsker("n1"), State: state,
|
|
Publish: func(subject string, body any, id string) error {
|
|
if a, ok := body.(asks.Ask); ok {
|
|
asked = append(asked, a)
|
|
}
|
|
return nil
|
|
}}
|
|
waiting := keepWaiting(vs)
|
|
askTakes(h, waiting, nil)
|
|
askTakes(h, waiting, nil)
|
|
if len(waiting) != 1 || waiting[0] != "library:media" || len(asked) != 1 {
|
|
t.Fatalf("waiting %v asked %d times", waiting, len(asked))
|
|
}
|
|
h.Heard(asks.Warrant{Ask: asked[0].ID, Asker: asks.EngineAsker("n1"), Outcome: asks.OutcomeExpired, At: time.Now()})
|
|
askTakes(h, waiting, nil)
|
|
if len(asked) != 1 {
|
|
t.Fatalf("the take was asked again after its ask ended: %d", len(asked))
|
|
}
|
|
// Kept in a key of its own (rev-l3 round 1): the acts gone from the record never make it ask again.
|
|
keys, _ := state.Keys("act.")
|
|
for _, k := range keys {
|
|
_ = state.Delete(k)
|
|
}
|
|
askTakes(h, waiting, nil)
|
|
if len(asked) != 1 {
|
|
t.Fatalf("the take was asked again with the acts gone: %d", len(asked))
|
|
}
|
|
})
|
|
}
|