Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package api
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/ai"
"github.com/rcourtman/pulse-go-rewrite/internal/config"
"github.com/rcourtman/pulse-go-rewrite/internal/deploy"
"github.com/rcourtman/pulse-go-rewrite/internal/updates"
internalauth "github.com/rcourtman/pulse-go-rewrite/pkg/auth"
)
const scopedReadToken = "synthetic-scoped-stream.12345678"
const scopedReadControl = "synthetic-scoped-control.12345678"
const scopedReadMonitor = "synthetic-monitor-reader.12345678"
func TestTokenStreamWriterNativeMedia(t *testing.T) {
cases := append(append([]responseMediaCase(nil), responseMediaCases...),
responseMediaCase{"sse", "text/event-stream", "text/event-stream; charset=utf-8"},
responseMediaCase{"sse_parameters", "Text/Event-Stream; charset=iso-8859-1", "text/event-stream; charset=utf-8"})
for _, media := range cases {
for _, commit := range []string{"write", "header", "flush", "informational"} {
t.Run(media.name+"/"+commit, func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithCancel(r.Context())
writer := &tokenStreamWriter{writer: w, flusher: w.(http.Flusher), ctx: ctx, cancel: cancel, allowed: func() bool { return true }}
defer writer.close()
if media.contentType != "" {
writer.Header().Set("Content-Type", media.contentType)
}
writer.Header()["content-type"] = []string{"text/html"}
writer.Header()["x-content-type-options"] = []string{"invalid"}
writer.Header().Set("X-Synthetic-Result", "preserved")
switch commit {
case "header":
writer.WriteHeader(http.StatusAccepted)
case "flush":
writer.Flush()
case "informational":
writer.WriteHeader(http.StatusEarlyHints)
}
if _, err := writer.Write([]byte(r.URL.Query().Get("content"))); err != nil {
t.Error(err)
}
}))
defer server.Close()
response, err := server.Client().Get(server.URL + "?content=" + url.QueryEscape(responseMediaMarkup))
if err != nil {
t.Fatal(err)
}
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
wantStatus := http.StatusOK
if commit == "header" {
wantStatus = http.StatusAccepted
}
if err != nil || response.StatusCode != wantStatus || string(body) != responseMediaMarkup || response.Header.Get("X-Synthetic-Result") != "preserved" {
t.Fatalf("response changed: status=%d headers=%v body=%q error=%v", response.StatusCode, response.Header, body, err)
}
if response.Header.Get("Content-Type") != media.wantType || len(response.Header.Values("Content-Type")) != 1 || response.Header.Get("X-Content-Type-Options") != "nosniff" || len(response.Header.Values("X-Content-Type-Options")) != 1 {
t.Fatalf("unsafe stream media: %v", response.Header)
}
})
}
}
}
var protectedReadKinds = []string{"updates", "patrol", "preflights", "jobs"}
type protectedReadFixture struct {
router *Router
cfg *config.Config
server *httptest.Server
patrol *ai.PatrolService
}
// Full production router: real auth context, tenant authorization/guard,
// route admin/scope policy, token lifetime guard, handlers and broadcasters.
// Only fresh temporary stores and synthetic events; no updater, Patrol run,
// deployment, command, agent or provider is started.
func newProtectedReadFixture(t *testing.T, scopes []string) *protectedReadFixture {
t.Helper()
cfg := newTestConfigWithTokens(t,
newTokenRecord(t, scopedReadToken, scopes, nil),
newTokenRecord(t, scopedReadControl, []string{config.ScopeWildcard}, nil),
newTokenRecord(t, scopedReadMonitor, []string{config.ScopeMonitoringRead}, nil))
cfg.AuthUser = "stream-admin"
cfg.ProxyAuthSecret = "synthetic-stream-proxy-secret"
cfg.ProxyAuthUserHeader = "X-Remote-User"
monitor, state, _ := newTestMonitor(t)
syncTestResourceStore(t, monitor, state)
router := NewRouter(cfg, monitor, nil, nil, nil, "test")
cleanupTestRouter(t, router)
svc := router.aiSettingsHandler.GetAIService(context.Background())
svc.SetStateProvider(&stubStateProvider{})
patrol := svc.GetPatrolService()
if patrol == nil || router.deployHandlers == nil {
t.Fatal("missing fixture read producer")
}
patrol.DebugResetStreamForRun("synthetic-read-run")
patrol.DebugSetStreamPhase("analyzing")
patrol.DebugAppendStreamContent("admitted-stream")
router.updateManager.GetSSEBroadcaster().Broadcast(updates.UpdateStatus{Status: "idle", Message: "admitted-stream"})
for _, kind := range []string{"preflights", "jobs"} {
job := &deploy.Job{ID: kind, OrgID: "default", Status: deploy.JobRunning, CreatedAt: time.Now(), UpdatedAt: time.Now()}
if err := router.deployStore.CreateJob(context.Background(), job); err != nil {
t.Fatal(err)
}
if err := router.deployStore.AppendEvent(context.Background(), &deploy.Event{ID: kind + "-initial", JobID: kind, Type: deploy.EventInstallOutput, Message: "admitted-stream", CreatedAt: time.Now()}); err != nil {
t.Fatal(err)
}
}
server := httptest.NewServer(router.Handler())
t.Cleanup(server.Close)
return &protectedReadFixture{router: router, cfg: cfg, server: server, patrol: patrol}
}
func protectedReadPath(kind string) string {
switch kind {
case "updates":
return "/api/updates/stream"
case "patrol":
return "/api/ai/patrol/stream"
default:
return "/api/agent-deploy/" + kind + "/" + kind + "/events"
}
}
func (f *protectedReadFixture) request(t *testing.T, kind, raw, transport string) *http.Request {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 22*time.Second)
t.Cleanup(cancel)
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, f.server.URL+protectedReadPath(kind), nil)
// Keep the selected org explicit: a token rebound to another org must not
// silently select that org instead of exercising the selected-org denial.
req.Header.Set("X-Pulse-Org-ID", "default")
switch transport {
case "bearer":
req.Header.Set("Authorization", "Bearer "+raw)
case "session":
req.AddCookie(&http.Cookie{Name: cookieNameSession, Value: raw})
case "proxy":
req.Header.Set("X-Proxy-Secret", f.cfg.ProxyAuthSecret)
req.Header.Set("X-Remote-User", "stream-admin")
default:
if raw != "" {
req.Header.Set("X-API-Token", raw)
}
}
return req
}
func (f *protectedReadFixture) open(t *testing.T, kind, raw, transport string) *bufio.Reader {
t.Helper()
resp, err := f.server.Client().Do(f.request(t, kind, raw, transport))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { resp.Body.Close() })
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(resp.Body)
t.Fatalf("%s admission %d: %s", kind, resp.StatusCode, body)
}
reader := bufio.NewReader(resp.Body)
readProtectedMarker(t, reader, "admitted-stream")
return reader
}
func readProtectedMarker(t *testing.T, reader *bufio.Reader, marker string) {
t.Helper()
for {
line, err := reader.ReadString('\n')
if err != nil {
t.Fatalf("before %q: %v", marker, err)
}
if strings.HasPrefix(line, "data:") && strings.Contains(line, marker) {
return
}
}
}
func (f *protectedReadFixture) emit(kind, marker string) {
switch kind {
case "updates":
f.router.updateManager.GetSSEBroadcaster().Broadcast(updates.UpdateStatus{Status: "idle", Message: marker})
case "patrol":
f.patrol.DebugAppendStreamContent(marker)
default:
f.router.deployHandlers.broadcastSSE(kind, &deploy.Event{ID: "live", JobID: kind, Type: deploy.EventInstallOutput, Message: marker})
}
}
func protectedReaderEOF(t *testing.T, reader *bufio.Reader, forbidden string) {
t.Helper()
for {
line, err := reader.ReadString('\n')
if strings.Contains(line, forbidden) {
t.Fatalf("withdrawn reader disclosed %q", forbidden)
}
if errors.Is(err, io.EOF) {
return
}
if err != nil {
t.Fatalf("withdrawn stream did not close: %v", err)
}
}
}
func (f *protectedReadFixture) assertJobAndSubscription(t *testing.T, kind string, wantReaders int) {
t.Helper()
if kind == "patrol" {
return
} // The HTTP handler owns Patrol unsubscription.
deadline := time.Now().Add(time.Second)
for {
count := 0
if kind == "updates" {
count = f.router.updateManager.GetSSEBroadcaster().GetClientCount()
} else {
h := f.router.deployHandlers
h.sseMu.Lock()
sub := h.sseSubs[kind]
h.sseMu.Unlock()
if sub != nil {
sub.mu.Lock()
count = len(sub.clients)
sub.mu.Unlock()
}
}
if count == wantReaders {
break
}
if time.Now().After(deadline) {
t.Fatalf("%s has %d subscribers, want %d", kind, count, wantReaders)
}
time.Sleep(time.Millisecond)
}
if kind == "jobs" || kind == "preflights" {
job, err := f.router.deployStore.GetJob(context.Background(), kind)
if err != nil || job == nil || job.Status != deploy.JobRunning {
t.Fatalf("read withdrawal changed job: %+v, %v", job, err)
}
// A later independent state transition still works; no job cancel ran.
if err := f.router.deployStore.UpdateJobStatus(context.Background(), kind, deploy.JobSucceeded); err != nil {
t.Fatal(err)
}
}
}
func TestProtectedReadStreamsWithdrawAuthority(t *testing.T) {
for _, kind := range protectedReadKinds {
for _, transport := range []string{"header", "bearer"} {
for _, change := range []string{"revoked", "expired", "scope_removed", "org_access_removed", "credential_replaced", "principal_replaced", "invalid_role"} {
t.Run(kind+"/"+transport+"/"+change, func(t *testing.T) {
scope := config.ScopeSettingsRead
if kind == "patrol" {
scope = config.ScopeAIExecute
}
f := newProtectedReadFixture(t, []string{scope})
control := f.open(t, kind, scopedReadControl, "header")
primary := f.open(t, kind, scopedReadToken, transport)
config.Mu.Lock()
switch change {
case "revoked":
f.cfg.RemoveAPIToken(f.cfg.APITokens[0].ID)
case "expired":
past := time.Now().Add(-time.Second)
f.cfg.APITokens[0].ExpiresAt = &past
case "scope_removed":
f.cfg.APITokens[0].Scopes = []string{config.ScopeMonitoringRead}
case "org_access_removed":
f.cfg.APITokens[0].OrgIDs = []string{"different-org"}
case "credential_replaced":
f.cfg.APITokens[0].ID = "different-credential"
case "principal_replaced":
f.cfg.APITokens[0].Metadata = map[string]string{apiTokenMetadataOwnerUserID: "different-principal"}
case "invalid_role":
f.cfg.APITokens[0].Metadata = map[string]string{internalauth.RuntimeRoleMetadataKey: internalauth.RuntimeRoleActionRunner}
}
config.Mu.Unlock()
forbidden := "private-after-withdrawal"
f.emit(kind, forbidden)
protectedReaderEOF(t, primary, forbidden)
readProtectedMarker(t, control, forbidden)
f.assertJobAndSubscription(t, kind, 1)
if change == "revoked" || change == "expired" || change == "scope_removed" || change == "org_access_removed" || change == "invalid_role" {
resp, err := f.server.Client().Do(f.request(t, kind, scopedReadToken, transport))
if err != nil {
t.Fatal(err)
}
resp.Body.Close()
want := http.StatusForbidden
if change == "revoked" || change == "expired" || change == "invalid_role" {
want = http.StatusUnauthorized
}
if resp.StatusCode != want {
t.Fatalf("fresh %s = %d want %d", change, resp.StatusCode, want)
}
}
})
}
}
}
}
func TestProtectedReadStreamsDurableDeletion(t *testing.T) {
for _, kind := range protectedReadKinds {
t.Run(kind, func(t *testing.T) {
f := newProtectedReadFixture(t, []string{config.ScopeSettingsRead, config.ScopeAIExecute})
primary := f.open(t, kind, scopedReadToken, "header")
control := f.open(t, kind, scopedReadControl, "header")
id := f.cfg.APITokens[0].ID
req, _ := http.NewRequest(http.MethodDelete, f.server.URL+"/api/security/tokens/"+id, nil)
req.Header.Set("X-API-Token", scopedReadControl)
resp, err := f.server.Client().Do(req)
if err != nil {
t.Fatal(err)
}
body, _ := io.ReadAll(resp.Body)
resp.Body.Close()
if resp.StatusCode != http.StatusNoContent {
t.Fatalf("token DELETE = %d: %s", resp.StatusCode, body)
}
persisted, err := f.router.persistence.LoadAPITokens()
if err != nil || len(persisted) != 2 {
t.Fatalf("durable tokens = %d: %v", len(persisted), err)
}
for _, record := range persisted {
if record.ID == id {
t.Fatal("deleted credential remains on disk")
}
}
f.emit(kind, "after-durable-delete")
protectedReaderEOF(t, primary, "after-durable-delete")
readProtectedMarker(t, control, "after-durable-delete")
f.assertJobAndSubscription(t, kind, 1)
})
}
}
func TestProtectedReadStreamsIdleWithdrawal(t *testing.T) {
f := newProtectedReadFixture(t, []string{config.ScopeSettingsRead, config.ScopeAIExecute})
readers := make(map[string]*bufio.Reader)
for _, kind := range protectedReadKinds {
readers[kind] = f.open(t, kind, scopedReadToken, "header")
}
config.Mu.Lock()
f.cfg.RemoveAPIToken(f.cfg.APITokens[0].ID)
config.Mu.Unlock()
start := time.Now()
// No synthetic event wakes these handlers. The production 15-second
// recheck must end even the silent update/deployment connections.
for _, kind := range protectedReadKinds {
protectedReaderEOF(t, readers[kind], "private-idle-withdrawn")
f.assertJobAndSubscription(t, kind, 0)
}
if time.Since(start) > 20*time.Second {
t.Fatal("idle withdrawal exceeded bounded recheck")
}
}
func TestProtectedReadStreamsPreserveSessionAndProxy(t *testing.T) {
for _, kind := range protectedReadKinds {
for _, transport := range []string{"session", "proxy"} {
t.Run(kind+"/"+transport, func(t *testing.T) {
f := newProtectedReadFixture(t, []string{config.ScopeSettingsRead, config.ScopeAIExecute})
session := fmt.Sprintf("synthetic-read-session-%d", time.Now().UnixNano())
GetSessionStore().CreateSession(session, time.Hour, "fixture", "127.0.0.1", "stream-admin")
t.Cleanup(func() { GetSessionStore().DeleteSession(session) })
reader := f.open(t, kind, session, transport)
config.Mu.Lock()
f.cfg.RemoveAPIToken(f.cfg.APITokens[0].ID)
config.Mu.Unlock()
f.emit(kind, "wanted-after-unrelated-deletion")
readProtectedMarker(t, reader, "wanted-after-unrelated-deletion")
})
}
}
}
func TestProtectedReadStreamsRetainAdmissionPolicy(t *testing.T) {
f := newProtectedReadFixture(t, []string{config.ScopeSettingsRead, config.ScopeAIExecute})
for _, kind := range protectedReadKinds {
for _, raw := range []string{"", scopedReadMonitor} {
t.Run(kind+"/"+raw, func(t *testing.T) {
resp, err := f.server.Client().Do(f.request(t, kind, raw, "header"))
if err != nil {
t.Fatal(err)
}
resp.Body.Close()
want := http.StatusForbidden
if raw == "" {
want = http.StatusUnauthorized
}
if resp.StatusCode != want {
t.Fatalf("admission = %d want %d", resp.StatusCode, want)
}
})
}
}
// A job belonging to another org stays hidden from an admitted default reader.
if err := f.router.deployStore.CreateJob(context.Background(), &deploy.Job{ID: "foreign", OrgID: "other-org", Status: deploy.JobRunning}); err != nil {
t.Fatal(err)
}
for _, kind := range []string{"jobs", "preflights"} {
req := f.request(t, kind, scopedReadControl, "header")
req.URL.Path = "/api/agent-deploy/" + kind + "/foreign/events"
resp, err := f.server.Client().Do(req)
if err != nil {
t.Fatal(err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusNotFound {
t.Fatalf("foreign %s = %d", kind, resp.StatusCode)
}
}
}
func TestProtectedReadStreamsKeepOrgAndInstanceSplit(t *testing.T) {
for _, kind := range protectedReadKinds {
t.Run(kind, func(t *testing.T) {
f := newProtectedReadFixture(t, []string{config.ScopeSettingsRead, config.ScopeAIExecute})
reader := f.open(t, kind, scopedReadToken, "header")
config.Mu.Lock()
f.cfg.APITokens[0].OrgIDs = []string{"default", "another-org"}
config.Mu.Unlock()
f.emit(kind, "still-in-selected-org")
if kind == "updates" {
protectedReaderEOF(t, reader, "still-in-selected-org")
} else {
readProtectedMarker(t, reader, "still-in-selected-org")
}
})
}
}
func TestTokenStreamWriterChecksReplayQueueAndFinalClosure(t *testing.T) {
for _, stage := range []string{"before_replay", "between_replay", "queued_write", "flush", "after_handler"} {
t.Run(stage, func(t *testing.T) {
cfg := newTestConfigWithTokens(t, newTokenRecord(t, scopedReadToken, []string{config.ScopeSettingsRead}, nil))
revoke := func() { config.Mu.Lock(); cfg.RemoveAPIToken(cfg.APITokens[0].ID); config.Mu.Unlock() }
var retained http.ResponseWriter
handler := retainTokenStreamAuthority(cfg, config.ScopeSettingsRead, true, func(w http.ResponseWriter, r *http.Request) {
retained = w
if stage == "before_replay" {
revoke()
}
fmt.Fprint(w, "data: admitted\n\n")
if stage != "before_replay" && stage != "after_handler" {
revoke()
}
if stage == "flush" {
w.(http.Flusher).Flush()
if r.Context().Err() == nil {
t.Error("withdrawn flush did not end read")
}
return
}
if stage == "after_handler" {
return
}
if stage == "queued_write" {
var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); fmt.Fprint(w, "data: forbidden\n\n") }()
wg.Wait()
} else {
fmt.Fprint(w, "data: forbidden\n\n")
}
if r.Context().Err() == nil {
t.Error("withdrawn write did not end read")
}
})
req := httptest.NewRequest(http.MethodGet, "/api/updates/stream", nil)
req.Header.Set("X-API-Token", scopedReadToken)
rec := httptest.NewRecorder()
AuthContextMiddleware(cfg, nil, handler).ServeHTTP(rec, req)
if stage == "after_handler" {
if _, err := retained.Write([]byte("data: forbidden\n\n")); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("late write = %v", err)
}
}
if strings.Contains(rec.Body.String(), "forbidden") {
t.Fatal("guard disclosed withdrawn/late frame")
}
if stage == "before_replay" && rec.Body.Len() != 0 {
t.Fatal("guard disclosed initial replay")
}
})
}
}
// The update broadcaster can still hold a writer after its HTTP handler has
// observed cancellation. Closure must join the active write and reject later
// queued writes before the ResponseWriter returns to the HTTP server.
type blockingTokenStreamWriter struct {
*httptest.ResponseRecorder
entered chan struct{}
release chan struct{}
}
func (w *blockingTokenStreamWriter) Write(p []byte) (int, error) {
close(w.entered)
<-w.release
return w.ResponseRecorder.Write(p)
}
func TestTokenStreamWriterCloseJoinsActiveWrite(t *testing.T) {
base := &blockingTokenStreamWriter{ResponseRecorder: httptest.NewRecorder(), entered: make(chan struct{}), release: make(chan struct{})}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
writer := &tokenStreamWriter{writer: base, flusher: base, ctx: ctx, cancel: cancel, allowed: func() bool { return true }}
wrote, closed := make(chan struct{}), make(chan struct{})
go func() { defer close(wrote); _, _ = writer.Write([]byte("admitted")) }()
<-base.entered
go func() { writer.close(); close(closed) }()
select {
case <-closed:
t.Error("closure returned during an active write")
case <-time.After(20 * time.Millisecond):
}
close(base.release)
<-wrote
<-closed
if _, err := writer.Write([]byte("forbidden")); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("late write = %v", err)
}
if base.Body.String() != "admitted" {
t.Fatalf("late bytes = %q", base.Body.String())
}
}
func TestTokenStreamWriterNonTokenReadClosesBeforeReturn(t *testing.T) {
var retained http.ResponseWriter
handler := retainTokenStreamAuthority(&config.Config{}, config.ScopeSettingsRead, true, func(w http.ResponseWriter, r *http.Request) {
retained = w
fmt.Fprint(w, "data: admitted-session\n\n")
w.(http.Flusher).Flush()
})
rec := httptest.NewRecorder()
handler(rec, httptest.NewRequest(http.MethodGet, "/api/updates/stream", nil))
if _, err := retained.Write([]byte("late-broadcast")); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("non-token writer outlived HTTP handler: %v", err)
}
if strings.Contains(rec.Body.String(), "late-broadcast") {
t.Fatal("non-token read accepted a write after handler return")
}
}
// Deadline forwarding is deliberately narrow: ResponseController must work,
// but Unwrap/ReaderFrom must not expose an unguarded output path.
type deadlineTokenStreamWriter struct {
*httptest.ResponseRecorder
writeDeadlines []time.Time
readDeadlines []time.Time
}
func (w *deadlineTokenStreamWriter) SetWriteDeadline(deadline time.Time) error {
w.writeDeadlines = append(w.writeDeadlines, deadline)
return nil
}
func (w *deadlineTokenStreamWriter) SetReadDeadline(deadline time.Time) error {
w.readDeadlines = append(w.readDeadlines, deadline)
return nil
}
func TestTokenStreamWriterPreservesDeadlineControlWithoutEscape(t *testing.T) {
base := &deadlineTokenStreamWriter{ResponseRecorder: httptest.NewRecorder()}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
allowed := true
writer := &tokenStreamWriter{writer: base, flusher: base, ctx: ctx, cancel: cancel, allowed: func() bool { return allowed }}
controller := http.NewResponseController(writer)
deadline := time.Now().Add(10 * time.Second)
for _, d := range []time.Time{{}, deadline} {
if err := controller.SetWriteDeadline(d); err != nil {
t.Fatal(err)
}
if err := controller.SetReadDeadline(d); err != nil {
t.Fatal(err)
}
}
if len(base.writeDeadlines) != 2 || !base.writeDeadlines[0].IsZero() || !base.writeDeadlines[1].Equal(deadline) || len(base.readDeadlines) != 2 || !base.readDeadlines[0].IsZero() || !base.readDeadlines[1].Equal(deadline) {
t.Fatal("deadline clearing/bounding did not reach the underlying transport")
}
if _, ok := any(writer).(interface{ Unwrap() http.ResponseWriter }); ok {
t.Fatal("writer exposes an unguarded response writer")
}
if _, ok := any(writer).(io.ReaderFrom); ok {
t.Fatal("writer exposes an unguarded ReaderFrom")
}
allowed = false
if err := controller.SetWriteDeadline(deadline); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("withdrawn deadline control = %v", err)
}
if err := controller.SetReadDeadline(deadline); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("closed deadline control = %v", err)
}
if len(base.writeDeadlines) != 2 || len(base.readDeadlines) != 2 || ctx.Err() == nil {
t.Fatal("withdrawn control reached transport or retained live request")
}
}
// A signed-in user's stream follows the organization access policy: a user who
// cannot use the request's organization is refused before anything streams.
func TestRetainTokenStreamAuthorityAppliesOrgAccessPolicy(t *testing.T) {
installTestRBACManager(t)
enableSharedMultiOrgForTest(t)
persistence, checker := newOrgAccessFixture(t, false)
saveDefaultOrgMembers(t, persistence, "dave")
streamed := 0
handler := retainTokenStreamAuthority(&config.Config{}, config.ScopeMonitoringRead, false, func(w http.ResponseWriter, r *http.Request) {
streamed++
w.WriteHeader(http.StatusOK)
})
serve := func(user string) int {
req := httptest.NewRequest(http.MethodGet, "/api/agent/events", nil)
ctx := context.WithValue(internalauth.WithUser(req.Context(), user), OrgIDContextKey, "default")
rec := httptest.NewRecorder()
handler(rec, req.WithContext(withOrgAccessChecker(ctx, checker)))
return rec.Code
}
if code := serve("dave"); code != http.StatusOK || streamed != 1 {
t.Fatalf("default member stream: status %d, streamed %d", code, streamed)
}
if code := serve("bob"); code != http.StatusUnauthorized || streamed != 1 {
t.Fatalf("tenant-only user stream: status %d, streamed %d, want refusal", code, streamed)
}
}