Skip to content

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

fix(bridge): clearing a tab's interception rules is idempotent and lists an empty array (PIN-364)

Luigi Agosti867268d9ff29
diff --git a/internal/bridge/route_lifecycle.go b/internal/bridge/route_lifecycle.go
index 4d5f6318..659bc826 100644
--- a/internal/bridge/route_lifecycle.go
+++ b/internal/bridge/route_lifecycle.go
@@ -83,12 +83,6 @@ const MaxRulesPerTab = 100
// MaxRulesPerTab rules and the incoming rule is not a same-pattern replace.
var ErrTooManyRules = errors.New("too many interception rules on this tab")
-// ErrTabNotRouted is returned by Remove when the tab has no rule state
-// registered with the manager — distinct from "tab found, pattern matched
-// nothing" which returns (0, nil). Callers can map this to a 404 to
-// differentiate from a benign no-op removal.
-var ErrTabNotRouted = errors.New("tab has no interception rules registered")
-
// AddRule installs (or replaces, by Pattern) a rule for the given tab.
func (rm *RouteManager) AddRule(ctx context.Context, tabID string, rule RouteRule) error {
if rm == nil {
@@ -257,7 +251,7 @@ func (rm *RouteManager) Remove(ctx context.Context, tabID string, pattern string
state := rm.perTab[tabID]
if state == nil {
rm.mu.Unlock()
- return 0, ErrTabNotRouted
+ return 0, nil
}
removed := 0
@@ -348,13 +342,13 @@ func (rm *RouteManager) RemoveTab(tabID string) {
func (rm *RouteManager) List(tabID string) []RouteRule {
if rm == nil {
- return nil
+ return []RouteRule{}
}
rm.mu.Lock()
defer rm.mu.Unlock()
state := rm.perTab[tabID]
if state == nil {
- return nil
+ return []RouteRule{}
}
out := make([]RouteRule, len(state.rules))
copy(out, state.rules)
diff --git a/internal/bridge/route_test.go b/internal/bridge/route_test.go
index 62be1ea6..40fa7096 100644
--- a/internal/bridge/route_test.go
+++ b/internal/bridge/route_test.go
@@ -89,14 +89,33 @@ func TestRouteManager_AddRule_FailedEnableRollsBackFetchEnabled(t *testing.T) {
}
}
-func TestRouteManager_Remove_TabNotRoutedReturnsSentinel(t *testing.T) {
+func TestRouteManager_RemoveOnATabWithNoRuleStateIsANoOp(t *testing.T) {
rm := NewRouteManager(nil)
- _, err := rm.Remove(t.Context(), "tab-never-routed", "*.png")
- if err == nil {
- t.Fatal("expected ErrTabNotRouted when tab has no rule state")
+ for _, pattern := range []string{"*.png", ""} {
+ removed, err := rm.Remove(t.Context(), "tab-never-routed", pattern)
+ if err != nil || removed != 0 {
+ t.Fatalf("Remove(%q) on a tab with no rule state = (%d, %v), want (0, nil) with no CDP call", pattern, removed, err)
+ }
+ }
+ if rules := rm.List("tab-never-routed"); rules == nil || len(rules) != 0 {
+ t.Fatalf("List on a tab with no rule state = %#v, want a non-nil empty slice", rules)
+ }
+}
+
+func TestRouteManager_ClearAllThenClearAgainStaysIdempotent(t *testing.T) {
+ rm := NewRouteManager(nil)
+ rm.mu.Lock()
+ rm.perTab["tab1"] = &tabRouteState{rules: []RouteRule{{Pattern: "a", Action: RouteActionAbort}}}
+ rm.mu.Unlock()
+
+ if removed, err := rm.Remove(t.Context(), "tab1", ""); err != nil || removed != 1 {
+ t.Fatalf("first clear = (%d, %v), want (1, nil)", removed, err)
+ }
+ if rules := rm.List("tab1"); rules == nil || len(rules) != 0 {
+ t.Fatalf("List after teardown = %#v, want a non-nil empty slice", rules)
}
- if !errors.Is(err, ErrTabNotRouted) {
- t.Errorf("expected errors.Is(err, ErrTabNotRouted), got %v", err)
+ if removed, err := rm.Remove(t.Context(), "tab1", ""); err != nil || removed != 0 {
+ t.Fatalf("second clear = (%d, %v), want (0, nil)", removed, err)
}
}
diff --git a/internal/handlers/network_route.go b/internal/handlers/network_route.go
index c4ab952c..c5af128e 100644
--- a/internal/handlers/network_route.go
+++ b/internal/handlers/network_route.go
@@ -3,7 +3,6 @@ package handlers
import (
"context"
"encoding/json"
- "errors"
"fmt"
"net/http"
@@ -205,10 +204,6 @@ func (h *Handlers) handleNetworkUnrouteFor(w http.ResponseWriter, r *http.Reques
removed, err := h.Bridge.RemoveRouteRule(resolvedID, pattern)
if err != nil {
- if errors.Is(err, bridge.ErrTabNotRouted) {
- WriteTabContextError(w, err, 404)
- return
- }
httpx.Error(w, 500, err)
return
}
@@ -231,9 +226,6 @@ func (h *Handlers) handleNetworkRouteListFor(w http.ResponseWriter, r *http.Requ
httpx.Error(w, 500, err)
return
}
- if rules == nil {
- rules = []bridge.RouteRule{}
- }
httpx.JSON(w, 200, map[string]any{
"tabId": resolvedID,
"rules": rules,
diff --git a/internal/handlers/network_route_test.go b/internal/handlers/network_route_test.go
index 9cf1c3d4..2c129b3f 100644
--- a/internal/handlers/network_route_test.go
+++ b/internal/handlers/network_route_test.go
@@ -2,6 +2,7 @@ package handlers
import (
"bytes"
+ "context"
"encoding/json"
"fmt"
"net/http"
@@ -36,6 +37,9 @@ func (m *routeMockBridge) AddRouteRule(tabID string, rule bridge.RouteRule) erro
}
func (m *routeMockBridge) RemoveRouteRule(tabID, pattern string) (int, error) {
+ if _, routed := m.rules[tabID]; !routed {
+ return bridge.NewRouteManager(nil).Remove(context.Background(), tabID, pattern)
+ }
if pattern == "" {
n := len(m.rules[tabID])
delete(m.rules, tabID)
@@ -55,9 +59,74 @@ func (m *routeMockBridge) RemoveRouteRule(tabID, pattern string) (int, error) {
}
func (m *routeMockBridge) ListRouteRules(tabID string) ([]bridge.RouteRule, error) {
+ if _, routed := m.rules[tabID]; !routed {
+ return bridge.NewRouteManager(nil).List(tabID), nil
+ }
return m.rules[tabID], nil
}
+func deleteTabRoutes(t *testing.T, h *Handlers, tabID string) *httptest.ResponseRecorder {
+ t.Helper()
+ req := httptest.NewRequest("DELETE", "/tabs/"+tabID+"/network/route", nil)
+ req.SetPathValue("id", tabID)
+ w := httptest.NewRecorder()
+ h.HandleTabNetworkUnroute(w, req)
+ return w
+}
+
+func requireClearedRoutes(t *testing.T, w *httptest.ResponseRecorder, wantRemoved int) {
+ t.Helper()
+ if w.Code != 200 {
+ t.Fatalf("status = %d, want 200: %s", w.Code, w.Body.String())
+ }
+ var resp struct {
+ OK bool `json:"ok"`
+ Removed int `json:"removed"`
+ }
+ if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+ t.Fatal(err)
+ }
+ if !resp.OK || resp.Removed != wantRemoved {
+ t.Fatalf("body = %s, want ok:true removed:%d", w.Body.String(), wantRemoved)
+ }
+ if !strings.Contains(w.Body.String(), `"rules":[]`) {
+ t.Fatalf("body = %s, want rules as an empty JSON array", w.Body.String())
+ }
+}
+
+func TestHandleTabNetworkUnroute_IsIdempotentOnATabWithNoRules(t *testing.T) {
+ b := newRouteMockBridge()
+ h := newRouteHandler(b)
+
+ requireClearedRoutes(t, deleteTabRoutes(t, h, "tab1"), 0)
+
+ if err := b.AddRouteRule("tab1", bridge.RouteRule{Pattern: "a", Action: bridge.RouteActionAbort}); err != nil {
+ t.Fatal(err)
+ }
+ requireClearedRoutes(t, deleteTabRoutes(t, h, "tab1"), 1)
+ requireClearedRoutes(t, deleteTabRoutes(t, h, "tab1"), 0)
+}
+
+func TestHandleTabNetworkUnroute_UnknownTabIsStillNotFound(t *testing.T) {
+ b := newRouteMockBridge()
+ b.failTab = true
+ h := newRouteHandler(b)
+ if w := deleteTabRoutes(t, h, "nope"); w.Code != 404 {
+ t.Fatalf("status = %d, want 404 from tab resolution: %s", w.Code, w.Body.String())
+ }
+}
+
+func TestHandleTabNetworkRouteList_EmptyTabAnswersAnEmptyArray(t *testing.T) {
+ h := newRouteHandler(newRouteMockBridge())
+ req := httptest.NewRequest("GET", "/tabs/tab1/network/route", nil)
+ req.SetPathValue("id", "tab1")
+ w := httptest.NewRecorder()
+ h.HandleTabNetworkRouteList(w, req)
+ if w.Code != 200 || !strings.Contains(w.Body.String(), `"rules":[]`) {
+ t.Fatalf("GET = %d %s, want 200 with rules as an empty JSON array", w.Code, w.Body.String())
+ }
+}
+
func newRouteHandler(b *routeMockBridge) *Handlers {
return New(b, &config.RuntimeConfig{AllowNetworkIntercept: true}, nil, nil, nil)
}