Files
archie/cmd/archie-messaging/main_test.go
T
sam 3944f544e8 feat(controlplane): runtime administration over the State Store's gRPC server
The Web UI and messaging channels now read and write Archie's runtime
settings through one versioned, audited control-plane API hosted on the
State Store's existing gRPC server: catalog, query, command, watch. Each
feature owns its resource, validation and commands; storage only writes
versions and audit records.

Workflows move with it. Definitions become portable YAML compiled through
a closed, typed step registry and stored as a control-plane resource, so
the yaegi interpretation paths (internal/gate, wfeval, wfextract,
gateeval, gateextract, skillbuild) are deleted rather than carried.

The UI process reads definitions as data: the JSON projection lives in
internal/domain/workflow/task so a dashboard decodes the stored
collection without linking the workflow engine, which cmd/archie-ui's
deletion gate forbids. Shipped definitions ride the catalog descriptor
rather than a bespoke REST route, keeping the API to its four operations.

archie-messaging gains -state-store-target/-state-store-token and reads
channel settings from the database, failing closed when the State Store
is unreachable: the database is authoritative for those settings.
2026-09-21 08:17:42 +10:00

154 lines
4.1 KiB
Go

package main
import (
"context"
"net"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"syscall"
"testing"
"time"
"google.golang.org/grpc"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/infrastructure/gatewayrpc"
)
func repoRoot(t *testing.T) string {
t.Helper()
_, file, _, ok := runtime.Caller(0)
if !ok {
t.Fatal("runtime.Caller failed")
}
dir := filepath.Dir(file)
for {
if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
return dir
}
parent := filepath.Dir(dir)
if parent == dir {
t.Fatal("could not find repo root")
}
dir = parent
}
}
func buildBinary(t *testing.T) string {
t.Helper()
bin := filepath.Join(t.TempDir(), "archie-messaging")
cmd := exec.CommandContext(t.Context(), "go", "build", "-o", bin, "./cmd/archie-messaging")
cmd.Dir = repoRoot(t)
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("go build archie-messaging: %v\n%s", err, string(out))
}
return bin
}
type fakeChatServer struct {
messaging.ChatContract
}
func (f *fakeChatServer) Snapshot(ctx context.Context) (messaging.ChatSnapshot, error) {
return messaging.ChatSnapshot{}, nil
}
func startTestGateway(t *testing.T) (target string, cleanup func()) {
t.Helper()
lis, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("net.Listen: %v", err)
}
srv := grpc.NewServer()
gatewayrpc.RegisterServer(srv, &fakeChatServer{})
go func() {
_ = srv.Serve(lis)
}()
return lis.Addr().String(), func() {
srv.GracefulStop()
_ = lis.Close()
}
}
// fakeControlPlane serves the empty channel-settings resource the Messaging
// Service reads at startup. The database is authoritative for channel
// settings, so the process refuses to start without a State Store to read.
type fakeControlPlane struct {
controlpb.UnimplementedControlPlaneServiceServer
}
func (f *fakeControlPlane) Catalog(context.Context, *controlpb.CatalogRequest) (*controlpb.CatalogResponse, error) {
return &controlpb.CatalogResponse{}, nil
}
func (f *fakeControlPlane) Query(_ context.Context, request *controlpb.QueryRequest) (*controlpb.QueryResponse, error) {
return &controlpb.QueryResponse{Resource: &controlpb.Resource{Kind: request.GetKind(), Version: 1, ValueJson: []byte("{}")}}, nil
}
func startTestStateStore(t *testing.T) (target string, cleanup func()) {
t.Helper()
lis, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("net.Listen: %v", err)
}
srv := grpc.NewServer()
controlpb.RegisterControlPlaneServiceServer(srv, &fakeControlPlane{})
go func() {
_ = srv.Serve(lis)
}()
return lis.Addr().String(), func() {
srv.GracefulStop()
_ = lis.Close()
}
}
func TestBinaryHelp(t *testing.T) {
bin := buildBinary(t)
cmd := exec.CommandContext(t.Context(), bin, "-help")
out, err := cmd.CombinedOutput()
// flag.ExitOnError or flag help returns exit 0 or 2 depending on standard library
if !strings.Contains(string(out), "gateway-target") {
t.Fatalf("help output missing gateway-target flag: %v\n%s", err, string(out))
}
}
func TestBinaryStartsAndShutsDownCleanly(t *testing.T) {
bin := buildBinary(t)
gatewayTarget, cleanup := startTestGateway(t)
defer cleanup()
stateStoreTarget, stopStateStore := startTestStateStore(t)
defer stopStateStore()
cmd := exec.CommandContext(t.Context(), bin, "-gateway-target", gatewayTarget, "-state-store-target", stateStoreTarget)
if err := cmd.Start(); err != nil {
t.Fatalf("cmd.Start: %v", err)
}
// Allow the process to start up.
time.Sleep(200 * time.Millisecond)
// Send SIGTERM to shut down gracefully.
if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
t.Fatalf("send SIGTERM: %v", err)
}
errCh := make(chan error, 1)
go func() {
errCh <- cmd.Wait()
}()
select {
case err := <-errCh:
if err != nil {
t.Fatalf("process exited with error on SIGTERM: %v", err)
}
case <-time.After(3 * time.Second):
_ = cmd.Process.Kill()
t.Fatal("process did not exit in time after SIGTERM")
}
}