Error Types¶

Sentinel Errors¶

import w3pilot "github.com/plexusone/w3pilot"

// Check specific error types
if errors.Is(err, w3pilot.ErrElementNotFound) {
    // Element not found
}

Error	Description
`ErrElementNotFound`	Element matching selector not found
`ErrTimeout`	Operation timed out
`ErrConnectionFailed`	Failed to connect to browser
`ErrConnectionClosed`	Connection to browser closed
`ErrBrowserCrashed`	Browser process crashed
`ErrClickerNotFound`	Clicker binary not found

Error Types¶

ElementNotFoundError¶

type ElementNotFoundError struct {
    Selector string
}

func (e ElementNotFoundError) Error() string
func (e ElementNotFoundError) Is(target error) bool

Example:

elem, err := pilot.Find(ctx, "#missing", nil)
if err != nil {
    var notFound w3pilot.ElementNotFoundError
    if errors.As(err, &notFound) {
        fmt.Printf("Selector not found: %s\n", notFound.Selector)
    }
}

TimeoutError¶

type TimeoutError struct {
    Selector string
    Timeout  time.Duration
    Reason   string
}

func (e TimeoutError) Error() string
func (e TimeoutError) Is(target error) bool

Example:

err := elem.Click(ctx, &w3pilot.ActionOptions{Timeout: time.Second})
if err != nil {
    var timeout w3pilot.TimeoutError
    if errors.As(err, &timeout) {
        fmt.Printf("Timed out after %v: %s\n", timeout.Timeout, timeout.Reason)
    }
}

ConnectionError¶

type ConnectionError struct {
    URL   string
    Cause error
}

func (e ConnectionError) Error() string
func (e ConnectionError) Is(target error) bool
func (e ConnectionError) Unwrap() error

BrowserCrashedError¶

type BrowserCrashedError struct {
    ExitCode int
    Output   string
}

func (e BrowserCrashedError) Error() string
func (e BrowserCrashedError) Is(target error) bool

BiDiError¶

WebDriver BiDi protocol errors.

type BiDiError struct {
    ErrorType string
    Message   string
}

func (e BiDiError) Error() string

Error Handling Patterns¶

Check Specific Error¶

elem, err := pilot.Find(ctx, selector, nil)
if err != nil {
    if errors.Is(err, w3pilot.ErrElementNotFound) {
        // Try alternative selector
        elem, err = pilot.Find(ctx, altSelector, nil)
    }
    if err != nil {
        return err
    }
}

Extract Error Details¶

err := elem.Click(ctx, nil)
if err != nil {
    var timeout w3pilot.TimeoutError
    if errors.As(err, &timeout) {
        log.Printf("Click timed out on %s after %v",
            timeout.Selector, timeout.Timeout)
    }
    return err
}

Retry on Timeout¶

func clickWithRetry(ctx context.Context, elem *w3pilot.Element, attempts int) error {
    var err error
    for i := 0; i < attempts; i++ {
        err = elem.Click(ctx, nil)
        if err == nil {
            return nil
        }
        if !errors.Is(err, w3pilot.ErrTimeout) {
            return err // Don't retry non-timeout errors
        }
        time.Sleep(time.Second)
    }
    return err
}

Handle Connection Issues¶

pilot, err := w3pilot.Launch(ctx)
if err != nil {
    if errors.Is(err, w3pilot.ErrClickerNotFound) {
        return fmt.Errorf("install vibium: npm install -g vibium")
    }
    if errors.Is(err, w3pilot.ErrConnectionFailed) {
        return fmt.Errorf("browser failed to start")
    }
    return err
}