Vi

Vitest proporciona funciones de utilidad a través de su asistente vi. Puedes acceder a él globalmente (cuando la configuración de globales está activada), o importarlo desde vitest:

import { vi } from 'vitest';

vi.advanceTimersByTime

Tipo: (ms: number) => Vitest
Funciona de la misma manera que runAllTimers, pero se detendrá después de los milisegundos especificados. Por ejemplo, esto imprimirá 1, 2, 3 sin lanzar un error:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.advanceTimersByTime(150);
```

vi.advanceTimersByTimeAsync

Tipo: (ms: number) => Promise<Vitest>
Funciona de la misma manera que runAllTimersAsync, pero se detendrá después de los milisegundos especificados. Esto incluirá los temporizadores establecidos asíncronamente. Por ejemplo, esto imprimirá 1, 2, 3 sin lanzar un error:
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

await vi.advanceTimersByTimeAsync(150);
```

vi.advanceTimersToNextTimer

Tipo: () => Vitest
Ejecutará el siguiente temporizador disponible. Útil para realizar aserciones entre cada llamada al temporizador. Puedes encadenar la llamada para gestionar los temporizadores manualmente.
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

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

vi.advanceTimersToNextTimerAsync

Tipo: () => Promise<Vitest>
Ejecutará el siguiente temporizador disponible, incluso si se estableció asíncronamente. Útil para realizar aserciones entre cada llamada al temporizador. Puedes encadenar la llamada para gestionar los temporizadores manualmente.
ts
```
let i = 0;
setInterval(() => Promise.resolve().then(() => console.log(++i)), 50);

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

vi.getTimerCount

Tipo: () => number
Devuelve el número de temporizadores pendientes.

vi.clearAllMocks

Llamará a .mockClear() en todas las funciones espía. Esto borrará el historial de mocks, pero no restablecerá su implementación a la predeterminada.

vi.clearAllTimers

Elimina todos los temporizadores que están programados para ejecutarse. Estos temporizadores no se ejecutarán.

vi.dynamicImportSettled

Espera a que se completen todas las importaciones dinámicas. Útil si tienes una llamada síncrona que inicia la importación de un módulo y necesitas esperar a que se complete.

vi.fn

Tipo: (fn?: Function) => Mock
Crea una función espía (mock) a partir de una función, aunque se puede iniciar sin una. Cada vez que se invoca la función, almacena sus argumentos, valores de retorno e instancias. Además, puedes manipular su comportamiento con métodos. Si no se proporciona ninguna función, la función simulada devolverá undefined cuando se invoque.
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

Tipo: () => Date | null
Devuelve la fecha actual simulada que se estableció usando setSystemTime. Si la fecha no está simulada, devolverá null.

vi.getRealSystemTime

Tipo: () => number
Cuando se usa vi.useFakeTimers, las llamadas a Date.now son simuladas. Si necesitas obtener la hora real en milisegundos, puedes llamar a esta función.

vi.hoisted

Tipo: <T>(factory: () => T) => T
Versión: Desde Vitest 0.31.0
Todas las declaraciones import estáticas en los módulos ES se elevan (hoisting) a la parte superior del archivo, por lo que cualquier código que se defina antes de las importaciones se ejecutará realmente después de que se evalúen las importaciones.
Sin embargo, puede ser útil invocar algún efecto secundario, como simular fechas, antes de importar un módulo.
Para evitar esta limitación, puedes reescribir las importaciones estáticas en dinámicas de esta manera:
diff
```
callFunctionWithSideEffect()
- import { value } from './some/module.ts'
+ const { value } = await import('./some/module.ts')
```
Cuando se ejecuta vitest, puedes hacer esto automáticamente usando el método vi.hoisted.
diff
```
- callFunctionWithSideEffect()
import { value } from './some/module.ts'
+ vi.hoisted(() => callFunctionWithSideEffect())
```
Este método devuelve el valor que se devolvió de la función fábrica. Puedes usar ese valor en tus fábricas vi.mock si necesitas un acceso fácil a las variables definidas localmente:
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

Tipo: (path: string, factory?: () => unknown) => void
Reemplaza todos los módulos importados desde la ruta proporcionada con otro módulo. Puedes usar alias de Vite configurados dentro de una ruta. La llamada a vi.mock se mueve al inicio, por lo que no importa dónde la llames. Siempre se ejecutará antes de todas las importaciones. Si necesitas hacer referencia a algunas variables fuera de su alcance, puedes definirlas dentro de vi.hoisted y hacer referencia a ellas dentro de vi.mock.
WARNING
vi.mock solo funciona para módulos que se importaron con la palabra clave import. No funciona con require.
Vitest analiza estáticamente tus archivos para elevar (hoist) vi.mock. Esto significa que no puedes usar vi que no se importó directamente desde el paquete vitest (por ejemplo, desde algún archivo de utilidad). Para solucionar esto, siempre usa vi.mock con vi importado desde vitest, o habilita la opción de configuración globals.
WARNING
La simulación de módulos (Mocking modules) no es compatible actualmente en el modo navegador. Puedes seguir esta función en el issue de GitHub.
Si se define factory, todas las importaciones devolverán su resultado. Vitest llama a la función fábrica solo una vez y almacena en caché el resultado para todas las importaciones posteriores hasta que se llama a vi.unmock o vi.doUnmock.
A diferencia de jest, la fábrica puede ser asíncrona, por lo que puedes usar vi.importActual o un helper, recibido como primer argumento, dentro para obtener el módulo original.
ts
```
vi.mock('./path/to/module.js', async importOriginal => {
  const mod = await importOriginal();
  return {
    ...mod,
    // reemplazar algunas exportaciones
    namedExport: vi.fn(),
  };
});
```
WARNING
vi.mock se mueve al inicio (en otras palabras, se eleva) a la parte superior del archivo. Esto significa que siempre que lo escribas (ya sea dentro de beforeEach o test), en realidad se llamará antes de eso.
Esto también significa que no puedes usar ninguna variable dentro de la fábrica que se defina fuera de la fábrica.
Si necesitas usar variables dentro de la fábrica, prueba vi.doMock. Funciona de la misma manera, pero no se eleva (hoisted). Ten en cuenta que solo simula las importaciones posteriores.
También puedes hacer referencia a las variables definidas por el método vi.hoisted si se declaró antes de 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
Si estás simulando un módulo con exportación predeterminada, deberás proporcionar una clave default dentro del objeto de la función fábrica devuelto. Esta es una advertencia específica de los módulos ES, por lo tanto, la documentación de jest puede diferir ya que jest usa módulos CommonJS. Por ejemplo,
ts
```
vi.mock('./path/to/module.js', () => {
  return {
    default: { myDefaultKey: vi.fn() },
    namedExport: vi.fn(),
    // etc...
  };
});
```
Si hay una carpeta __mocks__ junto a un archivo que estás simulando, y no se proporciona la función fábrica, Vitest intentará encontrar un archivo con el mismo nombre en la subcarpeta __mocks__ y lo usará como un módulo real. Si estás simulando una dependencia, Vitest intentará encontrar una carpeta __mocks__ en la raíz del proyecto (el valor predeterminado es process.cwd()). Puedes indicarle a Vitest dónde se encuentran las dependencias a través de la opción de configuración deps.moduleDirectories.
Por ejemplo, tienes esta estructura de archivos:
```
- __mocks__
  - axios.js
- src
  __mocks__
    - increment.js
  - increment.js
- tests
  - increment.test.js
```
Si llamas a vi.mock en un archivo de prueba sin proporcionar una función fábrica, encontrará un archivo en la carpeta __mocks__ para usarlo como módulo:
ts
```
// increment.test.js
import { vi } from 'vitest';

// axios es una exportación predeterminada de `__mocks__/axios.js`
import axios from 'axios';

// increment es una exportación con nombre de `src/__mocks__/increment.js`
import { increment } from '../increment.js';

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

axios.get(`/apples/${increment(1)}`);
```
WARNING
Ten en cuenta que si no llamas a vi.mock, los módulos no se simulan automáticamente. Para replicar el comportamiento de simulación automática de Jest, puedes llamar a vi.mock para cada módulo requerido dentro de setupFiles.
Si no hay una carpeta __mocks__ o una función fábrica proporcionada, Vitest importará el módulo original y simulará automáticamente todas sus exportaciones. Para conocer las reglas aplicadas, consulta algoritmo.

vi.doMock

Tipo: (path: string, factory?: () => unknown) => void
Lo mismo que vi.mock, pero no se eleva al inicio en la parte superior del archivo, por lo que puedes hacer referencia a variables en el ámbito del archivo global. La siguiente importación dinámica del módulo se simulará. Esto no simulará los módulos que fueron importados antes de llamar a esta función.

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

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

// el módulo no está simulado, porque vi.doMock aún no se ha llamado
increment(1) === 2;

let mockedIncrement = 100;

beforeEach(() => {
  // puedes acceder a las variables dentro de una función fábrica
  vi.doMock('./increment.js', () => ({ increment: () => ++mockedIncrement }));
});

test('importar el siguiente módulo importa el simulado', async () => {
  // la importación original NO FUE SIMULADA, porque vi.doMock se evalúa DESPUÉS de las importaciones
  expect(increment(1)).toBe(2);
  const { increment: mockedIncrement } = await import('./increment.js');
  // la nueva importación dinámica devuelve el módulo simulado
  expect(mockedIncrement(1)).toBe(101);
  expect(mockedIncrement(1)).toBe(102);
  expect(mockedIncrement(1)).toBe(103);
});

vi.mocked

Tipo: <T>(obj: T, deep?: boolean) => MaybeMockedDeep<T>
Tipo: <T>(obj: T, options?: { partial?: boolean; deep?: boolean }) => MaybePartiallyMockedDeep<T>
Utilidad de tipo para TypeScript. En realidad, solo devuelve el objeto que se pasó.
Cuando partial es true, esperará un Partial<T> como valor de retorno.
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

Tipo: <T>(path: string) => Promise<T>
Importa el módulo, omitiendo todas las comprobaciones sobre si debe simularse. Puede ser útil si deseas simular el módulo parcialmente.
ts
```
vi.mock('./example.js', async () => {
  const axios = await vi.importActual('./example.js');

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

vi.importMock

Tipo: <T>(path: string) => Promise<MaybeMockedDeep<T>>
Importa un módulo con todas sus propiedades (incluidas las propiedades anidadas) simuladas. Sigue las mismas reglas que sigue vi.mock. Para conocer las reglas aplicadas, consulta algoritmo.

vi.resetAllMocks

Llamará a .mockReset() en todas las funciones espía. Esto borrará el historial de mocks y restablecerá su implementación a una función vacía (devolverá undefined).

vi.resetConfig

Tipo: RuntimeConfig
Si se llamó a vi.setConfig antes, esto restaurará la configuración al estado original.

vi.resetModules

Tipo: () => Vitest

Restablece el registro de módulos borrando la caché de todos los módulos. Esto permite que los módulos se reevalúen cuando se vuelven a importar. Las importaciones de nivel superior no se pueden volver a evaluar. Podría ser útil para aislar módulos donde el estado local entra en conflicto entre las pruebas.

import { vi } from 'vitest';

import { data } from './data.js'; // No se volverá a evaluar beforeEach test

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

test('cambiar estado', async () => {
  const mod = await import('./some/path.js'); // Se volverá a evaluar
  mod.changeLocalState('new value');
  expect(mod.getLocalState()).toBe('new value');
});

test('el módulo mantiene el estado anterior', async () => {
  const mod = await import('./some/path.js'); // Se volverá a evaluar
  expect(mod.getLocalState()).toBe('old value');
});

WARNING

No restablece el registro de mocks. Para borrar el registro de mocks, usa vi.unmock o vi.doUnmock.

vi.restoreAllMocks

Llamará a .mockRestore() en todas las funciones espía. Esto borrará el historial de mocks y restablecerá su implementación a la original.

vi.stubEnv

Tipo: (name: string, value: string) => Vitest
Versión: Desde Vitest 0.26.0
Cambia el valor de la variable de entorno en process.env e import.meta.env. Puedes restaurar su valor llamando a vi.unstubAllEnvs.

import { vi } from 'vitest';

// `process.env.NODE_ENV` e `import.meta.env.NODE_ENV`
// son "development" antes de llamar a "vi.stubEnv"

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

process.env.NODE_ENV === 'production';
import.meta.env.NODE_ENV === 'production';
// no afecta a otras variables de entorno
import.meta.env.MODE === 'development';

TIP

También puedes cambiar el valor simplemente asignándolo, pero no podrás usar vi.unstubAllEnvs para restaurar el valor anterior:

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

vi.unstubAllEnvs

Tipo: () => Vitest
Versión: Desde Vitest 0.26.0
Restaura todos los valores de import.meta.env y process.env que fueron modificados con vi.stubEnv. La primera vez que se invoca, Vitest guarda el valor original y lo restaura cuando se llama a unstubAllEnvs.

import { vi } from 'vitest';

// `process.env.NODE_ENV` e `import.meta.env.NODE_ENV`
// son "development" antes de llamar a stubEnv

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();

// restaura al valor que se guardó antes de la primera llamada a "stubEnv"
process.env.NODE_ENV === 'development';
import.meta.env.NODE_ENV === 'development';

vi.stubGlobal

Tipo: (name: string | number | symbol, value: unknown) => Vitest
Modifica el valor de una variable global existente. Puedes restaurar su valor original invocando vi.unstubAllGlobals.

import { vi } from 'vitest';

// `innerWidth` es "0" antes de llamar a stubGlobal

vi.stubGlobal('innerWidth', 100);

innerWidth === 100;
globalThis.innerWidth === 100;
// si estás usando jsdom o happy-dom
window.innerWidth === 100;

TIP

También puedes cambiar el valor asignándolo directamente a globalThis o window (si estás usando el entorno jsdom o happy-dom), pero no podrás usar vi.unstubAllGlobals para restaurar el valor original:

globalThis.innerWidth = 100;
// si estás usando jsdom o happy-dom
window.innerWidth = 100;

vi.unstubAllGlobals

Tipo: () => Vitest
Versión: Desde Vitest 0.26.0
Restaura todos los valores globales en globalThis/global (y window/top/self/parent, si estás usando el entorno jsdom o happy-dom) que fueron modificados con vi.stubGlobal. La primera vez que se invoca, Vitest guarda el valor original y lo restaura cuando se llama a unstubAllGlobals.

import { vi } from 'vitest';

const Mock = vi.fn();

// IntersectionObserver es "undefined" antes de llamar a "stubGlobal"

vi.stubGlobal('IntersectionObserver', Mock);

IntersectionObserver === Mock;
global.IntersectionObserver === Mock;
globalThis.IntersectionObserver === Mock;
// si estás usando jsdom o happy-dom
window.IntersectionObserver === Mock;

vi.unstubAllGlobals();

globalThis.IntersectionObserver === undefined;
'IntersectionObserver' in globalThis === false;
// lanza ReferenceError, porque no está definido
IntersectionObserver === undefined;

vi.runAllTicks

Tipo: () => Vitest
Ejecuta cada microtarea que fue encolada por process.nextTick. También ejecutará todas las microtareas que se hayan programado a sí mismas.

vi.runAllTimers

Tipo: () => Vitest
Este método ejecuta todos los temporizadores pendientes hasta que la cola esté vacía. Esto significa que todos los temporizadores programados durante la ejecución de runAllTimers se ejecutarán. Si tienes un intervalo infinito, se lanzará un error después de 10 000 intentos. Por ejemplo, esto imprimirá 1, 2, 3 en la consola:
ts
```
let i = 0;
setTimeout(() => console.log(++i));
const interval = setInterval(() => {
  console.log(++i);
  if (i === 3) clearInterval(interval);
}, 50);

vi.runAllTimers();
```

vi.runAllTimersAsync

Tipo: () => Promise<Vitest>
Este método invoca asíncronamente cada temporizador iniciado hasta que la cola de temporizadores esté vacía. Esto significa que cada temporizador invocado durante runAllTimersAsync se ejecutará, incluso los asíncronos. Si tienes un intervalo infinito, se lanzará un error después de 10 000 intentos. Por ejemplo, esto registrará result:
ts
```
setTimeout(async () => {
  console.log(await Promise.resolve('result'));
}, 100);

await vi.runAllTimersAsync();
```

vi.runOnlyPendingTimers

Tipo: () => Vitest
Este método invoca cada temporizador que se haya iniciado después de la llamada a vi.useFakeTimers(). No ejecutará ningún temporizador que se haya iniciado durante su invocación. Por ejemplo, esto solo registrará 1:
ts
```
let i = 0;
setInterval(() => console.log(++i), 50);

vi.runOnlyPendingTimers();
```

vi.runOnlyPendingTimersAsync

Tipo: () => Promise<Vitest>
Este método invoca asíncronamente cada temporizador que se haya iniciado después de la llamada a vi.useFakeTimers(), incluso los asíncronos. No ejecutará ningún temporizador que se haya iniciado durante su invocación. Por ejemplo, esto imprimirá 2, 3, 3, 1 en la consola:
ts
```
setTimeout(() => {
  console.log(1);
}, 100);
setTimeout(() => {
  Promise.resolve().then(() => {
    console.log(2);
    setInterval(() => {
      console.log(3);
    }, 40);
  });
}, 10);

await vi.runOnlyPendingTimersAsync();
```

vi.setSystemTime

Tipo: (date: string | number | Date) => void
Establece la fecha actual a la fecha proporcionada. Todas las llamadas a Date devolverán esta fecha.
Útil si necesitas probar algo que depende de la fecha actual, por ejemplo, las llamadas a luxon dentro de tu código.
ts
```
const date = new Date(1998, 11, 19);

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

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

vi.useRealTimers();
```

vi.setConfig

Tipo: RuntimeConfig
Actualiza la configuración para el archivo de prueba actual. Solo puedes modificar los valores que se utilizan al ejecutar las pruebas.

vi.spyOn

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

Crea un espía para un método o un getter/setter de un objeto.

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

Tipo: (key: keyof globalThis & Window, value: any) => Vitest
Asigna un valor a una variable global. Si estás usando jsdom o happy-dom, también asigna el valor al objeto window.
Lee más en la sección "Mocking Globals" (Simulación de Globales).

vi.unmock

Tipo: (path: string) => void
Elimina el módulo del registro de simulaciones. Todas las importaciones devolverán el módulo original, incluso si se simuló previamente. Esta llamada se eleva (mueve) a la parte superior del archivo, por lo que solo anulará la simulación de los módulos que se definieron en setupFiles, por ejemplo.

vi.doUnmock

Tipo: (path: string) => void
Similar a vi.unmock, pero no se eleva a la parte superior del archivo. La siguiente importación del módulo importará el módulo original en lugar del mock. Esto no anulará la simulación de los módulos importados previamente.

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

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

// increment ya está simulado, porque vi.mock se eleva
increment(1) === 100;

// esto se eleva, y la fábrica se llama antes de la importación en la línea 1
vi.mock('./increment.js', () => ({ increment: () => 100 }));

// todas las llamadas están simuladas, e `increment` siempre devuelve 100
increment(1) === 100;
increment(30) === 100;

// esto no se eleva, por lo que otra importación devolverá el módulo no simulado
vi.doUnmock('./increment.js');

// esto TODAVÍA devuelve 100, porque `vi.doUnmock` no vuelve a evaluar un módulo
increment(1) === 100;
increment(30) === 100;

// la siguiente importación no está simulada, ahora `increment` es la función original que devuelve count + 1
const { increment: unmockedIncrement } = await import('./increment.js');

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

vi.useFakeTimers

Tipo: () => Vitest
Para habilitar la simulación de temporizadores, debes invocar este método. Interceptará todas las llamadas posteriores a los temporizadores (como setTimeout, setInterval, clearTimeout, clearInterval, nextTick, setImmediate, clearImmediate y Date), hasta que se invoque vi.useRealTimers().
La simulación de nextTick no es compatible cuando se ejecuta Vitest dentro de node:child_process usando --no-threads. NodeJS usa process.nextTick internamente en node:child_process y se bloquea cuando se simula. La simulación de nextTick es compatible cuando se ejecuta Vitest con --threads.
La implementación se basa internamente en @sinonjs/fake-timers.
TIP
Desde la versión 0.35.0, vi.useFakeTimers() ya no simula automáticamente process.nextTick. Todavía se puede simular especificando la opción en el argumento toFake: vi.useFakeTimers({ toFake: ['nextTick'] }).

vi.isFakeTimers

Tipo: () => boolean
Versión: Desde Vitest 0.34.5
Devuelve true si los temporizadores simulados están habilitados.

vi.useRealTimers

Tipo: () => Vitest
Cuando se desactivan los temporizadores simulados, puedes invocar este método para restaurar los temporizadores simulados a sus implementaciones originales. Los temporizadores que se ejecutaron previamente no se restaurarán.

vi.waitFor

Tipo: <T>(callback: WaitForCallback<T>, options?: number | WaitForOptions) => Promise<T>
Versión: Desde Vitest 0.34.5

Espera a que la función de callback se ejecute correctamente. Si el callback devuelve un error o una promesa rechazada, continuará esperando hasta que tenga éxito o se agote el tiempo.

Esto es muy útil cuando necesitas esperar a que se complete una acción asíncrona. Por ejemplo, cuando inicias un servidor y necesitas esperar a que esté listo.

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, // el valor predeterminado es 1000
      interval: 20, // el valor predeterminado es 50
    }
  );
  expect(server.isReady).toBe(true);
});

También funciona para callbacks asíncronos

// @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, // el valor predeterminado es 1000
      interval: 20, // el valor predeterminado es 50
    }
  );
  expect(element).toBeInstanceOf(HTMLElement);
});

Si se usa vi.useFakeTimers, vi.waitFor llama automáticamente a vi.advanceTimersByTime(interval) en cada invocación del callback de verificación.

vi.waitUntil

Tipo: <T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions) => Promise<T>
Versión: Desde Vitest 0.34.5

Es similar a vi.waitFor, pero si el callback lanza un error, la ejecución se interrumpe de inmediato y se genera un error. Si la función callback devuelve un valor falso, la siguiente verificación continuará hasta que se devuelva un valor verdadero. Esto es útil cuando necesitas esperar a que algo exista antes de dar el siguiente paso.

Ver el siguiente ejemplo. Se puede usar vi.waitUntil para esperar la aparición del elemento en la página, y luego podemos hacer algo con el elemento.

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

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

  // hacer algo con el elemento
  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