Files
archie/internal/app/archieui/compose_test.go
T
sam 96aa05c470 fix(archieui): let the boundary guard permit a contract-backed channel reader
The UI boundary test forbade wiring Server.Channels, and it was right about what
the field used to hold: a live *status.Manager is a runtime handle this process has
no business owning. It now holds a reader over the State Store's channel-status
contract, which is the same shape as the Mappings, Bindings and ApplyStatus fields
the guard already expects to be wired. The distinction it draws is the handle, not
the name, so the assertion moves with the field and says why.

Also adopts task fmt's rewrite of the reader's status construction: go fix drops
the explicit embedded Descriptor, and formatter output is law here.
2026-09-22 08:10:01 +10:00

157 lines
6.4 KiB
Go

package archieui
import (
"log/slog"
"reflect"
"testing"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/store"
)
// isNil reports whether v is nil, including a typed nil func or pointer
// carried inside a non-nil interface -- a plain `v != nil` reports those as
// present.
func isNil(v any) bool {
rv := reflect.ValueOf(v)
if !rv.IsValid() {
return true
}
switch rv.Kind() {
case reflect.Func, reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice, reflect.Chan:
return rv.IsNil()
default:
return false
}
}
// TestComposeUIServerHoldsNoDaemonState is the acceptance criterion the parent
// bead names first: the UI process's dashboard "no longer receives the
// daemon's live config.Holder". webui.Server no longer has a holder field to
// receive (archie-core-ml30), so that clause is now enforced by the type
// rather than asserted here. What remains to pin is the rest of the
// composition: the two contract-backed fields hold remote clients, and every
// daemon-local runtime handle stays nil so the process cannot hold in-process
// daemon state by accident (docs/prds/ui-service-boundary.md, "Boundary and
// ownership").
func TestComposeUIServerHoldsNoDaemonState(t *testing.T) {
stateConn, err := grpc.NewClient("passthrough:///127.0.0.1:1", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("state client: %v", err)
}
defer stateConn.Close()
gatewayConn, err := grpc.NewClient("passthrough:///127.0.0.1:1", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("gateway client: %v", err)
}
defer gatewayConn.Close()
srv := compose(deps{
Options: Options{Listen: "127.0.0.1:8484", Token: "tok"},
Log: slog.New(slog.DiscardHandler),
Store: staterpc.NewClient(stateConn),
Chat: gatewayrpc.NewClient(gatewayConn),
})
if _, ok := srv.Store.(*staterpc.Client); !ok {
t.Fatalf("Store = %T, want *staterpc.Client", srv.Store)
}
if _, ok := srv.Store.(*store.Store); ok {
t.Fatal("Store is the concrete *store.Store; the UI process must not open archie.db")
}
if srv.Chat == nil {
t.Fatal("Chat is nil; the UI process must dial the Gateway contract")
}
if _, ok := srv.Chat.Contract.(*gatewayrpc.Client); !ok {
t.Fatalf("Chat.Contract = %T, want *gatewayrpc.Client", srv.Chat.Contract)
}
if srv.Chat.Updates != nil {
t.Error("Chat.Updates is wired; host-local install/restart stays with the daemon")
}
if srv.Token != "tok" {
t.Fatalf("Token = %q, want the UI process's own token", srv.Token)
}
unwired := map[string]any{
"ReloadChannel": srv.ReloadChannel,
"RunningVersions": srv.RunningVersions,
"Events": srv.Events,
"Curators": srv.Curators,
"LogFeed": srv.LogFeed,
"WorkRequests": srv.WorkRequests,
}
for name, handle := range unwired {
if !isNil(handle) {
t.Errorf("%s is wired; it is a daemon-owned callback or runtime handle with no contract behind it yet", name)
}
}
// Channels is the same shape as Mappings/Bindings below: the field used to
// hold a live *status.Manager, which is a runtime handle this process has no
// business owning, and it now holds a reader over the State Store's
// channel-status contract (webui.RemoteChannelStatus). The distinction the
// guard draws is the handle, not the name.
if srv.Channels == nil {
t.Error("Channels is unwired; the channel-status pair is a State Store contract the composed client implements")
}
// Mappings and bindings are the other way round: ratified State Store
// contracts, carried by the client this process already holds, so
// leaving them nil would degrade two pages that have an owner.
if srv.Mappings == nil || srv.Bindings == nil {
t.Error("Mappings/Bindings are unwired; both are State Store contracts the composed client implements")
}
// TaskLogs is the same shape as Mappings/Bindings -- the store client
// carries TaskLogStore -- and it is the one that used to answer "task
// logging was not enabled for this run" for every attempt in a deployment
// where logging is unconditional (archie-core-iaqx).
if srv.TaskLogs == nil {
t.Error("TaskLogs is unwired; the State Store client implements TaskLogStore, so leaving it nil degrades a page that has an owner")
}
if _, ok := srv.TaskLogs.(*staterpc.Client); !ok {
t.Errorf("TaskLogs = %T, want the remote *staterpc.Client: the UI process owns no state directory to read a log file from", srv.TaskLogs)
}
if srv.UpdateReportPath != "" {
t.Error("UpdateReportPath is set; host-local update relay stays with the daemon")
}
}
// TestComposeWiresCaptureIntake pins the cutover rule: once the daemon's
// dashboard listener is gone (archie-core-8cda.5.4), this process is the
// only listener serving POST /webhooks/capture/{source}, so compose must
// mount the receiver when the store contract carries it -- a capture POST
// answered by a token-gated 404 would leave intake with no owner. Zero
// Options.Capture falls back to configuration.DefaultCapture, the same
// defaults a decoded config would project.
func TestComposeWiresCaptureIntake(t *testing.T) {
stateConn, err := grpc.NewClient("passthrough:///127.0.0.1:1", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
t.Fatalf("state client: %v", err)
}
defer stateConn.Close()
srv := compose(deps{
Options: Options{},
Log: slog.New(slog.DiscardHandler),
Store: staterpc.NewClient(stateConn),
})
if srv.Captures == nil || srv.CaptureIntake == nil {
t.Fatal("capture intake is unset; the UI process is the only listener serving POST /webhooks/capture/{source} after the cutover (bead archie-core-8cda.5.4)")
}
defaults := configuration.DefaultCapture()
if srv.CaptureMaxEvents != defaults.MaxEvents {
t.Errorf("CaptureMaxEvents = %d, want the default %d", srv.CaptureMaxEvents, defaults.MaxEvents)
}
// A store without the capture contract keeps both surfaces unset and
// degrades the read instead of mounting an intake route that cannot
// persist what arrives.
empty := compose(deps{Options: Options{}, Log: slog.New(slog.DiscardHandler)})
if empty.Captures != nil || empty.CaptureIntake != nil || empty.CaptureMaxEvents != 0 {
t.Error("capture surfaces wired without a CaptureStore behind them")
}
}