High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
package bridge
import (
"context"
"strings"
"sync"
"testing"
"time"
"github.com/chromedp/cdproto/target"
"github.com/pinchtab/pinchtab/internal/config"
)
func newTestBridge() *Bridge {
b := &Bridge{
TabManager: &TabManager{
tabs: make(map[string]*TabEntry),
snapshots: make(map[string]*RefCache),
},
}
return b
}
func TestRefCacheConcurrency(t *testing.T) {
b := newTestBridge()
// Simulate concurrent reads/writes to snapshot cache
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
tabID := "tab1"
b.SetRefCache(tabID, &RefCache{Refs: map[string]int64{
"e0": int64(i),
}})
cache := b.GetRefCache(tabID)
if cache == nil {
t.Error("cache should not be nil")
}
}(i)
}
wg.Wait()
}
func TestRefCacheLookup(t *testing.T) {
b := newTestBridge()
cache := b.GetRefCache("tab1")
if cache != nil {
t.Error("expected nil cache for unknown tab")
}
b.SetRefCache("tab1", &RefCache{Refs: map[string]int64{
"e0": 100,
"e1": 200,
}})
cache = b.GetRefCache("tab1")
if nid, ok := cache.Refs["e0"]; !ok || nid != 100 {
t.Errorf("e0 expected 100, got %d", nid)
}
if nid, ok := cache.Refs["e1"]; !ok || nid != 200 {
t.Errorf("e1 expected 200, got %d", nid)
}
if _, ok := cache.Refs["e99"]; ok {
t.Error("e99 should not exist")
}
}
func TestRefTargetsFromNodes(t *testing.T) {
nodes := []A11yNode{
{
Ref: "e0",
NodeID: 100,
FrameID: "frame-1",
FrameURL: "https://example.com/embed",
FrameName: "embed",
ChildFrameID: "frame-1-child",
ChildFrameURL: "https://example.com/embed/child",
ChildFrameName: "nested",
},
{
Ref: "e1",
NodeID: 200,
},
}
targets := RefTargetsFromNodes(nodes)
if len(targets) != 2 {
t.Fatalf("expected 2 targets, got %d", len(targets))
}
if targets["e0"].BackendNodeID != 100 {
t.Fatalf("e0 backend node = %d", targets["e0"].BackendNodeID)
}
if targets["e0"].FrameID != "frame-1" {
t.Fatalf("e0 frame id = %q", targets["e0"].FrameID)
}
if targets["e0"].ChildFrameID != "frame-1-child" {
t.Fatalf("e0 child frame id = %q", targets["e0"].ChildFrameID)
}
if targets["e1"].BackendNodeID != 200 {
t.Fatalf("e1 backend node = %d", targets["e1"].BackendNodeID)
}
}
func TestTabManagerRemoteAllocatorInitialization(t *testing.T) {
// Test that TabManager can be initialized without a valid browser context.
// This is the case for remote allocators where the browser context is
// established lazily.
cfg := &config.RuntimeConfig{}
// Use context.TODO() instead of nil to avoid lint warnings
ctx := context.TODO()
tm := NewTabManager(ctx, cfg, nil, nil, nil)
if tm == nil {
t.Error("TabManager should be created")
}
// Attempting to create a tab with an invalid context should fail gracefully
_, _, _, err := tm.CreateTab("about:blank")
if err == nil {
t.Error("CreateTab should fail when browserCtx is invalid")
}
}
func TestCreateTab_RejectsNilTabManager(t *testing.T) {
var tm *TabManager
_, _, _, err := tm.CreateTab("about:blank")
if err == nil {
t.Fatal("CreateTab should fail when tab manager is nil")
}
if err.Error() != "tab manager not initialized" {
t.Fatalf("unexpected error: %v", err)
}
}
func TestBridgeTabOperations_RejectNilTabManager(t *testing.T) {
b := &Bridge{}
tests := []struct {
name string
run func() error
}{
{name: "tab context", run: func() error {
_, _, err := b.TabContext("")
return err
}},
{name: "list targets", run: func() error {
_, err := b.ListTargets()
return err
}},
{name: "close tab", run: func() error {
return b.CloseTab("tab1")
}},
{name: "focus tab", run: func() error {
return b.FocusTab("tab1")
}},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
err := tc.run()
if err == nil {
t.Fatal("expected error")
}
if err.Error() != "tab manager not initialized" {
t.Fatalf("unexpected error: %v", err)
}
})
}
}
func TestTabContext_RejectsUnknownTabID(t *testing.T) {
// TabContext should reject tab IDs that aren't tracked
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
// Try to get context for a non-existent tab
_, _, err := tm.TabContext("tab_nonexistent")
if err == nil {
t.Error("TabContext should reject unknown tab IDs")
}
if err.Error() != "tab tab_nonexistent not found" {
t.Errorf("unexpected error message: %s", err.Error())
}
}
func TestTabContext_RejectsUnknownRawCDPID(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
rawCDPID := "A25658CE1BA82659EBE9C93C46CEE63A"
_, _, err := tm.TabContext(rawCDPID)
if err == nil {
t.Error("TabContext should reject unknown raw CDP target IDs")
}
}
func TestQuietStealthObservers(t *testing.T) {
if (&Bridge{Config: &config.RuntimeConfig{StealthLevel: "full"}}).quietStealthObservers() != true {
t.Fatal("expected full stealth to suppress nonessential observers")
}
if (&Bridge{Config: &config.RuntimeConfig{StealthLevel: "medium"}}).quietStealthObservers() {
t.Fatal("did not expect medium stealth to suppress observers")
}
}
func TestCreateTab_ReturnsRawCDPID(t *testing.T) {
// Verify TabIDFromCDPTarget returns raw CDP ID (no prefix)
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
if tm.idMgr == nil {
t.Error("TabManager should have idMgr initialized")
}
rawCDP := "A25658CE1BA82659EBE9C93C46CEE63A"
tabID := tm.idMgr.TabIDFromCDPTarget(rawCDP)
if tabID != rawCDP {
t.Errorf("expected %s, got %s", rawCDP, tabID)
}
}
func TestTabContext_AcceptsRegisteredID(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
rawCDPID := "RAWCDPID123456789012345678901234"
ctx := context.Background()
tm.tabs[rawCDPID] = &TabEntry{
Ctx: ctx,
CDPID: rawCDPID,
}
returnedCtx, resolvedID, err := tm.TabContext(rawCDPID)
if err != nil {
t.Errorf("TabContext should accept registered ID: %v", err)
}
if returnedCtx != ctx {
t.Error("TabContext should return the registered context")
}
if resolvedID != rawCDPID {
t.Errorf("resolvedID should be tab ID, got %s", resolvedID)
}
}
func TestTabContext_EmptyID_UsesCurrentTrackedTab(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
ctx := context.Background()
tabID := "SOMECDPID"
tm.mu.Lock()
tm.tabs[tabID] = &TabEntry{Ctx: ctx, CDPID: tabID}
tm.currentTab = tabID
tm.mu.Unlock()
returnedCtx, resolvedID, err := tm.TabContext("")
if err != nil {
t.Fatalf("TabContext(\"\") should resolve to current tab: %v", err)
}
if returnedCtx != ctx {
t.Error("should return the current tab's context")
}
if resolvedID != tabID {
t.Errorf("expected %s, got %s", tabID, resolvedID)
}
}
func TestSelectCurrentTrackedTabFallsBackToMostRecentlyUsed(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
now := time.Now()
tm.tabs["older"] = &TabEntry{Ctx: context.Background(), CreatedAt: now.Add(-3 * time.Minute), LastUsed: now.Add(-2 * time.Minute)}
tm.tabs["newer"] = &TabEntry{Ctx: context.Background(), CreatedAt: now.Add(-2 * time.Minute), LastUsed: now.Add(-1 * time.Minute)}
tm.currentTab = "stale-tab-id"
if got := tm.selectCurrentTrackedTab(); got != "newer" {
t.Fatalf("selectCurrentTrackedTab = %q, want most recently used tab", got)
}
}
func TestMarkAccessedUpdatesCurrentTabAndLastUsed(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
oldTime := time.Now().Add(-1 * time.Hour)
tm.tabs["tab1"] = &TabEntry{Ctx: context.Background(), CreatedAt: oldTime, LastUsed: oldTime}
tm.tabs["tab2"] = &TabEntry{Ctx: context.Background(), CreatedAt: oldTime, LastUsed: oldTime}
tm.currentTab = "tab1"
if err := tm.markAccessed("tab2"); err != nil {
t.Fatal(err)
}
if tm.currentTab != "tab2" {
t.Fatalf("currentTab = %q, want tab2", tm.currentTab)
}
if !tm.accessed["tab2"] {
t.Fatal("expected tab2 to be marked accessed")
}
if !tm.tabs["tab2"].LastUsed.After(oldTime) {
t.Fatalf("tab2 LastUsed = %v, want after %v", tm.tabs["tab2"].LastUsed, oldTime)
}
}
func TestCloseTab_PreventsLastTabClose(t *testing.T) {
// CloseTab should fail when attempting to close the last remaining tab
// This prevents Chrome from exiting and crashing the server
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
// Without a valid browser context, ListTargets will fail
// which triggers the guard at the start of CloseTab
err := tm.CloseTab("tab_fake1234")
if err == nil {
t.Error("CloseTab should fail when ListTargets fails")
}
// The error should mention listing targets
if err != nil && !strings.Contains(err.Error(), "list targets") {
t.Errorf("expected error about list targets, got: %s", err.Error())
}
}
func TestShouldBlockPopupTarget(t *testing.T) {
tests := []struct {
name string
info *target.Info
want bool
}{
{name: "nil target", info: nil, want: false},
{name: "top level page", info: &target.Info{Type: TargetTypePage}, want: false},
{name: "non-page target with opener", info: &target.Info{Type: "service_worker", OpenerID: target.ID("opener")}, want: false},
{name: "page popup", info: &target.Info{Type: TargetTypePage, OpenerID: target.ID("opener")}, want: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := shouldBlockPopupTarget(tc.info); got != tc.want {
t.Fatalf("shouldBlockPopupTarget(%+v) = %v, want %v", tc.info, got, tc.want)
}
})
}
}
func TestEvaluateTabPolicy(t *testing.T) {
cfg := config.IDPIConfig{
Enabled: true,
StrictMode: true,
}
allowedDomains := []string{"example.com"}
allowed := EvaluateTabPolicy("https://example.com/path", cfg, allowedDomains)
if allowed.Threat || allowed.Blocked {
t.Fatalf("expected allowed domain to pass, got %+v", allowed)
}
blocked := EvaluateTabPolicy("https://evil.example.net/path", cfg, allowedDomains)
if !blocked.Threat || !blocked.Blocked {
t.Fatalf("expected blocked domain to fail, got %+v", blocked)
}
if blocked.CurrentURL == "" || blocked.UpdatedAt.IsZero() {
t.Fatalf("expected policy state metadata to be populated, got %+v", blocked)
}
}
func TestTabManagerStoresTabPolicyState(t *testing.T) {
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, nil, nil)
tm.tabs["tab1"] = &TabEntry{Ctx: context.Background()}
state := TabPolicyState{
CurrentURL: "https://evil.example.net/path",
Threat: true,
Blocked: true,
Reason: "blocked",
UpdatedAt: time.Now(),
}
tm.SetTabPolicyState("tab1", state)
got, ok := tm.GetTabPolicyState("tab1")
if !ok {
t.Fatal("expected stored policy state")
}
if got.CurrentURL != state.CurrentURL || got.Blocked != state.Blocked || got.Reason != state.Reason {
t.Fatalf("stored policy state mismatch: got %+v want %+v", got, state)
}
}
func TestPurgeTrackedTabStateByTargetID(t *testing.T) {
logStore := NewConsoleLogStore(10)
tm := NewTabManager(context.Background(), &config.RuntimeConfig{}, nil, logStore, nil)
dm := NewDialogManager()
tm.SetDialogManager(dm)
tabID := "public-tab-id"
cdpID := "RAWCDPID123"
tm.tabs[tabID] = &TabEntry{Ctx: context.Background(), CDPID: cdpID}
tm.snapshots[tabID] = &RefCache{Refs: map[string]int64{"e0": 1}}
tm.accessed[tabID] = true
tm.currentTab = tabID
dm.SetPending(tabID, &DialogState{Type: "alert", Message: "secret"})
logStore.AddConsoleLog(cdpID, LogEntry{Level: "log", Message: "secret"})
logStore.AddErrorLog(cdpID, ErrorEntry{Message: "secret"})
if ok := tm.purgeTrackedTabStateByTargetID(cdpID); !ok {
t.Fatal("expected tab cleanup to succeed")
}
if _, ok := tm.tabs[tabID]; ok {
t.Fatal("expected tracked tab to be removed")
}
if _, ok := tm.snapshots[tabID]; ok {
t.Fatal("expected snapshot cache to be removed")
}
if tm.accessed[tabID] {
t.Fatal("expected accessed entry to be removed")
}
if tm.currentTab != "" {
t.Fatalf("expected current tab to be cleared, got %q", tm.currentTab)
}
if dm.GetPending(tabID) != nil {
t.Fatal("expected pending dialog to be cleared")
}
if logs := logStore.GetConsoleLogs(cdpID, 0); logs != nil {
t.Fatalf("expected console logs to be removed, got %v", logs)
}
if errs := logStore.GetErrorLogs(cdpID, 0); errs != nil {
t.Fatalf("expected error logs to be removed, got %v", errs)
}
}