Variable TestUtilsConst

Type declaration

• createTestAnimationEvent:function

  • createTestAnimationEvent(type, options?): AnimationEvent

  • Creates a test animation event

    Parameters

    • type: string

      Event type
    • options: AnimationEventInit = {}

      Event options

    Returns AnimationEvent

    Test animation event

• createTestClipboardEvent:function

  • createTestClipboardEvent(type, options?): ClipboardEvent

  • Creates a test clipboard event

    Parameters

    • type: string

      Event type
    • options: ClipboardEventInit = {}

      Event options

    Returns ClipboardEvent

    Test clipboard event

• createTestDataArrayGenerator:function

  • createTestDataArrayGenerator<T>(template): ((count, overrides?) => T[])

  • Creates a test data array generator

    Type Parameters

    • T extends object

    Parameters

    • template: T

      Template object

    Returns ((count, overrides?) => T[])

    Function that generates an array of test data

    • • (count, overrides?): T[]

      • Parameters

        • count: number
        • overrides: Partial<T> = {}

        Returns T[]

• createTestDataGenerator:function

  • createTestDataGenerator<T>(template): ((overrides?) => T)

  • Creates a test data generator

    Type Parameters

    • T extends object

    Parameters

    • template: T

      Template object

    Returns ((overrides?) => T)

    Function that generates test data

    • • (overrides?): T

      • Parameters

        • overrides: Partial<T> = {}

        Returns T

• createTestDragEvent:function

  • createTestDragEvent(type, options?): DragEvent

  • Creates a test drag event

    Parameters

    • type: string

      Event type
    • options: DragEventInit = {}

      Event options

    Returns DragEvent

    Test drag event

• createTestEvent:function

  • createTestEvent(type, options?): Event

  • Creates a test event

    Parameters

    • type: string

      Event type
    • options: EventInit = {}

      Event options

    Returns Event

    Test event

• createTestFocusEvent:function

  • createTestFocusEvent(type, options?): FocusEvent

  • Creates a test focus event

    Parameters

    • type: string

      Event type
    • options: FocusEventInit = {}

      Event options

    Returns FocusEvent

    Test focus event

• createTestInputEvent:function

  • createTestInputEvent(type, options?): InputEvent

  • Creates a test input event

    Parameters

    • type: string

      Event type
    • options: InputEventInit = {}

      Event options

    Returns InputEvent

    Test input event

• createTestKeyboardEvent:function

  • createTestKeyboardEvent(type, options?): KeyboardEvent

  • Creates a test keyboard event

    Parameters

    • type: string

      Event type
    • options: KeyboardEventInit = {}

      Event options

    Returns KeyboardEvent

    Test keyboard event

• createTestMouseEvent:function

  • createTestMouseEvent(type, options?): MouseEvent

  • Creates a test mouse event

    Parameters

    • type: string

      Event type
    • options: MouseEventInit = {}

      Event options

    Returns MouseEvent

    Test mouse event

• createTestTouchEvent:function

  • createTestTouchEvent(type, options?): TouchEvent

  • Creates a test touch event

    Parameters

    • type: string

      Event type
    • options: TouchEventInit = {}

      Event options

    Returns TouchEvent

    Test touch event

• createTestTransitionEvent:function

  • createTestTransitionEvent(type, options?): TransitionEvent

  • Creates a test transition event

    Parameters

    • type: string

      Event type
    • options: TransitionEventInit = {}

      Event options

    Returns TransitionEvent

    Test transition event

• createMockErrorPromise:function

  • createMockErrorPromise(error, delay?): Promise<never>

  • Creates a mock error promise

    Parameters

    • error: Error

      Error to reject with
    • delay: number = 0

      Delay in milliseconds

    Returns Promise<never>

    Mock error promise

• createMock:function

  • createMock<T>(implementation?): T

  • Creates a mock function

    Type Parameters

    • T extends ((...args) => any)

    Parameters

    • Optional implementation: T

      Optional implementation function

    Returns T

    Mock function

• createMockObject:function

  • createMockObject<T>(template): T

  • Creates a mock object

    Type Parameters

    • T extends object

    Parameters

    • template: T

      Template object to mock

    Returns T

    Mock object

• createMockPromise:function

  • createMockPromise<T>(value, delay?): Promise<T>

  • Creates a mock promise

    Type Parameters

    • T

    Parameters

    • value: T

      Value to resolve with
    • delay: number = 0

      Delay in milliseconds

    Returns Promise<T>

    Mock promise

• wait:function

  • wait(ms): Promise<void>

  • Waits for a number of milliseconds

    Parameters

    • ms: number

      Milliseconds to wait

    Returns Promise<void>

    Promise that resolves after the delay

• waitFor:function

  • waitFor(condition, timeout?, interval?): Promise<void>

  • Waits for a condition to be true

    Parameters

    • condition: (() => boolean)

      Function that returns a boolean

      • • (): boolean

        • Returns boolean

    • timeout: number = 5000

      Timeout in milliseconds
    • interval: number = 100

      Check interval in milliseconds

    Returns Promise<void>

    Promise that resolves when condition is true