Skip to content

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

4.1 KB
Raw Blame
package actions

import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"reflect"
	"strings"
	"testing"

	"github.com/spf13/cobra"
)

func TestSanitizeTerminalText(t *testing.T) {
	input := "hello\x1b[31mred\x1b[0m\r\nnext\tline\a"
	got := sanitizeTerminalText(input)
	want := "hello[31mred[0m\\r\\nnext\\tline"
	if got != want {
		t.Fatalf("sanitizeTerminalText() = %q, want %q", got, want)
	}
}

func TestPrintConsoleLogs_SanitizesTerminalOutput(t *testing.T) {
	output := captureStdout(t, func() {
		printConsoleLogs([]byte(`{"tabId":"tab1","console":[{"timestamp":"2026-03-19T12:00:00Z","level":"log","message":"hello\u001b[31m\r\nworld\t\u0007"}]}`))
	})

	if strings.ContainsRune(output, '\x1b') {
		t.Fatalf("expected output to strip escape characters, got %q", output)
	}
	if !strings.Contains(output, "hello[31m\\r\\nworld\\t") {
		t.Fatalf("expected sanitized output, got %q", output)
	}
}

func TestPrintErrorLogs_SanitizesTerminalOutput(t *testing.T) {
	output := captureStdout(t, func() {
		printErrorLogs([]byte(`{"tabId":"tab1","errors":[{"timestamp":"2026-03-19T12:00:00Z","message":"boom\u001b[2J","url":"https://example.com/\u001b]52;c;secret\u0007","line":1,"column":2}]}`))
	})

	if strings.ContainsRune(output, '\x1b') {
		t.Fatalf("expected output to strip escape characters, got %q", output)
	}
	if !strings.Contains(output, "boom[2J") {
		t.Fatalf("expected sanitized message, got %q", output)
	}
	if !strings.Contains(output, "https://example.com/]52;c;secret") {
		t.Fatalf("expected sanitized url, got %q", output)
	}
}

func captureStdout(t *testing.T, fn func()) string {
	t.Helper()

	oldStdout := os.Stdout
	reader, writer, err := os.Pipe()
	if err != nil {
		t.Fatalf("os.Pipe: %v", err)
	}
	os.Stdout = writer

	var buf bytes.Buffer
	done := make(chan error, 1)
	go func() {
		_, err := io.Copy(&buf, reader)
		_ = reader.Close()
		done <- err
	}()

	defer func() {
		os.Stdout = oldStdout
	}()

	fn()

	_ = writer.Close()
	if err := <-done; err != nil {
		t.Fatalf("io.Copy: %v", err)
	}
	return buf.String()
}

func logCommand(t *testing.T, args ...string) *cobra.Command {
	t.Helper()
	cmd := &cobra.Command{Use: "log"}
	cmd.Flags().Bool("clear", false, "")
	cmd.Flags().Bool("json", false, "")
	cmd.Flags().String("tab", "", "")
	cmd.Flags().String("limit", "", "")
	if err := cmd.Flags().Parse(args); err != nil {
		t.Fatalf("parse flags: %v", err)
	}
	return cmd
}

func TestConsoleAndErrors_JSONPrintsBodyOnce(t *testing.T) {
	bodies := map[string]string{
		"/console": `{"tabId":"tab1","console":[{"timestamp":"2026-03-19T12:00:00Z","level":"warning","message":"careful","source":"console-api"}]}`,
		"/errors":  `{"tabId":"tab1","errors":[{"timestamp":"2026-03-19T12:00:00Z","message":"boom","url":"https://example.com/a.js","line":2,"column":23,"stack":"ReferenceError: boom"}]}`,
	}
	var hits []string
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		hits = append(hits, r.URL.RequestURI())
		w.Header().Set("Content-Type", "application/json")
		_, _ = io.WriteString(w, bodies[r.URL.Path])
	}))
	defer srv.Close()

	run := map[string]func(*http.Client, string, string, *cobra.Command){"/console": Console, "/errors": Errors}
	for path, action := range run {
		hits = nil
		output := captureStdout(t, func() {
			action(srv.Client(), srv.URL, "", logCommand(t, "--json", "--tab", "tab1", "--limit", "5"))
		})
		var got, want map[string]any
		if err := json.Unmarshal([]byte(output), &got); err != nil {
			t.Fatalf("%s --json output is not one JSON document: %v\n%s", path, err, output)
		}
		_ = json.Unmarshal([]byte(bodies[path]), &want)
		if !reflect.DeepEqual(got, want) {
			t.Errorf("%s --json printed %v, want the response body %v", path, got, want)
		}
		if len(hits) != 1 || !strings.Contains(hits[0], "tabId=tab1") || !strings.Contains(hits[0], "limit=5") {
			t.Errorf("%s --json requests = %v, want one carrying tab and limit", path, hits)
		}
	}

	terse := captureStdout(t, func() {
		Errors(srv.Client(), srv.URL, "", logCommand(t))
	})
	if strings.Contains(terse, "{") || !strings.Contains(terse, "12:00:00 [ERROR] boom") {
		t.Errorf("terse errors output changed: %q", terse)
	}
}