Refactor page.waitForLoadState to return err

browser/mapping_test.go

@@ -350,7 +350,7 @@ type pageAPI interface {
  URL() (string, error)
  ViewportSize() map[string]float64
  WaitForFunction(fn, opts goja.Value, args ...goja.Value) (any, error)
- WaitForLoadState(state string, opts goja.Value)
+ WaitForLoadState(state string, opts goja.Value) error
  WaitForNavigation(opts goja.Value) (*common.Response, error)
  WaitForSelector(selector string, opts goja.Value) (*common.ElementHandle, error)
  WaitForTimeout(timeout int64)
@@ -412,7 +412,7 @@ type frameAPI interface {
  Uncheck(selector string, opts goja.Value) error
  URL() string
  WaitForFunction(pageFunc, opts goja.Value, args ...goja.Value) (any, error)
- WaitForLoadState(state string, opts goja.Value)
+ WaitForLoadState(state string, opts goja.Value) error
  WaitForNavigation(opts goja.Value) (*common.Response, error)
  WaitForSelector(selector string, opts goja.Value) (*common.ElementHandle, error)
  WaitForTimeout(timeout int64)

common/frame.go

@@ -1809,45 +1809,48 @@ func (f *Frame) waitForFunction(
 
 // WaitForLoadState waits for the given load state to be reached.
 // This will unblock if that lifecycle event has already been received.
-func (f *Frame) WaitForLoadState(state string, opts goja.Value) {
+func (f *Frame) WaitForLoadState(state string, opts goja.Value) error {
  f.log.Debugf("Frame:WaitForLoadState", "fid:%s furl:%q state:%s", f.ID(), f.URL(), state)
  defer f.log.Debugf("Frame:WaitForLoadState:return", "fid:%s furl:%q state:%s", f.ID(), f.URL(), state)
 
- parsedOpts := NewFrameWaitForLoadStateOptions(f.defaultTimeout())
- err := parsedOpts.Parse(f.ctx, opts)
- if err != nil {
- k6ext.Panic(f.ctx, "parsing waitForLoadState %q options: %v", state, err)
+ waitForLoadStateOpts := NewFrameWaitForLoadStateOptions(f.defaultTimeout())
+ if err := waitForLoadStateOpts.Parse(f.ctx, opts); err != nil {
+ return fmt.Errorf("parsing waitForLoadState %q options: %w", state, err)
  }
 
- timeoutCtx, timeoutCancel := context.WithTimeout(f.ctx, parsedOpts.Timeout)
+ timeoutCtx, timeoutCancel := context.WithTimeout(f.ctx, waitForLoadStateOpts.Timeout)
  defer timeoutCancel()
 
  waitUntil := LifecycleEventLoad
  if state != "" {
- if err = waitUntil.UnmarshalText([]byte(state)); err != nil {
- k6ext.Panic(f.ctx, "waiting for load state: %v", err)
+ if err := waitUntil.UnmarshalText([]byte(state)); err != nil {
+ return fmt.Errorf("unmarshaling wait for load state %q: %w", state, err)
  }
  }
 
- lifecycleEvtCh, lifecycleEvtCancel := createWaitForEventPredicateHandler(
- timeoutCtx, f, []string{EventFrameAddLifecycle},
+ lifecycleEvent, lifecycleEventCancel := createWaitForEventPredicateHandler(
+ timeoutCtx,
+ f,
+ []string{EventFrameAddLifecycle},
  func(data any) bool {
  if le, ok := data.(FrameLifecycleEvent); ok {
  return le.Event == waitUntil
  }
  return false
  })
- defer lifecycleEvtCancel()
+ defer lifecycleEventCancel()
 
  if f.hasLifecycleEventFired(waitUntil) {
- return
+ return nil
  }
 
  select {
- case <-lifecycleEvtCh:
+ case <-lifecycleEvent:
  case <-timeoutCtx.Done():
- k6ext.Panic(f.ctx, "waiting for load state %q: %v", state, err)
+ return fmt.Errorf("waiting for load state %q: %w", state, timeoutCtx.Err())
  }
+
+ return nil
 }
 
 // WaitForNavigation waits for the given navigation lifecycle event to happen.

common/page.go

@@ -1305,10 +1305,10 @@ func (p *Page) WaitForFunction(js string, opts *FrameWaitForFunctionOptions, jsA
 }
 
 // WaitForLoadState waits for the specified page life cycle event.
-func (p *Page) WaitForLoadState(state string, opts goja.Value) {
+func (p *Page) WaitForLoadState(state string, opts goja.Value) error {
  p.logger.Debugf("Page:WaitForLoadState", "sid:%v state:%q", p.sessionID(), state)
 
- p.frameManager.MainFrame().WaitForLoadState(state, opts)
+ return p.frameManager.MainFrame().WaitForLoadState(state, opts)
 }
 
 // WaitForNavigation waits for the given navigation lifecycle event to happen.

tests/lifecycle_wait_test.go

@@ -278,7 +278,8 @@ func TestLifecycleWaitForLoadState(t *testing.T) {
  pingJSSlow: false,
  waitUntil: common.LifecycleEventDOMContentLoad,
  assertFunc: func(p *common.Page) {
- p.WaitForLoadState(common.LifecycleEventNetworkIdle.String(), nil)
+ err := p.WaitForLoadState(common.LifecycleEventNetworkIdle.String(), nil)
+ require.NoError(t, err)
 
  result, err := p.TextContent("#pingRequestText", nil)
  require.NoError(t, err)
@@ -321,9 +322,7 @@ func TestLifecycleWaitForLoadState(t *testing.T) {
  tt.pingJSTextAssert(result)
 
  // This shouldn't block and return after calling hasLifecycleEventFired.
- p.WaitForLoadState(tt.waitUntil.String(), nil)
-
- return nil
+ return p.WaitForLoadState(tt.waitUntil.String(), nil)
  }, nil, "")
  })
  }

tests/page_test.go

@@ -865,10 +865,9 @@ func TestPageWaitForLoadState(t *testing.T) {
  t.Parallel()
 
  tb := newTestBrowser(t)
- assertExceptionContains(t, tb.runtime(), func() {
- p := tb.NewPage(nil)
- p.WaitForLoadState("none", nil)
- }, `invalid lifecycle event: "none"; must be one of: load, domcontentloaded, networkidle`)
+ p := tb.NewPage(nil)
+ err := p.WaitForLoadState("none", nil)
+ require.ErrorContains(t, err, `invalid lifecycle event: "none"; must be one of: load, domcontentloaded, networkidle`)
  })
 }