cdp_hub/internal/platform/browser/smoke_windows_test.go

//go:build windows && smoke

package browser

import (
	"context"
	"errors"
	"testing"
	"time"

	"chub/internal/domain"
)

func TestRealChromiumSmoke(t *testing.T) {
	ctx := context.Background()
	discoverer := NewDiscoverer()
	launcher := NewOSLauncher()
	cdp := NewCDPInspector()
	type running struct {
		kind   domain.BrowserKind
		dir    string
		handle ProcessHandle
	}
	var processes []running
	for _, kind := range []domain.BrowserKind{domain.BrowserChrome, domain.BrowserEdge} {
		executable, err := discoverer.Resolve(ctx, kind, "")
		if errors.Is(err, ErrExecutableNotFound) {
			t.Logf("%s not installed; skipping", kind)
			continue
		}
		if err != nil {
			t.Fatalf("resolve %s: %v", kind, err)
		}
		dir := t.TempDir()
		var handle ProcessHandle
		t.Cleanup(func() {
			if handle == nil {
				return
			}
			if err := launcher.StopProfile(ctx, dir, true); err != nil && !errors.Is(err, domain.ErrInstanceNotFound) {
				t.Errorf("cleanup force stop %s: %v", kind, err)
				return
			}
			waitCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
			_, _ = handle.Wait(waitCtx)
			cancel()
		})
		port, err := cdp.FindAvailableRemoteDebugPort(ctx, domain.DefaultRemoteDebugPort)
		if err != nil {
			t.Fatalf("allocate %s CDP port: %v", kind, err)
		}
		handle, err = launcher.Start(ctx, domain.LaunchSpec{Kind: kind, Executable: executable, UserDataDir: dir, RemoteDebugPort: port, TargetURL: "https://example.com", Headless: true, ExtraArgs: []string{"--disable-gpu"}})
		if err != nil {
			t.Fatalf("start %s: %v", kind, err)
		}
		processes = append(processes, running{kind: kind, dir: dir, handle: handle})
		if handle.PID() <= 0 {
			t.Fatalf("%s returned invalid PID %d", kind, handle.PID())
		}
		endpointCtx, cancelEndpoint := context.WithTimeout(ctx, 10*time.Second)
		endpoint, endpointErr := cdp.WaitForRemoteDebugPort(endpointCtx, kind, port)
		cancelEndpoint()
		if endpointErr != nil || endpoint.Port != port {
			t.Fatalf("%s CDP endpoint = %+v, %v; want port %d", kind, endpoint, endpointErr, port)
		}
		use, err := launcher.InspectProfile(ctx, dir)
		if err != nil || !use.Occupied || use.PID != handle.PID() {
			t.Fatalf("%s registry = %+v, %v", kind, use, err)
		}
		external := NewWindowsProfileInspector()
		externalUse, externalErr := external.InspectProfile(ctx, kind, dir, handle.PID())
		if externalErr != nil {
			t.Logf("%s external profile inspection unavailable in headless smoke: %v", kind, externalErr)
		} else if !externalUse.Occupied {
			t.Logf("%s external profile inspection found no lock/window evidence in headless mode", kind)
		} else {
			t.Logf("%s external profile evidence: %+v", kind, externalUse)
		}
		if _, err := launcher.Start(ctx, domain.LaunchSpec{Kind: kind, Executable: executable, UserDataDir: dir, TargetURL: "https://example.com", Headless: true}); !errors.Is(err, domain.ErrProfileOccupied) {
			t.Fatalf("duplicate %s error = %v", kind, err)
		}
	}
	if len(processes) < 2 {
		t.Skip("Chrome and Edge are not both installed")
	}
	if processes[0].handle.PID() == processes[1].handle.PID() {
		t.Fatalf("Chrome and Edge shared PID %d", processes[0].handle.PID())
	}
}