Refactor module mappings test

Author: inancgumus

browser/mapping_test.go

@@ -23,105 +23,111 @@ import (
 func TestMappings(t *testing.T) {
 	t.Parallel()
 
-	vu := &k6modulestest.VU{
-		RuntimeField: goja.New(),
-		InitEnvField: &k6common.InitEnvironment{
-			Registry: k6metrics.NewRegistry(),
-		},
+	type test struct {
+		apiInterface any
+		mapp         func() mapping
 	}
-	rt := vu.Runtime()
 
-	type test struct {
-		apiObj any
-		mapp   func() mapping
+	var (
+		vu = &k6modulestest.VU{
+			RuntimeField: goja.New(),
+			InitEnvField: &k6common.InitEnvironment{
+				Registry: k6metrics.NewRegistry(),
+			},
+		}
+		rt        = vu.Runtime()
+		wildcards = wildcards()
+	)
+
+	// testMapping tests that all the methods of an API are mapped
+	// to the module. And wildcards are mapped correctly and their
+	// methods are not mapped.
+	testMapping := func(tt test) {
+		var (
+			typ    = reflect.TypeOf(tt.apiInterface).Elem()
+			mapped = tt.mapp()
+		)
+		for i := 0; i < typ.NumMethod(); i++ {
+			method := typ.Method(i)
+			require.NotNil(t, method)
+
+			// goja uses methods that starts with lowercase.
+			// so we need to convert the first letter to lowercase.
+			m := toFirstLetterLower(method.Name)
+
+			wm, wok := isWildcard(wildcards, typ.Name(), m)
+			// if the method is a wildcard method, it should not
+			// be mapped to the module. so we should not find it
+			// in the mapped methods.
+			if _, ok := mapped[m]; wok && ok {
+				t.Errorf("method %s should not be mapped", m)
+			}
+			// change the method name if it is mapped to a wildcard
+			// method. these wildcard methods are not exist on our
+			// API. so we need to use the mapped method instead.
+			if wok {
+				m = wm
+			}
+			if _, ok := mapped[m]; !ok {
+				t.Errorf("method %s not found", m)
+			}
+		}
 	}
-	mappers := map[string]test{
+
+	for name, tt := range map[string]test{
 		"browserType": {
-			apiObj: (*api.BrowserType)(nil),
+			apiInterface: (*api.BrowserType)(nil),
 			mapp: func() mapping {
 				return mapBrowserType(rt, &chromium.BrowserType{})
 			},
 		},
 		"browser": {
-			apiObj: (*api.Browser)(nil),
+			apiInterface: (*api.Browser)(nil),
 			mapp: func() mapping {
 				return mapBrowser(rt, &chromium.Browser{})
 			},
 		},
 		"browserContext": {
-			apiObj: (*api.BrowserContext)(nil),
+			apiInterface: (*api.BrowserContext)(nil),
 			mapp: func() mapping {
 				return mapBrowserContext(rt, &common.BrowserContext{})
 			},
 		},
 		"page": {
-			apiObj: (*api.Page)(nil),
+			apiInterface: (*api.Page)(nil),
 			mapp: func() mapping {
 				return mapPage(rt, &common.Page{})
 			},
 		},
 		"elementHandle": {
-			apiObj: (*api.ElementHandle)(nil),
+			apiInterface: (*api.ElementHandle)(nil),
 			mapp: func() mapping {
 				return mapElementHandle(rt, &common.ElementHandle{})
 			},
 		},
 		"frame": {
-			apiObj: (*api.Frame)(nil),
+			apiInterface: (*api.Frame)(nil),
 			mapp: func() mapping {
 				return mapFrame(rt, &common.Frame{})
 			},
 		},
 		"mapRequest": {
-			apiObj: (*api.Request)(nil),
+			apiInterface: (*api.Request)(nil),
 			mapp: func() mapping {
 				return mapRequest(rt, &common.Request{})
 			},
 		},
 		"mapResponse": {
-			apiObj: (*api.Response)(nil),
+			apiInterface: (*api.Response)(nil),
 			mapp: func() mapping {
 				return mapResponse(rt, &common.Response{})
 			},
 		},
-	}
-
-	wildcards := wildcards()
-
-	for name, tt := range mappers {
+	} {
 		tt := tt
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
-
-			var (
-				typ    = reflect.TypeOf(tt.apiObj).Elem()
-				mapped = tt.mapp()
-			)
-			for i := 0; i < typ.NumMethod(); i++ {
-				method := typ.Method(i)
-				require.NotNil(t, method)
-
-				// goja uses methods that starts with lowercase.
-				// so we need to convert the first letter to lowercase.
-				m := toFirstLetterLower(method.Name)
-
-				wm, wok := isWildcard(wildcards, typ.Name(), m)
-				// if the method is a wildcard method, it should not
-				// be mapped to the module. so we should not find it
-				// in the mapped methods.
-				if _, ok := mapped[m]; wok && ok {
-					t.Errorf("method %s should not be mapped", m)
-				}
-				// change the method name if it is mapped to a wildcard
-				// method. these wildcard methods are not exist on our
-				// API. so we need to use the mapped method instead.
-				if wok {
-					m = wm
-				}
-				if _, ok := mapped[m]; !ok {
-					t.Errorf("method %s not found", m)
-				}
-			}
+			testMapping(tt)
 		})
 	}
 }