Function expect

  • expect<T>(actual, messageOrOptions?): MakeMatchers<void, T, {}>

  • Type Parameters

    • T = unknown

    Parameters

    • actual: T
    • Optional messageOrOptions: string | {
          message?: string;
      }

    Returns MakeMatchers<void, T, {}>

Properties

configure not poll soft

Methods

any anything arrayContaining arrayOf closeTo extend getState objectContaining stringContaining stringMatching

Properties

configure

configure: ((configuration) => Expect<{}>)

Type declaration

    • (configuration): Expect<{}>

    • Parameters

      • configuration: {
            message?: string;
            soft?: boolean;
            timeout?: number;
        }
        • Optional message?: string
        • Optional soft?: boolean
        • Optional timeout?: number

      Returns Expect<{}>

not

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

poll

poll: (<T>(actual, messageOrOptions?) => PollMatchers<Promise<void>, T, {}>)

Type declaration

    • <T>(actual, messageOrOptions?): PollMatchers<Promise<void>, T, {}>

    • Type Parameters

      • T = unknown

      Parameters

      • actual: (() => T | Promise<T>)
          • (): T | Promise<T>

          • Returns T | Promise<T>

      • Optional messageOrOptions: string | {
            intervals?: number[];
            message?: string;
            timeout?: number;
        }

      Returns PollMatchers<Promise<void>, T, {}>

soft

soft: (<T>(actual, messageOrOptions?) => MakeMatchers<void, T, {}>)

Type declaration

    • <T>(actual, messageOrOptions?): MakeMatchers<void, T, {}>

    • Type Parameters

      • T = unknown

      Parameters

      • actual: T
      • Optional messageOrOptions: string | {
            message?: string;
        }

      Returns MakeMatchers<void, T, {}>

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

arrayOf

  • arrayOf(sample): AsymmetricMatcher

  • expect.arrayOf() matches array of objects 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(), new Example()]).toEqual(expect.arrayOf(Example));

    // Match any string.
    expect(['a', 'b', 'c']).toEqual(expect.arrayOf(String));

    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
    • Optional precision: number

    Returns AsymmetricMatcher

extend

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

Theme

On This Page

configurenotpollsoftanyanythingarrayContainingarrayOfcloseToextendgetStateobjectContainingstringContainingstringMatching