Merge pull request #608 from grafana/fix/605-browsertype-launch-opts

Parse BrowserType.Launch options and return errors

Author: inancgumus

common/browser_options.go

@@ -0,0 +1,98 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/dop251/goja"
+
+	"github.com/grafana/xk6-browser/k6ext"
+)
+
+// ProxyOptions allows configuring a proxy server.
+type ProxyOptions struct {
+	Server   string
+	Bypass   string
+	Username string
+	Password string
+}
+
+// LaunchOptions stores browser launch options.
+type LaunchOptions struct {
+	Args              []string
+	Debug             bool
+	Devtools          bool
+	Env               map[string]string
+	ExecutablePath    string
+	Headless          bool
+	IgnoreDefaultArgs []string
+	LogCategoryFilter string
+	Proxy             ProxyOptions
+	SlowMo            time.Duration
+	Timeout           time.Duration
+}
+
+// LaunchPersistentContextOptions stores browser launch options for persistent context.
+type LaunchPersistentContextOptions struct {
+	LaunchOptions
+	BrowserContextOptions
+}
+
+// NewLaunchOptions returns a new LaunchOptions.
+func NewLaunchOptions() *LaunchOptions {
+	launchOpts := LaunchOptions{
+		Env:               make(map[string]string),
+		Headless:          true,
+		LogCategoryFilter: ".*",
+		Timeout:           DefaultTimeout,
+	}
+	return &launchOpts
+}
+
+// Parse parses launch options from a JS object.
+func (l *LaunchOptions) Parse(ctx context.Context, opts goja.Value) error { //nolint:cyclop
+	if !gojaValueExists(opts) {
+		return errors.New("LaunchOptions does not exist in the runtime")
+	}
+	var (
+		rt = k6ext.Runtime(ctx)
+		o  = opts.ToObject(rt)
+	)
+	for _, k := range o.Keys() {
+		v := o.Get(k)
+		if v.Export() == nil {
+			continue // don't override the defaults on `null``
+		}
+		var err error
+		switch k {
+		case "args":
+			err = exportOpt(rt, k, v, &l.Args)
+		case "debug":
+			l.Debug, err = parseBoolOpt(k, v)
+		case "devtools":
+			l.Devtools, err = parseBoolOpt(k, v)
+		case "env":
+			err = exportOpt(rt, k, v, &l.Env)
+		case "executablePath":
+			l.ExecutablePath, err = parseStrOpt(k, v)
+		case "headless":
+			l.Headless, err = parseBoolOpt(k, v)
+		case "ignoreDefaultArgs":
+			err = exportOpt(rt, k, v, &l.IgnoreDefaultArgs)
+		case "logCategoryFilter":
+			l.LogCategoryFilter, err = parseStrOpt(k, v)
+		case "proxy":
+			err = exportOpt(rt, k, v, &l.Proxy)
+		case "slowMo":
+			l.SlowMo, err = parseTimeOpt(k, v)
+		case "timeout":
+			l.Timeout, err = parseTimeOpt(k, v)
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

common/browser_options_test.go

@@ -0,0 +1,225 @@
+package common
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/grafana/xk6-browser/k6ext/k6test"
+)
+
+func TestBrowserLaunchOptionsParse(t *testing.T) {
+	t.Parallel()
+
+	for name, tt := range map[string]struct {
+		opts   map[string]any
+		assert func(testing.TB, *LaunchOptions)
+		err    string
+	}{
+		"defaults": {
+			opts: map[string]any{},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, &LaunchOptions{
+					Env:               make(map[string]string),
+					Headless:          true,
+					LogCategoryFilter: ".*",
+					Timeout:           DefaultTimeout,
+				}, lo)
+			},
+		},
+		"nulls": { // don't override the defaults on `null`
+			opts: map[string]any{
+				"env":               nil,
+				"headless":          nil,
+				"logCategoryFilter": nil,
+				"timeout":           nil,
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(tb, &LaunchOptions{
+					Env:               make(map[string]string),
+					Headless:          true,
+					LogCategoryFilter: ".*",
+					Timeout:           DefaultTimeout,
+				}, lo)
+			},
+		},
+		"args": {
+			opts: map[string]any{
+				"args": []any{"browser-arg1='value1", "browser-arg2=value2", "browser-flag"},
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				require.Len(tb, lo.Args, 3)
+				assert.Equal(tb, "browser-arg1='value1", lo.Args[0])
+				assert.Equal(tb, "browser-arg2=value2", lo.Args[1])
+				assert.Equal(tb, "browser-flag", lo.Args[2])
+			},
+		},
+		"args_err": {
+			opts: map[string]any{
+				"args": 1,
+			},
+			err: "args should be an array of strings",
+		},
+		"debug": {
+			opts: map[string]any{"debug": true},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.True(t, lo.Debug)
+			},
+		},
+		"debug_err": {
+			opts: map[string]any{"debug": "true"},
+			err:  "debug should be a boolean",
+		},
+		"devtools": {
+			opts: map[string]any{
+				"devtools": true,
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.True(t, lo.Devtools)
+			},
+		},
+		"devtools_err": {
+			opts: map[string]any{"devtools": "true"},
+			err:  "devtools should be a boolean",
+		},
+		"env": {
+			opts: map[string]any{
+				"env": map[string]string{"key": "value"},
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, map[string]string{"key": "value"}, lo.Env)
+			},
+		},
+		"env_err": {
+			opts: map[string]any{"env": 1},
+			err:  "env should be a map",
+		},
+		"executablePath": {
+			opts: map[string]any{
+				"executablePath": "cmd/somewhere",
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, "cmd/somewhere", lo.ExecutablePath)
+			},
+		},
+		"executablePath_err": {
+			opts: map[string]any{"executablePath": 1},
+			err:  "executablePath should be a string",
+		},
+		"headless": {
+			opts: map[string]any{
+				"headless": false,
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.False(t, lo.Headless)
+			},
+		},
+		"headless_err": {
+			opts: map[string]any{"headless": "true"},
+			err:  "headless should be a boolean",
+		},
+		"ignoreDefaultArgs": {
+			opts: map[string]any{
+				"ignoreDefaultArgs": []string{"--hide-scrollbars", "--hide-something"},
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Len(t, lo.IgnoreDefaultArgs, 2)
+				assert.Equal(t, "--hide-scrollbars", lo.IgnoreDefaultArgs[0])
+				assert.Equal(t, "--hide-something", lo.IgnoreDefaultArgs[1])
+			},
+		},
+		"ignoreDefaultArgs_err": {
+			opts: map[string]any{"ignoreDefaultArgs": "ABC"},
+			err:  "ignoreDefaultArgs should be an array of strings",
+		},
+		"logCategoryFilter": {
+			opts: map[string]any{
+				"logCategoryFilter": "**",
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, "**", lo.LogCategoryFilter)
+			},
+		},
+		"logCategoryFilter_err": {
+			opts: map[string]any{"logCategoryFilter": 1},
+			err:  "logCategoryFilter should be a string",
+		},
+		"proxy": {
+			opts: map[string]any{
+				"proxy": ProxyOptions{
+					Server:   "serverVal",
+					Bypass:   "bypassVal",
+					Username: "usernameVal",
+					Password: "passwordVal",
+				},
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, ProxyOptions{
+					Server:   "serverVal",
+					Bypass:   "bypassVal",
+					Username: "usernameVal",
+					Password: "passwordVal",
+				}, lo.Proxy)
+			},
+		},
+		"proxy_err": {
+			opts: map[string]any{"proxy": 1},
+			err:  "proxy should be an object",
+		},
+		"slowMo": {
+			opts: map[string]any{
+				"slowMo": "5s",
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, 5*time.Second, lo.SlowMo)
+			},
+		},
+		"slowMo_err": {
+			opts: map[string]any{"slowMo": "ABC"},
+			err:  "slowMo should be a time duration value",
+		},
+		"timeout": {
+			opts: map[string]any{
+				"timeout": "10s",
+			},
+			assert: func(tb testing.TB, lo *LaunchOptions) {
+				tb.Helper()
+				assert.Equal(t, 10*time.Second, lo.Timeout)
+			},
+		},
+		"timeout_err": {
+			opts: map[string]any{"timeout": "ABC"},
+			err:  "timeout should be a time duration value",
+		},
+	} {
+		tt := tt
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			var (
+				vu = k6test.NewVU(t)
+				lo = NewLaunchOptions()
+			)
+			err := lo.Parse(vu.Context(), vu.ToGojaValue(tt.opts))
+			if tt.err != "" {
+				require.ErrorContains(t, err, tt.err)
+			} else {
+				require.NoError(t, err)
+				tt.assert(t, lo)
+			}
+		})
+	}
+}