mesh-adminandClaude Opus 5.5
661918f4e4
mesh/merge-gate head 661918f4e4e0 merged into trunk 71362c196dbc — pass: the change touches no module of the mesh's graph
mesh/repo-check head 661918f4e4e0 merged into trunk 71362c196dbc — pass: its merge-check.sh passed
mesh/delivery delivered
mesh/delivery-group group pkg/57-v1-vault-in-go delivered: every member is delivered
The vault hands a secret only on request and reply, sealed to the asker's key (hq ADR 0349 §11). The seat set is the controller's, so the verb is promised here; optional until the vault that runs serves it (design 33 §7). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
57 lines
2.4 KiB
Go
57 lines
2.4 KiB
Go
package catalogue
|
|
|
|
import "testing"
|
|
|
|
// The vault's provision is one the controller itself dereferences — every minted credential is
|
|
// sealed with it — so it is delivered by a seat of the mesh's own, and a second provider is a second
|
|
// claimant refused by name rather than a candidate for a pin (novox/hq ADR 0161, issue 106).
|
|
func TestTheVaultsSeatDeliversSecret(t *testing.T) {
|
|
seat, known := SeatNamed("mesh-vault")
|
|
if !known {
|
|
t.Fatal("mesh-vault is not in the mesh's own set")
|
|
}
|
|
if seat.Scope != ScopeMesh || seat.Delivers != "secret" {
|
|
t.Fatalf("mesh-vault is %s-scoped and delivers %q; one per mesh, delivering secret", seat.Scope, seat.Delivers)
|
|
}
|
|
vault := Manifest{Module: "mesh-vault", Provides: []Offer{{Name: "secret", Scope: ScopeMesh}},
|
|
Claims: []Claim{{Name: "mesh-vault", Scope: ScopeMesh}}}
|
|
if err := CanHold(vault, seat); err != nil {
|
|
t.Fatalf("the vault, claiming its seat and providing secret, was refused: %v", err)
|
|
}
|
|
another := Manifest{Module: "other-vault", Provides: []Offer{{Name: "secret", Scope: ScopeMesh}}}
|
|
if err := CanHold(another, seat); err == nil {
|
|
t.Fatal("a provider of secret that does not claim the seat was allowed to hold it")
|
|
}
|
|
}
|
|
|
|
// The vault answers `get` on request and reply (novox/hq ADR 0349 §11, issue 674): the seat promises the
|
|
// verb, so a holder serving it is accepted — and, optional while the vault that runs is the TypeScript one,
|
|
// so is a holder that does not yet.
|
|
func TestTheVaultsSeatPromisesGet(t *testing.T) {
|
|
seat, _ := SeatNamed("mesh-vault")
|
|
var get *Verb
|
|
for i := range seat.Serves {
|
|
if seat.Serves[i].Name == "get" {
|
|
get = &seat.Serves[i]
|
|
}
|
|
}
|
|
if get == nil {
|
|
t.Fatal("the vault's seat does not promise get")
|
|
}
|
|
for _, arg := range []string{"name", "public_key"} {
|
|
if props, _ := get.Input["properties"].(map[string]any); props[arg] == nil {
|
|
t.Errorf("get takes no %s", arg)
|
|
}
|
|
}
|
|
serving := Manifest{Module: "mesh-vault", Provides: []Offer{{Name: "secret", Scope: ScopeMesh}},
|
|
Claims: []Claim{{Name: "mesh-vault", Scope: ScopeMesh, Serves: []string{"get"}}}}
|
|
if err := CanHold(serving, seat); err != nil {
|
|
t.Fatalf("the vault serving get was refused: %v", err)
|
|
}
|
|
notYet := Manifest{Module: "mesh-vault", Provides: []Offer{{Name: "secret", Scope: ScopeMesh}},
|
|
Claims: []Claim{{Name: "mesh-vault", Scope: ScopeMesh}}}
|
|
if err := CanHold(notYet, seat); err != nil {
|
|
t.Fatalf("the vault that does not serve get yet was refused: %v", err)
|
|
}
|
|
}
|