Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

23.4 KB
Raw Blame
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)
	}
}