Function expect

Function to extend Playwright’s expect assertion capabilities. This adds a new method toBeVisible which checks if an element is visible on the screen.

  • expect<T>(actual, messageOrOptions?): MakeMatchers<void, T, {
        toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
            actual: boolean;
            expected: boolean;
            message: (() => "" | "Element was not found on the screen");
            name: string;
            pass: boolean;
        }>);
    }>

  • Type Parameters

    • T = unknown

    Parameters

    • actual: T
    • OptionalmessageOrOptions: string | {
          message?: string;
      }

    Returns MakeMatchers<void, T, {
        toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
            actual: boolean;
            expected: boolean;
            message: (() => "" | "Element was not found on the screen");
            name: string;
            pass: boolean;
        }>);
    }>

Properties

configure not poll soft

Methods

any anything arrayContaining closeTo extend getState objectContaining stringContaining stringMatching

Properties

configure

configure: ((configuration: {
    message?: string;
    soft?: boolean;
    timeout?: number;
}) => Expect<{
    toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
        actual: boolean;
        expected: boolean;
        message: (() => "" | "Element was not found on the screen");
        name: string;
        pass: boolean;
    }>);
}>)

not

not: Omit<AsymmetricMatchers, "any" | "anything">

poll

poll: (<T>(actual: (() => T | Promise<T>), messageOrOptions?: string | {
    intervals?: number[];
    message?: string;
    timeout?: number;
}) => PollMatchers<Promise<void>, T, {
    toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
        actual: boolean;
        expected: boolean;
        message: (() => "" | "Element was not found on the screen");
        name: string;
        pass: boolean;
    }>);
}>)

soft

soft: (<T>(actual: T, messageOrOptions?: string | {
    message?: string;
}) => MakeMatchers<void, T, {
    toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
        actual: boolean;
        expected: boolean;
        message: (() => "" | "Element was not found on the screen");
        name: string;
        pass: boolean;
    }>);
}>)

Methods

any

  • any(sample): AsymmetricMatcher

  • expect.any() matches any object instance created from the constructor or a corresponding primitive type. Use it inside expect(value).toEqual(expected) to perform pattern matching.

    Usage

    // Match instance of a class.
    class Example {}
    expect(new Example()).toEqual(expect.any(Example));

    // Match any number.
    expect({ prop: 1 }).toEqual({ prop: expect.any(Number) });

    // Match any string.
    expect('abc').toEqual(expect.any(String));

    Parameters

    • sample: unknown

    Returns AsymmetricMatcher

anything

  • anything(): AsymmetricMatcher

  • expect.anything() matches everything except null and undefined. Use it inside expect(value).toEqual(expected) to perform pattern matching.

    Usage

    const value = { prop: 1 };
    expect(value).toEqual({ prop: expect.anything() });
    expect(value).not.toEqual({ otherProp: expect.anything() });

    Returns AsymmetricMatcher

arrayContaining

  • arrayContaining(sample): AsymmetricMatcher

  • expect.arrayContaining() matches an array that contains all of the elements in the expected array, in any order. Note that received array may be a superset of the expected array and contain some extra elements.

    Use this method inside expect(value).toEqual(expected) to perform pattern matching.

    Usage

    expect([1, 2, 3]).toEqual(expect.arrayContaining([3, 1]));
    expect([1, 2, 3]).not.toEqual(expect.arrayContaining([1, 4]));

    Parameters

    • sample: unknown[]

    Returns AsymmetricMatcher

closeTo

  • closeTo(sample, precision?): AsymmetricMatcher

  • Compares floating point numbers for approximate equality. Use this method inside expect(value).toEqual(expected) to perform pattern matching. When just comparing two numbers, prefer expect(value).toBeCloseTo(expected[, numDigits]).

    Usage

    expect({ prop: 0.1 + 0.2 }).not.toEqual({ prop: 0.3 });
    expect({ prop: 0.1 + 0.2 }).toEqual({ prop: expect.closeTo(0.3, 5) });

    Parameters

    • sample: number
    • Optionalprecision: number

    Returns AsymmetricMatcher

extend

  • extend<MoreMatchers>(matchers): Expect<{
        toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
            actual: boolean;
            expected: boolean;
            message: (() => "" | "Element was not found on the screen");
            name: string;
            pass: boolean;
        }>);
    } & MoreMatchers>

  • Type Parameters

    • MoreMatchers extends Record<string, ((this: ExpectMatcherState, receiver: any, ...args: any[]) => MatcherReturnType | Promise<MatcherReturnType>)>

    Parameters

    Returns Expect<{
        toBeVisible: ((locator: AppwrightLocator, options?: ActionOptions) => Promise<{
            actual: boolean;
            expected: boolean;
            message: (() => "" | "Element was not found on the screen");
            name: string;
            pass: boolean;
        }>);
    } & MoreMatchers>

getState

  • getState(): unknown

  • Returns unknown

objectContaining

  • objectContaining(sample): AsymmetricMatcher

  • expect.objectContaining() matches an object that contains and matches all of the properties in the expected object. Note that received object may be a superset of the expected object and contain some extra properties.

    Use this method inside expect(value).toEqual(expected) to perform pattern matching. Object properties can be matchers to further relax the expectation. See examples.

    Usage

    // Assert some of the properties.
    expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ foo: 1 }));

    // Matchers can be used on the properties as well.
    expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ bar: expect.any(Number) }));

    // Complex matching of sub-properties.
    expect({
      list: [1, 2, 3],
      obj: { prop: 'Hello world!', another: 'some other value' },
      extra: 'extra',
    }).toEqual(expect.objectContaining({
      list: expect.arrayContaining([2, 3]),
      obj: expect.objectContaining({ prop: expect.stringContaining('Hello') }),
    }));

    Parameters

    • sample: Record<string, unknown>

    Returns AsymmetricMatcher

stringContaining

  • stringContaining(sample): AsymmetricMatcher

  • expect.stringContaining() matches a string that contains the expected substring. Use this method inside expect(value).toEqual(expected) to perform pattern matching.

    Usage

    expect('Hello world!').toEqual(expect.stringContaining('Hello'));

    Parameters

    • sample: string

    Returns AsymmetricMatcher

stringMatching

  • stringMatching(sample): AsymmetricMatcher

  • expect.stringMatching() matches a received string that in turn matches the expected pattern. Use this method inside expect(value).toEqual(expected) to perform pattern matching.

    Usage

    expect('123ms').toEqual(expect.stringMatching(/\d+m?s/));

    // Inside another matcher.
    expect({
      status: 'passed',
      time: '123ms',
    }).toEqual({
      status: expect.stringMatching(/passed|failed/),
      time: expect.stringMatching(/\d+m?s/),
    });

    Parameters

    • sample: string | RegExp

    Returns AsymmetricMatcher

Settings

Member Visibility

On This Page

Properties
Methods