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.
154 lines
4.1 KiB
Go
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")
|
|
}
|
|
}
|