mockCondition

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

Метод TestRuntime, возвращаемого createTestRuntime. Регистрирует условие для триггера, принимая либо статическое значение, либо геттер без аргументов.

mockCondition — тестовый аналог useCondition: тот же механизм регистрации, без React.

Импорт

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

const rt = createTestRuntime();
rt.mockCondition(/* ... */);

Сигнатура

mockCondition<S extends TriggerSchema, K extends ConditionKey<S>>(
  trigger: Trigger<S>,
  name: K,
  valueOrGetter: ConditionMap<S>[K] | (() => ConditionMap<S>[K]),
): RegistrationToken;

Параметры

Параметр	Тип	Описание
`trigger`	`Trigger<S>`	Триггер, чьё условие подменяешь.
`name`	`K extends ConditionKey<S>`	Условие, объявленное в схеме триггера.
`valueOrGetter`	`T \| (() => T)`	Либо статическое значение (захваченное замыканием), либо геттер без аргументов.

Возвращает

RegistrationToken со { unregister(): void }. Вызови unregister(), чтобы сбросить подмена — полезно для смены условий по ходу теста.

Примеры

Статическое значение

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';

const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
const tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}> = createTriggercreateTrigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}>(config: CreateTriggerConfig<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}>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: {
    ping: void;
}: { pingping: void: void };
  conditionsconditions: {
    user: {
        id: string;
    } | null;
}: { useruser: {
    id: string;
} | null: { idid: string: string } | null };
}>(
  {
    idid: string: 'demo',
    eventsevents: readonly "ping"[]: ['ping'],
    handlerhandler: TriggerHandler<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}, never>() {},
  },
  rtconst rt: TestRuntime,
);

rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}, "user">(trigger: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}>, name: "user", valueOrGetter: {
    id: string;
} | (() => {
    id: string;
} | null) | null): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            id: string;
        } | null;
    };
}>, 'user', { idid: string: 'u-1' });

Динамический геттер (читать свежий стейт на каждом fire)

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';

const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
const tconst t: Trigger<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: void;
    };
    conditions: {
        counter: 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: void;
}: { ticktick: void: void };
  conditionsconditions: {
    counter: number;
}: { countercounter: number: number };
}>(
  {
    idid: string: 'demo',
    eventsevents: readonly "tick"[]: ['tick'],
    handlerhandler: TriggerHandler<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}, never>() {},
  },
  rtconst rt: TestRuntime,
);

let counterlet counter: number = 0;
rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}, "counter">(trigger: Trigger<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}>, name: "counter", valueOrGetter: number | (() => number)): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        tick: void;
    };
    conditions: {
        counter: number;
    };
}>, 'counter', () => counterlet counter: number);

rtconst rt: TestRuntime.fireSyncfunction fireSync(eventName: string, payload?: unknown): voidRun dispatch synchronously (for tests and benchmarks).('tick'); // handler sees counter=0
counterlet counter: number = 5;
rtconst rt: TestRuntime.fireSyncfunction fireSync(eventName: string, payload?: unknown): voidRun dispatch synchronously (for tests and benchmarks).('tick'); // handler sees counter=5

Подмена по ходу теста

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';

const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
const tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}> = createTriggercreateTrigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>(config: CreateTriggerConfig<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>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: {
    ping: void;
}: { pingping: void: void };
  conditionsconditions: {
    flag: boolean;
}: { flagflag: boolean: boolean };
}>(
  { idid: string: 'demo', eventsevents: readonly "ping"[]: ['ping'], handlerhandler: TriggerHandler<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}, never>() {} },
  rtconst rt: TestRuntime,
);

const offconst off: RegistrationToken = rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}, "flag">(trigger: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>, name: "flag", valueOrGetter: boolean | (() => boolean)): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>, 'flag', true);
rtconst rt: TestRuntime.fireSyncfunction fireSync(eventName: string, payload?: unknown): voidRun dispatch synchronously (for tests and benchmarks).('ping'); // handler sees flag=true

offconst off: RegistrationToken.unregisterfunction unregister(): voidIdempotent unregister.();
rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}, "flag">(trigger: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>, name: "flag", valueOrGetter: boolean | (() => boolean)): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        flag: boolean;
    };
}>, 'flag', false);
rtconst rt: TestRuntime.fireSyncfunction fireSync(eventName: string, payload?: unknown): voidRun dispatch synchronously (for tests and benchmarks).('ping'); // handler sees flag=false

Условие с функциональным типом требует явный геттер

Когда значение условия — это функция без аргументов, эвристика может ошибочно принять её за геттер. Передавай явный геттер:

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';

const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
type Callbacktype Callback = () => void = () => void;

const tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}> = createTriggercreateTrigger<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}>(config: CreateTriggerConfig<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}>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: {
    ping: void;
}: { pingping: void: void };
  conditionsconditions: {
    onTick: Callback;
}: { onTickonTick: Callback: Callbacktype Callback = () => void };
}>(
  { idid: string: 'demo', eventsevents: readonly "ping"[]: ['ping'], handlerhandler: TriggerHandler<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}, never>() {} },
  rtconst rt: TestRuntime,
);

const cbconst cb: Callback: Callbacktype Callback = () => void = () => consolevar console: Console.logConsole.log(...data: any[]): voidThe **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)('tick');
// Wrap in a getter so the runtime stores `cb`, not the result of calling cb.
rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}, "onTick">(trigger: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}>, name: "onTick", valueOrGetter: Callback | (() => Callback)): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        onTick: Callback;
    };
}>, 'onTick', () => cbconst cb: Callback);

Замечания

См. также

createTestRuntime Рантайм, который предоставляет этот метод.

mockAction Подменить действие — вторая половина тестовой обвязки.

useCondition Рантайм-аналог в React.

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