js/data: ModuleV2 migration

js/modules/k6/data/data.go

@@ -21,23 +21,87 @@
 package data
 
 import (
-	"context"
 	"errors"
 	"strconv"
 	"sync"
 
 	"github.com/dop251/goja"
 	"go.k6.io/k6/js/common"
-	"go.k6.io/k6/lib"
+	"go.k6.io/k6/js/modules"
 )
 
-type data struct {
-	shared sharedArrays
+type (
+	// RootModule is the global module instance that will create module
+	// instances for each VU.
+	RootModule struct {
+		shared sharedArrays
+	}
+
+	// Data represents an instance of the data module.
+	Data struct {
+		vu     modules.VU
+		shared *sharedArrays
+	}
+
+	sharedArrays struct {
+		data map[string]sharedArray
+		mu   sync.RWMutex
+	}
+)
+
+var (
+	_ modules.Module   = &RootModule{}
+	_ modules.Instance = &Data{}
+)
+
+// New returns a pointer to a new RootModule instance.
+func New() *RootModule {
+	return &RootModule{
+		shared: sharedArrays{
+			data: make(map[string]sharedArray),
+		},
+	}
 }
 
-type sharedArrays struct {
-	data map[string]sharedArray
-	mu   sync.RWMutex
+// NewModuleInstance implements the modules.Module interface to return
+// a new instance for each VU.
+func (rm *RootModule) NewModuleInstance(vu modules.VU) modules.Instance {
+	return &Data{
+		vu:     vu,
+		shared: &rm.shared,
+	}
+}
+
+// Exports returns the exports of the data module.
+func (d *Data) Exports() modules.Exports {
+	return modules.Exports{
+		Named: map[string]interface{}{
+			"SharedArray": d.sharedArray,
+		},
+	}
+}
+
+// sharedArray is a constructor returning a shareable read-only array
+// indentified by the name and having their contents be whatever the call returns
+func (d *Data) sharedArray(call goja.ConstructorCall) *goja.Object {
+	rt := d.vu.Runtime()
+
+	if d.vu.State() != nil {
+		common.Throw(rt, errors.New("new SharedArray must be called in the init context"))
+	}
+
+	name := call.Argument(0).String()
+	if name == "" {
+		common.Throw(rt, errors.New("empty name provided to SharedArray's constructor"))
+	}
+
+	fn, ok := goja.AssertFunction(call.Argument(1))
+	if !ok {
+		common.Throw(rt, errors.New("a function is expected as the second argument of SharedArray's constructor"))
+	}
+
+	array := d.shared.get(rt, name, fn)
+	return array.wrap(rt).ToObject(rt)
 }
 
 func (s *sharedArrays) get(rt *goja.Runtime, name string, call goja.Callable) sharedArray {
@@ -57,32 +121,6 @@ func (s *sharedArrays) get(rt *goja.Runtime, name string, call goja.Callable) sh
 	return array
 }
 
-// New return a new Module instance
-func New() interface{} {
-	return &data{
-		shared: sharedArrays{
-			data: make(map[string]sharedArray),
-		},
-	}
-}
-
-// XSharedArray is a constructor returning a shareable read-only array
-// indentified by the name and having their contents be whatever the call returns
-func (d *data) XSharedArray(ctx context.Context, name string, call goja.Callable) (goja.Value, error) {
-	if lib.GetState(ctx) != nil {
-		return nil, errors.New("new SharedArray must be called in the init context")
-	}
-
-	if len(name) == 0 {
-		return nil, errors.New("empty name provided to SharedArray's constructor")
-	}
-
-	rt := common.GetRuntime(ctx)
-	array := d.shared.get(rt, name, call)
-
-	return array.wrap(rt), nil
-}
-
 func getShareArrayFromCall(rt *goja.Runtime, call goja.Callable) sharedArray {
 	gojaValue, err := call(goja.Undefined())
 	if err != nil {

js/modules/k6/data/share_test.go

@@ -22,6 +22,7 @@ package data
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"testing"
 	"time"
@@ -30,6 +31,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"go.k6.io/k6/js/common"
+	"go.k6.io/k6/js/modulestest"
 )
 
 const makeArrayScript = `
@@ -43,22 +45,33 @@ var array = new data.SharedArray("shared",function() {
 });
 `
 
-func newConfiguredRuntime(moduleInstance interface{}) (*goja.Runtime, error) {
+func newConfiguredRuntime() (*goja.Runtime, error) {
 	rt := goja.New()
 	rt.SetFieldNameMapper(common.FieldNameMapper{})
-	ctx := common.WithRuntime(context.Background(), rt)
-	err := rt.Set("data", common.Bind(rt, moduleInstance, &ctx))
+
+	m, ok := New().NewModuleInstance(
+		&modulestest.VU{
+			RuntimeField: rt,
+			InitEnvField: &common.InitEnvironment{},
+			CtxField:     common.WithRuntime(context.Background(), rt),
+			StateField:   nil,
+		},
+	).(*Data)
+	if !ok {
+		return rt, fmt.Errorf("not a Data module instance")
+	}
+
+	err := rt.Set("data", m.Exports().Named)
 	if err != nil {
 		return rt, err //nolint:wrapcheck
 	}
 	_, err = rt.RunString("var SharedArray = data.SharedArray;")
-
 	return rt, err //nolint:wrapcheck
 }
 
 func TestSharedArrayConstructorExceptions(t *testing.T) {
 	t.Parallel()
-	rt, err := newConfiguredRuntime(New())
+	rt, err := newConfiguredRuntime()
 	require.NoError(t, err)
 	cases := map[string]struct {
 		code, err string
@@ -80,6 +93,10 @@ func TestSharedArrayConstructorExceptions(t *testing.T) {
 		`,
 			err: "",
 		},
+		"not a function": {
+			code: `var s = new SharedArray("wat3", "astring");`,
+			err:  "a function is expected",
+		},
 	}
 
 	for name, testCase := range cases {
@@ -101,13 +118,12 @@ func TestSharedArrayConstructorExceptions(t *testing.T) {
 func TestSharedArrayAnotherRuntimeExceptions(t *testing.T) {
 	t.Parallel()
 
-	moduleInstance := New()
-	rt, err := newConfiguredRuntime(moduleInstance)
+	rt, err := newConfiguredRuntime()
 	require.NoError(t, err)
 	_, err = rt.RunString(makeArrayScript)
 	require.NoError(t, err)
 
-	rt, err = newConfiguredRuntime(moduleInstance)
+	rt, err = newConfiguredRuntime()
 	require.NoError(t, err)
 	_, err = rt.RunString(makeArrayScript)
 	require.NoError(t, err)
@@ -153,15 +169,26 @@ func TestSharedArrayAnotherRuntimeExceptions(t *testing.T) {
 func TestSharedArrayAnotherRuntimeWorking(t *testing.T) {
 	t.Parallel()
 
-	moduleInstance := New()
-	rt, err := newConfiguredRuntime(moduleInstance)
-	require.NoError(t, err)
-	_, err = rt.RunString(makeArrayScript)
+	rt := goja.New()
+	vu := &modulestest.VU{
+		RuntimeField: rt,
+		InitEnvField: &common.InitEnvironment{},
+		CtxField:     common.WithRuntime(context.Background(), rt),
+		StateField:   nil,
+	}
+	m, ok := New().NewModuleInstance(vu).(*Data)
+	require.True(t, ok)
+	require.NoError(t, rt.Set("data", m.Exports().Named))
+
+	_, err := rt.RunString(makeArrayScript)
 	require.NoError(t, err)
 
 	// create another Runtime with new ctx but keep the initEnv
-	rt, err = newConfiguredRuntime(moduleInstance)
-	require.NoError(t, err)
+	rt = goja.New()
+	vu.RuntimeField = rt
+	vu.CtxField = common.WithRuntime(context.Background(), rt)
+	require.NoError(t, rt.Set("data", m.Exports().Named))
+
 	_, err = rt.RunString(`var array = new data.SharedArray("shared", function() {throw "wat";});`)
 	require.NoError(t, err)
 
@@ -201,9 +228,8 @@ func TestSharedArrayRaceInInitialization(t *testing.T) {
 	const repeats = 100
 	for i := 0; i < repeats; i++ {
 		runtimes := make([]*goja.Runtime, instances)
-		moduleInstance := New()
 		for j := 0; j < instances; j++ {
-			rt, err := newConfiguredRuntime(moduleInstance)
+			rt, err := newConfiguredRuntime()
 			require.NoError(t, err)
 			runtimes[j] = rt
 		}

js/share_test.go

@@ -99,15 +99,15 @@ exports.default = function() {
 			t.Parallel()
 			samples := make(chan stats.SampleContainer, 100)
 			initVU, err := r.NewVU(1, 1, samples)
-			if assert.NoError(t, err) {
-				ctx, cancel := context.WithCancel(context.Background())
-				defer cancel()
-				vu := initVU.Activate(&lib.VUActivationParams{RunContext: ctx})
-				err := vu.RunOnce()
-				assert.NoError(t, err)
-				entries := hook.Drain()
-				require.Len(t, entries, 0)
-			}
+			require.NoError(t, err)
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			vu := initVU.Activate(&lib.VUActivationParams{RunContext: ctx})
+			err = vu.RunOnce()
+			assert.NoError(t, err)
+			entries := hook.Drain()
+			assert.Len(t, entries, 0)
 		})
 	}
 }