Skip to content

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

3.6 KB
Raw Blame
package browserops

import (
	"encoding/json"
	"testing"
)

func singleBrowserRoute(browser string) *RouteMetadata {
	return &RouteMetadata{
		RequestedBrowser: browser,
		UsedBrowser:      browser,
		Attempts:         []RouteAttempt{{Browser: browser, Accepted: true}},
	}
}

func TestRouteMetadataJSONKeys(t *testing.T) {
	result := NavigateResult{
		TabID: "tab-1",
		URL:   "https://example.com",
		Title: "Example",
		Route: singleBrowserRoute("chrome"),
	}

	data, err := json.Marshal(result)
	if err != nil {
		t.Fatalf("Marshal: %v", err)
	}

	var m map[string]any
	if err := json.Unmarshal(data, &m); err != nil {
		t.Fatalf("Unmarshal: %v", err)
	}

	routeRaw, ok := m["route"]
	if !ok {
		t.Fatal("expected \"route\" key in JSON output")
	}
	route, ok := routeRaw.(map[string]any)
	if !ok {
		t.Fatalf("route is %T, want map[string]any", routeRaw)
	}

	// Must use provider naming.
	if _, ok := route["requestedProvider"]; !ok {
		t.Fatal("route missing \"requestedProvider\" key")
	}
	if _, ok := route["usedProvider"]; !ok {
		t.Fatal("route missing \"usedProvider\" key")
	}
	if _, ok := route["browserops"]; ok {
		t.Fatal("route must not contain \"browserops\" key")
	}

	if got := route["requestedProvider"]; got != "chrome" {
		t.Fatalf("requestedProvider = %v, want \"chrome\"", got)
	}
	if got := route["usedProvider"]; got != "chrome" {
		t.Fatalf("usedProvider = %v, want \"chrome\"", got)
	}
	if got := route["escalated"]; got != false {
		t.Fatalf("escalated = %v, want false", got)
	}

	attemptsRaw, ok := route["attempts"]
	if !ok {
		t.Fatal("route missing \"attempts\" key")
	}
	attempts, ok := attemptsRaw.([]any)
	if !ok {
		t.Fatalf("attempts is %T, want []any", attemptsRaw)
	}
	if len(attempts) == 0 {
		t.Fatal("attempts is empty, want at least one entry")
	}
	first, ok := attempts[0].(map[string]any)
	if !ok {
		t.Fatalf("attempts[0] is %T, want map[string]any", attempts[0])
	}
	if got := first["provider"]; got != "chrome" {
		t.Fatalf("attempts[0].provider = %v, want \"chrome\"", got)
	}
	if got := first["accepted"]; got != true {
		t.Fatalf("attempts[0].accepted = %v, want true", got)
	}
}

// TestResultStructsOmitEngine verifies that all result structs serialize
// with "route" metadata and never include an "browserops" key.
func TestResultStructsOmitEngine(t *testing.T) {
	route := singleBrowserRoute("lite")

	tests := []struct {
		name string
		data any
	}{
		{
			name: "NavigateResult",
			data: NavigateResult{TabID: "t1", URL: "https://x.com", Title: "X", Route: route},
		},
		{
			name: "SnapshotResult",
			data: SnapshotResult{Nodes: []SnapshotNode{{Ref: "e1", Role: "button", Name: "OK"}}, Route: route},
		},
		{
			name: "TextResult",
			data: TextResult{Text: "hello", URL: "https://x.com", Route: route},
		},
		{
			name: "ActionResult",
			data: ActionResult{Data: map[string]any{"ok": true}, Route: route},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			b, err := json.Marshal(tc.data)
			if err != nil {
				t.Fatalf("Marshal: %v", err)
			}
			var m map[string]any
			if err := json.Unmarshal(b, &m); err != nil {
				t.Fatalf("Unmarshal: %v", err)
			}
			if _, ok := m["browserops"]; ok {
				t.Fatalf("%s JSON must not contain \"browserops\" key", tc.name)
			}
			routeRaw, ok := m["route"]
			if !ok {
				t.Fatalf("%s JSON must contain \"route\" key", tc.name)
			}
			routeMap, ok := routeRaw.(map[string]any)
			if !ok {
				t.Fatalf("route is %T, want map[string]any", routeRaw)
			}
			if _, ok := routeMap["requestedProvider"]; !ok {
				t.Fatal("route missing requestedProvider")
			}
			if _, ok := routeMap["usedProvider"]; !ok {
				t.Fatal("route missing usedProvider")
			}
		})
	}
}