Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

28.0 KB
Raw Blame
package handlers

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/pinchtab/pinchtab/internal/bridge"
	"github.com/pinchtab/pinchtab/internal/config"
	"sort"
)

type noFlusherResponseWriter struct {
	header http.Header
	body   bytes.Buffer
	status int
}

func (w *noFlusherResponseWriter) Header() http.Header {
	if w.header == nil {
		w.header = make(http.Header)
	}
	return w.header
}

func (w *noFlusherResponseWriter) Write(b []byte) (int, error) {
	if w.status == 0 {
		w.status = http.StatusOK
	}
	return w.body.Write(b)
}

func (w *noFlusherResponseWriter) WriteHeader(statusCode int) {
	w.status = statusCode
}

// networkMockBridge extends mockBridge with a real NetworkMonitor.
type networkMockBridge struct {
	mockBridge
	nm *bridge.NetworkMonitor
}

func (m *networkMockBridge) NetworkMonitor() *bridge.NetworkMonitor {
	return m.nm
}

func newNetworkTestHandler(nm *bridge.NetworkMonitor) *Handlers {
	b := &networkMockBridge{nm: nm}
	return New(b, &config.RuntimeConfig{AllowNetworkIntercept: true}, nil, nil, nil)
}

func TestNetworkDetailAndClearRequireNetworkIntercept(t *testing.T) {
	h := New(&networkMockBridge{nm: bridge.NewNetworkMonitor(100)}, &config.RuntimeConfig{}, nil, nil, nil)
	mux := http.NewServeMux()
	h.RegisterRoutes(mux, nil)

	for _, tc := range []struct {
		method string
		path   string
	}{
		{http.MethodGet, "/network/request-1"},
		{http.MethodGet, "/tabs/tab1/network/request-1"},
		{http.MethodPost, "/network/clear"},
	} {
		t.Run(tc.method+" "+tc.path, func(t *testing.T) {
			req := httptest.NewRequest(tc.method, tc.path, nil)
			w := httptest.NewRecorder()
			mux.ServeHTTP(w, req)

			if w.Code != http.StatusForbidden {
				t.Fatalf("status = %d, want 403: %s", w.Code, w.Body.String())
			}
			if !strings.Contains(w.Body.String(), "network_intercept_disabled") ||
				!strings.Contains(w.Body.String(), "security.allowNetworkIntercept") {
				t.Fatalf("disabled response missing catalog metadata: %s", w.Body.String())
			}
		})
	}
}

func seedBuffer(nm *bridge.NetworkMonitor, tabID string) {
	buf := nm.GetOrCreateBufferForTest(tabID)
	buf.Add(bridge.NetworkEntry{RequestID: "r1", URL: "https://api.example.com/users", Method: "GET", Status: 200, ResourceType: "XHR", Finished: true})
	buf.Add(bridge.NetworkEntry{RequestID: "r2", URL: "https://api.example.com/posts", Method: "POST", Status: 404, ResourceType: "XHR", Finished: true})
	buf.Add(bridge.NetworkEntry{RequestID: "r3", URL: "https://cdn.example.com/style.css", Method: "GET", Status: 200, ResourceType: "Stylesheet", Finished: true})
}

func TestHandleNetwork_ReturnsEntries(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}

	var resp struct {
		Entries []bridge.NetworkEntry `json:"entries"`
		Count   int                   `json:"count"`
	}
	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if resp.Count != 3 {
		t.Errorf("expected 3 entries, got %d", resp.Count)
	}
}

func TestHandleNetwork_FilterByMethod(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?method=POST", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Entries []bridge.NetworkEntry `json:"entries"`
		Count   int                   `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 1 {
		t.Errorf("expected 1 POST entry, got %d", resp.Count)
	}
	if resp.Count > 0 && resp.Entries[0].RequestID != "r2" {
		t.Errorf("expected r2, got %s", resp.Entries[0].RequestID)
	}
}

func TestHandleNetwork_FilterByURLPattern(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?filter=cdn.example", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 1 {
		t.Errorf("expected 1 entry matching cdn.example, got %d", resp.Count)
	}
}

func TestHandleNetwork_FilterByStatus(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?status=4xx", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 1 {
		t.Errorf("expected 1 4xx entry, got %d", resp.Count)
	}
}

func TestHandleNetwork_FilterByType(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?type=xhr", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 2 {
		t.Errorf("expected 2 XHR entries, got %d", resp.Count)
	}
}

func TestHandleNetwork_Limit(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?limit=1", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 1 {
		t.Errorf("expected 1 entry with limit=1, got %d", resp.Count)
	}
}

func TestHandleNetwork_NilMonitor(t *testing.T) {
	h := newNetworkTestHandler(nil)

	req := httptest.NewRequest("GET", "/network", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Entries []any `json:"entries"`
		Count   int   `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 0 {
		t.Errorf("expected 0 entries when monitor is nil, got %d", resp.Count)
	}
}

func TestHandleNetworkByIDUsesRetainedBody(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	const retainedBody = "{\"ok\":true}"
	buf.Add(bridge.NetworkEntry{
		RequestID:     "retained-1",
		URL:           "https://api.example.com/data",
		Method:        "GET",
		ResourceType:  "XHR",
		Finished:      true,
		ResponseBody:  retainedBody,
		Base64Encoded: false,
		BodyRetained:  true,
	})
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/retained-1?body=true", nil)
	req.SetPathValue("requestId", "retained-1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if got["responseBody"] != retainedBody {
		t.Fatalf("expected retained response body, got %v", got["responseBody"])
	}
	if got["bodyRetained"] != true {
		t.Fatalf("expected bodyRetained=true, got %v", got["bodyRetained"])
	}
}

func TestHandleNetworkByIDRetainedPreferredReturnsBodyAfterPendingResolves(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	buf.Add(bridge.NetworkEntry{
		RequestID:    "pending-1",
		URL:          "https://api.example.com/data",
		Method:       "GET",
		ResourceType: "XHR",
		Finished:     true,
		BodyPending:  true,
	})
	h := newNetworkTestHandler(nm)

	go func() {
		time.Sleep(40 * time.Millisecond)
		buf.Update("pending-1", func(entry *bridge.NetworkEntry) {
			entry.ResponseBody = "{\"ok\":true}"
			entry.BodyRetained = true
			entry.BodyPending = false
		})
		// Mirror maybeRetainBody: signal so the waiter wakes immediately.
		buf.SignalBodyChange()
	}()

	req := httptest.NewRequest("GET", "/network/pending-1?body=true&bodyMode=retained-preferred&timeoutMs=250", nil)
	req.SetPathValue("requestId", "pending-1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if got["responseBody"] != "{\"ok\":true}" {
		t.Fatalf("expected retained response body, got %v", got["responseBody"])
	}
	if got["bodyRetained"] != true {
		t.Fatalf("expected bodyRetained=true, got %v", got["bodyRetained"])
	}
	if got["bodySource"] != "retained" {
		t.Fatalf("expected bodySource=retained, got %v", got["bodySource"])
	}
	if _, ok := got["bodyPending"]; ok {
		t.Fatalf("expected bodyPending to clear after wait, got %v", got["bodyPending"])
	}
	entryMap, ok := got["entry"].(map[string]any)
	if !ok {
		t.Fatalf("expected entry map, got %T", got["entry"])
	}
	if entryMap["bodyRetained"] != true {
		t.Fatalf("expected nested entry bodyRetained=true, got %v", entryMap["bodyRetained"])
	}
}

func TestHandleNetworkByIDRetainedPreferredTimeoutReturnsPendingState(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	buf.Add(bridge.NetworkEntry{
		RequestID:    "pending-timeout",
		URL:          "https://api.example.com/data",
		Method:       "GET",
		ResourceType: "XHR",
		Finished:     true,
		BodyPending:  true,
	})
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/pending-timeout?body=true&bodyMode=retained-preferred&timeoutMs=20", nil)
	req.SetPathValue("requestId", "pending-timeout")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if got["bodyPending"] != true {
		t.Fatalf("expected bodyPending=true on timeout, got %v", got["bodyPending"])
	}
	if _, ok := got["responseBody"]; ok {
		t.Fatalf("expected no responseBody on timeout, got %v", got["responseBody"])
	}
	if _, ok := got["bodyError"]; ok {
		t.Fatalf("expected no bodyError on timeout, got %v", got["bodyError"])
	}
	entryMap, ok := got["entry"].(map[string]any)
	if !ok {
		t.Fatalf("expected entry map, got %T", got["entry"])
	}
	if entryMap["bodyPending"] != true {
		t.Fatalf("expected nested entry bodyPending=true, got %v", entryMap["bodyPending"])
	}
}

func TestWaitForRetainedBodyWakesOnSignal(t *testing.T) {
	buf := bridge.NewNetworkBuffer(10)
	buf.Add(bridge.NetworkEntry{RequestID: "r1", Finished: true, BodyPending: true})

	go func() {
		time.Sleep(20 * time.Millisecond)
		buf.Update("r1", func(e *bridge.NetworkEntry) {
			e.BodyRetained = true
			e.BodyPending = false
		})
		buf.SignalBodyChange()
	}()

	start := time.Now()
	// Generous 2s budget: if the signal weren't wired, this would block the full 2s.
	entry, ok := waitForRetainedBody(buf, "r1", 2*time.Second)
	elapsed := time.Since(start)

	if !ok || !entry.BodyRetained {
		t.Fatalf("expected retained body, got ok=%v entry=%+v", ok, entry)
	}
	if elapsed > 500*time.Millisecond {
		t.Fatalf("waitForRetainedBody did not wake promptly on signal (took %v)", elapsed)
	}
}

func TestWaitForRetainedBodyTimeoutReturnsCurrentEntry(t *testing.T) {
	buf := bridge.NewNetworkBuffer(10)
	buf.Add(bridge.NetworkEntry{RequestID: "r1", Finished: true, BodyPending: true})

	entry, ok := waitForRetainedBody(buf, "r1", 30*time.Millisecond)
	if !ok {
		t.Fatal("expected ok=true on timeout with a present entry")
	}
	if entry.BodyRetained || !entry.BodyPending {
		t.Fatalf("expected the unresolved pending entry at timeout, got %+v", entry)
	}

	// Missing request: no entry to return.
	if _, ok := waitForRetainedBody(buf, "missing", 10*time.Millisecond); ok {
		t.Fatal("expected ok=false for a missing request")
	}
}

func TestHandleNetworkByIDRetainedOnlyReturnsSkippedStateWithoutBodyError(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	buf.Add(bridge.NetworkEntry{
		RequestID:      "skipped-1",
		URL:            "https://api.example.com/data",
		Method:         "GET",
		ResourceType:   "XHR",
		Finished:       true,
		BodySkipped:    true,
		BodySkipReason: "retention budget exceeded",
	})
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/skipped-1?body=true&bodyMode=retained-only", nil)
	req.SetPathValue("requestId", "skipped-1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if got["bodySkipped"] != true {
		t.Fatalf("expected bodySkipped=true, got %v", got["bodySkipped"])
	}
	if got["bodySkipReason"] != "retention budget exceeded" {
		t.Fatalf("expected bodySkipReason to be preserved, got %v", got["bodySkipReason"])
	}
	if _, ok := got["bodyError"]; ok {
		t.Fatalf("expected no bodyError for skipped retention, got %v", got["bodyError"])
	}
	if _, ok := got["responseBody"]; ok {
		t.Fatalf("expected no responseBody in retained-only skip state, got %v", got["responseBody"])
	}
}

func TestHandleNetworkByIDRetainedPreferredDoesNotPretendSkippedBodyWasRetained(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	buf := nm.GetOrCreateBufferForTest("tab1")
	buf.Update("r1", func(entry *bridge.NetworkEntry) {
		entry.BodySkipped = true
		entry.BodySkipReason = "retention disabled"
	})
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/r1?body=true&bodyMode=retained-preferred", nil)
	req.SetPathValue("requestId", "r1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if _, ok := got["bodyRetained"]; ok {
		t.Fatalf("expected no bodyRetained marker for skipped retention, got %v", got["bodyRetained"])
	}
	if got["bodySkipped"] != true {
		t.Fatalf("expected skip state to remain visible, got %v", got["bodySkipped"])
	}
	if got["bodySkipReason"] != "retention disabled" {
		t.Fatalf("expected skip reason to remain visible, got %v", got["bodySkipReason"])
	}
	entryMap, ok := got["entry"].(map[string]any)
	if !ok {
		t.Fatalf("expected entry map, got %T", got["entry"])
	}
	if entryMap["bodySkipped"] != true {
		t.Fatalf("expected nested entry bodySkipped=true, got %v", entryMap["bodySkipped"])
	}
}

func TestHandleNetworkByID_Found(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/r1", nil)
	req.SetPathValue("requestId", "r1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}

	var resp struct {
		Entry bridge.NetworkEntry `json:"entry"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Entry.RequestID != "r1" {
		t.Errorf("expected r1, got %s", resp.Entry.RequestID)
	}
	if resp.Entry.URL != "https://api.example.com/users" {
		t.Errorf("expected users URL, got %s", resp.Entry.URL)
	}
}

func TestHandleNetworkByID_NotFound(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/nonexistent", nil)
	req.SetPathValue("requestId", "nonexistent")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 404 {
		t.Fatalf("expected 404, got %d", w.Code)
	}
}

func TestHandleNetworkByID_MissingRequestID(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/", nil)
	// No path value set
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 400 {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestHandleNetworkByID_NilMonitor(t *testing.T) {
	h := newNetworkTestHandler(nil)

	req := httptest.NewRequest("GET", "/network/r1", nil)
	req.SetPathValue("requestId", "r1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 404 {
		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
	}
}

func TestHandleNetworkClear_All(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	seedBuffer(nm, "tab2")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("POST", "/network/clear", nil)
	w := httptest.NewRecorder()
	h.HandleNetworkClear(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Cleared bool `json:"cleared"`
		All     bool `json:"all"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if !resp.Cleared || !resp.All {
		t.Errorf("expected cleared=true, all=true, got cleared=%v, all=%v", resp.Cleared, resp.All)
	}

	buf1 := nm.GetBuffer("tab1")
	buf2 := nm.GetBuffer("tab2")
	if buf1 != nil && buf1.Len() != 0 {
		t.Errorf("expected tab1 buffer cleared, got %d entries", buf1.Len())
	}
	if buf2 != nil && buf2.Len() != 0 {
		t.Errorf("expected tab2 buffer cleared, got %d entries", buf2.Len())
	}
}

func TestHandleNetworkClear_ByTab(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("POST", "/network/clear?tabId=tab1", nil)
	w := httptest.NewRecorder()
	h.HandleNetworkClear(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Cleared bool   `json:"cleared"`
		TabID   string `json:"tabId"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if !resp.Cleared {
		t.Error("expected cleared=true")
	}
	if resp.TabID != "tab1" {
		t.Errorf("expected tabId=tab1, got %s", resp.TabID)
	}
}

func TestHandleNetworkClear_NilMonitor(t *testing.T) {
	h := newNetworkTestHandler(nil)

	req := httptest.NewRequest("POST", "/network/clear", nil)
	w := httptest.NewRecorder()
	h.HandleNetworkClear(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
}

func TestHandleTabNetwork(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	mux := http.NewServeMux()
	h.RegisterRoutes(mux, nil)

	req := httptest.NewRequest("GET", "/tabs/tab1/network", nil)
	w := httptest.NewRecorder()
	mux.ServeHTTP(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 3 {
		t.Errorf("expected 3 entries, got %d", resp.Count)
	}
}

func TestHandleTabNetwork_MissingTabID(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/tabs//network", nil)
	w := httptest.NewRecorder()
	h.HandleTabNetwork(w, req)

	if w.Code != 400 {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestHandleNetwork_CombinedFilters(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network?method=GET&type=xhr", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var resp struct {
		Count int `json:"count"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &resp)
	if resp.Count != 1 {
		t.Errorf("expected 1 GET+XHR entry, got %d", resp.Count)
	}
}

// networkFailTabBridge is a mock that fails TabContext calls.
type networkFailTabBridge struct {
	mockBridge
	nm *bridge.NetworkMonitor
}

func (m *networkFailTabBridge) NetworkMonitor() *bridge.NetworkMonitor {
	return m.nm
}

func (m *networkFailTabBridge) TabContext(tabID string) (*bridge.TabHandle, string, error) {
	return nil, "", fmt.Errorf("tab not found")
}

func (m *networkFailTabBridge) EnsureBrowser(cfg *config.RuntimeConfig) error {
	return nil
}

func (m *networkFailTabBridge) RestartBrowser(cfg *config.RuntimeConfig) error {
	return nil
}

func TestHandleNetwork_TabNotFound(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	b := &networkFailTabBridge{nm: nm}
	h := New(b, &config.RuntimeConfig{}, nil, nil, nil)

	req := httptest.NewRequest("GET", "/network?tabId=nonexistent", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 404 {
		t.Fatalf("expected 404, got %d", w.Code)
	}
}

func TestHandleNetworkByID_NoBufferForTab(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	// Don't seed any buffer for tab1
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network/r1", nil)
	req.SetPathValue("requestId", "r1")
	w := httptest.NewRecorder()
	h.HandleNetworkByID(w, req)

	if w.Code != 404 {
		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
	}
}

func TestParseBufferSize(t *testing.T) {
	tests := []struct {
		query string
		want  int
	}{
		{"", 0},
		{"bufferSize=200", 200},
		{"bufferSize=0", 0},
		{"bufferSize=-1", 0},
		{"bufferSize=abc", 0},
		{"bufferSize=500", 500},
	}
	for _, tt := range tests {
		url := "/network"
		if tt.query != "" {
			url += "?" + tt.query
		}
		req := httptest.NewRequest("GET", url, nil)
		got := parseBufferSize(req)
		if got != tt.want {
			t.Errorf("parseBufferSize(%q) = %d, want %d", tt.query, got, tt.want)
		}
	}
}

func TestHandleNetworkStream_SSEHeaders(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	// Use a context that we cancel quickly to end the stream
	ctx, cancel := context.WithCancel(context.Background())
	req := httptest.NewRequest("GET", "/network/stream", nil).WithContext(ctx)
	w := httptest.NewRecorder()

	done := make(chan struct{})
	go func() {
		h.HandleNetworkStream(w, req)
		close(done)
	}()

	// Give it a moment to set headers, then cancel
	time.Sleep(50 * time.Millisecond)
	cancel()
	<-done

	if ct := w.Header().Get("Content-Type"); ct != "text/event-stream" {
		t.Errorf("expected Content-Type text/event-stream, got %s", ct)
	}
	if cc := w.Header().Get("Cache-Control"); cc != "no-cache" {
		t.Errorf("expected Cache-Control no-cache, got %s", cc)
	}
	if xa := w.Header().Get("X-Accel-Buffering"); xa != "no" {
		t.Errorf("expected X-Accel-Buffering no, got %s", xa)
	}
}

func TestHandleNetworkStream_ReceivesEntries(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	h := newNetworkTestHandler(nm)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	req := httptest.NewRequest("GET", "/network/stream", nil).WithContext(ctx)
	w := httptest.NewRecorder()

	done := make(chan struct{})
	go func() {
		h.HandleNetworkStream(w, req)
		close(done)
	}()

	// Wait for subscription to be set up
	time.Sleep(50 * time.Millisecond)

	// Add an entry — subscriber should receive it
	buf.Add(bridge.NetworkEntry{RequestID: "stream1", URL: "https://example.com/api", Method: "GET"})

	// Give time for the SSE write
	time.Sleep(50 * time.Millisecond)
	cancel()
	<-done

	body := w.Body.String()
	if !strings.Contains(body, "event: network") {
		t.Errorf("expected SSE event, got: %s", body)
	}
	if !strings.Contains(body, "stream1") {
		t.Errorf("expected stream1 in SSE data, got: %s", body)
	}
}

func TestHandleNetworkStream_FilterApplied(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	buf := nm.GetOrCreateBufferForTest("tab1")
	h := newNetworkTestHandler(nm)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	req := httptest.NewRequest("GET", "/network/stream?method=POST", nil).WithContext(ctx)
	w := httptest.NewRecorder()

	done := make(chan struct{})
	go func() {
		h.HandleNetworkStream(w, req)
		close(done)
	}()

	time.Sleep(50 * time.Millisecond)

	// Add a GET entry (should be filtered out) and a POST entry (should pass)
	buf.Add(bridge.NetworkEntry{RequestID: "get1", Method: "GET"})
	buf.Add(bridge.NetworkEntry{RequestID: "post1", Method: "POST"})

	time.Sleep(50 * time.Millisecond)
	cancel()
	<-done

	body := w.Body.String()
	if strings.Contains(body, "get1") {
		t.Errorf("GET entry should have been filtered out, got: %s", body)
	}
	if !strings.Contains(body, "post1") {
		t.Errorf("expected POST entry in stream, got: %s", body)
	}
}

func TestHandleNetworkStream_NilMonitor(t *testing.T) {
	h := newNetworkTestHandler(nil)

	req := httptest.NewRequest("GET", "/network/stream", nil)
	w := httptest.NewRecorder()
	h.HandleNetworkStream(w, req)

	if w.Code != 500 {
		t.Fatalf("expected 500, got %d", w.Code)
	}
}

func TestHandleNetworkStream_StreamingNotSupportedReturnsProblem(t *testing.T) {
	h := newNetworkTestHandler(bridge.NewNetworkMonitor(100))

	req := httptest.NewRequest("GET", "/network/stream", nil)
	w := &noFlusherResponseWriter{}
	h.HandleNetworkStream(w, req)

	if w.status != http.StatusInternalServerError {
		t.Fatalf("expected 500, got %d", w.status)
	}
	if ct := w.Header().Get("Content-Type"); ct != "application/problem+json" {
		t.Fatalf("expected application/problem+json, got %q", ct)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.body.Bytes(), &payload); err != nil {
		t.Fatalf("decode problem payload: %v", err)
	}
	if payload["code"] != "streaming_not_supported" {
		t.Fatalf("code = %v, want streaming_not_supported", payload["code"])
	}
}

func TestHandleTabNetworkStream_MissingTabID(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/tabs//network/stream", nil)
	w := httptest.NewRecorder()
	h.HandleTabNetworkStream(w, req)

	if w.Code != 400 {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

// networkEnvelopeKeys decodes the response into a raw map so the assertion is
// about which keys the payload carries, not about its size.
func networkEnvelopeKeys(t *testing.T, body []byte) map[string]any {
	t.Helper()
	var envelope map[string]any
	if err := json.Unmarshal(body, &envelope); err != nil {
		t.Fatalf("decode: %v (body=%s)", err, body)
	}
	return envelope
}

// entries was duplicated under items, so every response carried the whole
// network log twice; items had no reader anywhere.
func TestHandleNetwork_EnvelopeCarriesEntriesOnce(t *testing.T) {
	nm := bridge.NewNetworkMonitor(100)
	seedBuffer(nm, "tab1")
	h := newNetworkTestHandler(nm)

	req := httptest.NewRequest("GET", "/network", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	envelope := networkEnvelopeKeys(t, w.Body.Bytes())

	if _, dup := envelope["items"]; dup {
		t.Fatalf("response still carries the duplicate items key: %v", keysOf(envelope))
	}
	entries, ok := envelope["entries"].([]any)
	if !ok {
		t.Fatalf("entries missing or not an array: %v", keysOf(envelope))
	}
	if len(entries) != 3 {
		t.Fatalf("entries has %d records, want the 3 seeded", len(entries))
	}
	if count, _ := envelope["count"].(float64); int(count) != len(entries) {
		t.Fatalf("count = %v, want %d", envelope["count"], len(entries))
	}
	first, _ := entries[0].(map[string]any)
	if url, _ := first["url"].(string); url == "" {
		t.Fatalf("entries were emptied rather than deduplicated: %v", entries[0])
	}
}

func TestHandleNetwork_EmptyEnvelopeCarriesEntriesOnce(t *testing.T) {
	h := newNetworkTestHandler(nil)

	req := httptest.NewRequest("GET", "/network", nil)
	w := httptest.NewRecorder()
	h.HandleNetwork(w, req)

	if w.Code != 200 {
		t.Fatalf("expected 200, got %d", w.Code)
	}
	envelope := networkEnvelopeKeys(t, w.Body.Bytes())

	if _, dup := envelope["items"]; dup {
		t.Fatalf("empty response still carries the duplicate items key: %v", keysOf(envelope))
	}
	entries, ok := envelope["entries"].([]any)
	if !ok || len(entries) != 0 {
		t.Fatalf("empty envelope must still carry an empty entries array: %v", envelope["entries"])
	}
	if count, _ := envelope["count"].(float64); int(count) != 0 {
		t.Fatalf("count = %v, want 0", envelope["count"])
	}
}

func keysOf(m map[string]any) []string {
	out := make([]string, 0, len(m))
	for k := range m {
		out = append(out, k)
	}
	sort.Strings(out)
	return out
}