Vi

Vitest предоставляет вспомогательные функции через помощник vi. Вы можете получить к нему доступ в глобальной области (если конфигурация globals включена), или импортировать из vitest:

import { vi } from 'vitest';

vi.advanceTimersByTime

Тип: (ms: number) => Vitest
Работает аналогично runAllTimers, но останавливается по истечении указанного времени в миллисекундах. Например, следующий код выведет в консоль 1, 2, 3 без ошибок:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersByTime(150);
```

vi.advanceTimersByTimeAsync

Тип: (ms: number) => Promise<Vitest>
Работает аналогично runAllTimersAsync, но останавливается по истечении указанного времени в миллисекундах. Это также учитывает таймеры, установленные асинхронно. Например, следующий код выведет в консоль 1, 2, 3 без ошибок:
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

await vi.advanceTimersByTimeAsync(150);
```

vi.advanceTimersToNextTimer

Тип: () => Vitest
Вызывает следующий доступный таймер. Полезно для проверки условий между вызовами таймеров. Рекомендуется вызывать его по цепочке для более точного управления таймерами.
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersToNextTimer() // log 1
  .advanceTimersToNextTimer() // log 2
  .advanceTimersToNextTimer(); // log 3
```

vi.advanceTimersToNextTimerAsync

Тип: () => Promise<Vitest>
Вызывает следующий доступный таймер, даже если он был установлен асинхронно. Полезно для проверки условий между вызовами таймеров. Рекомендуется вызывать его по цепочке для более точного управления таймерами.
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

vi.advanceTimersToNextTimerAsync() // log 1
  .advanceTimersToNextTimerAsync() // log 2
  .advanceTimersToNextTimerAsync(); // log 3
```

vi.getTimerCount

Тип: () => number
Возвращает количество ожидающих выполнения таймеров.

vi.clearAllMocks

Вызывает .mockClear() для всех моков. Это очищает историю мокирования, но не восстанавливает исходную реализацию.

vi.clearAllTimers

Удаляет все таймеры, запланированные для запуска. Эти таймеры не будут запущены.

vi.dynamicImportSettled

Ожидает завершения загрузки всех динамических импортов. Рекомендуется использовать, если у вас есть синхронный вызов, который инициирует импорт модуля, и ожидание его завершения другими способами невозможно.

vi.fn

Тип: (fn?: Function) => Mock
Создает мок для функции, который может быть создан как с функцией, так и без нее. Каждый раз, когда функция вызывается, она сохраняет свои аргументы, возвращаемые значения и экземпляры. Для изменения поведения мока рекомендуется использовать методы. Если функция не указана, мок возвращает undefined при вызове.
ts
```
const getApples = vi.fn(() => 0);

getApples();

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

getApples.mockReturnValueOnce(5);

const res = getApples();
expect(res).toBe(5);
expect(getApples).toHaveNthReturnedWith(2, 5);
```

vi.getMockedSystemTime

Тип: () => Date | null
Возвращает текущее моковое время, установленное с помощью setSystemTime. Если время не замокано, возвращает null.

vi.getRealSystemTime

Тип: () => number
При использовании vi.useFakeTimers вызовы Date.now мокируются. Если вам необходимо получить реальное время в миллисекундах, используйте эту функцию.

vi.hoisted

Тип: <T>(factory: () => T) => T
Версия: Since Vitest 0.31.0
Все статические операторы import в ES-модулях перемещаются в начало файла, поэтому любой код, определенный до импортов, фактически будет выполнен после вычисления импортов.
Однако может потребоваться выполнить некоторый побочный эффект, например, замокать даты перед импортом модуля.
Чтобы обойти это ограничение, рекомендуется преобразовать статические импорты в динамические, например:
diff
```
callFunctionWithSideEffect()
- import { value } from './some/module.ts'
+ const { value } = await import('./some/module.ts')
```
При запуске vitest рекомендуется сделать это автоматически, используя метод vi.hoisted.
diff
```
- callFunctionWithSideEffect()
import { value } from './some/module.ts'
+ vi.hoisted(() => callFunctionWithSideEffect())
```
Этот метод возвращает значение, возвращенное из фабрики. Рекомендуется использовать это значение в ваших фабриках vi.mock, если вам нужен легкий доступ к локально определенным переменным:
ts
```
import { expect, vi } from 'vitest';
import { originalMethod } from './path/to/module.js';

const { mockedMethod } = vi.hoisted(() => {
  return { mockedMethod: vi.fn() };
});

vi.mock('./path/to/module.js', () => {
  return { originalMethod: mockedMethod };
});

mockedMethod.mockReturnValue(100);
expect(originalMethod()).toBe(100);
```

vi.mock

Тип: (path: string, factory?: () => unknown) => void
Заменяет все импортированные модули из указанного path другим модулем. Рекомендуется использовать настроенные алиасы Vite в пути. Вызов vi.mock перемещается вверх, поэтому не имеет значения, где вы его вызываете. Он всегда будет выполнен перед всеми импортами. Если вам нужно сослаться на переменные вне его области видимости, рекомендуется определить их внутри vi.hoisted и сослаться на них внутри vi.mock.
WARNING
vi.mock работает только для модулей, импортированных с помощью ключевого слова import. Он не работает с require.
Vitest статически анализирует ваши файлы, чтобы переместить vi.mock вверх. Это означает, что вы не можете использовать vi, который не был импортирован непосредственно из пакета vitest (например, из какого-либо служебного файла). Чтобы исправить это, всегда используйте vi.mock с vi, импортированным из vitest, или включите параметр конфигурации globals.
WARNING
Мокирование модулей в настоящее время не поддерживается в режиме браузера. Вы можете отслеживать эту функцию в GitHub issue.
Если factory определен, все импорты вернут его результат. Vitest вызывает фабрику только один раз и кэширует результат для всех последующих импортов до тех пор, пока не будет вызван vi.unmock или vi.doUnmock.
В отличие от jest, фабрика может быть асинхронной, поэтому рекомендуется использовать vi.importActual или хелпер, полученный в качестве первого аргумента, внутри, чтобы получить исходный модуль.
ts
```
vi.mock('./path/to/module.js', async importOriginal => {
  const mod = await importOriginal();
  return {
    ...mod,
    // replace some exports
    namedExport: vi.fn(),
  };
});
```
WARNING
vi.mock перемещается вверх (другими словами, поднимается) в начало файла. Это означает, что где бы вы его ни написали (будь то внутри beforeEach или test), он фактически будет вызван раньше.
Это также означает, что вы не можете использовать какие-либо переменные внутри фабрики, которые определены вне фабрики.
Если вам нужно использовать переменные внутри фабрики, попробуйте vi.doMock. Он работает так же, но не перемещается вверх. Имейте в виду, что он мокает только последующие импорты.
Вы также можете ссылаться на переменные, определенные методом vi.hoisted, если он был объявлен до vi.mock:
ts
```
import { namedExport } from './path/to/module.js';

const mocks = vi.hoisted(() => {
  return {
    namedExport: vi.fn(),
  };
});

vi.mock('./path/to/module.js', () => {
  return {
    namedExport: mocks.namedExport,
  };
});

vi.mocked(namedExport).mockReturnValue(100);

expect(namedExport()).toBe(100);
expect(namedExport).toBe(mocks.namedExport);
```
WARNING
Если вы мокаете модуль с экспортом по умолчанию (default export), вам нужно будет предоставить ключ default внутри возвращаемого объекта фабричной функции. Это особенность ES-модулей, в отличие от jest, который использует модули CommonJS. Например,
ts
```
vi.mock('./path/to/module.js', () => {
  return {
    default: { myDefaultKey: vi.fn() },
    namedExport: vi.fn(),
    // etc...
  };
});
```
Если рядом с файлом, который вы мокаете, есть папка __mocks__, и фабрика не предоставлена, Vitest попытается найти соответствующий файл в папке __mocks__ и использует его как модуль. Если вы мокаете зависимость, Vitest попытается найти папку __mocks__ в корне проекта (по умолчанию process.cwd()). Вы можете указать Vitest, где находятся зависимости, с помощью параметра конфигурации deps.moduleDirectories.
Например, у вас есть следующая структура файлов:
```
- __mocks__
  - axios.js
- src
  __mocks__
    - increment.js
  - increment.js
- tests
  - increment.test.js
```
Если вы вызываете vi.mock в тестовом файле без предоставленной фабрики, он найдет файл в папке __mocks__, который будет использоваться в качестве модуля:
ts
```
// increment.test.js
import { vi } from 'vitest';

// axios is a default export from `__mocks__/axios.js`
import axios from 'axios';

// increment is a named export from `src/__mocks__/increment.js`
import { increment } from '../increment.js';

vi.mock('axios');
vi.mock('../increment.js');

axios.get(`/apples/${increment(1)}`);
```
WARNING
Имейте в виду, что если вы не вызываете vi.mock, модули не заменяются моками автоматически. Чтобы воспроизвести поведение automocking в Jest, рекомендуется вызвать vi.mock для каждого необходимого модуля внутри setupFiles.
Если нет папки __mocks__ или предоставленной фабрики, Vitest импортирует исходный модуль и автоматически мокает все его экспорты. Правила, которые применяются, см. в алгоритме.

vi.doMock

Тип: (path: string, factory?: () => unknown) => void
То же самое, что и vi.mock, но он не перемещается вверх в начало файла, поэтому вы можете ссылаться на переменные в глобальной области файла. Следующий динамический импорт модуля будет замокан. Это не будет заменять моками модули, которые были импортированы до этого вызова.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { beforeEach, test } from 'vitest';
import { increment } from './increment.js';

// the module is not mocked, because vi.doMock is not called yet
increment(1) === 2;

let mockedIncrement = 100;

beforeEach(() => {
  // you can access variables inside a factory
  vi.doMock('./increment.js', () => ({ increment: () => ++mockedIncrement }));
});

test('importing the next module imports mocked one', async () => {
  // original import WAS NOT MOCKED, because vi.doMock is evaluated AFTER imports
  expect(increment(1)).toBe(2);
  const { increment: mockedIncrement } = await import('./increment.js');
  // new dynamic import returns mocked module
  expect(mockedIncrement(1)).toBe(101);
  expect(mockedIncrement(1)).toBe(102);
  expect(mockedIncrement(1)).toBe(103);
});

vi.mocked

Тип: <T>(obj: T, deep?: boolean) => MaybeMockedDeep<T>
Тип: <T>(obj: T, options?: { partial?: boolean; deep?: boolean }) => MaybePartiallyMockedDeep<T>
Вспомогательный тип для TypeScript. Фактически просто возвращает переданный объект.
Когда partial имеет значение true, он ожидает Partial<T> в качестве возвращаемого значения.
ts
```
import example from './example.js';

vi.mock('./example.js');

test('1+1 equals 2', async () => {
  vi.mocked(example.calc).mockRestore();

  const res = example.calc(1, '+', 1);

  expect(res).toBe(2);
});
```

vi.importActual

Тип: <T>(path: string) => Promise<T>
Импортирует модуль, игнорируя все проверки на необходимость мокирования. Может быть полезно, если вы хотите замокать модуль частично.
ts
```
vi.mock('./example.js', async () => {
  const axios = await vi.importActual('./example.js');

  return { ...axios, get: vi.fn() };
});
```

vi.importMock

Тип: <T>(path: string) => Promise<MaybeMockedDeep<T>>
Импортирует модуль со всеми его свойствами (включая вложенные свойства), замоканными. Следует тем же правилам, что и vi.mock. Правила, которые применяются, см. в алгоритме.

vi.resetAllMocks

Вызывает .mockReset() для всех моков. Это очищает историю мокирования и сбрасывает их реализацию на пустую функцию.

vi.resetConfig

Тип: RuntimeConfig
Если vi.setConfig был вызван ранее, это сбросит конфигурацию к исходному состоянию.

vi.resetModules

Тип: () => Vitest

Сбрасывает реестр модулей, очищая кэш всех модулей. Это позволяет переоценивать модули при повторном импорте. Импорты верхнего уровня остаются без изменений. Рекомендуется для изоляции модулей в случаях, когда локальное состояние вызывает конфликты между тестами.

import { vi } from 'vitest';

import { data } from './data.js'; // Will not get reevaluated beforeEach test

beforeEach(() => {
  vi.resetModules();
});

test('change state', async () => {
  const mod = await import('./some/path.js'); // Will get reevaluated
  mod.changeLocalState('new value');
  expect(mod.getLocalState()).toBe('new value');
});

test('module has old state', async () => {
  const mod = await import('./some/path.js'); // Will get reevaluated
  expect(mod.getLocalState()).toBe('old value');
});

WARNING

Не сбрасывает реестр моков. Чтобы очистить реестр моков, используйте vi.unmock или vi.doUnmock.

vi.restoreAllMocks

Вызывает .mockRestore() для всех моков. Это очищает историю мокирования и сбрасывает их реализацию к исходной.

vi.stubEnv

Тип: (name: string, value: string) => Vitest
Версия: Since Vitest 0.26.0
Позволяет изменить значение переменной окружения в process.env и import.meta.env. Рекомендуется восстановить его значение, вызвав vi.unstubAllEnvs.

import { vi } from 'vitest';

// `process.env.NODE_ENV` and `import.meta.env.NODE_ENV`
// are "development" before calling "vi.stubEnv"

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';
// doesn't change other envs
import.meta.env.MODE === 'development';

TIP

Значение можно изменить и прямым присваиванием, но вы не сможете использовать vi.unstubAllEnvs для восстановления предыдущего значения:

import.meta.env.MODE = 'test';

vi.unstubAllEnvs

Тип: () => Vitest
Версия: С Vitest 0.26.0
Восстанавливает исходные значения для import.meta.env и process.env, которые были изменены с помощью vi.stubEnv. Vitest сохраняет исходное значение при первом вызове vi.stubEnv и использует его для восстановления до тех пор, пока не будет вызван vi.unstubAllEnvs.

import { vi } from 'vitest';

// Изначально `process.env.NODE_ENV` и `import.meta.env.NODE_ENV`
// имеют значение "development"

vi.stubEnv('NODE_ENV', 'production');

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';

vi.stubEnv('NODE_ENV', 'staging');

process.env.NODE_ENV === 'staging';
import.meta.env.NODE_ENV === 'staging';

vi.unstubAllEnvs();

// Восстанавливает значение, сохраненное до первого вызова "stubEnv"
process.env.NODE_ENV === 'development';
import.meta.env.NODE_ENV === 'development';

vi.stubGlobal

Тип: (name: string | number | symbol, value: unknown) => Vitest
Изменяет значение глобальной переменной на указанное. Исходное значение можно восстановить, вызвав vi.unstubAllGlobals.

import { vi } from 'vitest';

// Изначально `innerWidth` имеет значение "0"

vi.stubGlobal('innerWidth', 100);

innerWidth === 100;
globalThis.innerWidth === 100;
// если вы используете jsdom или happy-dom
window.innerWidth === 100;

TIP

Вы также можете изменить значение, просто присвоив его globalThis или window (если вы используете окружение jsdom или happy-dom), но в этом случае vi.unstubAllGlobals не сможет восстановить исходное значение:

globalThis.innerWidth = 100;
// если вы используете jsdom или happy-dom
window.innerWidth = 100;

vi.unstubAllGlobals

Тип: () => Vitest
Версия: С Vitest 0.26.0
Восстанавливает исходные значения всех глобальных переменных в globalThis/global (и window/top/self/parent, если вы используете окружение jsdom или happy-dom), которые были изменены с помощью vi.stubGlobal. Vitest сохраняет исходное значение при первом вызове vi.stubGlobal и использует его для восстановления до тех пор, пока не будет вызван vi.unstubAllGlobals.

import { vi } from 'vitest';

const Mock = vi.fn();

// Изначально IntersectionObserver имеет значение "undefined"

vi.stubGlobal('IntersectionObserver', Mock);

IntersectionObserver === Mock;
global.IntersectionObserver === Mock;
globalThis.IntersectionObserver === Mock;
// если вы используете jsdom или happy-dom
window.IntersectionObserver === Mock;

vi.unstubAllGlobals();

globalThis.IntersectionObserver === undefined;
'IntersectionObserver' in globalThis === false;
// выдает ReferenceError, потому что он не определен
IntersectionObserver === undefined;

vi.runAllTicks

Тип: () => Vitest
Выполняет все микрозадачи, поставленные в очередь с помощью process.nextTick. Это также запустит все микрозадачи, запланированные этими микрозадачами.

vi.runAllTimers

Тип: () => Vitest
Вызывает все установленные таймеры до тех пор, пока очередь таймеров не станет пустой. Это означает, что каждый таймер, вызванный во время runAllTimers, будет запущен. Если у вас есть бесконечный интервал, будет выдана ошибка после 10 000 попыток. Например, следующий код выведет в консоль 1, 2, 3:
ts
```
let i = 0;
setTimeout(() => console.log(++i));
const interval = setInterval(() => {
  console.log(++i);
  if (i === 3) clearInterval(interval);
}, 50);

vi.runAllTimers();
```

vi.runAllTimersAsync

Тип: () => Promise<Vitest>
Асинхронно вызывает все установленные таймеры до тех пор, пока очередь таймеров не станет пустой. Это означает, что каждый таймер, вызванный во время runAllTimersAsync, будет запущен, даже асинхронные таймеры. Если у вас есть бесконечный интервал, будет выдана ошибка после 10 000 попыток. Например, следующий код выведет в консоль result:
ts
```
setTimeout(async () => {
  console.log(await Promise.resolve('result'));
}, 100);

await vi.runAllTimersAsync();
```

vi.runOnlyPendingTimers

Тип: () => Vitest
Вызывает только те таймеры, которые были инициированы после вызова vi.useFakeTimers(). Он не вызывает таймеры, которые были инициированы во время его вызова. Например, следующий код выведет в консоль только 1:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.runOnlyPendingTimers();
```

vi.runOnlyPendingTimersAsync

Тип: () => Promise<Vitest>
Асинхронно вызывает только те таймеры, которые были инициированы после вызова vi.useFakeTimers(), включая асинхронные. Он не запустит таймеры, которые были инициированы во время его вызова. Например, следующий код выведет в консоль 2, 3, 3, 1:
ts
```
setTimeout(() => {
  console.log(1);
}, 100);
setTimeout(() => {
  Promise.resolve().then(() => {
    console.log(2);
    setInterval(() => {
      console.log(3);
    }, 40);
  });
}, 10);

await vi.runOnlyPendingTimersAsync();
```

vi.setSystemTime

Тип: (date: string | number | Date) => void
Устанавливает текущее системное время в соответствии с переданным значением. Все вызовы Date будут возвращать это время.
Полезно, если вам нужно протестировать код, зависящий от текущей даты, например, вызовы luxon.
ts
```
const date = new Date(1998, 11, 19);

vi.useFakeTimers();
vi.setSystemTime(date);

expect(Date.now()).toBe(date.valueOf());

vi.useRealTimers();
```

vi.setConfig

Тип: RuntimeConfig
Обновляет конфигурацию для текущего тестового файла. Вы можете изменить только те значения, которые используются при выполнении тестов.

vi.spyOn

Тип: <T, K extends keyof T>(object: T, method: K, accessType?: 'get' | 'set') => MockInstance

Создает перехватчик (spy) для метода или геттера/сеттера объекта.

let apples = 0;
const cart = {
  getApples: () => 13,
};

const spy = vi.spyOn(cart, 'getApples').mockImplementation(() => apples);
apples = 1;

expect(cart.getApples()).toBe(1);

expect(spy).toHaveBeenCalled();
expect(spy).toHaveReturnedWith(1);

vi.stubGlobal

Тип: (key: keyof globalThis & Window, value: any) => Vitest
Устанавливает значение глобальной переменной. Если вы используете jsdom или happy-dom, значение также устанавливается в объект window.
Подробнее в разделе "Mocking Globals".

vi.unmock

Тип: (path: string) => void
Удаляет модуль из списка замокированных. Все вызовы import будут возвращать исходный модуль, даже если он был замокирован ранее. Этот вызов поднимается (hoisted) в начало файла, поэтому он размокирует только модули, которые были определены в setupFiles, например.

vi.doUnmock

Тип: (path: string) => void
То же самое, что и vi.unmock, но не поднимается (hoisted) в начало файла. Следующий импорт модуля импортирует исходный модуль вместо мока. Это не размокирует модули, которые были импортированы ранее.

// ./increment.js
export function increment(number) {
  return number + 1;
}

import { increment } from './increment.js';

// increment уже замокирован, потому что vi.mock поднят (hoisted)
increment(1) === 100;

// это поднято (hoisted), и фабрика вызывается до импорта в строке 1
vi.mock('./increment.js', () => ({ increment: () => 100 }));

// все вызовы замокированы, и `increment` всегда возвращает 100
increment(1) === 100;
increment(30) === 100;

// это не поднимается (hoisted), поэтому следующий импорт вернет немокированный модуль
vi.doUnmock('./increment.js');

// это ВСЕ ЕЩЕ возвращает 100, потому что `vi.doUnmock` не переоценивает модуль
increment(1) === 100;
increment(30) === 100;

// следующий импорт не замокирован, теперь `increment` - это исходная функция, которая возвращает count + 1
const { increment: unmockedIncrement } = await import('./increment.js');

unmockedIncrement(1) === 2;
unmockedIncrement(30) === 31;

vi.useFakeTimers

Тип: () => Vitest
Включает мокирование таймеров. Этот метод заменяет все дальнейшие вызовы таймеров (такие как setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate, clearImmediate и Date) моками, пока не будет вызван vi.useRealTimers().
Мокирование nextTick не поддерживается при запуске Vitest внутри node:child_process с использованием --no-threads. NodeJS использует process.nextTick внутри node:child_process и зависает, когда он замокирован. Мокирование nextTick поддерживается при запуске Vitest с --threads.
Реализация основана на @sinonjs/fake-timers.
TIP
Начиная с версии 0.35.0, vi.useFakeTimers() больше не мокирует автоматически process.nextTick. Его все еще можно замокировать, указав опцию в аргументе toFake: vi.useFakeTimers({ toFake: ['nextTick'] }).

vi.isFakeTimers

Тип: () => boolean
Версия: С Vitest 0.34.5
Возвращает true, если включено использование фейковых таймеров.

vi.useRealTimers

Тип: () => Vitest
Возвращает мокированные таймеры к их исходным реализациям. Все таймеры, которые были запущены ранее, не будут восстановлены.

vi.waitFor

Тип: <T>(callback: WaitForCallback<T>, options?: number | WaitForOptions) => Promise<T>
Версия: С Vitest 0.34.5

Ожидает успешного завершения обратного вызова. Если обратный вызов выдает ошибку или возвращает отклоненный промис, функция будет продолжать ждать, пока не завершится успешно или не истечет время ожидания.

Это очень полезно, когда вам нужно дождаться завершения некоторого асинхронного действия, например, когда вы запускаете сервер и вам нужно дождаться его запуска.

import { expect, test, vi } from 'vitest';
import { createServer } from './server.js';

test('Server started successfully', async () => {
  const server = createServer();

  await vi.waitFor(
    () => {
      if (!server.isReady) throw new Error('Server not started');

      console.log('Server started');
    },
    {
      timeout: 500, // default is 1000
      interval: 20, // default is 50
    }
  );
  expect(server.isReady).toBe(true);
});

Это также работает для асинхронных обратных вызовов

// @vitest-environment jsdom

import { expect, test, vi } from 'vitest';
import { getDOMElementAsync, populateDOMAsync } from './dom.js';

test('Element exists in a DOM', async () => {
  // start populating DOM
  populateDOMAsync();

  const element = await vi.waitFor(
    async () => {
      // try to get the element until it exists
      const element = (await getDOMElementAsync()) as HTMLElement | null;
      expect(element).toBeTruthy();
      expect(element.dataset.initialized).toBeTruthy();
      return element;
    },
    {
      timeout: 500, // default is 1000
      interval: 20, // default is 50
    }
  );
  expect(element).toBeInstanceOf(HTMLElement);
});

Если используется vi.useFakeTimers, vi.waitFor автоматически вызывает vi.advanceTimersByTime(interval) в каждом обратном вызове проверки.

vi.waitUntil

Тип: <T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions) => Promise<T>
Версия: С Vitest 0.34.5

Функция аналогична vi.waitFor, но если обратный вызов выдает ошибку, выполнение немедленно прерывается и возвращается сообщение об ошибке. Если обратный вызов возвращает ложное значение, следующая проверка будет продолжаться до тех пор, пока не будет возвращено истинное значение. Это полезно, когда вам нужно дождаться, пока что-то появится, прежде чем предпринимать следующий шаг.

Посмотрите на пример ниже. Мы можем использовать vi.waitUntil, чтобы дождаться появления элемента на странице, а затем мы можем что-то сделать с элементом.

import { expect, test, vi } from 'vitest';

test('Element render correctly', async () => {
  const element = await vi.waitUntil(() => document.querySelector('.element'), {
    timeout: 500, // default is 1000
    interval: 20, // default is 50
  });

  // do something with the element
  expect(element.querySelector('.element-child')).toBeTruthy();
});

Vi ​

vi.advanceTimersByTime ​

vi.advanceTimersByTimeAsync ​

vi.advanceTimersToNextTimer ​

vi.advanceTimersToNextTimerAsync ​

vi.getTimerCount ​

vi.clearAllMocks ​

vi.clearAllTimers ​

vi.dynamicImportSettled ​

vi.fn ​

vi.getMockedSystemTime ​

vi.getRealSystemTime ​

vi.hoisted ​

vi.mock ​

vi.doMock ​

vi.mocked ​

vi.importActual ​

vi.importMock ​

vi.resetAllMocks ​

vi.resetConfig ​

vi.resetModules ​

vi.restoreAllMocks ​

vi.stubEnv ​

vi.unstubAllEnvs ​

vi.stubGlobal ​

vi.unstubAllGlobals ​

vi.runAllTicks ​

vi.runAllTimers ​

vi.runAllTimersAsync ​

vi.runOnlyPendingTimers ​

vi.runOnlyPendingTimersAsync ​

vi.setSystemTime ​

vi.setConfig ​

vi.spyOn ​

vi.stubGlobal ​

vi.unmock ​

vi.doUnmock ​

vi.useFakeTimers ​

vi.isFakeTimers ​

vi.useRealTimers ​

vi.waitFor ​

vi.waitUntil ​

Vi

vi.advanceTimersByTime

vi.advanceTimersByTimeAsync

vi.advanceTimersToNextTimer

vi.advanceTimersToNextTimerAsync

vi.getTimerCount

vi.clearAllMocks

vi.clearAllTimers

vi.dynamicImportSettled

vi.fn

vi.getMockedSystemTime

vi.getRealSystemTime

vi.hoisted

vi.mock

vi.doMock

vi.mocked

vi.importActual

vi.importMock

vi.resetAllMocks

vi.resetConfig

vi.resetModules

vi.restoreAllMocks

vi.stubEnv

vi.unstubAllEnvs

vi.stubGlobal

vi.unstubAllGlobals

vi.runAllTicks

vi.runAllTimers

vi.runAllTimersAsync

vi.runOnlyPendingTimers

vi.runOnlyPendingTimersAsync

vi.setSystemTime

vi.setConfig

vi.spyOn

vi.stubGlobal

vi.unmock

vi.doUnmock

vi.useFakeTimers

vi.isFakeTimers

vi.useRealTimers

vi.waitFor

vi.waitUntil