Interface Scheduler<TMetaData>

Instance able to reschedule the ordering of promises for a given app

Remarks

Since 1.20.0

interface Scheduler<TMetaData> {
    report: (() => SchedulerReportItem<TMetaData>[]);
    schedule: (<T>(task, label?, metadata?, customAct?) => Promise<T>);
    scheduleFunction: (<TArgs, T>(asyncFunction, customAct?) => ((...args) => Promise<T>));
    waitAll: ((customAct?) => Promise<void>);
    waitFor: (<T>(unscheduledTask, customAct?) => Promise<T>);
    waitOne: ((customAct?) => Promise<void>);
    count(): number;
    scheduleSequence(sequenceBuilders, customAct?): {
        done: boolean;
        faulty: boolean;
        task: Promise<{
            done: boolean;
            faulty: boolean;
        }>;
    };
}

Type Parameters

  • TMetaData = unknown

Properties

report schedule scheduleFunction waitAll waitFor waitOne

Methods

count scheduleSequence

Properties

report

report: (() => SchedulerReportItem<TMetaData>[])

Produce an array containing all the scheduled tasks so far with their execution status. If the task has been executed, it includes a string representation of the associated output or error produced by the task if any.

Tasks will be returned in the order they get executed by the scheduler.

Type declaration

Remarks

Since 1.25.0

schedule

schedule: (<T>(task, label?, metadata?, customAct?) => Promise<T>)

Wrap a new task using the Scheduler

Type declaration

    • <T>(task, label?, metadata?, customAct?): Promise<T>

    • Type Parameters

      • T

      Parameters

      Returns Promise<T>

Remarks

Since 1.20.0

scheduleFunction

scheduleFunction: (<TArgs, T>(asyncFunction, customAct?) => ((...args) => Promise<T>))

Automatically wrap function output using the Scheduler

Type declaration

    • <TArgs, T>(asyncFunction, customAct?): ((...args) => Promise<T>)

    • Type Parameters

      • TArgs extends any[]
      • T

      Parameters

      • asyncFunction: ((...args) => Promise<T>)
          • (...args): Promise<T>

          • Parameters

            Returns Promise<T>

      • Optional customAct: SchedulerAct

      Returns ((...args) => Promise<T>)

        • (...args): Promise<T>

        • Parameters

          Returns Promise<T>

Remarks

Since 1.20.0

waitAll

waitAll: ((customAct?) => Promise<void>)

Wait all scheduled tasks, including the ones that might be created by one of the resolved task

Type declaration

    • (customAct?): Promise<void>

    • Parameters

      Returns Promise<void>

Remarks

Since 1.20.0

waitFor

waitFor: (<T>(unscheduledTask, customAct?) => Promise<T>)

Wait as many scheduled tasks as need to resolve the received Promise

Some tests frameworks like supertest are not triggering calls to subsequent queries in a synchronous way, some are waiting an explicit call to then to trigger them (either synchronously or asynchronously)... As a consequence, none of waitOne or waitAll cannot wait for them out-of-the-box.

This helper is responsible to wait as many scheduled tasks as needed (but the bare minimal) to get unscheduledTask resolved. Once resolved it returns its output either success or failure.

Be aware that while this helper will wait eveything to be ready for unscheduledTask to resolve, having uncontrolled tasks triggering stuff required for unscheduledTask might be a source a uncontrollable and not reproducible randomness as those triggers cannot be handled and scheduled by fast-check.

Type declaration

    • <T>(unscheduledTask, customAct?): Promise<T>

    • Type Parameters

      • T

      Parameters

      Returns Promise<T>

Remarks

Since 2.24.0

waitOne

waitOne: ((customAct?) => Promise<void>)

Wait one scheduled task to be executed

Type declaration

    • (customAct?): Promise<void>

    • Parameters

      Returns Promise<void>

Throws

Whenever there is no task scheduled

Remarks

Since 1.20.0

Methods

count

scheduleSequence

  • scheduleSequence(sequenceBuilders, customAct?): {
        done: boolean;
        faulty: boolean;
        task: Promise<{
            done: boolean;
            faulty: boolean;
        }>;
    }

  • Schedule a sequence of Promise to be executed sequencially. Items within the sequence might be interleaved by other scheduled operations.

    Please note that whenever an item from the sequence has started, the scheduler will wait until its end before moving to another scheduled task.

    A handle is returned by the function in order to monitor the state of the sequence. Sequence will be marked:

    • done if all the promises have been executed properly
    • faulty if one of the promises within the sequence throws

    Parameters

    Returns {
        done: boolean;
        faulty: boolean;
        task: Promise<{
            done: boolean;
            faulty: boolean;
        }>;
    }

    • done: boolean
    • faulty: boolean
    • task: Promise<{
          done: boolean;
          faulty: boolean;
      }>

    Remarks

    Since 1.20.0

Settings

Member Visibility

Theme

On This Page

reportschedulescheduleFunctionwaitAllwaitForwaitOnecountscheduleSequence