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.
157 lines
6.5 KiB
Go
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")
|
|
}
|
|
}
|