Mocking

Tesztíráskor gyakran előfordul, hogy egy belső vagy külső szolgáltatás „hamisított” verzióját kell létrehozni. Ezt általában mockingnak nevezik. A Vitest a vi segítő objektumon keresztül biztosít segédfüggvényeket. A vi importálható a vitest csomagból, vagy elérhető globálisan (ha a globális konfiguráció engedélyezve van).

WARNING

Fontos, hogy a mockokat minden tesztfutás előtt vagy után törölje vagy állítsa vissza, hogy elkerülje a mock állapotának változását a futások között! További információért lásd a mockReset dokumentációját.

Ha azonnal bele szeretne merülni, nézze meg az API szekciót, különben olvasson tovább, hogy jobban megismerje a mocking világát.

Dátumok

Néha a tesztelés során ellenőrizni kell a dátumot a konzisztencia érdekében. A Vitest a @sinonjs/fake-timers csomagot használja az időzítők és a rendszerdátum manipulálására. Az API-ról részletesebben itt talál információt.

Példa

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

const businessHours = [9, 17];

function purchase() {
  const currentHour = new Date().getHours();
  const [open, close] = businessHours;

  if (currentHour > open && currentHour < close) {
    return { message: 'Success' };
  }

  return { message: 'Error' };
}

describe('purchasing flow', () => {
  beforeEach(() => {
    // tájékoztatjuk a Vitest-et, hogy mockolt időt használunk
    vi.useFakeTimers();
  });

  afterEach(() => {
    // a dátum visszaállítása minden tesztfutás után
    vi.useRealTimers();
  });

  it('allows purchases within business hours', () => {
    // munkaidőn belüli óra beállítása
    const date = new Date(2000, 1, 1, 13);
    vi.setSystemTime(date);

    // a Date.now() elérése a fent beállított dátumot eredményezi
    expect(purchase()).toEqual({ message: 'Success' });
  });

  it('disallows purchases outside of business hours', () => {
    // óra beállítása munkaidőn kívül
    const date = new Date(2000, 1, 1, 19);
    vi.setSystemTime(date);

    // a Date.now() elérése a fent beállított dátumot eredményezi
    expect(purchase()).toEqual({ message: 'Error' });
  });
});

Függvények

A függvények mockingja két különböző kategóriába sorolható: spying és mocking.

Néha csak azt kell ellenőriznie, hogy egy adott függvényt meghívtak-e (és esetleg milyen argumentumokat adtak át). Ezekben az esetekben egy kémfüggvény (spy function) lenne minden, amire szükségünk van, amelyet közvetlenül a vi.spyOn()-nal használhat (további információ itt).

A kémfüggvények azonban csak a függvényeket tudják megfigyelni, nem tudják megváltoztatni ezen függvények implementációját. Abban az esetben, ha egy függvény hamis (vagy mockolt) verzióját kell létrehoznunk, használhatjuk a vi.fn()-t (további információ itt).

A Tinyspy alapján mockoljuk a függvényeket, de van saját burkolónk, hogy jest kompatibilissé tegyük. Mind a vi.fn(), mind a vi.spyOn() ugyanazokat a metódusokat osztja meg, azonban csak a vi.fn() által visszaadott érték hívható meg.

Példa

import { afterEach, describe, expect, it, vi } from 'vitest';

const messages = {
  items: [
    { message: 'Simple test message', from: 'Testman' },
    // ...
  ],
  getLatest, // amennyiben támogatott, lehet getter vagy setter is
};

function getLatest(index = messages.items.length - 1) {
  return messages.items[index];
}

describe('reading messages', () => {
  afterEach(() => {
    vi.restoreAllMocks();
  });

  it('should get the latest message with a spy', () => {
    const spy = vi.spyOn(messages, 'getLatest');
    expect(spy.getMockName()).toEqual('getLatest');

    expect(messages.getLatest()).toEqual(
      messages.items[messages.items.length - 1]
    );

    expect(spy).toHaveBeenCalledTimes(1);

    spy.mockImplementationOnce(() => 'access-restricted');
    expect(messages.getLatest()).toEqual('access-restricted');

    expect(spy).toHaveBeenCalledTimes(2);
  });

  it('should get with a mock', () => {
    const mock = vi.fn().mockImplementation(getLatest);

    expect(mock()).toEqual(messages.items[messages.items.length - 1]);
    expect(mock).toHaveBeenCalledTimes(1);

    mock.mockImplementationOnce(() => 'access-restricted');
    expect(mock()).toEqual('access-restricted');

    expect(mock).toHaveBeenCalledTimes(2);

    expect(mock()).toEqual(messages.items[messages.items.length - 1]);
    expect(mock).toHaveBeenCalledTimes(3);
  });
});

Továbbiak

Jest Mock Függvények

Globális változók

Mockolhatja azokat a globális változókat, amelyek nincsenek jelen jsdom vagy node környezetben a vi.stubGlobal segítővel. Ez a globális változó értékét a globalThis objektumba helyezi.

import { vi } from 'vitest';

const IntersectionObserverMock = vi.fn(() => ({
  disconnect: vi.fn(),
  observe: vi.fn(),
  takeRecords: vi.fn(),
  unobserve: vi.fn(),
}));

vi.stubGlobal('IntersectionObserver', IntersectionObserverMock);

// most már elérheti `IntersectionObserver` vagy `window.IntersectionObserver` néven

Modulok

A mock modulok harmadik féltől származó könyvtárakat kezelnek, amelyeket más kódban hívnak meg, lehetővé téve az argumentumok, kimenet tesztelését, vagy akár az implementáció újradeklarálását.

A részletesebb API leírásért lásd a vi.mock() API szekciót.

Automatikus Mockolási Algoritmus

Ha a kódja egy mockolt modult importál, anélkül, hogy ehhez a modulhoz __mocks__ fájl vagy factory tartozna, a Vitest magát a modult fogja mockolni, azáltal, hogy meghívja és minden exportot mockol.

A következő elvek alkalmazandók:

Minden tömb kiürül
Minden primitív és gyűjtemény változatlan marad
Minden objektum mélyen klónozódik
Az osztályok minden példánya és prototípusa mélyen klónozódik

Virtuális Modulok

A Vitest támogatja a Vite virtuális modulok mockingját. Ez másképp működik, mint ahogyan a virtuális modulokat a Jest kezeli. Ahelyett, hogy virtual: true értéket adna át egy vi.mock függvénynek, meg kell mondania a Vite-nek, hogy a modul létezik, különben a feldolgozás során hiba történik. Ezt többféleképpen teheti meg:

Adjon meg egy aliast

// vitest.config.js
export default {
  test: {
    alias: {
      '$app/forms': resolve('./mocks/forms.js'),
    },
  },
};

Adjon meg egy plugint, amely feloldja a virtuális modult

// vitest.config.js
export default {
  plugins: [
    {
      name: 'virtual-modules',
      resolveId(id) {
        if (id === '$app/forms') {
          return 'virtual:$app/forms';
        }
      },
    },
  ],
};

A második megközelítés előnye, hogy dinamikusan hozhat létre különböző virtuális belépési pontokat. Ha több virtuális modult egyetlen fájlba átirányít, akkor mindegyiket érinti a vi.mock, ezért ügyeljen az egyedi azonosítók használatára.

Mockolási buktatók

Fontos megjegyezni, hogy nem lehetséges mockolni azokat a metódushívásokat, amelyek ugyanazon fájl más metódusaiban vannak meghívva. Például ebben a kódban:

export function foo() {
  return 'foo';
}

export function foobar() {
  return `${foo()}bar`;
}

Nem lehetséges a foo metódust kívülről mockolni, mert közvetlenül hivatkoznak rá. Tehát ez a kód nem lesz hatással a foobar belsejében lévő foo hívásra (de hatással lesz a foo hívásra más modulokban):

import { vi } from 'vitest';
import * as mod from './foobar.js';

// ez csak az eredeti modulon kívüli "foo"-ra lesz hatással
vi.spyOn(mod, 'foo');
vi.mock('./foobar.js', async importOriginal => {
  return {
    ...(await importOriginal<typeof import('./foobar.js')>()),
    // ez csak az eredeti modulon kívüli "foo"-ra lesz hatással
    foo: () => 'mocked',
  };
});

Ezt a viselkedést megerősítheti, ha közvetlenül megadja a foobar metódus implementációját:

// foobar.test.js
import * as mod from './foobar.js';

vi.spyOn(mod, 'foo');

// az exportált foo a hamisított metódusra mutat
mod.foobar(mod.foo);

// foobar.js
export function foo() {
  return 'foo';
}

export function foobar(injectedFoo) {
  return injectedFoo === foo; // false
}

Ez a szándékolt viselkedés. Általában nem optimális kódra utal, ha a mocking ilyen módon történik. Fontolja meg a kód refaktorálását több fájlba, vagy az alkalmazás architektúrájának javítását olyan technikák alkalmazásával, mint a függőséginjektálás.

Példa

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { Client } from 'pg';
import { failure, success } from './handlers.js';

// teendők lekérése
export async function getTodos(event, context) {
  const client = new Client({
    // ...clientOptions
  });

  await client.connect();

  try {
    const result = await client.query('SELECT * FROM todos;');

    client.end();

    return success({
      message: `${result.rowCount} item(s) returned`,
      data: result.rows,
      status: true,
    });
  } catch (e) {
    console.error(e.stack);

    client.end();

    return failure({ message: e, status: false });
  }
}

vi.mock('pg', () => {
  const Client = vi.fn();
  Client.prototype.connect = vi.fn();
  Client.prototype.query = vi.fn();
  Client.prototype.end = vi.fn();

  return { Client };
});

vi.mock('./handlers.js', () => {
  return {
    success: vi.fn(),
    failure: vi.fn(),
  };
});

describe('get a list of todo items', () => {
  let client;

  beforeEach(() => {
    client = new Client();
  });

  afterEach(() => {
    vi.clearAllMocks();
  });

  it('should return items successfully', async () => {
    client.query.mockResolvedValueOnce({ rows: [], rowCount: 0 });

    await getTodos();

    expect(client.connect).toBeCalledTimes(1);
    expect(client.query).toBeCalledWith('SELECT * FROM todos;');
    expect(client.end).toBeCalledTimes(1);

    expect(success).toBeCalledWith({
      message: '0 item(s) returned',
      data: [],
      status: true,
    });
  });

  it('should throw an error', async () => {
    const mError = new Error('Unable to retrieve rows');
    client.query.mockRejectedValueOnce(mError);

    await getTodos();

    expect(client.connect).toBeCalledTimes(1);
    expect(client.query).toBeCalledWith('SELECT * FROM todos;');
    expect(client.end).toBeCalledTimes(1);
    expect(failure).toBeCalledWith({ message: mError, status: false });
  });
});

Fájlrendszer

A fájlrendszer mockingja biztosítja, hogy a tesztek ne függjenek a tényleges fájlrendszertől, ezáltal megbízhatóbbá és kiszámíthatóbbá téve azokat. Ez az izoláció segít elkerülni az előző tesztek mellékhatásait. Lehetővé teszi olyan hibaállapotok és szélsőséges esetek tesztelését, amelyeket nehéz vagy lehetetlen lenne reprodukálni egy tényleges fájlrendszerrel, mint például engedélyezési problémák, megtelt lemezforgatókönyvek vagy olvasási/írási hibák.

A Vitest alapértelmezetten nem biztosít fájlrendszer mocking API-t. Használhatja a vi.mock-ot az fs modul manuális mockingjára, de ezt nehéz karbantartani. Ehelyett javasoljuk a memfs használatát. A memfs egy memóriabeli fájlrendszert hoz létre, amely szimulálja a fájlrendszer műveleteket anélkül, hogy a tényleges lemezt érintené. Ez a megközelítés gyors és biztonságos, megelőzve a valós fájlrendszerre gyakorolt esetleges mellékhatásokat.

Példa

Ahhoz, hogy minden fs hívást automatikusan átirányítson a memfs-re, létrehozhatja a __mocks__/fs.cjs és __mocks__/fs/promises.cjs fájlokat a projekt gyökerében:

__mocks__/fs.cjs__mocks__/fs/promises.cjs

// használhatunk `import`-ot is, de ekkor
// minden exportot explicit módon kell definiálni

const { fs } = require('memfs');
module.exports = fs;

// használhatunk `import`-ot is, de ekkor
// minden exportot explicit módon kell definiálni

const { fs } = require('memfs');
module.exports = fs.promises;

// read-hello-world.js
import { readFileSync } from 'node:fs';

export function readHelloWorld(path) {
  return readFileSync(path);
}

// hello-world.test.js
import { beforeEach, expect, it, vi } from 'vitest';
import { fs, vol } from 'memfs';
import { readHelloWorld } from './read-hello-world.js';

// jelezzük a vitestnek, hogy az fs mockot a __mocks__ mappából használja
// ez egy setup fájlban is megtehető, ha az fs-t mindig mockolni kell
vi.mock('node:fs');
vi.mock('node:fs/promises');

beforeEach(() => {
  // az in-memory fs állapotának visszaállítása
  vol.reset();
});

it('should return correct text', () => {
  const path = '/hello-world.txt';
  fs.writeFileSync(path, 'hello world');

  const text = readHelloWorld(path);
  expect(text).toBe('hello world');
});

it('can return a value multiple times', () => {
  // a vol.fromJSON segítségével több fájlt is definiálhat
  vol.fromJSON(
    {
      './dir1/hw.txt': 'hello dir1',
      './dir2/hw.txt': 'hello dir2',
    },
    // alapértelmezett cwd
    '/tmp'
  );

  expect(readHelloWorld('/tmp/dir1/hw.txt')).toBe('hello dir1');
  expect(readHelloWorld('/tmp/dir2/hw.txt')).toBe('hello dir2');
});

Kérések

Mivel a Vitest Node-ban fut, a hálózati kérések mockingja kihívást jelent; a webes API-k nem állnak rendelkezésre, ezért szükségünk van valamire, ami utánozza a hálózati viselkedést. Ehhez a Mock Service Worker használatát javasoljuk. Ez lehetővé teszi mind a REST, mind a GraphQL hálózati kérések mockingját, és keretrendszer-független.

A Mock Service Worker (MSW) úgy működik, hogy elfogja a tesztek által küldött kéréseket, így anélkül használható, hogy megváltoztatná az alkalmazáskódját. Böngészőben ez a Service Worker API használja. Node.js-ben és a Vitest esetében a @mswjs/interceptors könyvtárat használja. Az MSW-ről bővebben olvashat a bevezetőjükben

Konfiguráció

Az alábbiak szerint használhatja a setup fájljában

import { afterAll, afterEach, beforeAll } from 'vitest';
import { setupServer } from 'msw/node';
import { graphql, http, HttpResponse } from 'msw';

const posts = [
  {
    userId: 1,
    id: 1,
    title: 'first post title',
    body: 'first post body',
  },
  // ...
];

export const restHandlers = [
  http.get('https://rest-endpoint.example/path/to/posts', () => {
    return HttpResponse.json(posts);
  }),
];

const graphqlHandlers = [
  graphql.query('ListPosts', () => {
    return HttpResponse.json({
      data: { posts },
    });
  }),
];

const server = setupServer(...restHandlers, ...graphqlHandlers);

// Szerver indítása minden teszt előtt
beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));

// Szerver bezárása minden teszt után
afterAll(() => server.close());

// Kezelők visszaállítása minden teszt után (fontos a teszt izolációjához)
afterEach(() => server.resetHandlers());

A szerver onUnhandledRequest: 'error' konfigurálása biztosítja, hogy hiba keletkezzen, amennyiben olyan kérés érkezik, amelyhez nincs megfelelő kéréskezelő.

Továbbiak

Az MSW számos további lehetőséget kínál. Hozzáférhet sütikhez és lekérdezési paraméterekhez, mock hibaüzeneteket definiálhat, és még sok mást! Az MSW-vel kapcsolatos összes lehetőséget megtekintheti a dokumentációjukban.

Időzítők

Amikor időtúllépéseket vagy intervallumokat tartalmazó kódot tesztelünk, ahelyett, hogy a tesztjeink kivárnák az időt vagy időtúllépnének, felgyorsíthatjuk a tesztjeinket "hamis" időzítők használatával, amelyek mockolják a setTimeout és setInterval hívásokat.

A részletesebb API leírásért lásd a vi.useFakeTimers API szekciót.

Példa

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

function executeAfterTwoHours(func) {
  setTimeout(func, 1000 * 60 * 60 * 2); // 2 óra
}

function executeEveryMinute(func) {
  setInterval(func, 1000 * 60); // 1 perc
}

const mock = vi.fn(() => console.log('executed'));

describe('delayed execution', () => {
  beforeEach(() => {
    vi.useFakeTimers();
  });
  afterEach(() => {
    vi.restoreAllMocks();
  });
  it('should execute the function', () => {
    executeAfterTwoHours(mock);
    vi.runAllTimers();
    expect(mock).toHaveBeenCalledTimes(1);
  });
  it('should not execute the function', () => {
    executeAfterTwoHours(mock);
    // 2ms-mal való előrehaladás nem fogja kiváltani a függvényt
    vi.advanceTimersByTime(2);
    expect(mock).not.toHaveBeenCalled();
  });
  it('should execute every minute', () => {
    executeEveryMinute(mock);
    vi.advanceTimersToNextTimer();
    expect(mock).toHaveBeenCalledTimes(1);
    vi.advanceTimersToNextTimer();
    expect(mock).toHaveBeenCalledTimes(2);
  });
});

Osztályok

Egy egész osztályt mockolhat egyetlen vi.fn hívással – mivel minden osztály függvény is, ez alapértelmezetten működik. Fontos megjegyezni, hogy jelenleg a Vitest nem veszi figyelembe a new kulcsszót, így a new.target mindig undefined a függvény törzsében.

class Dog {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  static getType(): string {
    return 'animal';
  }

  speak(): string {
    return 'bark!';
  }

  isHungry() {}
  feed() {}
}

Ezt az osztályt újra létrehozhatjuk ES5 függvényekkel:

const Dog = vi.fn(function (name) {
  this.name = name;
});

// Kérjük, vegye figyelembe, hogy a statikus metódusok közvetlenül a függvényen vannak mockolva,
// nem az osztály példányán
Dog.getType = vi.fn(() => 'mocked animal');

// mockolja a "speak" és "feed" metódusokat az osztály minden példányán
// minden `new Dog()` példány örökölni fogja ezeket a megfigyelőket
Dog.prototype.speak = vi.fn(() => 'loud bark!');
Dog.prototype.feed = vi.fn();

MIKOR HASZNÁLJUK?

Általánosságban elmondható, hogy egy osztályt így hozna létre újra a modulgyárban, ha az osztályt egy másik modulból exportálják újra:

import { Dog } from './dog.js';

vi.mock(import('./dog.js'), () => {
  const Dog = vi.fn();
  Dog.prototype.feed = vi.fn();
  // ... egyéb mockok
  return { Dog };
});

Ez a módszer arra is használható, hogy egy osztály példányát átadjuk egy olyan függvénynek, amely ugyanazt az interfészt elfogadja:

// ./src/feed.ts
function feed(dog: Dog) {
  // ...
}

// ./tests/dog.test.ts
import { expect, test, vi } from 'vitest';
import { feed } from '../src/feed.js';

const Dog = vi.fn();
Dog.prototype.feed = vi.fn();

test('can feed dogs', () => {
  const dogMax = new Dog('Max');

  feed(dogMax);

  expect(dogMax.feed).toHaveBeenCalled();
  expect(dogMax.isHungry()).toBe(false);
});

Most, amikor létrehozunk egy új Dog osztálypéldányt, a speak metódusa (a feed mellett) már mockolva van:

const dog = new Dog('Cooper');
dog.speak(); // hangos ugatás!

// beépített állításokat használhat a hívás érvényességének ellenőrzésére
expect(dog.speak).toHaveBeenCalled();

Újra hozzárendelhetjük a visszatérési értéket egy adott példányhoz:

const dog = new Dog('Cooper');

// a "vi.mocked" egy típussegítő, mivel
// a TypeScript nem tudja, hogy a Dog egy mockolt osztály.
// Ezért bármely függvényt MockInstance<T> típusba csomagol,
// anélkül, hogy ellenőrizné, hogy a függvény mock-e.
vi.mocked(dog.speak).mockReturnValue('vau-vau');

dog.speak(); // vau-vau

A tulajdonság mockolásához használhatjuk a vi.spyOn(dog, 'name', 'get') metódust. Ez lehetővé teszi a kém állítások használatát a mockolt tulajdonságon:

const dog = new Dog('Cooper');

const nameSpy = vi.spyOn(dog, 'name', 'get').mockReturnValue('Max');

expect(dog.name).toBe('Max');
expect(nameSpy).toHaveBeenCalledTimes(1);

TIP

Ugyanezzel a módszerrel megfigyelheti a getterek és setterek működését is.

Csalólap

INFO

Az alábbi példákban a vi közvetlenül a vitest-ből importálva van. Globálisan is használhatja, ha a konfigurációban a globals értéket true-ra állítja.

Azt akarom, hogy…

Exportált változók mockolása

// some-path.js
export const getter = 'variable';

// some-path.test.ts
import * as exports from './some-path.js';

vi.spyOn(exports, 'getter', 'get').mockReturnValue('mocked');

Exportált függvény mockolása

Példa vi.mock-kal:

WARNING

Ne feledje, hogy a vi.mock hívás a fájl tetejére emelkedik. Mindig az összes import előtt fog végrehajtódni.

// ./some-path.js
export function method() {}

import { method } from './some-path.js';

vi.mock('./some-path.js', () => ({
  method: vi.fn(),
}));

Példa vi.spyOn-nal:

import * as exports from './some-path.js';

vi.spyOn(exports, 'method').mockImplementation(() => {});

Exportált osztály implementációjának mockolása

Példa vi.mock-kal és .prototype-pal:

// ./some-path.ts
export class SomeClass {}

import { SomeClass } from './some-path.js';

vi.mock(import('./some-path.js'), () => {
  const SomeClass = vi.fn();
  SomeClass.prototype.someMethod = vi.fn();
  return { SomeClass };
});
// A SomeClass.mock.instances tartalmazni fogja a SomeClass példányait

Példa vi.spyOn-nal:

import * as mod from './some-path.js';

const SomeClass = vi.fn();
SomeClass.prototype.someMethod = vi.fn();

vi.spyOn(mod, 'SomeClass').mockImplementation(SomeClass);

Egy függvényből visszaadott objektum kémkedése

Példa gyorsítótár használatával:

// some-path.ts
export function useObject() {
  return { method: () => true };
}

// useObject.js
import { useObject } from './some-path.js';

const obj = useObject();
obj.method();

// useObject.test.js
import { useObject } from './some-path.js';

vi.mock(import('./some-path.js'), () => {
  let _cache;
  const useObject = () => {
    if (!_cache) {
      _cache = {
        method: vi.fn(),
      };
    }
    // mostantól minden alkalommal, amikor a useObject() meghívódik,
    // ugyanazt az objektumreferenciát adja vissza
    return _cache;
  };
  return { useObject };
});

const obj = useObject();
// az obj.method a some-path-on belül meghívásra került
expect(obj.method).toHaveBeenCalled();

Egy modul részének mockolása

import { mocked, original } from './some-path.js';

vi.mock(import('./some-path.js'), async importOriginal => {
  const mod = await importOriginal();
  return {
    ...mod,
    mocked: vi.fn(),
  };
});
original(); // eredeti viselkedéssel bír
mocked(); // egy megfigyelő függvény

WARNING

Ne feledje, hogy ez csak a külső hozzáférést helyettesíti. Ebben a példában, ha az original belsőleg hívja a mocked-et, akkor mindig a modulban definiált függvényt fogja hívni, nem a mock factory-ban lévőt.

Az aktuális dátum mockolása

A Date idejének mockolásához használhatja a vi.setSystemTime segédfüggvényt. Ez az érték nem fog automatikusan resetelődni a különböző tesztek között.

Vigyázzon, hogy a vi.useFakeTimers használata is megváltoztatja a Date idejét.

const mockDate = new Date(2022, 0, 1);
vi.setSystemTime(mockDate);
const now = new Date();
expect(now.valueOf()).toBe(mockDate.valueOf());
// mockolt idő visszaállítása
vi.useRealTimers();

Globális változó mockolása

Globális változót beállíthat úgy, hogy értéket rendel a globalThis-hez, vagy a vi.stubGlobal segítőt használja. A vi.stubGlobal használatakor az érték nem fog automatikusan visszaállni a különböző tesztek között, hacsak nem engedélyezi az unstubGlobals konfigurációs opciót, vagy nem hívja meg a vi.unstubAllGlobals függvényt.

vi.stubGlobal('__VERSION__', '1.0.0');
expect(__VERSION__).toBe('1.0.0');

`import.meta.env` mockolása

A környezeti változó megváltoztatásához egyszerűen hozzárendelhet egy új értéket.

WARNING

A környezeti változó értéke nem fog automatikusan visszaállni a különböző tesztek között.

import { beforeEach, expect, it } from 'vitest';

// a tesztek futtatása előtt a "VITE_ENV" értéke "test"
const originalViteEnv = import.meta.env.VITE_ENV;

beforeEach(() => {
  import.meta.env.VITE_ENV = originalViteEnv;
});

it('changes value', () => {
  import.meta.env.VITE_ENV = 'staging';
  expect(import.meta.env.VITE_ENV).toBe('staging');
});

Ha automatikusan vissza szeretné állítani az érték(ek)et, használhatja a vi.stubEnv segítőt az unstubEnvs konfigurációs opció engedélyezésével (vagy manuálisan hívja meg a vi.unstubAllEnvs függvényt egy beforeEach hookban):

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

// a tesztek futtatása előtt a "VITE_ENV" értéke "test"
import.meta.env.VITE_ENV === 'test';

it('changes value', () => {
  vi.stubEnv('VITE_ENV', 'staging');
  expect(import.meta.env.VITE_ENV).toBe('staging');
});

it('the value is restored before running an other test', () => {
  expect(import.meta.env.VITE_ENV).toBe('test');
});

// vitest.config.ts
export default defineConfig({
  test: {
    unstubEnvs: true,
  },
});

Mocking ​

Dátumok ​

Példa ​

Függvények ​

Példa ​

Továbbiak ​

Globális változók ​

Modulok ​

Automatikus Mockolási Algoritmus ​

Virtuális Modulok ​

Mockolási buktatók ​

Példa ​

Fájlrendszer ​

Példa ​

Kérések ​

Konfiguráció ​

Továbbiak ​

Időzítők ​

Példa ​

Osztályok ​

Csalólap ​

Exportált változók mockolása ​

Exportált függvény mockolása ​

Exportált osztály implementációjának mockolása ​

Egy függvényből visszaadott objektum kémkedése ​

Egy modul részének mockolása ​

Az aktuális dátum mockolása ​

Globális változó mockolása ​

import.meta.env mockolása ​

Mocking

Dátumok

Példa

Függvények

Példa

Továbbiak

Globális változók

Modulok

Automatikus Mockolási Algoritmus

Virtuális Modulok

Mockolási buktatók

Példa

Fájlrendszer

Példa

Kérések

Konfiguráció

Továbbiak

Időzítők

Példa

Osztályok

Csalólap

Exportált változók mockolása

Exportált függvény mockolása

Exportált osztály implementációjának mockolása

Egy függvényből visszaadott objektum kémkedése

Egy modul részének mockolása

Az aktuális dátum mockolása

Globális változó mockolása

`import.meta.env` mockolása