Add basic event loop with some API to be used by modules

core/local/eventloop_test.go

@@ -23,7 +23,7 @@ func eventLoopTest(t *testing.T, script []byte, testHandle func(context.Context,
 	logHook := &testutils.SimpleLogrusHook{HookedLevels: []logrus.Level{logrus.InfoLevel, logrus.WarnLevel, logrus.ErrorLevel}}
 	logger.AddHook(logHook)
 
-	script = []byte(`import {setTimeout} from "k6";
+	script = []byte(`import {setTimeout} from "k6/experimental";
   ` + string(script))
 	registry := metrics.NewRegistry()
 	builtinMetrics := metrics.RegisterBuiltinMetrics(registry)

js/initcontext.go

@@ -43,6 +43,7 @@ import (
 	"go.k6.io/k6/js/modules/k6/data"
 	"go.k6.io/k6/js/modules/k6/encoding"
 	"go.k6.io/k6/js/modules/k6/execution"
+	"go.k6.io/k6/js/modules/k6/experimental"
 	"go.k6.io/k6/js/modules/k6/grpc"
 	"go.k6.io/k6/js/modules/k6/html"
 	"go.k6.io/k6/js/modules/k6/http"
@@ -383,17 +384,18 @@ func (i *InitContext) allowOnlyOpenedFiles() {
 
 func getInternalJSModules() map[string]interface{} {
 	return map[string]interface{}{
-		"k6":             k6.New(),
-		"k6/crypto":      crypto.New(),
-		"k6/crypto/x509": x509.New(),
-		"k6/data":        data.New(),
-		"k6/encoding":    encoding.New(),
-		"k6/execution":   execution.New(),
-		"k6/net/grpc":    grpc.New(),
-		"k6/html":        html.New(),
-		"k6/http":        http.New(),
-		"k6/metrics":     metrics.New(),
-		"k6/ws":          ws.New(),
+		"k6":              k6.New(),
+		"k6/crypto":       crypto.New(),
+		"k6/crypto/x509":  x509.New(),
+		"k6/data":         data.New(),
+		"k6/encoding":     encoding.New(),
+		"k6/execution":    execution.New(),
+		"k6/net/grpc":     grpc.New(),
+		"k6/html":         html.New(),
+		"k6/http":         http.New(),
+		"k6/metrics":      metrics.New(),
+		"k6/ws":           ws.New(),
+		"k6/experimental": experimental.New(),
 	}
 }
 

js/modules/k6/experimental/experimental.go

@@ -0,0 +1,68 @@
+// Package experimental includes experimental module features
+package experimental
+
+import (
+	"errors"
+	"time"
+
+	"github.com/dop251/goja"
+	"go.k6.io/k6/js/common"
+	"go.k6.io/k6/js/modules"
+)
+
+type (
+	// RootModule is the root experimental module
+	RootModule struct{}
+	// ModuleInstance represents an instance of the experimental module
+	ModuleInstance struct {
+		vu modules.VU
+	}
+)
+
+var (
+	_ modules.Module   = &RootModule{}
+	_ modules.Instance = &ModuleInstance{}
+)
+
+// NewModuleInstance implements modules.Module interface
+func (*RootModule) NewModuleInstance(m modules.VU) modules.Instance {
+	return &ModuleInstance{vu: m}
+}
+
+// New returns a new RootModule.
+func New() *RootModule {
+	return &RootModule{}
+}
+
+// Exports returns the exports of the experimental module
+func (mi *ModuleInstance) Exports() modules.Exports {
+	return modules.Exports{
+		Named: map[string]interface{}{
+			"setTimeout": mi.setTimeout,
+		},
+	}
+}
+
+func (mi *ModuleInstance) setTimeout(f goja.Callable, t float64) {
+	if f == nil {
+		common.Throw(mi.vu.Runtime(), errors.New("setTimeout requires a function as first argument"))
+	}
+	// TODO maybe really return something to use with `clearTimeout
+	// TODO support arguments ... maybe
+	runOnLoop := mi.vu.RegisterCallback()
+	go func() {
+		timer := time.NewTimer(time.Duration(t * float64(time.Millisecond)))
+		select {
+		case <-timer.C:
+			runOnLoop(func() error {
+				_, err := f(goja.Undefined())
+				return err
+			})
+		case <-mi.vu.Context().Done():
+			// TODO log something?
+
+			timer.Stop()
+			runOnLoop(func() error { return nil })
+		}
+	}()
+}

js/modules/k6/k6.go

@@ -78,7 +78,6 @@ func (mi *K6) Exports() modules.Exports {
 			"group":      mi.Group,
 			"randomSeed": mi.RandomSeed,
 			"sleep":      mi.Sleep,
-			"setTimeout": mi.setTimeout,
 		},
 	}
 }
@@ -232,27 +231,3 @@ func (mi *K6) Check(arg0, checks goja.Value, extras ...goja.Value) (bool, error)
 
 	return succ, nil
 }
-
-func (mi *K6) setTimeout(f goja.Callable, t float64) {
-	if f == nil {
-		common.Throw(mi.vu.Runtime(), errors.New("setTimeout requires a function as first argument"))
-	}
-	// TODO maybe really return something to use with `clearTimeout
-	// TODO support arguments ... maybe
-	runOnLoop := mi.vu.RegisterCallback()
-	go func() {
-		timer := time.NewTimer(time.Duration(t * float64(time.Millisecond)))
-		select {
-		case <-timer.C:
-			runOnLoop(func() error {
-				_, err := f(goja.Undefined())
-				return err
-			})
-		case <-mi.vu.Context().Done():
-			// TODO log something?
-
-			timer.Stop()
-			runOnLoop(func() error { return nil })
-		}
-	}()
-}