Files
archie/internal/app/archieui/compose_test.go
T
sam ae552db7e0 refactor(store)!: remove the SQLite task store, the PocketBase event store and the SQLite session store
The State Store, event capture and Gateway conversations already serve from
PostgreSQL. This deletes internal/store and internal/infrastructure/edastore,
the SQLite gateway session store and openProductionTaskStore, and the -db
recovery path on a legacy task file; backup, restore, validate and rollback
work on the database database_url names.

- The binding-secret cipher moves to internal/infrastructure/bindingcipher and
  ToolCall to internal/infrastructure/postgres.
- NewSessionStoreMemory is now a pure in-memory store that passes the shared
  SessionStore conformance suite.
- Tests run against PostgreSQL through internal/infrastructure/postgres/pgstore;
  legacyimport/legacyfixture writes the legacy files the import and the boot
  gate read.
- The cron dialect is owned in internal/domain/scheduling, so
  github.com/pocketbase/pocketbase and pocketbase/dbx leave go.mod.
  modernc.org/sqlite stays for the one-time import (legacyread).
- The UI and Messaging architecture gates ban the Postgres and legacy readers
  in place of internal/store.
2026-09-24 14:43:50 +10:00

157 lines
6.5 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/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
)
// 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.(*pgstore.TaskDB); ok {
t.Fatal("Store is the concrete *pgstore.TaskDB; 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")
}
}