flushMicrotasks

Стабильный · с 0.1.0

Метод на TestRuntime. Дважды await-ит, чтобы слить очередь микротасков — сначала ту, что ты ожидаешь, потом любые follow-up микротаски, заведённые уже отработавшими обработчиками.

Используй после rt.fire(...), когда schedule триггера — 'microtask' (по умолчанию) и тесту нужно, чтобы обработчик завершился до следующего assert’а. fireSync этого не требует — он гоняет обработчики в стеке вызывающего.

Импорт

import { createTestRuntime } from '@triggery/testing';

const rt = createTestRuntime();
await rt.flushMicrotasks();

Сигнатура

flushMicrotasks(): Promise<void>;

Параметры

Нет.

Возвращает

Promise<void>, резолвящийся после двух тиков микротасков.

Примеры

Async-fire, потом assert

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import { expectconst expect: ExpectStatic, itconst it: TestAPIDefines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```, viconst vi: VitestUtils } from 'vitest';

itit<object>(name: string | Function, fn?: TestFunction<object> | undefined, options?: number): void (+1 overload)Defines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```('completes a microtask-scheduled handler', async () => {
  const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
  const tconst t: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
    eventsevents: {
    tick: void;
}: { ticktick: void: void };
    actionsactions: {
    log: void;
}: { loglog: void: void };
  }>(
    { idid: string: 'demo', eventsevents: readonly "tick"[]: ['tick'], handlerhandler: TriggerHandler<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}, never>({ actionsactions: ActionsCtx<{
    log: void;
}> }) { actionsactions: ActionsCtx<{
    log: void;
}>.loglog?: (() => void) | undefined?.(); } },
    rtconst rt: TestRuntime,
  );

  const logconst log: Mock<Procedure> = viconst vi: VitestUtils.fnVitestUtils.fn: <Procedure>(originalImplementation?: Procedure | undefined) => Mock<Procedure>Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).

If no function is given, mock will return `undefined`, when invoked.
@example```ts
const getApples = vi.fn(() => 0)

getApples()

expect(getApples).toHaveBeenCalled()
expect(getApples).toHaveReturnedWith(0)

getApples.mockReturnValueOnce(5)

expect(getApples()).toBe(5)
expect(getApples).toHaveNthReturnedWith(2, 5)
```();
  rtconst rt: TestRuntime.mockActionmockAction<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}, "log">(trigger: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, name: "log", handler: () => void): RegistrationTokenRegister an action handler — typically a `vi.fn()`.(tconst t: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, 'log', logconst log: Mock<Procedure>);

  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('tick');
  expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(logconst log: Mock<Procedure>).notnot: Assertion<Mock<Procedure>>.toHaveBeenCalledJestAssertion<Mock<Procedure>>.toHaveBeenCalled: () => voidEnsures that a mock function is called.

Also under the alias `expect.toBeCalled`.
@exampleexpect(mockFunc).toHaveBeenCalled();(); // handler not run yet

  await rtconst rt: TestRuntime.flushMicrotasksfunction flushMicrotasks(): Promise<void>Flush pending microtasks. The default scheduler uses `queueMicrotask` —
after `rt.fire(...)` you await `flushMicrotasks()` before asserting.

`fireSync` does not need this: it runs handlers immediately.();
  expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(logconst log: Mock<Procedure>).toHaveBeenCalledOnceAssertion<Mock<Procedure>>.toHaveBeenCalledOnce: () => voidAsserts that a mock function was called exactly once.
@exampleexpect(mockFunc).toHaveBeenCalledOnce();();
});

Цепочка async-обработчика

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import { expectconst expect: ExpectStatic, itconst it: TestAPIDefines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```, viconst vi: VitestUtils } from 'vitest';

itit<object>(name: string | Function, fn?: TestFunction<object> | undefined, options?: number): void (+1 overload)Defines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```('awaits an async action chain', async () => {
  const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
  const tconst t: Trigger<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}> = createTriggercreateTrigger<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}>(config: CreateTriggerConfig<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
    eventsevents: {
    fetch: string;
}: { fetchfetch: string: string };
    actionsactions: {
    setData: {
        value: string;
    };
}: { setDatasetData: {
    value: string;
}: { valuevalue: string: string } };
  }>(
    {
      idid: string: 'demo',
      eventsevents: readonly "fetch"[]: ['fetch'],
      async handlerhandler: TriggerHandler<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}, never>({ eventevent: {
    readonly name: "fetch";
    readonly payload: string;
}, actionsactions: ActionsCtx<{
    setData: {
        value: string;
    };
}> }) {
        const valueconst value: string = await Promisevar Promise: PromiseConstructorRepresents the completion of an asynchronous operation.resolvePromiseConstructor.resolve<string>(value: string): Promise<string> (+2 overloads)Creates a new resolved promise for the provided value.
@paramvalue A promise.@returnsA promise whose internal state matches the provided promise.(`got-${eventevent: {
    readonly name: "fetch";
    readonly payload: string;
}.payloadpayload: string}`);
        actionsactions: ActionsCtx<{
    setData: {
        value: string;
    };
}>.setDatasetData?: ((payload: {
    value: string;
}) => void) | undefined?.({ valuevalue: string });
      },
    },
    rtconst rt: TestRuntime,
  );

  const setDataconst setData: Mock<Procedure> = viconst vi: VitestUtils.fnVitestUtils.fn: <Procedure>(originalImplementation?: Procedure | undefined) => Mock<Procedure>Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).

If no function is given, mock will return `undefined`, when invoked.
@example```ts
const getApples = vi.fn(() => 0)

getApples()

expect(getApples).toHaveBeenCalled()
expect(getApples).toHaveReturnedWith(0)

getApples.mockReturnValueOnce(5)

expect(getApples()).toBe(5)
expect(getApples).toHaveNthReturnedWith(2, 5)
```();
  rtconst rt: TestRuntime.mockActionmockAction<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}, "setData">(trigger: Trigger<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}>, name: "setData", handler: (payload: {
    value: string;
}) => void): RegistrationTokenRegister an action handler — typically a `vi.fn()`.(tconst t: Trigger<{
    events: {
        fetch: string;
    };
    actions: {
        setData: {
            value: string;
        };
    };
}>, 'setData', setDataconst setData: Mock<Procedure>);

  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('fetch', 'x');
  await rtconst rt: TestRuntime.flushMicrotasksfunction flushMicrotasks(): Promise<void>Flush pending microtasks. The default scheduler uses `queueMicrotask` —
after `rt.fire(...)` you await `flushMicrotasks()` before asserting.

`fireSync` does not need this: it runs handlers immediately.();
  expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(setDataconst setData: Mock<Procedure>).toHaveBeenCalledWithJestAssertion<Mock<Procedure>>.toHaveBeenCalledWith: <[{
    value: string;
}]>(args_0: {
    value: string;
}) => voidEnsure that a mock function is called with specific arguments.

Also under the alias `expect.toBeCalledWith`.
@exampleexpect(mockFunc).toHaveBeenCalledWith('arg1', 42);({ valuevalue: string: 'got-x' });
});

Несколько fires, один flush

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import { expectconst expect: ExpectStatic, itconst it: TestAPIDefines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```, viconst vi: VitestUtils } from 'vitest';

itit<object>(name: string | Function, fn?: TestFunction<object> | undefined, options?: number): void (+1 overload)Defines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```('drains all queued runs together', async () => {
  const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
  const tconst t: Trigger<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
    eventsevents: {
    tick: number;
}: { ticktick: number: number };
    actionsactions: {
    log: number;
}: { loglog: number: number };
  }>(
    { idid: string: 'demo', eventsevents: readonly "tick"[]: ['tick'], handlerhandler: TriggerHandler<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}, never>({ eventevent: {
    readonly name: "tick";
    readonly payload: number;
}, actionsactions: ActionsCtx<{
    log: number;
}> }) { actionsactions: ActionsCtx<{
    log: number;
}>.loglog?: ((payload: number) => void) | undefined?.(eventevent: {
    readonly name: "tick";
    readonly payload: number;
}.payloadpayload: number); } },
    rtconst rt: TestRuntime,
  );

  const logconst log: Mock<Procedure> = viconst vi: VitestUtils.fnVitestUtils.fn: <Procedure>(originalImplementation?: Procedure | undefined) => Mock<Procedure>Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).

If no function is given, mock will return `undefined`, when invoked.
@example```ts
const getApples = vi.fn(() => 0)

getApples()

expect(getApples).toHaveBeenCalled()
expect(getApples).toHaveReturnedWith(0)

getApples.mockReturnValueOnce(5)

expect(getApples()).toBe(5)
expect(getApples).toHaveNthReturnedWith(2, 5)
```();
  rtconst rt: TestRuntime.mockActionmockAction<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}, "log">(trigger: Trigger<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}>, name: "log", handler: (payload: number) => void): RegistrationTokenRegister an action handler — typically a `vi.fn()`.(tconst t: Trigger<{
    events: {
        tick: number;
    };
    actions: {
        log: number;
    };
}>, 'log', logconst log: Mock<Procedure>);

  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('tick', 1);
  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('tick', 2);
  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('tick', 3);

  await rtconst rt: TestRuntime.flushMicrotasksfunction flushMicrotasks(): Promise<void>Flush pending microtasks. The default scheduler uses `queueMicrotask` —
after `rt.fire(...)` you await `flushMicrotasks()` before asserting.

`fireSync` does not need this: it runs handlers immediately.();
  expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(logconst log: Mock<Procedure>).toHaveBeenCalledTimesJestAssertion<Mock<Procedure>>.toHaveBeenCalledTimes: (times: number) => voidEnsures that a mock function is called an exact number of times.

Also under the alias `expect.toBeCalledTimes`.
@exampleexpect(mockFunc).toHaveBeenCalledTimes(2);(3);
});

Замечания

См. также

createTestRuntime Рантайм, экспонирующий этот метод.

createFakeScheduler Виртуальные часы для таймерных обработчиков.

createScheduler Микротасковый планировщик, который сливается.

Руководство по тестированию Паттерны async-тестов.