263 lines
8.2 KiB
Go
263 lines
8.2 KiB
Go
package webui
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/credentials/insecure"
|
|
"google.golang.org/grpc/test/bufconn"
|
|
|
|
"github.com/samcharles93/archie-core/internal/app/controlplane"
|
|
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/workflowsteps"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
)
|
|
|
|
type liveResourceStore struct{ controlplane.ResourceStore }
|
|
|
|
func (*liveResourceStore) Resource(_ context.Context, kind string) (storecontract.Resource, error) {
|
|
if kind == controlplane.PersonasKind {
|
|
return storecontract.Resource{Kind: kind, Version: 1, Value: []byte(`{"default":"archie","personas":[]}`)}, nil
|
|
}
|
|
return storecontract.Resource{}, storecontract.ErrResourceNotFound
|
|
}
|
|
|
|
// The real control-plane server (not a scripted Recv) must keep one upstream
|
|
// Watch per generic kind independently of how many browser streams connect.
|
|
// Its 250ms Resource poll runs once per kind, not once per browser.
|
|
func TestLiveHubSharesRealControlPlaneWatches(t *testing.T) {
|
|
steps, err := workflowsteps.NewManager()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
upstream, err := controlplane.NewServer(&liveResourceStore{}, steps)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var watches atomic.Int32
|
|
listener := bufconn.Listen(1 << 20)
|
|
grpcServer := grpc.NewServer(grpc.StreamInterceptor(func(srv any, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
|
|
if info.FullMethod == controlpb.ControlPlaneService_Watch_FullMethodName {
|
|
watches.Add(1)
|
|
}
|
|
return handler(srv, stream)
|
|
}))
|
|
controlpb.RegisterControlPlaneServiceServer(grpcServer, upstream)
|
|
go func() { _ = grpcServer.Serve(listener) }()
|
|
t.Cleanup(func() { grpcServer.Stop(); _ = listener.Close() })
|
|
conn, err := grpc.NewClient("passthrough:///controlplane", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) {
|
|
return listener.DialContext(ctx)
|
|
}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = conn.Close() })
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
defer cancel()
|
|
srv := &Server{ControlPlane: controlpb.NewControlPlaneServiceClient(conn), Store: &fakeEventStore{}, Log: slog.New(slog.DiscardHandler)}
|
|
go srv.RunLive(ctx)
|
|
catalog, err := upstream.Catalog(ctx, &controlpb.CatalogRequest{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
generic := 0
|
|
for _, descriptor := range catalog.Resources {
|
|
if descriptor.ApplyMode != "domain-managed" && descriptor.QueryService == "" {
|
|
generic++
|
|
}
|
|
}
|
|
waitUntil(t, func() bool { return int(watches.Load()) == generic })
|
|
waitUntil(t, func() bool {
|
|
srv.mu.Lock()
|
|
defer srv.mu.Unlock()
|
|
_, ok := srv.latest["control-plane/"+controlplane.PersonasKind]
|
|
return ok
|
|
})
|
|
|
|
httpServer := httptest.NewServer(srv.Handler())
|
|
defer httpServer.Close()
|
|
for range 3 {
|
|
request, err := http.NewRequestWithContext(ctx, http.MethodGet, httpServer.URL+"/api/stream", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
response, err := http.DefaultClient.Do(request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
line, err := readTopic(bufio.NewScanner(response.Body), "control-plane")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var frame struct {
|
|
Data controlPlaneResourceResponse `json:"data"`
|
|
}
|
|
if err := json.Unmarshal([]byte(line), &frame); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if frame.Data.Resource.Kind != controlplane.PersonasKind || frame.Data.Resource.Version != 1 {
|
|
t.Fatalf("late subscriber got %+v", frame.Data.Resource)
|
|
}
|
|
_ = response.Body.Close()
|
|
}
|
|
if got := int(watches.Load()); got != generic {
|
|
t.Fatalf("%d upstream watches after three clients, want %d", got, generic)
|
|
}
|
|
}
|
|
|
|
func readTopic(scanner *bufio.Scanner, topic string) (string, error) {
|
|
for scanner.Scan() {
|
|
line := scanner.Text()
|
|
if !strings.HasPrefix(line, "data: ") {
|
|
continue
|
|
}
|
|
data := strings.TrimPrefix(line, "data: ")
|
|
var frame struct {
|
|
Topic string `json:"topic"`
|
|
}
|
|
if err := json.Unmarshal([]byte(data), &frame); err != nil {
|
|
return "", err
|
|
}
|
|
if frame.Topic == topic {
|
|
return data, nil
|
|
}
|
|
}
|
|
return "", errors.New("stream ended before topic " + topic)
|
|
}
|
|
|
|
func waitUntil(t *testing.T, ready func() bool) {
|
|
t.Helper()
|
|
deadline := time.Now().Add(3 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if ready() {
|
|
return
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
t.Fatal("live producer did not become ready")
|
|
}
|
|
|
|
type countedIdentities struct {
|
|
identity.Repository
|
|
reads atomic.Int32
|
|
}
|
|
|
|
func (f *countedIdentities) List(context.Context) ([]identity.Identity, error) {
|
|
f.reads.Add(1)
|
|
return []identity.Identity{identity.System()}, nil
|
|
}
|
|
|
|
func TestIdentitiesPollOnceForSeveralClients(t *testing.T) {
|
|
identities := &countedIdentities{}
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
defer cancel()
|
|
srv := &Server{Store: &fakeEventStore{}, Log: slog.New(slog.DiscardHandler), Identities: identities}
|
|
go srv.RunLive(ctx)
|
|
waitUntil(t, func() bool { return identities.reads.Load() >= 1 })
|
|
server := httptest.NewServer(srv.Handler())
|
|
defer server.Close()
|
|
for range 3 {
|
|
request, _ := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/api/stream", nil)
|
|
response, err := http.DefaultClient.Do(request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer response.Body.Close()
|
|
if _, err := readTopic(bufio.NewScanner(response.Body), "identities"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
waitUntil(t, func() bool { return identities.reads.Load() >= 2 })
|
|
if got := identities.reads.Load(); got != 2 {
|
|
t.Fatalf("%d identity reads with three clients, want 2 (one per poll tick)", got)
|
|
}
|
|
}
|
|
|
|
func TestSlowLiveSubscriberIsDisconnectedForSnapshotReplay(t *testing.T) {
|
|
srv := &Server{}
|
|
_, _, stale, unregister := srv.registerSSEConn()
|
|
defer unregister()
|
|
for i := range 65 {
|
|
srv.Broadcast(events.Event{ID: int64(i + 1), At: testAt})
|
|
}
|
|
select {
|
|
case <-stale:
|
|
default:
|
|
t.Fatal("full subscriber was not disconnected: its dropped updates cannot be replayed until reconnect")
|
|
}
|
|
}
|
|
|
|
func TestLiveStreamReplaysLogsOnlyWhenRequestedAndResumesBothCursors(t *testing.T) {
|
|
feed := logging.NewFeed(20)
|
|
// Feed's production writer stamps IDs; drive it through its public slog handler.
|
|
log := slog.New(logging.NewFeedHandler(slog.NewTextHandler(new(bytes.Buffer), nil), feed))
|
|
log.Info("before")
|
|
srv := &Server{Store: &fakeEventStore{all: []events.Event{{ID: 1, At: testAt}, {ID: 2, At: testAt}}}, Log: slog.New(slog.DiscardHandler), LogFeed: feed}
|
|
base := httptest.NewServer(srv.Handler())
|
|
defer base.Close()
|
|
ctx, cancel := context.WithTimeout(t.Context(), 3*time.Second)
|
|
defer cancel()
|
|
get := func(path string) *http.Response {
|
|
t.Helper()
|
|
request, _ := http.NewRequestWithContext(ctx, http.MethodGet, base.URL+path, nil)
|
|
response, err := http.DefaultClient.Do(request)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return response
|
|
}
|
|
// A task-only connection must not subscribe to log traffic.
|
|
plain := get("/api/stream")
|
|
defer plain.Body.Close()
|
|
withLogs := get("/api/stream?topics=logs")
|
|
line, err := readTopic(bufio.NewScanner(withLogs.Body), "logs")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var frame struct {
|
|
Data logging.Entry `json:"data"`
|
|
}
|
|
if err := json.Unmarshal([]byte(line), &frame); err != nil || frame.Data.ID != 1 {
|
|
t.Fatalf("log replay = %q, %v", line, err)
|
|
}
|
|
_ = withLogs.Body.Close()
|
|
log.Info("after")
|
|
cursor := streamCursors{Tasks: cursor(1), Logs: 1}.id()
|
|
resumed := get("/api/stream?topics=logs&since=" + cursor)
|
|
defer resumed.Body.Close()
|
|
reader := bufio.NewScanner(resumed.Body)
|
|
line, err = readTopic(reader, "tasks")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var taskFrame struct {
|
|
Data events.Event `json:"data"`
|
|
}
|
|
if err := json.Unmarshal([]byte(line), &taskFrame); err != nil || taskFrame.Data.ID != 2 {
|
|
t.Fatalf("resumed task = %q, %v", line, err)
|
|
}
|
|
line, err = readTopic(reader, "logs")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal([]byte(line), &frame); err != nil || frame.Data.ID != 2 {
|
|
t.Fatalf("resumed log = %q, %v", line, err)
|
|
}
|
|
}
|