novox/mesh-delivery
19
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

mesh-delivery-indexer: its integration test no longer reads verdicts through mesh-sdk's composition reader

Browse Source 
ADR 0593 §7: compose and frombus left mesh-sdk for the node-engine, so how a composer holds a refused
module is the engine's to test; the indexer's test keeps proving the verdicts and refusals it writes.

Claude-Session: https://claude.ai/code/session_01NcbgfJ9Gum47zkFKWRaovL
This commit is contained in:
jschoubben
2026-11-02 19:00:16 +01:00
parent fbb50f8fcd
commit c12804f4d9
1 changed files with 2 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go
+2 -112
View File
@@ -4,9 +4,6 @@ package main
import (
"context"
"crypto/ecdh"
"crypto/rand"
"encoding/base64"
"encoding/json"
"fmt"
"io"
@@ -21,8 +18,6 @@ import (
"github.com/nats-io/nats.go/jetstream"
"git.novox.be/novox/mesh-sdk/go/buscompose"
"git.novox.be/novox/mesh-sdk/go/compose"
"git.novox.be/novox/mesh-sdk/go/compose/frombus"
"git.novox.be/novox/mesh-sdk/go/delivery"
"git.novox.be/novox/mesh-sdk/go/process"
)
@@ -343,113 +338,8 @@ func TestIndexerKeepsManifestsAtAMerge(t *testing.T) { // 1444/AC4, 1449/AC4, 15
if !said["bad"] || !said["later"] || said["good"] {
t.Errorf("manifest-refused said for %v, want bad and later", said)
}
// mesh-sdk's bus reader over the indexer's modules and manifests: the refused modules held and named, the valid one
// composed, the read whole.
r := judgedReader{ctx: ctx, js: js, t: t}
items, _, held, err := frombus.DataItemsHeld(ctx, r, frombus.Mesh{}, frombus.Scope{Node: "n1"})
if err != nil || len(items["good"]) != 1 || items["bad"] != nil || items["later"] != nil ||
!strings.Contains(held["bad"], `provides "amqp"`) || !strings.Contains(held["later"], "a-field-from-later") {
t.Errorf("the bus reader after the judge: items %v held %v: %v", items, held, err)
}
// Before any verdict (a value without one, as an older indexer wrote it), the reader takes each as accepted and names
// the field it set aside.
for _, name := range []string{"bad", "later"} {
e, err := modules.Get(ctx, name)
if err != nil {
t.Fatal(err)
}
m, _ := delivery.DecodeModule(e.Value())
m.Verdict, m.Problems = "", nil
raw, _ := delivery.EncodeModule(m)
r.unjudged = append(r.unjudged, raw)
if r.values == nil {
r.values = map[string][]byte{}
}
r.values[name] = raw
}
in, err := frombus.Input(ctx, r, frombus.Mesh{}, frombus.Scope{Node: "n1"})
if err != nil || len(in.Refused) != 0 || !strings.Contains(in.SetAside["later"], "a-field-from-later") || in.Catalogue["later"].Stubbed {
t.Errorf("the bus reader before the judge: refused %v, set aside %v: %v", in.Refused, in.SetAside, err)
}
}
// judgedReader is mesh-sdk's bus reader over the indexer's modules and manifests on the bus, with good, bad and later placed
// on n1 and n1's record; values stand in for a module's value where set. It reads nothing else.
type judgedReader struct {
ctx context.Context
js jetstream.JetStream
t *testing.T
values map[string][]byte
unjudged [][]byte
}
func (r judgedReader) Placements(context.Context) (map[string]delivery.Placement, error) {
p := delivery.Placement{Node: "n1", Decided: delivery.NodeDecided{Hub: true, Address: "10.77.0.1"}}
for _, m := range []string{"good", "bad", "later"} {
p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
}
return map[string]delivery.Placement{"n1": p}, nil
}
func (r judgedReader) Records(context.Context) (map[string]delivery.NodeRecord, error) {
k, err := ecdh.X25519().GenerateKey(rand.Reader)
if err != nil {
return nil, err
}
return map[string]delivery.NodeRecord{"n1": {Node: "n1", TunnelKey: base64.StdEncoding.EncodeToString(k.PublicKey().Bytes()),
SealingKey: "sk", Capabilities: []string{"systemd"}}}, nil
}
func (r judgedReader) Modules(ctx context.Context) (map[string]delivery.Module, error) {
kv, err := r.js.KeyValue(ctx, delivery.ModulesBucket)
if err != nil {
return nil, err
}
out := map[string]delivery.Module{}
for _, name := range []string{"good", "bad", "later"} {
e, err := kv.Get(ctx, name)
if err != nil {
return nil, err
}
raw := e.Value()
if v, ok := r.values[name]; ok {
raw = v
}
m, err := delivery.DecodeModule(raw)
if err != nil {
return nil, err
}
out[name] = m
}
return out, nil
}
func (r judgedReader) Manifest(ctx context.Context, digest string) ([]byte, error) {
kv, err := r.js.KeyValue(ctx, delivery.ManifestsBucket)
if err != nil {
return nil, err
}
e, err := kv.Get(ctx, digest)
if err != nil {
return nil, err
}
m, err := delivery.DecodeManifest(e.Value())
return []byte(m.JSON), err
}
func (judgedReader) Values(context.Context, string, string) (map[string]any, error) { return nil, nil }
func (judgedReader) OwnSecrets(context.Context, string) ([]compose.OwnSecretRow, error) {
return nil, nil
}
func (judgedReader) Credentials(context.Context, string, []compose.CredentialKey, []compose.CredentialKey) ([]compose.Credential, []compose.Issued, error) {
return nil, nil, nil
}
func (judgedReader) Build(context.Context, string, string) (*delivery.BuilderBuild, error) {
return nil, nil
}
func (judgedReader) Archive(context.Context, string, string) ([]byte, error) { return nil, nil }
func (judgedReader) Served(context.Context, string, string, []string) (map[string]any, error) {
return nil, nil
// How a composer holds a refused module by these verdicts is the node-engine's to test (ADR 0593 §7: the composer
// and its bus reader are its own).
}
// TestIndexerWritesAGoModuleAgainWhenTheBuildModuleReportsItsToolchain: the bucket mesh-build-go_toolchains exists (the state