High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
package chrome_test
import (
"context"
"os"
"path/filepath"
"runtime"
"slices"
"strings"
"testing"
"time"
"github.com/pinchtab/pinchtab/internal/browsers"
"github.com/pinchtab/pinchtab/internal/browsers/chrome"
)
func TestRegistration(t *testing.T) {
b, ok := browsers.Get("chrome")
if !ok {
t.Fatal("expected chrome to be registered via init()")
}
if b == nil {
t.Fatal("expected non-nil browser")
}
}
func TestID(t *testing.T) {
b, _ := browsers.Get("chrome")
if got := b.ID(); got != "chrome" {
t.Fatalf("ID() = %q, want %q", got, "chrome")
}
}
func TestDisplayName(t *testing.T) {
b, _ := browsers.Get("chrome")
if got := b.DisplayName(); got != "Google Chrome" {
t.Fatalf("DisplayName() = %q, want %q", got, "Google Chrome")
}
}
func TestCapabilities(t *testing.T) {
b, _ := browsers.Get("chrome")
caps := b.Capabilities()
want := []browsers.BrowserCapability{
browsers.CapCDP,
browsers.CapHeadless,
browsers.CapPDF,
browsers.CapExtensions,
browsers.CapDownloads,
browsers.CapNetworkInterception,
browsers.CapEventScreencast,
browsers.CapRuntimeConsoleEvents,
}
for _, c := range want {
if !caps.Has(c) {
t.Errorf("expected capability %q to be present", c)
}
}
if caps.Has(browsers.CapNativeStealth) {
t.Error("chrome should NOT have CapNativeStealth")
}
if caps.Len() != len(want) {
t.Errorf("Len() = %d, want %d", caps.Len(), len(want))
}
}
func TestSupportsRemoteCDP(t *testing.T) {
b, _ := browsers.Get("chrome")
if !b.SupportsRemoteCDP() {
t.Fatal("expected SupportsRemoteCDP() = true")
}
}
func TestGeoAlignmentEmpty(t *testing.T) {
b, _ := browsers.Get("chrome")
geo := b.GeoAlignment(browsers.GeoConfig{})
if len(geo.Flags) != 0 {
t.Errorf("expected no flags, got %v", geo.Flags)
}
if len(geo.Env) != 0 {
t.Errorf("expected no env, got %v", geo.Env)
}
}
func TestBinaryNamesReturnsExpectedNames(t *testing.T) {
names := chrome.BinaryNames()
required := []string{"google-chrome", "chromium-browser", "chrome"}
for _, want := range required {
found := false
for _, n := range names {
if n == want {
found = true
break
}
}
if !found {
t.Errorf("BinaryNames() missing %q; got %v", want, names)
}
}
names[0] = "MUTATED"
fresh := chrome.BinaryNames()
if fresh[0] == "MUTATED" {
t.Fatal("BinaryNames() did not return a defensive copy")
}
}
func TestCommonPathsPerOS(t *testing.T) {
tests := []struct {
goos string
want string // substring that must appear in at least one path
wantNil bool
}{
{"linux", "/usr/bin/google-chrome", false},
{"darwin", "Google Chrome.app", false},
{"windows", "chrome.exe", false},
{"freebsd", "", true},
}
for _, tt := range tests {
paths := chrome.CommonPaths(tt.goos)
if tt.wantNil {
if paths != nil {
t.Errorf("CommonPaths(%q) = %v, want nil", tt.goos, paths)
}
continue
}
if len(paths) == 0 {
t.Errorf("CommonPaths(%q) returned empty slice", tt.goos)
continue
}
found := false
for _, p := range paths {
if strings.Contains(p, tt.want) {
found = true
break
}
}
if !found {
t.Errorf("CommonPaths(%q) missing path containing %q; got %v", tt.goos, tt.want, paths)
}
}
}
func TestCommonPathsDarwinPrefersDedicatedBrowser(t *testing.T) {
paths := chrome.CommonPaths("darwin")
if len(paths) == 0 {
t.Fatal("darwin CommonPaths empty")
}
primary := "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
cft := "/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
// The user's daily Chrome must be the LAST resort (issue #583): launching it
// for automation collides with macOS LaunchServices.
if got := paths[len(paths)-1]; got != primary {
t.Errorf("expected primary Chrome to be last; got last = %q in %v", got, paths)
}
primaryIdx := indexOf(paths, primary)
cftIdx := indexOf(paths, cft)
if cftIdx < 0 {
t.Fatalf("expected Chrome for Testing in darwin CommonPaths; got %v", paths)
}
if cftIdx >= primaryIdx {
t.Errorf("Chrome for Testing (%d) must be preferred over primary Chrome (%d)", cftIdx, primaryIdx)
}
}
func TestDiscoverBinaryReturnsValidResult(t *testing.T) {
b, ok := browsers.Get("chrome")
if !ok {
t.Fatal("chrome not registered")
}
d := b.DiscoverBinary()
// In CI the binary may not be installed, so Found can be empty.
// But Probed must always be non-empty because we check at least the
// binary names via PATH.
if len(d.Probed) == 0 {
t.Fatal("DiscoverBinary().Probed is empty; expected at least PATH probes")
}
_ = browsers.BinaryDiscovery(d)
}
func TestBuildLaunchArgsReturnsBaseFlags(t *testing.T) {
args, _, err := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
if err != nil {
t.Fatalf("BuildLaunchArgs() error = %v", err)
}
for _, want := range []string{
"--disable-background-networking",
"--disable-metrics-reporting",
"--metrics-recording-only",
"--password-store=basic",
"--use-mock-keychain",
} {
if !slices.Contains(args, want) {
t.Errorf("expected args to contain %q", want)
}
}
if len(args) != 25 {
t.Fatalf("expected 25 args (23 base + 1 --disable-extensions + 1 --window-size), got %d: %v", len(args), args)
}
}
func TestBuildLaunchArgsReturnsNoEnv(t *testing.T) {
_, env, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
if env != nil {
t.Fatalf("expected nil env, got %v", env)
}
}
func TestBuildLaunchArgsHeadlessAppendsFlags(t *testing.T) {
args, env, err := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{Headless: true})
if err != nil {
t.Fatalf("BuildLaunchArgs() error = %v", err)
}
if env != nil {
t.Fatalf("expected nil env, got %v", env)
}
for _, want := range []string{
"--headless=new",
"--disable-vulkan",
"--use-angle=swiftshader",
"--enable-unsafe-swiftshader",
} {
if !slices.Contains(args, want) {
t.Errorf("expected headless args to contain %q", want)
}
}
// --disable-gpu must NOT appear: under --headless=new it removes the
// compositor's GPU backend and capture/print CDP calls hang.
if slices.Contains(args, "--disable-gpu") {
t.Error("headless args must not contain --disable-gpu")
}
if len(args) != 29 {
t.Fatalf("expected 29 args (23 base + 4 headless + 1 --disable-extensions + 1 --window-size), got %d: %v", len(args), args)
}
}
func TestBuildLaunchArgsHeadedOmitsHeadlessFlags(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{Headless: false})
for _, forbidden := range []string{
"--headless=new",
"--disable-gpu",
"--disable-vulkan",
} {
if slices.Contains(args, forbidden) {
t.Errorf("headed mode should not contain %q", forbidden)
}
}
}
func TestBuildLaunchArgsDoesNotContainStealthOrProfileFlags(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
forbidden := []string{
"--enable-automation=false",
"--disable-blink-features=AutomationControlled",
"--headless=new",
"--user-data-dir",
"--no-sandbox",
"--enable-network-information-downlink-max",
}
for _, f := range forbidden {
if slices.Contains(args, f) {
t.Errorf("args should not contain %q", f)
}
}
}
func TestBuildLaunchArgsWithDebugPort(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{DebugPort: 9222})
if len(args) == 0 || args[0] != "--remote-debugging-port=9222" {
t.Fatalf("expected first arg to be --remote-debugging-port=9222, got %v", args)
}
}
func TestBuildLaunchArgsWithProfileDir(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{ProfileDir: "/tmp/test-profile"})
if !slices.Contains(args, "--user-data-dir=/tmp/test-profile") {
t.Fatalf("expected --user-data-dir=/tmp/test-profile in args")
}
}
func TestBuildLaunchArgsWithExtensions(t *testing.T) {
dir1 := t.TempDir()
dir2 := t.TempDir()
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{
ExtensionPaths: []string{dir1, dir2, "/nonexistent/path"},
})
wantLoad := "--load-extension=" + dir1 + "," + dir2
wantExcept := "--disable-extensions-except=" + dir1 + "," + dir2
if !slices.Contains(args, wantLoad) {
t.Fatalf("expected %q in args, got %v", wantLoad, args)
}
if !slices.Contains(args, wantExcept) {
t.Fatalf("expected %q in args, got %v", wantExcept, args)
}
}
func TestBuildLaunchArgsNoExtensions(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
if !slices.Contains(args, "--disable-extensions") {
t.Fatalf("expected --disable-extensions when no extension paths given")
}
}
func TestBuildLaunchArgsWithTimezone(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{Timezone: "America/New_York"})
if !slices.Contains(args, "--tz=America/New_York") {
t.Fatalf("expected --tz=America/New_York in args")
}
}
func TestBuildLaunchArgsIncludesWindowSize(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
found := false
for _, arg := range args {
if strings.HasPrefix(arg, "--window-size=") {
found = true
break
}
}
if !found {
t.Fatalf("expected --window-size= in args")
}
}
func TestBuildLaunchArgsWithExtraFlags(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{
ExtraFlags: []string{"--custom-flag=value"},
})
if !slices.Contains(args, "--custom-flag=value") {
t.Fatalf("expected --custom-flag=value in args")
}
}
func TestBuildLaunchArgsNoSandbox(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{NoSandbox: true})
if !slices.Contains(args, "--no-sandbox") {
t.Fatalf("expected --no-sandbox when NoSandbox=true")
}
argsNoSandbox, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{NoSandbox: false})
if slices.Contains(argsNoSandbox, "--no-sandbox") {
t.Fatalf("expected no --no-sandbox when NoSandbox=false")
}
}
func indexOf(args []string, prefix string) int {
for i, a := range args {
if strings.HasPrefix(a, prefix) {
return i
}
}
return -1
}
func TestBuildLaunchArgsParityWithRepresentativeConfigs(t *testing.T) {
t.Run("full headless config", func(t *testing.T) {
extDir := t.TempDir()
cfg := browsers.LaunchConfig{
Headless: true,
DebugPort: 9222,
ProfileDir: "/tmp/profile",
Timezone: "America/New_York",
ExtensionPaths: []string{extDir},
ExtraFlags: []string{"--custom=1"},
NoSandbox: true,
}
args, env, err := chrome.Browser{}.BuildLaunchArgs(cfg)
if err != nil {
t.Fatalf("error = %v", err)
}
if env != nil {
t.Fatalf("expected nil env, got %v", env)
}
mustContain := []string{
"--remote-debugging-port=9222",
"--disable-background-networking",
"--disable-metrics-reporting",
"--password-store=basic",
"--headless=new",
"--disable-vulkan",
"--use-angle=swiftshader",
"--enable-unsafe-swiftshader",
"--load-extension=" + extDir,
"--disable-extensions-except=" + extDir,
"--user-data-dir=/tmp/profile",
"--tz=America/New_York",
"--custom=1",
"--no-sandbox",
}
for _, want := range mustContain {
if !slices.Contains(args, want) {
t.Errorf("missing %q in args", want)
}
}
if indexOf(args, "--window-size=") < 0 {
t.Error("missing --window-size= arg")
}
if args[0] != "--remote-debugging-port=9222" {
t.Errorf("first arg = %q, want --remote-debugging-port=9222", args[0])
}
if args[len(args)-1] != "--no-sandbox" {
t.Errorf("last arg = %q, want --no-sandbox", args[len(args)-1])
}
order := []string{
"--remote-debugging-port=",
"--disable-background-networking",
"--headless=new",
"--load-extension=",
"--user-data-dir=",
"--window-size=",
"--tz=",
"--custom=1",
"--no-sandbox",
}
prev := -1
for _, prefix := range order {
idx := indexOf(args, prefix)
if idx < 0 {
t.Fatalf("ordering check: %q not found", prefix)
}
if idx <= prev {
t.Fatalf("ordering violation: %q at %d, expected after index %d", prefix, idx, prev)
}
prev = idx
}
})
t.Run("headed minimal", func(t *testing.T) {
args, _, err := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{})
if err != nil {
t.Fatalf("error = %v", err)
}
if len(args) != 25 {
t.Fatalf("expected 25 args (23 base + disable-extensions + window-size), got %d", len(args))
}
if !slices.Contains(args, "--disable-background-networking") {
t.Error("missing base flag --disable-background-networking")
}
if !slices.Contains(args, "--disable-extensions") {
t.Error("missing --disable-extensions")
}
if indexOf(args, "--window-size=") < 0 {
t.Error("missing --window-size=")
}
mustNotContain := []string{
"--headless=new",
"--remote-debugging-port=",
"--user-data-dir=",
"--tz=",
"--no-sandbox",
}
for _, prefix := range mustNotContain {
if indexOf(args, prefix) >= 0 {
t.Errorf("headed minimal should not contain %q", prefix)
}
}
})
t.Run("extensions with missing paths", func(t *testing.T) {
validDir := t.TempDir()
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{
ExtensionPaths: []string{validDir, "/nonexistent/ext/path"},
})
loadIdx := indexOf(args, "--load-extension=")
if loadIdx < 0 {
t.Fatal("expected --load-extension= arg")
}
if strings.Contains(args[loadIdx], "/nonexistent/ext/path") {
t.Error("invalid extension path should be filtered out")
}
if !strings.Contains(args[loadIdx], validDir) {
t.Error("valid extension path should be included")
}
})
t.Run("empty extensions list", func(t *testing.T) {
args, _, _ := chrome.Browser{}.BuildLaunchArgs(browsers.LaunchConfig{
ExtensionPaths: []string{},
})
if !slices.Contains(args, "--disable-extensions") {
t.Error("expected --disable-extensions with empty list")
}
if indexOf(args, "--load-extension=") >= 0 {
t.Error("should not have --load-extension with empty list")
}
})
}
func TestClassifyLaunchErrorAlwaysUnknown(t *testing.T) {
b, _ := browsers.Get("chrome")
kind := b.ClassifyLaunchError(browsers.LaunchFailure{
Err: context.Canceled,
Elapsed: 500 * time.Millisecond,
ParentCanceled: false,
BrowserCanceled: true,
})
if kind != browsers.LaunchErrorUnknown {
t.Errorf("Chrome should always return LaunchErrorUnknown; got %v", kind)
}
}
func TestChrome_CanHandle(t *testing.T) {
b := &chrome.Browser{}
result := b.CanHandle(browsers.RequestIntent{Shape: "static-read"})
if result.Decision != browsers.DecisionHandle {
t.Errorf("Chrome CanHandle = %q, want %q", result.Decision, browsers.DecisionHandle)
}
}
func TestChrome_CanHandle_AllShapes(t *testing.T) {
b := &chrome.Browser{}
shapes := []string{
browsers.ShapeStaticRead,
browsers.ShapeStaticSnapshot,
browsers.ShapeRenderedRead,
browsers.ShapeVisual,
browsers.ShapeInteraction,
browsers.ShapeSessionState,
browsers.ShapeNetworkControl,
browsers.ShapeDownloadUpload,
"unknown",
"",
}
for _, shape := range shapes {
t.Run(shape, func(t *testing.T) {
got := b.CanHandle(browsers.RequestIntent{Shape: shape})
if got.Decision != browsers.DecisionHandle {
t.Errorf("Chrome CanHandle(%q) = %q, want %q", shape, got.Decision, browsers.DecisionHandle)
}
})
}
}
func TestChrome_ValidateTarget(t *testing.T) {
b := &chrome.Browser{}
if err := b.ValidateTarget(browsers.TargetConfig{}); err != nil {
t.Errorf("ValidateTarget(empty) = %v, want nil", err)
}
if err := b.ValidateTarget(browsers.TargetConfig{Binary: "/usr/bin/chrome"}); err != nil {
t.Errorf("ValidateTarget(binary) = %v, want nil", err)
}
}
// TestChromePresentHonorsBrowserBinaryOverride guards the issue #583 follow-up:
// a configured browser.binary that sits off the static discovery path must PASS
// chrome_present (it's what the runtime launches), not report a false "no
// chrome/chromium found" FAIL while the binary_* checks pass right below it.
func TestChromePresentHonorsBrowserBinaryOverride(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("the override stub is a shell script; the windows path is covered by " +
"TestChromePresent_ProducesAVerdictOnWindows in internal/doctor")
}
dir := t.TempDir()
fake := filepath.Join(dir, "fakechrome")
if err := os.WriteFile(fake, []byte("#!/bin/sh\necho 'Chromium 149.0.0.0'\n"), 0o755); err != nil {
t.Fatal(err)
}
check := findCheckByID(t, (&chrome.Browser{}).DoctorChecks(browsers.TargetConfig{}), "chrome_present")
res := check.Fn(context.Background(), &browsers.DoctorEnv{Binary: fake})
if res.Status != browsers.DoctorPass {
t.Fatalf("chrome_present with override status = %v, want DoctorPass; detail: %s", res.Status, res.Detail)
}
if !strings.Contains(res.Detail, fake) {
t.Errorf("expected detail to reference the override path %q; got %q", fake, res.Detail)
}
}
func findCheckByID(t *testing.T, checks []browsers.DoctorCheck, id string) browsers.DoctorCheck {
t.Helper()
for _, c := range checks {
if c.ID == id {
return c
}
}
t.Fatalf("check %q not found", id)
return browsers.DoctorCheck{}
}
func TestChromeHandleDecisionsCheck(t *testing.T) {
b := &chrome.Browser{}
checks := b.DoctorChecks(browsers.TargetConfig{})
var found *browsers.DoctorCheck
for i := range checks {
if checks[i].ID == "handle_decisions" {
found = &checks[i]
break
}
}
if found == nil {
t.Fatal("handle_decisions check not found in Chrome DoctorChecks")
}
if found.Description == "" {
t.Error("handle_decisions check has empty description")
}
result := found.Fn(context.Background(), nil)
if result.Status != browsers.DoctorPass {
t.Errorf("handle_decisions status = %v, want DoctorPass; detail: %s", result.Status, result.Detail)
}
if result.Detail != "all 8 request shapes handled" {
t.Errorf("handle_decisions detail = %q, want %q", result.Detail, "all 8 request shapes handled")
}
}
func TestBuildLaunchArgs_RejectsLiteMode(t *testing.T) {
b, _ := browsers.Get("chrome")
_, _, err := b.BuildLaunchArgs(browsers.LaunchConfig{Mode: browsers.LaunchModeLite})
if err == nil {
t.Fatal("expected error for lite mode")
}
if !strings.Contains(err.Error(), "chrome") || !strings.Contains(err.Error(), "lite") {
t.Errorf("error should mention provider and mode; got: %v", err)
}
}