Files
archie/internal/webui/live_hub_test.go
T

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)
}
}