The control plane replaces this, rather than extending it (docs/prds/runtime-control-plane.md, "First implementation"). Until now both paths existed: overlay kept dashboard edits in its own SQLite file beside archie.db and layered them over the file config at boot and on every reload, which is the duplicate configuration authority the PRD set out to remove. Gone with it: the --no-config-overlay flag and ARCHIE_SKIP_CONFIG_OVERLAY recovery hatch, which existed because a bad overlay row could brick the boot; ReloadStatus.OverlayUnavailable; and the reload controller's overlay source. The -config-overlay file overlay is a different thing and stays. The dashboard's three write seams went too. UpdateConfig, ResetConfig and UpdateRepoField were assigned only in internal/webui's own tests, so in production they answered 503 and ConfigView.Editable was permanently false (archie-core-j28m). Removing Editable would otherwise have flipped the SPA's controls on, since configEditable read a missing field as true, so the config pages become what they already were in practice: a read of what each process is running with. Configuration is written through the control plane. apply.go survives this deliberately; archie-core-xrux carries the question of whether its map merge is still guarding the file overlay path.
150 lines
6.0 KiB
Go
150 lines
6.0 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,
|
|
"Channels": srv.Channels,
|
|
"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)
|
|
}
|
|
}
|
|
// 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")
|
|
}
|
|
}
|