W styczniu opublikowałem 1 wpis:

JavaScript:

1. Vitest: Jak sprawdzić, czy funkcja rzuciła wyjątkiem?

Przeczytałem 2 książki:

1. Praca z zastanym kodem. Najlepsze techniki — Michael Feathers
2. Rozdroże kruków — Andrzej Sapkowski

Przesłuchałem 4 audiobooki:

1. Sekret pacjentki — Loreth Anne White
2. Mleczarz — Anna Burns
3. Ja, które nie poznałam mężczyzn — Jacqueline Harpman
4. Pas Ilmarinena — Marcin Mortka

Testowanie wyjątków w Vitest

Mamy prostą funkcję:

function loadFile(fileName?: string): string {
    if (!fileName) {
        throw new Error('File not exist!');
    }

    return 'Some content';
}

I chcemy stestować, czy funkcja rzuca wyjątek. Można to zrobić to w taki sposób:

import { expect, test } from 'vitest';

test('should check file not exist', () => {
    expect(() => loadFile()).toThrowError('File not exist!');
});

Testowanie wersji asynchronicznej

Jak stestować wersją asynchroniczną?

function loadFile(fileName?: string): Promise<string> {
    if (!fileName) {
        throw new Error('File not exist!');
    }

    return Promise.resolve('Some content')
}

Test:

import { expect, test } from 'vitest';

test('should check file not exist', async () => {
    await expect(async () => await loadFile()).rejects.toThrowError('File not exist!');
});

W grudniu opublikowałem 2 wpisy:

NodeJS:

1. Co zrobić, aby działały ścieżki absolutne w Vitest?
2. Jak pisać testy dla operacji na plikach z Vitest?

Przeczytałem 1 książkę:

1. Na własne ryzyko — Nassim Nicholas Taleb

Przesłuchałem 4 audiobooki:

1. Północna Droga. Trzy młode pieśni — Elżbieta Cherezińska
2. Lot — Lynn Steger Strong
3. Wyjście z cienia — Janusz A. Zajdel
4. Miasteczko Twin Falls — Loreth Anne White

Testowanie plików

Pisanie testów, które mają sprawdzać kod operujący na plikach, może być problematyczne. Jednym ze sposobów może być użycie mocków. Na przykład chcesz sprawdzić wczytywanie pliku. Wystarczy, że stworzysz mocka dla funkcji, która wczytuje plik. Osobiście nie lubię takiego podejścia. Pisanie testów, w taki sposób za bardzo skupia się na szczegółach implementacyjnych. Utrzymanie takich testów staje się uciążliwe.

Jakie jest inne wyjście? Możemy skorzystać z biblioteki, która symuluje operacje na plikach. Wszystko to dzieje się nie na dysku, ale w pamięci RAM, więc mamy gwarancję, że nasze testy będą szybkie.

Jedną z takich bibliotek jest: memfs. Ma takie samo API jak standardowa biblioteka fs NodeJS.

Instalacja memfs

Odpal komendę:

npm i -D memfs

Konfiguracja Vitest

Zanim napiszemy test musimy skonfigurować Vitest, żeby podczas uruchamiania testów podmieniał bibliotekę fs na memfs.

Otwórz plik vitest.config.js i dodaj ten fragment:

import { defineConfig } from 'vite'
import path from 'path'

export default defineConfig({
    resolve: {
        alias: {
            'node:fs': path.resolve(__dirname, './node_modules/memfs'),
        },
    },
})

Dzięki temu kiedy Vitest napotka w testowanym kodzie import:

import fs from 'node:fs'

Podmieni to na bibliotekę memfs:

import { fs } from 'memfs';

Przykład użycia memfs

Plik: file.ts:

import fs from 'node:fs'

export function createFile(name: string, content: string): void {
    fs.writeFileSync(name, content);
}

Test: file.test.ts:

import { expect, test } from 'vitest';
import { fs } from 'memfs';
import { createFile } from './file';

test('should create a file', async () => {
    // given
    fs.mkdirSync('.', { recursive: true })
    const fileName = './test';
    createFile(fileName, 'Some content')

    // when
   const content = fs.readFileSync(fileName, 'utf8');

   // then
   expect(content).toEqual('Some content');
});

Konfiguracja

Załóżmy, że mamy taką strukturę katalogów:

tsconfig.json
vitest.config.js
src
	index.ts
	calculator
		add.ts
		sub.ts
		index.ts

Tak wygląda konfiguracja pliku tsconfig.json:

{
	"compilerOptions": {
		...
		"baseUrl": ".",
		"paths": {
			"@/*": ["./src/*"]
		},
		"include": ["src"]
	}
}

Skupiłem się głównie na konfiguracji ścieżek absolutnych, resztę pominąłem.

Teraz pliki z kodem:

calculator/add.ts:

export function add(a, b): number {
	return a + b;
}

calculator/sub.ts:

export function sub(a, b): number {
	return a - b;
}

calculator/index.ts:

export * from './add'
export * from './sub'

index.ts:

import { add, sub } from '@/calculator'

const resultAdd = add(2, 2);
const resultSub = sub(2, 2);

console.log('resultAdd: ', resultAdd); // 4
console.log('resultSub: ', resultSub); // 0

Po uruchomieniu kodu wszystko działa prawidłowo. Napiszmy teraz test przy użyciu Vitest.

add.test.ts:

import { expect, test } from 'vitest'
import { add } from '@/calculator'

test('should add two numbers', () => {
    // given
    const a = 2;
    const b = 2;
    const expected = 4;

    // when
    const result = add(a, b);

    // then
    expect(result).toEqual(expected)
})

Po uruchomieniu testu okazuje się, że mamy problem!

Error: Failed to load url @/calculator (resolved id: @/calculator)

Jak sobie z tym poradzić?

Ścieżki absolutne w Vitest

Można to naprawić w łatwy sposób. Otwórz plik vitest.config.js i dodaj taki kod:

import { defineConfig } from 'vite'
import path from 'path'

export default defineConfig({
    resolve: {
        alias: {
            '@': path.resolve(__dirname, './src')
        },
    },
})

Linijka:

 '@': path.resolve(__dirname, './src')

Poinformuje Vitest, jak ma "czytać" ścieżki zaczynające się od @.

Po dodaniu konfiguracji test zostanie poprawnie uruchomiony.