Skip to content

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

7.7 KB
Raw Blame
package runtimekit

import (
	"strings"
	"testing"

	"github.com/pinchtab/pinchtab/internal/browsers"
	_ "github.com/pinchtab/pinchtab/internal/browsers/builtin"
	"github.com/pinchtab/pinchtab/internal/config"
)

func TestRuntimeProxyConfig_NilConfig(t *testing.T) {
	got := RuntimeProxyConfig(nil)
	if got.Server != "" || got.Username != "" || got.Password != "" || got.BypassList != nil || got.Geo != nil {
		t.Fatalf("RuntimeProxyConfig(nil) = %+v, want zero value", got)
	}
}

func TestRuntimeProxyConfig_MapsFields(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Proxy: config.BrowserProxyConfig{
			Server:     "http://proxy.example:8080",
			Username:   "user",
			Password:   "pw",
			BypassList: []string{"*.internal", "localhost"},
			Geo: &config.BrowserProxyGeoConfig{
				Timezone:   "Europe/Rome",
				Locale:     "it-IT",
				WebRTCIP:   "203.0.113.7",
				CountryISO: "IT",
			},
		},
	}
	got := RuntimeProxyConfig(cfg)
	if got.Server != "http://proxy.example:8080" || got.Username != "user" || got.Password != "pw" {
		t.Fatalf("proxy fields not mapped: %+v", got)
	}
	if len(got.BypassList) != 2 || got.BypassList[0] != "*.internal" {
		t.Fatalf("bypass list not mapped: %v", got.BypassList)
	}
	if got.Geo == nil || got.Geo.Timezone != "Europe/Rome" || got.Geo.Locale != "it-IT" ||
		got.Geo.WebRTCIP != "203.0.113.7" || got.Geo.CountryISO != "IT" {
		t.Fatalf("geo not mapped: %+v", got.Geo)
	}
}

func TestRuntimeProxyConfig_CopiesBypassList(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Proxy: config.BrowserProxyConfig{
			Server:     "http://proxy.example:8080",
			BypassList: []string{"a.example"},
		},
	}
	got := RuntimeProxyConfig(cfg)
	cfg.Proxy.BypassList[0] = "mutated.example"
	if got.BypassList[0] != "a.example" {
		t.Fatalf("BypassList aliases the input slice; want an independent copy")
	}
}

func TestRuntimeProxyConfig_NilGeoStaysNil(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Proxy: config.BrowserProxyConfig{Server: "http://proxy.example:8080"},
	}
	if got := RuntimeProxyConfig(cfg); got.Geo != nil {
		t.Fatalf("Geo = %+v, want nil when source geo is nil", got.Geo)
	}
}

func TestLaunchConfigFromRuntime_MapsFields(t *testing.T) {
	cfg := &config.RuntimeConfig{
		DefaultBrowser: "chrome",
		ProfileDir:     "/tmp/profile",
		Headless:       true,
		Timezone:       "UTC",
		ExtensionPaths: []string{"/ext/a"},
		NoRestore:      true,
		UserAgent:      "ua-test",
		Cloak: config.CloakBrowserRuntimeConfig{
			FingerprintSeed: "seed",
			Platform:        "macos",
			Locale:          "en-US",
			Timezone:        "Europe/Rome",
			WebRTCIP:        "203.0.113.7",
			FontsDir:        "/fonts",
			StorageQuotaMB:  64,
		},
	}
	got := LaunchConfigFromRuntime(cfg, "/bin/chrome", 9222, true)
	if got.Binary != "/bin/chrome" || got.DebugPort != 9222 || !got.NoSandbox {
		t.Fatalf("binary/port/sandbox not mapped: %+v", got)
	}
	if got.ProfileDir != "/tmp/profile" || !got.Headless || got.Timezone != "UTC" ||
		got.NoRestore != true || got.UserAgent != "ua-test" {
		t.Fatalf("runtime fields not mapped: %+v", got)
	}
	if len(got.ExtensionPaths) != 1 || got.ExtensionPaths[0] != "/ext/a" {
		t.Fatalf("extension paths not mapped: %v", got.ExtensionPaths)
	}
	if got.Cloak.FingerprintSeed != "seed" || got.Cloak.Platform != "macos" ||
		got.Cloak.FontsDir != "/fonts" || got.Cloak.StorageQuotaMB != 64 {
		t.Fatalf("cloak fingerprint not mapped: %+v", got.Cloak)
	}
	if got.Mode != browsers.LaunchModeChrome {
		t.Fatalf("Mode = %v, want LaunchModeChrome for chrome", got.Mode)
	}
}

func TestLaunchConfigFromRuntime_GhostChromeUsesAutoMode(t *testing.T) {
	cfg := &config.RuntimeConfig{DefaultBrowser: "ghost-chrome"}
	if got := LaunchConfigFromRuntime(cfg, "", 0, false); got.Mode != browsers.LaunchModeAuto {
		t.Fatalf("Mode = %v, want LaunchModeAuto for ghost-chrome", got.Mode)
	}
}

func TestChromeNeedsNoSandbox(t *testing.T) {
	cases := []struct {
		name        string
		goos        string
		euid        int
		inContainer bool
		want        bool
	}{
		{name: "darwin never needs it", goos: "darwin", euid: 0, inContainer: true, want: false},
		{name: "windows never needs it", goos: "windows", euid: 0, inContainer: true, want: false},
		{name: "linux root", goos: "linux", euid: 0, inContainer: false, want: true},
		{name: "linux non-root in container", goos: "linux", euid: 1000, inContainer: true, want: true},
		{name: "linux non-root no container", goos: "linux", euid: 1000, inContainer: false, want: false},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if got := ChromeNeedsNoSandbox(tc.goos, tc.euid, tc.inContainer); got != tc.want {
				t.Fatalf("ChromeNeedsNoSandbox(%q, %d, %v) = %v, want %v", tc.goos, tc.euid, tc.inContainer, got, tc.want)
			}
		})
	}
}

func TestResolveProviderLaunchPlan_Chrome(t *testing.T) {
	cfg := &config.RuntimeConfig{DefaultBrowser: "chrome"}
	launchCfg := LaunchConfigFromRuntime(cfg, "  /bin/chrome  ", 0, false)
	plan, err := ResolveProviderLaunchPlan(cfg, launchCfg)
	if err != nil {
		t.Fatalf("ResolveProviderLaunchPlan returned %v", err)
	}
	if plan.Browser == nil {
		t.Fatal("plan.Browser is nil; expected the registered chrome provider")
	}
	if plan.Binary != "/bin/chrome" {
		t.Fatalf("Binary = %q, want trimmed %q", plan.Binary, "/bin/chrome")
	}
	if len(plan.Args) == 0 {
		t.Fatal("plan.Args is empty; expected chrome base flags")
	}
	found := false
	for _, arg := range plan.Args {
		if arg == "--disable-background-networking" {
			found = true
			break
		}
	}
	if !found {
		t.Fatalf("plan.Args missing a known chrome base flag: %v", plan.Args)
	}
}

func TestFindBrowserBinary_UnknownProvider(t *testing.T) {
	if got := FindBrowserBinary("no-such-browser"); got != "" {
		t.Fatalf("FindBrowserBinary(unknown) = %q, want empty", got)
	}
}

func TestResolveEffectiveBrowser_PromotesDefaultTargetBinary(t *testing.T) {
	cfg := &config.RuntimeConfig{
		DefaultBrowser: config.BrowserChrome,
		Targets: config.BrowserTargetsConfig{
			"only": {
				Provider: config.BrowserCloak,
				Binary:   "/opt/cloak/chrome",
			},
		},
	}
	got := ResolveEffectiveBrowser(cfg)
	if got.ID != config.BrowserCloak {
		t.Fatalf("ID = %q, want %q", got.ID, config.BrowserCloak)
	}
	if got.Binary != "/opt/cloak/chrome" {
		t.Fatalf("Binary = %q, want %q", got.Binary, "/opt/cloak/chrome")
	}
	if got.Config == nil || got.Config.BrowserBinary != "/opt/cloak/chrome" {
		t.Fatalf("resolved config missing target binary: %+v", got.Config)
	}
}

func TestBaseFlagArgs_Chrome(t *testing.T) {
	args := BaseFlagArgs("chrome", false)
	if len(args) == 0 {
		t.Fatal("BaseFlagArgs(chrome, false) is empty")
	}
	for _, arg := range args {
		if !strings.HasPrefix(arg, "--") {
			t.Fatalf("unexpected non-flag arg %q in %v", arg, args)
		}
	}
}

func TestCloakBrowserFlagArgs_NilAndNonCloak(t *testing.T) {
	if got := CloakBrowserFlagArgs(nil); got != nil {
		t.Fatalf("CloakBrowserFlagArgs(nil) = %v, want nil", got)
	}
	cfg := &config.RuntimeConfig{DefaultBrowser: "chrome"}
	if got := CloakBrowserFlagArgs(cfg); got != nil {
		t.Fatalf("CloakBrowserFlagArgs(chrome cfg) = %v, want nil", got)
	}
}

func TestCloakBrowserFlagArgs_OnlyFingerprintFlagsSurvive(t *testing.T) {
	cfg := &config.RuntimeConfig{
		DefaultBrowser: config.BrowserCloak,
		Cloak: config.CloakBrowserRuntimeConfig{
			FingerprintSeed: "seed-1",
			Timezone:        "Europe/Rome",
		},
	}
	args := CloakBrowserFlagArgs(cfg)
	if len(args) == 0 {
		t.Fatal("expected fingerprint flags for cloak config, got none")
	}
	for _, arg := range args {
		if !strings.HasPrefix(arg, "--fingerprint") {
			t.Fatalf("non-fingerprint flag %q leaked into cloak flag args: %v", arg, args)
		}
	}
	joined := strings.Join(args, " ")
	if !strings.Contains(joined, "seed-1") || !strings.Contains(joined, "Europe/Rome") {
		t.Fatalf("configured fingerprint values missing from args: %v", args)
	}
}