Async Frame

browser/frame_mapping.go

@@ -13,18 +13,21 @@ import (
 //
 //nolint:funlen
 func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
-	rt := vu.Runtime()
 	maps := mapping{
-		"check": f.Check,
-		"childFrames": func() *goja.Object {
+		"check": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Check(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"childFrames": func() []mapping {
 			var (
 				mcfs []mapping
 				cfs  = f.ChildFrames()
 			)
 			for _, fr := range cfs {
 				mcfs = append(mcfs, mapFrame(vu, fr))
 			}
-			return rt.ToValue(mcfs).ToObject(rt)
+			return mcfs
 		},
 		"click": func(selector string, opts goja.Value) (*goja.Promise, error) {
 			popts, err := parseFrameClickOptions(vu.Context(), opts, f.Timeout())
@@ -37,35 +40,63 @@ func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
 				return nil, err //nolint:wrapcheck
 			}), nil
 		},
-		"content":  f.Content,
-		"dblclick": f.Dblclick,
-		"dispatchEvent": func(selector, typ string, eventInit, opts goja.Value) error {
+		"content": func() *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.Content() //nolint:wrapcheck
+			})
+		},
+		"dblclick": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Dblclick(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"dispatchEvent": func(selector, typ string, eventInit, opts goja.Value) (*goja.Promise, error) {
 			popts := common.NewFrameDispatchEventOptions(f.Timeout())
 			if err := popts.Parse(vu.Context(), opts); err != nil {
-				return fmt.Errorf("parsing frame dispatch event options: %w", err)
+				return nil, fmt.Errorf("parsing frame dispatch event options: %w", err)
 			}
-			return f.DispatchEvent(selector, typ, exportArg(eventInit), popts) //nolint:wrapcheck
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.DispatchEvent(selector, typ, exportArg(eventInit), popts) //nolint:wrapcheck
+			}), nil
 		},
-		"evaluate": func(pageFunction goja.Value, gargs ...goja.Value) (any, error) {
-			return f.Evaluate(pageFunction.String(), exportArgs(gargs)...) //nolint:wrapcheck
+		"evaluate": func(pageFunction goja.Value, gargs ...goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.Evaluate(pageFunction.String(), exportArgs(gargs)...) //nolint:wrapcheck
+			})
 		},
-		"evaluateHandle": func(pageFunction goja.Value, gargs ...goja.Value) (mapping, error) {
-			jsh, err := f.EvaluateHandle(pageFunction.String(), exportArgs(gargs)...)
-			if err != nil {
-				return nil, err //nolint:wrapcheck
-			}
-			return mapJSHandle(vu, jsh), nil
+		"evaluateHandle": func(pageFunction goja.Value, gargs ...goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				jsh, err := f.EvaluateHandle(pageFunction.String(), exportArgs(gargs)...)
+				if err != nil {
+					return nil, err //nolint:wrapcheck
+				}
+				return mapJSHandle(vu, jsh), nil
+			})
 		},
-		"fill":  f.Fill,
-		"focus": f.Focus,
-		"frameElement": func() (mapping, error) {
-			fe, err := f.FrameElement()
-			if err != nil {
-				return nil, err //nolint:wrapcheck
-			}
-			return mapElementHandle(vu, fe), nil
+		"fill": func(selector, value string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Fill(selector, value, opts) //nolint:wrapcheck
+			})
+		},
+		"focus": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Focus(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"frameElement": func() *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				fe, err := f.FrameElement()
+				if err != nil {
+					return nil, err //nolint:wrapcheck
+				}
+				return mapElementHandle(vu, fe), nil
+			})
+		},
+		"getAttribute": func(selector, name string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.GetAttribute(selector, name, opts) //nolint:wrapcheck
+			})
 		},
-		"getAttribute": f.GetAttribute,
 		"goto": func(url string, opts goja.Value) (*goja.Promise, error) {
 			gopts := common.NewFrameGotoOptions(
 				f.Referrer(),
@@ -83,34 +114,87 @@ func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
 				return mapResponse(vu, resp), nil
 			}), nil
 		},
-		"hover":      f.Hover,
-		"innerHTML":  f.InnerHTML,
-		"innerText":  f.InnerText,
-		"inputValue": f.InputValue,
-		"isChecked":  f.IsChecked,
+		"hover": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Hover(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"innerHTML": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.InnerHTML(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"innerText": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.InnerText(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"inputValue": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.InputValue(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"isChecked": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsChecked(selector, opts) //nolint:wrapcheck
+			})
+		},
 		"isDetached": f.IsDetached,
-		"isDisabled": f.IsDisabled,
-		"isEditable": f.IsEditable,
-		"isEnabled":  f.IsEnabled,
-		"isHidden":   f.IsHidden,
-		"isVisible":  f.IsVisible,
-		"locator": func(selector string, opts goja.Value) *goja.Object {
-			ml := mapLocator(vu, f.Locator(selector, opts))
-			return rt.ToValue(ml).ToObject(rt)
+		"isDisabled": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsDisabled(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"isEditable": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsEditable(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"isEnabled": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsEnabled(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"isHidden": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsHidden(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"isVisible": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.IsVisible(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"locator": func(selector string, opts goja.Value) mapping {
+			return mapLocator(vu, f.Locator(selector, opts))
 		},
 		"name": f.Name,
-		"page": func() *goja.Object {
-			mp := mapPage(vu, f.Page())
-			return rt.ToValue(mp).ToObject(rt)
-		},
-		"parentFrame": func() *goja.Object {
-			mf := mapFrame(vu, f.ParentFrame())
-			return rt.ToValue(mf).ToObject(rt)
-		},
-		"press":         f.Press,
-		"selectOption":  f.SelectOption,
-		"setContent":    f.SetContent,
-		"setInputFiles": f.SetInputFiles,
+		"page": func() mapping {
+			return mapPage(vu, f.Page())
+		},
+		"parentFrame": func() mapping {
+			return mapFrame(vu, f.ParentFrame())
+		},
+		"press": func(selector, key string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Press(selector, key, opts) //nolint:wrapcheck
+			})
+		},
+		"selectOption": func(selector string, values goja.Value, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.SelectOption(selector, values, opts) //nolint:wrapcheck
+			})
+		},
+		"setContent": func(html string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.SetContent(html, opts) //nolint:wrapcheck
+			})
+		},
+		"setInputFiles": func(selector string, files goja.Value, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.SetInputFiles(selector, files, opts) //nolint:wrapcheck
+			})
+		},
 		"tap": func(selector string, opts goja.Value) (*goja.Promise, error) {
 			popts := common.NewFrameTapOptions(f.Timeout())
 			if err := popts.Parse(vu.Context(), opts); err != nil {
@@ -120,11 +204,27 @@ func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
 				return nil, f.Tap(selector, popts) //nolint:wrapcheck
 			}), nil
 		},
-		"textContent": f.TextContent,
-		"title":       f.Title,
-		"type":        f.Type,
-		"uncheck":     f.Uncheck,
-		"url":         f.URL,
+		"textContent": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.TextContent(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"title": func() *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return f.Title(), nil
+			})
+		},
+		"type": func(selector, text string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Type(selector, text, opts) //nolint:wrapcheck
+			})
+		},
+		"uncheck": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.Uncheck(selector, opts) //nolint:wrapcheck
+			})
+		},
+		"url": f.URL,
 		"waitForFunction": func(pageFunc, opts goja.Value, args ...goja.Value) (*goja.Promise, error) {
 			js, popts, pargs, err := parseWaitForFunctionArgs(
 				vu.Context(), f.Timeout(), pageFunc, opts, args...,
@@ -137,7 +237,11 @@ func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
 				return f.WaitForFunction(js, popts, pargs...) //nolint:wrapcheck
 			}), nil
 		},
-		"waitForLoadState": f.WaitForLoadState,
+		"waitForLoadState": func(state string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				return nil, f.WaitForLoadState(state, opts) //nolint:wrapcheck
+			})
+		},
 		"waitForNavigation": func(opts goja.Value) (*goja.Promise, error) {
 			popts := common.NewFrameWaitForNavigationOptions(f.Timeout())
 			if err := popts.Parse(vu.Context(), opts); err != nil {
@@ -152,41 +256,52 @@ func mapFrame(vu moduleVU, f *common.Frame) mapping { //nolint:gocognit,cyclop
 				return mapResponse(vu, resp), nil
 			}), nil
 		},
-		"waitForSelector": func(selector string, opts goja.Value) (mapping, error) {
-			eh, err := f.WaitForSelector(selector, opts)
+		"waitForSelector": func(selector string, opts goja.Value) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				eh, err := f.WaitForSelector(selector, opts)
+				if err != nil {
+					return nil, err //nolint:wrapcheck
+				}
+				return mapElementHandle(vu, eh), nil
+			})
+		},
+		"waitForTimeout": func(timeout int64) *goja.Promise {
+			return k6ext.Promise(vu.Context(), func() (any, error) {
+				f.WaitForTimeout(timeout)
+				return nil, nil
+			})
+		},
+	}
+	maps["$"] = func(selector string) *goja.Promise {
+		return k6ext.Promise(vu.Context(), func() (any, error) {
+			eh, err := f.Query(selector, common.StrictModeOff)
 			if err != nil {
 				return nil, err //nolint:wrapcheck
 			}
-			return mapElementHandle(vu, eh), nil
-		},
-		"waitForTimeout": f.WaitForTimeout,
-	}
-	maps["$"] = func(selector string) (mapping, error) {
-		eh, err := f.Query(selector, common.StrictModeOff)
-		if err != nil {
-			return nil, err //nolint:wrapcheck
-		}
-		// ElementHandle can be null when the selector does not match any elements.
-		// We do not want to map nil elementHandles since the expectation is a
-		// null result in the test script for this case.
-		if eh == nil {
-			return nil, nil //nolint:nilnil
-		}
-		ehm := mapElementHandle(vu, eh)
+			// ElementHandle can be null when the selector does not match any elements.
+			// We do not want to map nil elementHandles since the expectation is a
+			// null result in the test script for this case.
+			if eh == nil {
+				return nil, nil
+			}
+			ehm := mapElementHandle(vu, eh)
 
-		return ehm, nil
+			return ehm, nil
+		})
 	}
-	maps["$$"] = func(selector string) ([]mapping, error) {
-		ehs, err := f.QueryAll(selector)
-		if err != nil {
-			return nil, err //nolint:wrapcheck
-		}
-		var mehs []mapping
-		for _, eh := range ehs {
-			ehm := mapElementHandle(vu, eh)
-			mehs = append(mehs, ehm)
-		}
-		return mehs, nil
+	maps["$$"] = func(selector string) *goja.Promise {
+		return k6ext.Promise(vu.Context(), func() (any, error) {
+			ehs, err := f.QueryAll(selector)
+			if err != nil {
+				return nil, err //nolint:wrapcheck
+			}
+			var mehs []mapping
+			for _, eh := range ehs {
+				ehm := mapElementHandle(vu, eh)
+				mehs = append(mehs, ehm)
+			}
+			return mehs, nil
+		})
 	}
 
 	return maps

common/frame.go

@@ -861,18 +861,19 @@ func (f *Frame) EvaluateGlobal(ctx context.Context, js string) error {
 func (f *Frame) EvaluateHandle(pageFunc string, args ...any) (handle JSHandleAPI, _ error) {
 	f.log.Debugf("Frame:EvaluateHandle", "fid:%s furl:%q", f.ID(), f.URL())
 
-	f.waitForExecutionContext(mainWorld)
+	evalHandle := func() (JSHandleAPI, error) {
+		f.executionContextMu.RLock()
+		defer f.executionContextMu.RUnlock()
 
-	var err error
-	f.executionContextMu.RLock()
-	{
 		ec := f.executionContexts[mainWorld]
 		if ec == nil {
-			k6ext.Panic(f.ctx, "evaluating handle for frame: execution context %q not found", mainWorld)
+			return nil, fmt.Errorf("evaluating handle for frame: execution context %q not found", mainWorld)
 		}
-		handle, err = ec.EvalHandle(f.ctx, pageFunc, args...)
+		return ec.EvalHandle(f.ctx, pageFunc, args...) //nolint:wrapcheck
 	}
-	f.executionContextMu.RUnlock()
+
+	f.waitForExecutionContext(mainWorld)
+	handle, err := evalHandle()
 	if err != nil {
 		return nil, fmt.Errorf("evaluating handle for frame: %w", err)
 	}
@@ -1411,7 +1412,7 @@ func (f *Frame) Query(selector string, strict bool) (*ElementHandle, error) {
 
 	document, err := f.document()
 	if err != nil {
-		k6ext.Panic(f.ctx, "getting document: %w", err)
+		return nil, fmt.Errorf("getting document: %w", err)
 	}
 	return document.Query(selector, strict)
 }
@@ -1422,7 +1423,7 @@ func (f *Frame) QueryAll(selector string) ([]*ElementHandle, error) {
 
 	document, err := f.document()
 	if err != nil {
-		k6ext.Panic(f.ctx, "getting document: %w", err)
+		return nil, fmt.Errorf("getting document: %w", err)
 	}
 	return document.QueryAll(selector)
 }