Merge pull request #141 from grafana/refactor/tests

Refactor: Tests

Author: inancgumus

chromium/browser_type.go

@@ -79,6 +79,7 @@ func (b *BrowserType) Launch(opts goja.Value) api.Browser {
 
 	launchOpts := common.NewLaunchOptions()
 	launchOpts.Parse(b.Ctx, opts)
+
 	b.Ctx = common.WithLaunchOptions(b.Ctx, launchOpts)
 
 	envs := make([]string, 0, len(launchOpts.Env))

common/browser.go

@@ -380,7 +380,7 @@ func (b *Browser) NewContext(opts goja.Value) api.BrowserContext {
 	browserContextID, err := action.Do(cdp.WithExecutor(b.ctx, b.conn))
 	b.logger.Debugf("Browser:NewContext", "browserContextID: %v", browserContextID)
 	if err != nil {
-		k6Throw(b.ctx, "unable to execute %T: %w", action, err)
+		k6Throw(b.ctx, "cannot create browser context (%s): %w", browserContextID, err)
 	}
 
 	browserCtxOpts := NewBrowserContextOptions()

common/connection_test.go

@@ -30,14 +30,13 @@ import (
 	"github.com/chromedp/cdproto/cdp"
 	"github.com/chromedp/cdproto/target"
 	"github.com/gorilla/websocket"
-	"github.com/grafana/xk6-browser/testutils"
 	"github.com/mailru/easyjson"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestConnection(t *testing.T) {
-	server := testutils.NewWSTestServerWithEcho(t)
+	server := NewWSServerWithEcho(t)
 	defer server.Cleanup()
 
 	t.Run("connect", func(t *testing.T) {
@@ -52,7 +51,7 @@ func TestConnection(t *testing.T) {
 }
 
 func TestConnectionClosureAbnormal(t *testing.T) {
-	server := testutils.NewWSTestServerWithClosureAbnormal(t)
+	server := NewWSServerWithClosureAbnormal(t)
 	defer server.Cleanup()
 
 	t.Run("closure abnormal", func(t *testing.T) {
@@ -70,7 +69,7 @@ func TestConnectionClosureAbnormal(t *testing.T) {
 }
 
 func TestConnectionSendRecv(t *testing.T) {
-	server := testutils.NewWSTestServerWithCDPHandler(t, testutils.CDPDefaultHandler, nil)
+	server := NewWSServerWithCDPHandler(t, CDPDefaultHandler, nil)
 	defer server.Cleanup()
 
 	t.Run("send command with empty reply", func(t *testing.T) {
@@ -134,7 +133,7 @@ func TestConnectionCreateSession(t *testing.T) {
 		}
 	}
 
-	server := testutils.NewWSTestServerWithCDPHandler(t, handler, &cmdsReceived)
+	server := NewWSServerWithCDPHandler(t, handler, &cmdsReceived)
 	defer server.Cleanup()
 
 	t.Run("create session for target", func(t *testing.T) {

common/helpers.go

@@ -29,6 +29,7 @@ import (
 	"os"
 	"reflect"
 	"strings"
+	"sync"
 	"time"
 
 	cdpruntime "github.com/chromedp/cdproto/runtime"
@@ -235,6 +236,15 @@ func waitForEvent(ctx context.Context, emitter EventEmitter, events []string, pr
 // browser process from the context and kills it if it still exists.
 // TODO: test
 func k6Throw(ctx context.Context, format string, a ...interface{}) {
+	k6ThrowOnce.Do(func() {
+		k6ThrowUnsafe(ctx, format, a...)
+	})
+}
+
+// k6ThrowUnsafe is the real k6Throw but it's not protected from concurrency
+// errors.
+// see: k6ThrowOnce
+func k6ThrowUnsafe(ctx context.Context, format string, a ...interface{}) {
 	rt := k6common.GetRuntime(ctx)
 	if rt == nil {
 		// this should never happen unless a programmer error
@@ -258,3 +268,12 @@ func k6Throw(ctx context.Context, format string, a ...interface{}) {
 	_ = p.Release()
 	_ = p.Kill()
 }
+
+// There is a data-race in Goja, and this prevents it from happening.
+//
+// Reproduce with an integration test in tests/:
+//
+// ctx, cancel := context.WithCancel(context.Background())
+// tb := testBrowser(t, withContext(ctx))
+// cancel()
+var k6ThrowOnce sync.Once

testutils/cdp.go renamed to common/protocol_test.go

@@ -18,19 +18,31 @@
  *
  */
 
-// Package testutils is indended only for use in tests, do not import in production code!
-package testutils
+package common
 
 import (
+	"context"
 	"fmt"
+	"io"
+	"net"
 	"net/http"
+	"net/http/httptest"
+	"net/url"
 	"testing"
+	"time"
 
 	"github.com/chromedp/cdproto"
 	"github.com/gorilla/websocket"
 	"github.com/mailru/easyjson"
 	"github.com/mailru/easyjson/jlexer"
 	"github.com/mailru/easyjson/jwriter"
+	"github.com/mccutchen/go-httpbin/httpbin"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/net/http2"
+
+	k6lib "go.k6.io/k6/lib"
+	k6netext "go.k6.io/k6/lib/netext"
+	k6types "go.k6.io/k6/lib/types"
 )
 
 const (
@@ -106,12 +118,12 @@ func getWebsocketHandlerCDP(
 	})
 }
 
-// NewWSTestServerWithCDPHandler creates a WS test server with a custom CDP handler function
-func NewWSTestServerWithCDPHandler(
+// NewWSServerWithCDPHandler creates a WS test server with a custom CDP handler function
+func NewWSServerWithCDPHandler(
 	t testing.TB,
 	fn func(conn *websocket.Conn, msg *cdproto.Message, writeCh chan cdproto.Message, done chan struct{}),
 	cmdsReceived *[]cdproto.MethodType) *WSTestServer {
-	return NewWSTestServer(t, "/cdp", getWebsocketHandlerCDP(fn, cmdsReceived))
+	return NewWSServer(t, "/cdp", getWebsocketHandlerCDP(fn, cmdsReceived))
 }
 
 // CDPDefaultCDPHandler is a default handler for the CDP WS server
@@ -182,3 +194,118 @@ func CDPWriteMsg(conn *websocket.Conn, msg *cdproto.Message) {
 		return
 	}
 }
+
+const httpDomain = "wsbin.local"
+
+// WSTestServer can be used as a test alternative to a real CDP compatible browser.
+type WSTestServer struct {
+	Mux           *http.ServeMux
+	ServerHTTP    *httptest.Server
+	Dialer        *k6netext.Dialer
+	HTTPTransport *http.Transport
+	Context       context.Context
+	Cleanup       func()
+}
+
+func getWebsocketHandlerAbnormalClosure() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		conn, err := (&websocket.Upgrader{}).Upgrade(w, req, w.Header())
+		if err != nil {
+			return
+		}
+		err = conn.Close() // This forces a connection closure without a proper WS close message exchange
+		if err != nil {
+			return
+		}
+	})
+}
+
+func getWebsocketHandlerEcho() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		conn, err := (&websocket.Upgrader{}).Upgrade(w, req, w.Header())
+		if err != nil {
+			return
+		}
+		messageType, r, e := conn.NextReader()
+		if e != nil {
+			return
+		}
+		var wc io.WriteCloser
+		wc, err = conn.NextWriter(messageType)
+		if err != nil {
+			return
+		}
+		if _, err = io.Copy(wc, r); err != nil {
+			return
+		}
+		if err = wc.Close(); err != nil {
+			return
+		}
+		err = conn.WriteControl(websocket.CloseMessage,
+			websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""),
+			time.Now().Add(10*time.Second),
+		)
+		if err != nil {
+			return
+		}
+	})
+}
+
+// NewWSServerWithClosureAbnormal creates a WS test server with abnormal closure behavior
+func NewWSServerWithClosureAbnormal(t testing.TB) *WSTestServer {
+	return NewWSServer(t, "/closure-abnormal", getWebsocketHandlerAbnormalClosure())
+}
+
+// NewWSServerWithEcho creates a WS test server with an echo handler
+func NewWSServerWithEcho(t testing.TB) *WSTestServer {
+	return NewWSServer(t, "/echo", getWebsocketHandlerEcho())
+}
+
+// NewWSServer returns a fully configured and running WS test server
+func NewWSServer(t testing.TB, path string, handler http.Handler) *WSTestServer {
+	t.Helper()
+
+	// Create a http.ServeMux and set the httpbin handler as the default
+	mux := http.NewServeMux()
+	mux.Handle(path, handler)
+	mux.Handle("/", httpbin.New().Handler())
+
+	// Initialize the HTTP server and get its details
+	httpSrv := httptest.NewServer(mux)
+	httpURL, err := url.Parse(httpSrv.URL)
+	require.NoError(t, err)
+	httpIP := net.ParseIP(httpURL.Hostname())
+	require.NotNil(t, httpIP)
+
+	httpDomainValue, err := k6lib.NewHostAddress(httpIP, "")
+	require.NoError(t, err)
+
+	// Set up the dialer with shorter timeouts and the custom domains
+	dialer := k6netext.NewDialer(net.Dialer{
+		Timeout:   2 * time.Second,
+		KeepAlive: 10 * time.Second,
+		DualStack: true,
+	}, k6netext.NewResolver(net.LookupIP, 0, k6types.DNSfirst, k6types.DNSpreferIPv4))
+	dialer.Hosts = map[string]*k6lib.HostAddress{
+		httpDomain: httpDomainValue,
+	}
+
+	// Pre-configure the HTTP client transport with the dialer and TLS config (incl. HTTP2 support)
+	transport := &http.Transport{
+		DialContext: dialer.DialContext,
+	}
+	require.NoError(t, http2.ConfigureTransport(transport))
+
+	ctx, ctxCancel := context.WithCancel(context.Background())
+	return &WSTestServer{
+		Mux:           mux,
+		ServerHTTP:    httpSrv,
+		Dialer:        dialer,
+		HTTPTransport: transport,
+		Context:       ctx,
+		Cleanup: func() {
+			httpSrv.Close()
+			ctxCancel()
+		},
+	}
+}

common/session_test.go

@@ -31,7 +31,6 @@ import (
 	cdppage "github.com/chromedp/cdproto/page"
 	"github.com/chromedp/cdproto/target"
 	"github.com/gorilla/websocket"
-	"github.com/grafana/xk6-browser/testutils"
 	"github.com/mailru/easyjson"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -60,18 +59,18 @@ func TestSessionCreateSession(t *testing.T) {
 			case cdproto.MethodType(cdproto.CommandTargetAttachToTarget):
 				writeCh <- cdproto.Message{
 					Method: cdproto.EventTargetAttachedToTarget,
-					Params: easyjson.RawMessage([]byte(testutils.DEFAULT_CDP_TARGET_ATTACHED_TO_TARGET_MSG)),
+					Params: easyjson.RawMessage([]byte(DEFAULT_CDP_TARGET_ATTACHED_TO_TARGET_MSG)),
 				}
 				writeCh <- cdproto.Message{
 					ID:        msg.ID,
 					SessionID: msg.SessionID,
-					Result:    easyjson.RawMessage([]byte(testutils.DEFAULT_CDP_TARGET_ATTACH_TO_TARGET_RESPONSE)),
+					Result:    easyjson.RawMessage([]byte(DEFAULT_CDP_TARGET_ATTACH_TO_TARGET_RESPONSE)),
 				}
 			}
 		}
 	}
 
-	server := testutils.NewWSTestServerWithCDPHandler(t, handler, &cmdsReceived)
+	server := NewWSServerWithCDPHandler(t, handler, &cmdsReceived)
 	defer server.Cleanup()
 
 	t.Run("send and recv session commands", func(t *testing.T) {
@@ -82,9 +81,9 @@ func TestSessionCreateSession(t *testing.T) {
 
 		if assert.NoError(t, err) {
 			session, err := conn.createSession(&target.Info{
-				TargetID:         testutils.DEFAULT_CDP_TARGET_ID,
+				TargetID:         DEFAULT_CDP_TARGET_ID,
 				Type:             "page",
-				BrowserContextID: testutils.DEFAULT_CDP_BROWSER_CONTEXT_ID,
+				BrowserContextID: DEFAULT_CDP_BROWSER_CONTEXT_ID,
 			})
 
 			if assert.NoError(t, err) {

tests/browser_context_options_test.go

@@ -26,24 +26,13 @@ import (
 	"testing"
 
 	"github.com/grafana/xk6-browser/common"
-	"github.com/grafana/xk6-browser/testutils/browsertest"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestBrowserContextOptions(t *testing.T) {
-	bt := browsertest.NewBrowserTest(t)
-	t.Cleanup(bt.Browser.Close)
+func TestBrowserContextOptionsDefaultValues(t *testing.T) {
+	t.Parallel()
 
-	t.Run("BrowserContextOptions", func(t *testing.T) {
-		t.Run("should have correct default values", func(t *testing.T) { testBrowserContextOptionsDefaultValues(t, bt) })
-		t.Run("should correctly set default viewport", func(t *testing.T) { testBrowserContextOptionsDefaultViewport(t, bt) })
-		t.Run("should correctly set custom viewport", func(t *testing.T) { testBrowserContextOptionsSetViewport(t, bt) })
-		t.Run("should correctly set extra headers", func(t *testing.T) { testBrowserContextOptionsExtraHTTPHeaders(t, bt) })
-	})
-}
-
-func testBrowserContextOptionsDefaultValues(t *testing.T, bt *browsertest.BrowserTest) {
 	opts := common.NewBrowserContextOptions()
 	assert.False(t, opts.AcceptDownloads)
 	assert.False(t, opts.BypassCSP)
@@ -66,17 +55,17 @@ func testBrowserContextOptionsDefaultValues(t *testing.T, bt *browsertest.Browse
 	assert.Equal(t, &common.Viewport{Width: common.DefaultScreenWidth, Height: common.DefaultScreenHeight}, opts.Viewport)
 }
 
-func testBrowserContextOptionsDefaultViewport(t *testing.T, bt *browsertest.BrowserTest) {
-	p := bt.Browser.NewPage(nil)
-	t.Cleanup(func() { p.Close(nil) })
+func TestBrowserContextOptionsDefaultViewport(t *testing.T) {
+	p := newTestBrowser(t).NewPage(nil)
 
 	viewportSize := p.ViewportSize()
 	assert.Equal(t, float64(common.DefaultScreenWidth), viewportSize["width"])
 	assert.Equal(t, float64(common.DefaultScreenHeight), viewportSize["height"])
 }
 
-func testBrowserContextOptionsSetViewport(t *testing.T, bt *browsertest.BrowserTest) {
-	bctx := bt.Browser.NewContext(bt.Runtime.ToValue(struct {
+func TestBrowserContextOptionsSetViewport(t *testing.T) {
+	tb := newTestBrowser(t)
+	bctx := tb.NewContext(tb.rt.ToValue(struct {
 		Viewport common.Viewport `js:"viewport"`
 	}{
 		Viewport: common.Viewport{
@@ -92,8 +81,9 @@ func testBrowserContextOptionsSetViewport(t *testing.T, bt *browsertest.BrowserT
 	assert.Equal(t, float64(600), viewportSize["height"])
 }
 
-func testBrowserContextOptionsExtraHTTPHeaders(t *testing.T, bt *browsertest.BrowserTest) {
-	bctx := bt.Browser.NewContext(bt.Runtime.ToValue(struct {
+func TestBrowserContextOptionsExtraHTTPHeaders(t *testing.T) {
+	tb := newTestBrowser(t, withHTTPServer())
+	bctx := tb.NewContext(tb.rt.ToValue(struct {
 		ExtraHTTPHeaders map[string]string `js:"extraHTTPHeaders"`
 	}{
 		ExtraHTTPHeaders: map[string]string{
@@ -103,7 +93,7 @@ func testBrowserContextOptionsExtraHTTPHeaders(t *testing.T, bt *browsertest.Bro
 	t.Cleanup(bctx.Close)
 
 	p := bctx.NewPage()
-	resp := p.Goto(bt.HTTPMultiBin.ServerHTTP.URL+"/get", nil)
+	resp := p.Goto(tb.URL("/get"), nil)
 
 	require.NotNil(t, resp)
 	var body struct{ Headers map[string][]string }