High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
package handlers
import (
"crypto/tls"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/pinchtab/pinchtab/internal/activity"
"github.com/pinchtab/pinchtab/internal/authn"
"github.com/pinchtab/pinchtab/internal/browsersession"
"github.com/pinchtab/pinchtab/internal/config"
"github.com/pinchtab/pinchtab/internal/httpx"
"github.com/pinchtab/pinchtab/internal/session"
)
type activityCaptureRecorder struct {
events []activity.Event
}
func (c *activityCaptureRecorder) Enabled() bool { return true }
func (c *activityCaptureRecorder) Record(evt activity.Event) error {
c.events = append(c.events, evt)
return nil
}
func (c *activityCaptureRecorder) Query(activity.Filter) ([]activity.Event, error) {
return append([]activity.Event(nil), c.events...), nil
}
func resetRateLimitStateForTests() {
rateMu.Lock()
rateBuckets = map[string][]time.Time{}
rateMu.Unlock()
streamMu.Lock()
streamConnections = map[string]int{}
streamMu.Unlock()
}
func TestAuthMiddleware_NoToken(t *testing.T) {
cfg := &config.RuntimeConfig{Token: ""}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Error("handler should NOT have been called when token is missing")
}
if w.Code != http.StatusServiceUnavailable {
t.Fatalf("expected 503 when token is missing, got %d", w.Code)
}
}
func TestSecurityHeadersMiddleware_AddsHeaders(t *testing.T) {
handler := SecurityHeadersMiddleware(nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/dashboard", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if got := w.Header().Get("X-Content-Type-Options"); got != "nosniff" {
t.Fatalf("X-Content-Type-Options = %q, want nosniff", got)
}
if got := w.Header().Get("X-Frame-Options"); got != "DENY" {
t.Fatalf("X-Frame-Options = %q, want DENY", got)
}
if got := w.Header().Get("Content-Security-Policy"); got != defaultCSP {
t.Fatalf("Content-Security-Policy = %q, want %q", got, defaultCSP)
}
if got := w.Header().Get("Strict-Transport-Security"); got != "" {
t.Fatalf("Strict-Transport-Security = %q, want empty for http requests", got)
}
}
func TestSecurityHeadersMiddleware_AddsHSTSForTLS(t *testing.T) {
handler := SecurityHeadersMiddleware(nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
request := httptest.NewRequest(http.MethodGet, "https://pinchtab.test/dashboard", nil)
request.TLS = &tls.ConnectionState{}
w := httptest.NewRecorder()
handler.ServeHTTP(w, request)
if got := w.Header().Get("Strict-Transport-Security"); got != strictTransportSecurity {
t.Fatalf("Strict-Transport-Security = %q, want %q", got, strictTransportSecurity)
}
}
func TestSecurityHeadersMiddleware_UsesTrustedForwardedProtoForHSTS(t *testing.T) {
handler := SecurityHeadersMiddleware(config.NewLive(&config.RuntimeConfig{TrustProxyHeaders: true}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
request := httptest.NewRequest(http.MethodGet, "http://pinchtab/dashboard", nil)
request.Header.Set("X-Forwarded-Proto", "https")
w := httptest.NewRecorder()
handler.ServeHTTP(w, request)
if got := w.Header().Get("Strict-Transport-Security"); got != strictTransportSecurity {
t.Fatalf("Strict-Transport-Security = %q, want %q", got, strictTransportSecurity)
}
}
func TestAuthMiddleware_ValidToken(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
req.Header.Set("Authorization", "Bearer secret123")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Error("handler should have been called with valid token")
}
}
func TestAuthMiddleware_AllowsBackgroundHealthProbeMarker(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123", BackgroundMarker: "marker-123"}
called := false
handler := StripInternalHeadersMiddleware(AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
})))
req := httptest.NewRequest(http.MethodGet, backgroundHealthPath, nil)
req.Header.Set(backgroundHealthHeader, "marker-123")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200", w.Code)
}
if !called {
t.Fatal("handler should have been called with the background marker")
}
}
func TestAuthMiddleware_RejectsWrongBackgroundHealthProbeMarker(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123", BackgroundMarker: "marker-123"}
called := false
handler := StripInternalHeadersMiddleware(AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
})))
req := httptest.NewRequest(http.MethodGet, backgroundHealthPath, nil)
req.Header.Set(backgroundHealthHeader, "other")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusUnauthorized {
t.Fatalf("status = %d, want 401", w.Code)
}
if called {
t.Fatal("handler should not have been called with the wrong background marker")
}
}
func TestAuthMiddleware_InvalidToken(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
}))
req := httptest.NewRequest("GET", "/test", nil)
req.Header.Set("Authorization", "Bearer wrong")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Error("handler should NOT have been called with invalid token")
}
if w.Code != 401 {
t.Errorf("expected 401, got %d", w.Code)
}
if w.Header().Get("WWW-Authenticate") == "" {
t.Error("expected WWW-Authenticate header")
}
}
func TestAuthMiddleware_MissingTokenHeader(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 401 {
t.Errorf("expected 401, got %d", w.Code)
}
if w.Header().Get("WWW-Authenticate") == "" {
t.Error("expected WWW-Authenticate header")
}
}
func TestAuthMiddleware_ValidCookie(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/health", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should have been called with valid cookie auth")
}
if w.Code != 200 {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieRestrictedEndpointRejected(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not allow cookie auth on restricted endpoint")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieAllowsTabCloseEndpoint(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPost, "/tabs/tab_123/close", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow same-origin cookie-authenticated tab close")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieAllowsActionEndpoint(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPost, "/action", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Origin", "http://example.com")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow same-origin cookie-authenticated actions from the dashboard")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieAllowsInstanceStartEndpoint(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPost, "/instances/start", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Origin", "http://example.com")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow same-origin cookie-authenticated instance start from the dashboard")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieCrossOriginRejected(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Origin", "https://evil.example")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not allow cross-origin cookie auth")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieRequestWithoutOriginOrRefererRejected(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not allow cookie auth without same-origin headers")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieSameOriginRefererAccepted(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow same-origin cookie-authenticated request with referer")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieIgnoresForwardedOriginHints(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
req.Host = "127.0.0.1:9867"
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Origin", "https://pinchtab.example")
req.Header.Set("X-Forwarded-Proto", "https")
req.Header.Set("X-Forwarded-Host", "pinchtab.example")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should ignore forwarded host/proto headers for cookie same-origin checks")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieWebSocketRequiresSameOrigin(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/instances/inst1/proxy/screencast", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Connection", "Upgrade")
req.Header.Set("Upgrade", "websocket")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not allow cookie-authenticated websocket upgrade without an Origin header")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
called = false
req = httptest.NewRequest(http.MethodGet, "/instances/inst1/proxy/screencast", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Connection", "Upgrade")
req.Header.Set("Upgrade", "websocket")
req.Header.Set("Origin", "http://example.com")
w = httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow same-origin cookie-authenticated websocket upgrade")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieElevatedEndpointRequiresElevation(t *testing.T) {
cfg := &config.RuntimeConfig{
Token: "secret123",
Sessions: config.SessionsRuntimeConfig{
Dashboard: config.DashboardSessionRuntimeConfig{
RequireElevation: true,
},
},
}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPut, "/api/config", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not allow elevated endpoint without elevation")
}
if w.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", w.Code)
}
if !sessions.Elevate(sessionID, cfg.Token) {
t.Fatal("expected session elevation to succeed in test setup")
}
called = false
req = httptest.NewRequest(http.MethodPut, "/api/config", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w = httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow elevated endpoint with elevation")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_CookieConfigEndpointDoesNotRequireElevationByDefault(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
sessions := browsersession.NewManager(browsersession.Config{})
sessionID, err := sessions.Create(cfg.Token)
if err != nil {
t.Fatalf("Create() error = %v", err)
}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), sessions, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPut, "/api/config", nil)
req.AddCookie(&http.Cookie{Name: authn.CookieName, Value: sessionID})
req.Header.Set("Referer", "http://example.com/dashboard")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow config endpoint without elevation when requireElevation is disabled")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_HeaderAllowsRestrictedEndpoint(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
req.Header.Set("Authorization", "Bearer secret123")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should allow header auth on restricted endpoint")
}
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_QueryTokenRejected(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test?token=secret123", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called {
t.Fatal("handler should not accept query-string tokens")
}
if w.Code != 401 {
t.Fatalf("expected 401, got %d", w.Code)
}
}
func TestAuthMiddleware_PublicDashboardPathBypassesAuth(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/login", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should have been called for public dashboard path")
}
if w.Code != 200 {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_PublicDashboardSubpathBypassesAuth(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/dashboard/monitoring", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should have been called for public dashboard subpath")
}
if w.Code != 200 {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_PublicAuthPathBypassesAuth(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("POST", "/api/auth/login", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !called {
t.Fatal("handler should have been called for public auth path")
}
if w.Code != 200 {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestAuthMiddleware_ProtectedAPIStillRequiresAuth(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "secret123"}
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/api/config", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 401 {
t.Fatalf("expected 401, got %d", w.Code)
}
}
func TestAuthMiddleware_TableDriven(t *testing.T) {
tests := []struct {
name string
token string
authHeader string
wantCode int
wantCalled bool
}{
{"correct token", "secret", "Bearer secret", 200, true},
{"wrong token", "secret", "Bearer wrong", 401, false},
{"partial match", "secret", "Bearer secre", 401, false},
{"empty bearer", "secret", "Bearer ", 401, false},
{"missing header", "secret", "", 401, false},
{"query token rejected", "secret", "", 401, false},
{"no token configured", "", "", http.StatusServiceUnavailable, false},
{"no token configured with header", "", "Bearer anything", http.StatusServiceUnavailable, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
cfg := &config.RuntimeConfig{Token: tt.token}
called := false
handler := AuthMiddleware(config.NewLive(cfg), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
if tt.name == "query token rejected" {
req = httptest.NewRequest("GET", "/test?token=secret", nil)
}
if tt.authHeader != "" {
req.Header.Set("Authorization", tt.authHeader)
}
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if called != tt.wantCalled {
t.Errorf("handler called = %v, want %v", called, tt.wantCalled)
}
if w.Code != tt.wantCode {
t.Errorf("status = %d, want %d", w.Code, tt.wantCode)
}
})
}
}
func TestCorsMiddleware(t *testing.T) {
handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("OPTIONS", "/test", nil)
req.Header.Set("Origin", "https://evil.example")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 204 {
t.Errorf("OPTIONS expected 204, got %d", w.Code)
}
if w.Header().Get("Access-Control-Allow-Origin") != "*" {
t.Error("missing CORS origin header")
}
req = httptest.NewRequest("GET", "/test", nil)
req.Header.Set("Origin", "https://evil.example")
w = httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 200 {
t.Errorf("GET expected 200, got %d", w.Code)
}
if w.Header().Get("Access-Control-Allow-Origin") != "*" {
t.Error("missing CORS origin header on GET")
}
}
func TestCorsMiddleware_AuthEnabledAllowsOnlySameOrigin(t *testing.T) {
handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{Token: "secret"}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("OPTIONS", "/test", nil)
req.Host = "pinchtab.test"
req.Header.Set("Origin", "http://pinchtab.test")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 204 {
t.Fatalf("OPTIONS expected 204, got %d", w.Code)
}
if got := w.Header().Get("Access-Control-Allow-Origin"); got != "http://pinchtab.test" {
t.Fatalf("Access-Control-Allow-Origin = %q, want same origin", got)
}
if got := w.Header().Get("Access-Control-Allow-Credentials"); got != "true" {
t.Fatalf("Access-Control-Allow-Credentials = %q, want true", got)
}
}
func TestCorsMiddleware_AuthEnabledRejectsCrossOriginPreflight(t *testing.T) {
handler := CorsMiddleware(config.NewLive(&config.RuntimeConfig{Token: "secret"}), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("OPTIONS", "/test", nil)
req.Host = "pinchtab.test"
req.Header.Set("Origin", "https://evil.example")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusForbidden {
t.Fatalf("OPTIONS expected 403, got %d", w.Code)
}
if got := w.Header().Get("Access-Control-Allow-Origin"); got != "" {
t.Fatalf("Access-Control-Allow-Origin = %q, want empty", got)
}
}
func TestLoggingMiddleware(t *testing.T) {
resetObservabilityForTests()
handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(201)
}))
req := httptest.NewRequest("GET", "/test", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 201 {
t.Errorf("expected 201, got %d", w.Code)
}
}
func TestLoggingMiddleware_RecordsFailure(t *testing.T) {
resetObservabilityForTests()
handler := RequestIDMiddleware(LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
})))
req := httptest.NewRequest("GET", "/boom", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
snap := FailureSnapshot(LayerInstance)
if got := snap["requestsFailed"].(uint64); got != 1 {
t.Fatalf("requestsFailed = %d, want 1", got)
}
recent, ok := snap["recent"].([]map[string]any)
if !ok || len(recent) != 1 {
t.Fatalf("recent failures = %#v, want 1 event", snap["recent"])
}
if recent[0]["path"] != "/boom" {
t.Fatalf("recent path = %v, want /boom", recent[0]["path"])
}
if recent[0]["requestId"] == "" {
t.Fatal("expected request id on failure event")
}
}
func TestStripInternalHeadersMiddleware_RemovesPinchtabHeaders(t *testing.T) {
var seen http.Header
handler := StripInternalHeadersMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
seen = r.Header.Clone()
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
req.Header.Set("X-PinchTab-Session-Id", "spoofed")
req.Header.Set("X-PinchTab-Tab-Id", "tab-spoof")
req.Header.Set("x-pinchtab-source", "evil")
req.Header.Set("Authorization", "Session abc")
req.Header.Set("X-Other", "keep-me")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
for _, h := range []string{"X-PinchTab-Session-Id", "X-PinchTab-Tab-Id", "X-Pinchtab-Source"} {
if seen.Get(h) != "" {
t.Fatalf("expected %s to be stripped, got %q", h, seen.Get(h))
}
}
if seen.Get("Authorization") != "Session abc" {
t.Fatal("Authorization should be preserved")
}
if seen.Get("X-Other") != "keep-me" {
t.Fatal("non-pinchtab headers should be preserved")
}
}
func TestTrustedInternalProxyStripMiddleware_ValidTokenMarksContextAndPreservesHeaders(t *testing.T) {
const secret = "shared-internal-secret"
var (
seenSession string
seenTrusted bool
seenToken string
)
mw := TrustedInternalProxyStripMiddleware(secret)
handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
seenSession = r.Header.Get("X-PinchTab-Session-Id")
seenTrusted = IsTrustedInternalProxy(r)
seenToken = r.Header.Get(InternalTokenHeader)
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/x", nil)
req.Header.Set(InternalTokenHeader, secret)
req.Header.Set("X-PinchTab-Session-Id", "ses_propagated")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if !seenTrusted {
t.Fatal("expected request to be marked trusted-internal-proxy")
}
if seenSession != "ses_propagated" {
t.Fatalf("session header = %q, want ses_propagated", seenSession)
}
if seenToken != "" {
t.Fatalf("internal token header should be removed, got %q", seenToken)
}
}
func TestTrustedInternalProxyStripMiddleware_BadTokenStripsHeaders(t *testing.T) {
var (
seenSession string
seenTrusted bool
)
mw := TrustedInternalProxyStripMiddleware("expected-secret")
handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
seenSession = r.Header.Get("X-PinchTab-Session-Id")
seenTrusted = IsTrustedInternalProxy(r)
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/x", nil)
req.Header.Set(InternalTokenHeader, "wrong-secret")
req.Header.Set("X-PinchTab-Session-Id", "spoofed")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if seenTrusted {
t.Fatal("expected untrusted request not to be marked")
}
if seenSession != "" {
t.Fatalf("session header should be stripped, got %q", seenSession)
}
}
func TestTrustedInternalProxyStripMiddleware_EmptySecretAlwaysStrips(t *testing.T) {
var (
seenSession string
seenTrusted bool
)
mw := TrustedInternalProxyStripMiddleware("")
handler := mw(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
seenSession = r.Header.Get("X-PinchTab-Session-Id")
seenTrusted = IsTrustedInternalProxy(r)
w.WriteHeader(200)
}))
// Even when the request looks like it has the right header, an empty
// configured secret means trust verification is disabled — always strip.
req := httptest.NewRequest("GET", "/x", nil)
req.Header.Set(InternalTokenHeader, "anything")
req.Header.Set("X-PinchTab-Session-Id", "spoofed")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if seenTrusted {
t.Fatal("empty secret must never mark trusted")
}
if seenSession != "" {
t.Fatal("empty secret must still strip pinchtab headers")
}
}
func TestRequestIDMiddleware_SetsHeader(t *testing.T) {
handler := RequestIDMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Header().Get("X-Request-Id") == "" {
t.Fatal("expected X-Request-Id")
}
}
func TestRateLimitMiddleware_AllowsRequest(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/test", nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != 200 {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestRateLimitMiddleware_RateLimitsHealthAndMetrics(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}))
for _, p := range []string{"/health", "/metrics"} {
resetRateLimitStateForTests()
for i := 0; i < rateLimitMaxReq; i++ {
req := httptest.NewRequest("GET", p, nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("%s request %d: expected 200, got %d", p, i+1, w.Code)
}
}
req := httptest.NewRequest("GET", p, nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusTooManyRequests {
t.Fatalf("expected 429 for %s after limit exceeded, got %d", p, w.Code)
}
}
}
func TestRateLimitMiddleware_DoesNotRateLimitStreamingEndpoints(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
for _, p := range []string{
"/api/events",
"/api/agents/agent-1/events",
"/instances/inst-1/logs/stream",
} {
resetRateLimitStateForTests()
for i := 0; i < rateLimitMaxReq+5; i++ {
req := httptest.NewRequest(http.MethodGet, p, nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("%s request %d: expected 200, got %d", p, i+1, w.Code)
}
}
}
}
func TestRateLimitMiddleware_LimitsConcurrentStreamingEndpointsPerHost(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
entered := make(chan struct{}, maxConcurrentStreamRequestsPerHost)
release := make(chan struct{})
results := make(chan int, maxConcurrentStreamRequestsPerHost)
handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
entered <- struct{}{}
<-release
w.WriteHeader(http.StatusOK)
}))
for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
go func() {
req := httptest.NewRequest(http.MethodGet, "/api/events", nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
results <- w.Code
}()
}
for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
select {
case <-entered:
case <-time.After(2 * time.Second):
t.Fatalf("timed out waiting for stream %d to enter handler", i+1)
}
}
req := httptest.NewRequest(http.MethodGet, "/api/events", nil)
req.RemoteAddr = "127.0.0.1:12345"
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusTooManyRequests {
t.Fatalf("expected 429 once concurrent stream limit is reached, got %d", w.Code)
}
close(release)
for i := 0; i < maxConcurrentStreamRequestsPerHost; i++ {
select {
case code := <-results:
if code != http.StatusOK {
t.Fatalf("stream %d completed with %d, want 200", i+1, code)
}
case <-time.After(2 * time.Second):
t.Fatalf("timed out waiting for stream %d to complete", i+1)
}
}
}
func TestRateLimitMiddleware_IgnoresSpoofedForwardedHeaders(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
now := time.Now()
hits := make([]time.Time, rateLimitMaxReq)
for i := range hits {
hits[i] = now
}
rateMu.Lock()
rateBuckets["198.51.100.10"] = hits
rateMu.Unlock()
handler := RateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/test", nil)
req.RemoteAddr = "198.51.100.10:41000"
req.Header.Set("X-Forwarded-For", "203.0.113.1")
req.Header.Set("X-Real-Ip", "203.0.113.2")
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
if w.Code != http.StatusTooManyRequests {
t.Fatalf("expected 429 when forwarded headers spoof a new IP, got %d", w.Code)
}
}
func TestEvictStaleRateBuckets_DeletesEmptyHosts(t *testing.T) {
resetRateLimitStateForTests()
t.Cleanup(resetRateLimitStateForTests)
now := time.Now()
window := 10 * time.Second
rateMu.Lock()
rateBuckets = map[string][]time.Time{
"stale-only": {now.Add(-2 * window)},
"mixed": {now.Add(-2 * window), now.Add(-window / 2)},
"fresh": {now.Add(-window / 3)},
}
rateMu.Unlock()
evictStaleRateBuckets(now, window)
rateMu.Lock()
defer rateMu.Unlock()
if _, ok := rateBuckets["stale-only"]; ok {
t.Fatal("expected stale-only bucket to be deleted")
}
if got := len(rateBuckets["mixed"]); got != 1 {
t.Fatalf("expected mixed bucket to keep 1 hit, got %d", got)
}
if got := len(rateBuckets["fresh"]); got != 1 {
t.Fatalf("expected fresh bucket to keep 1 hit, got %d", got)
}
}
func TestStatusWriter(t *testing.T) {
w := httptest.NewRecorder()
sw := &httpx.StatusWriter{ResponseWriter: w, Code: 200}
sw.WriteHeader(404)
if sw.Code != 404 {
t.Errorf("expected 404, got %d", sw.Code)
}
}
func TestAuthMiddleware_SessionAuth(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
_, token, _ := store.Create("test-agent", "test", "")
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(200)
}))
req := httptest.NewRequest("GET", "/health", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if !called {
t.Fatal("expected handler to be called with valid session token")
}
if rr.Code != 200 {
t.Fatalf("expected 200, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthRejectsDashboardAdminRoute(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
_, token, _ := store.Create("test-agent", "test", "")
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/api/config", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if called {
t.Fatal("handler should not be called for dashboard/admin route via session auth")
}
if rr.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthWithoutGrantsAllowsNonAdminRoutes(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
_, token, _ := store.Create("test-agent", "test", "")
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPost, "/evaluate", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if !called {
t.Fatal("handler should be called for non-admin route when grants are empty")
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthAllowsRevokeRouteToReachHandler(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
sessionID, token, _ := store.Create("test-agent", "test", "")
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodPost, "/sessions/"+sessionID+"/revoke", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if !called {
t.Fatal("handler should be called for session revoke route")
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthHonorsBrowseGrant(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
sessionID, token, _ := store.Create("test-agent", "test", "")
if !store.SetGrants(sessionID, []string{"browse"}) {
t.Fatal("expected session to exist")
}
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/text", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if !called {
t.Fatal("handler should be called for route covered by browse grant")
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthRejectsRouteOutsideGrant(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
sessionID, token, _ := store.Create("test-agent", "test", "")
if !store.SetGrants(sessionID, []string{"browse"}) {
t.Fatal("expected session to exist")
}
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/clipboard/read", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if called {
t.Fatal("handler should not be called for route outside granted scope")
}
if rr.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", rr.Code)
}
}
func TestAuthMiddleware_ForbiddenSessionRequestDoesNotExtendIdleLifetime(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 100 * time.Millisecond, MaxLifetime: 24 * time.Hour})
sessionID, token, _ := store.Create("test-agent", "test", "")
if !store.SetGrants(sessionID, []string{"browse"}) {
t.Fatal("expected session to exist")
}
cfg := &config.RuntimeConfig{Token: "server-token"}
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
time.Sleep(30 * time.Millisecond)
req := httptest.NewRequest(http.MethodGet, "/clipboard/read", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if rr.Code != http.StatusForbidden {
t.Fatalf("expected 403, got %d", rr.Code)
}
time.Sleep(90 * time.Millisecond)
req = httptest.NewRequest(http.MethodGet, "/text", nil)
req.Header.Set("Authorization", "Session "+token)
rr = httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if rr.Code != http.StatusUnauthorized {
t.Fatalf("expected 401 after idle timeout, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthEnrichesActivity(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
sessionID, token, _ := store.Create("test-agent", "test", "")
rec := &activityCaptureRecorder{}
cfg := &config.RuntimeConfig{Token: "server-token"}
handler := activity.Middleware(rec, "server", AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})))
req := httptest.NewRequest(http.MethodGet, "/text", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
if len(rec.events) != 1 {
t.Fatalf("len(events) = %d, want 1", len(rec.events))
}
if rec.events[0].SessionID != sessionID {
t.Fatalf("event.SessionID = %q, want %q", rec.events[0].SessionID, sessionID)
}
if rec.events[0].AgentID != "test-agent" {
t.Fatalf("event.AgentID = %q, want test-agent", rec.events[0].AgentID)
}
}
func TestAuthMiddleware_SessionAttachesAuthenticatedSessionToContext(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
_, token, _ := store.Create("test-agent", "test", "")
var (
called bool
gotSession *session.Session
)
cfg := &config.RuntimeConfig{Token: "server-token"}
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
gotSession, _ = session.FromRequest(r)
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/sessions/me", nil)
req.Header.Set("Authorization", "Session "+token)
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if !called {
t.Fatal("handler should have been called with valid session auth")
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
if gotSession == nil {
t.Fatal("expected agent session on request context")
}
if gotSession.AgentID != "test-agent" {
t.Fatalf("AgentID = %q, want test-agent", gotSession.AgentID)
}
}
func TestAuthMiddleware_HeaderAuthDoesNotAttachAgentSessionToContext(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "server-token"}
var gotSession *session.Session
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
gotSession, _ = session.FromRequest(r)
w.WriteHeader(http.StatusOK)
}))
req := httptest.NewRequest(http.MethodGet, "/health", nil)
req.Header.Set("Authorization", "Bearer server-token")
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", rr.Code)
}
if gotSession != nil {
t.Fatal("expected no agent session on request context for bearer auth")
}
}
func TestAuthMiddleware_SessionAuthInvalid(t *testing.T) {
store := session.NewStore(session.Config{Enabled: true})
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, store, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
}))
req := httptest.NewRequest("GET", "/health", nil)
req.Header.Set("Authorization", "Session ses_invalidtoken")
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if called {
t.Fatal("handler should not be called with invalid session token")
}
if rr.Code != 401 {
t.Fatalf("expected 401, got %d", rr.Code)
}
}
func TestAuthMiddleware_SessionAuthDisabled(t *testing.T) {
cfg := &config.RuntimeConfig{Token: "server-token"}
called := false
handler := AuthMiddlewareWithSessions(config.NewLive(cfg), nil, nil, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
}))
req := httptest.NewRequest("GET", "/health", nil)
req.Header.Set("Authorization", "Session ses_sometoken")
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
if called {
t.Fatal("handler should not be called when agent sessions disabled")
}
if rr.Code != 401 {
t.Fatalf("expected 401, got %d", rr.Code)
}
}