From python
Provides TypeScript testing patterns using Vitest for unit tests, MSW for API mocking, typed mocks for dependency injection, and snapshot testing.
npx claudepluginhub martinffx/atelier --plugin pythonThis skill uses the workspace's default tool permissions.
Comprehensive testing patterns using Vitest for unit testing, MSW for API mocking, and snapshot testing for complex object validation.
Guides Vitest unit and integration tests for JS/TS with Vite: vi.mock hoisting, MSW v2 HTTP mocking, fake timers, snapshots, test isolation, and async patterns. Use for test writing, mocking, or setup.
Guides Vitest testing for TypeScript/JavaScript projects: installation, config, running tests with watch/UI/coverage, assertions, and mocking.
Delivers Vitest best practices for test setup, async patterns, vi.* mocking, snapshots, and performance. Use when writing, debugging, or reviewing Vitest tests.
Share bugs, ideas, or general feedback.
Comprehensive testing patterns using Vitest for unit testing, MSW for API mocking, and snapshot testing for complex object validation.
# Core testing dependencies
bun add -d vitest @vitest/ui
# MSW for API mocking
bun add -d msw
# Optional: coverage reporting
bun add -d @vitest/coverage-v8
import { describe, it, expect, vi, beforeEach } from 'vitest'
describe('UserService', () => {
beforeEach(() => {
vi.clearAllMocks()
})
it('creates user with valid data', async () => {
const result = await userService.create({ name: 'Alice' })
expect(result).toMatchObject({ name: 'Alice' })
})
})
Create type-safe mocks for dependency injection using vi.mocked():
import { vi } from 'vitest'
import type { UserRepository } from './user-repository'
// Mock the entire module
vi.mock('./user-repository')
// Get typed mock instance
const mockUserRepo = vi.mocked<UserRepository>({
findById: vi.fn(),
save: vi.fn(),
delete: vi.fn(),
})
// Type-safe mock return values
mockUserRepo.findById.mockResolvedValue({
id: '123',
name: 'Alice',
email: 'alice@example.com',
})
// Assertions with full type safety
expect(mockUserRepo.findById).toHaveBeenCalledWith('123')
// Single return value
mockRepo.findById.mockResolvedValue(user)
// Multiple calls, different returns
mockRepo.findById
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(user)
// Conditional logic
mockRepo.findById.mockImplementation(async (id) => {
if (id === '123') return user
return null
})
// Throw errors
mockRepo.save.mockRejectedValue(new Error('Database error'))
import { vi } from 'vitest'
import { emailService } from './email-service'
// Spy on method without replacing it
vi.spyOn(emailService, 'send')
// Call real implementation
await emailService.send({ to: 'alice@example.com', subject: 'Test' })
// Assert it was called
expect(emailService.send).toHaveBeenCalledOnce()
// Temporarily override return value
emailService.send.mockResolvedValueOnce({ messageId: 'test-123' })
See references/mocking.md for comprehensive mocking patterns including module mocks, class mocks, stateful handlers, and dependency injection.
Mock HTTP requests at the network level for integration tests:
import { http, HttpResponse } from 'msw'
import { setupServer } from 'msw/node'
import { afterAll, afterEach, beforeAll } from 'vitest'
// Define handlers
const handlers = [
http.get('/api/users/:id', ({ params }) => {
return HttpResponse.json({
id: params.id,
name: 'Alice',
email: 'alice@example.com',
})
}),
http.post('/api/users', async ({ request }) => {
const body = await request.json()
return HttpResponse.json({ id: '123', ...body }, { status: 201 })
}),
]
// Setup server
const server = setupServer(...handlers)
beforeAll(() => server.listen())
afterEach(() => server.resetHandlers())
afterAll(() => server.close())
See references/msw.md for advanced MSW patterns including error simulation, delays, and per-test overrides.
Validate complex objects and output without manual assertions:
import { it, expect } from 'vitest'
it('generates correct user profile', () => {
const profile = generateUserProfile(user)
// Snapshot entire object
expect(profile).toMatchSnapshot()
})
// Handle dynamic values (dates, IDs)
it('creates order with timestamp', () => {
const order = createOrder(items)
expect(order).toMatchSnapshot({
id: expect.any(String),
createdAt: expect.any(Date),
})
})
// Inline snapshots for small objects
it('formats error message', () => {
const error = formatError(new Error('Failed'))
expect(error).toMatchInlineSnapshot(`
{
"message": "Failed",
"code": "UNKNOWN_ERROR",
}
`)
})
See references/snapshot-testing.md for snapshot maintenance, custom serializers, and best practices.
// Promises
it('loads user data', async () => {
const user = await userService.findById('123')
expect(user).toBeDefined()
})
// Callbacks
it('calls callback on completion', () => {
return new Promise<void>((resolve) => {
processData(data, (result) => {
expect(result).toBe(expected)
resolve()
})
})
})
// Timers
it('retries after delay', async () => {
vi.useFakeTimers()
const promise = retryOperation()
vi.advanceTimersByTime(1000)
const result = await promise
expect(result).toBe('success')
vi.useRealTimers()
})
// Group related tests
describe('UserService', () => {
describe('create', () => {
it('succeeds with valid data', () => {})
it('throws on duplicate email', () => {})
})
describe('update', () => {
it('updates existing user', () => {})
it('throws on not found', () => {})
})
})
// Shared setup
describe('authenticated requests', () => {
beforeEach(() => {
mockAuth.isAuthenticated.mockReturnValue(true)
})
it('allows user creation', () => {})
it('allows user deletion', () => {})
})
vi.mocked<T>() provides type safety for mock setup and assertionsexpect.any()beforeEach/afterEach to ensure test isolationasync/await for cleaner async test codevi.useFakeTimers() to control time in testsexpect().rejects.toThrow()class UserService {
constructor(
private repo: UserRepository,
private email: EmailService,
) {}
async create(data: CreateUserInput) {
const user = await this.repo.save(data)
await this.email.sendWelcome(user.email)
return user
}
}
// Test with mocks
it('sends welcome email on create', async () => {
const mockRepo = vi.mocked<UserRepository>({
save: vi.fn().mockResolvedValue(savedUser),
})
const mockEmail = vi.mocked<EmailService>({
sendWelcome: vi.fn().mockResolvedValue(undefined),
})
const service = new UserService(mockRepo, mockEmail)
await service.create(userData)
expect(mockEmail.sendWelcome).toHaveBeenCalledWith('alice@example.com')
})
it('handles repository errors gracefully', async () => {
mockRepo.save.mockRejectedValue(new Error('Database error'))
await expect(
service.create(userData)
).rejects.toThrow('Failed to create user')
// Verify cleanup or rollback occurred
expect(mockEmail.sendWelcome).not.toHaveBeenCalled()
})
it('handles concurrent requests correctly', async () => {
const promises = [
service.processOrder(order1),
service.processOrder(order2),
service.processOrder(order3),
]
const results = await Promise.all(promises)
expect(results).toHaveLength(3)
expect(new Set(results.map(r => r.id)).size).toBe(3)
})
# Run single test file
vitest run path/to/test.spec.ts
# Run tests matching pattern
vitest run -t "creates user"
# Watch mode for TDD
vitest watch
# UI mode for debugging
vitest --ui
# Coverage report
vitest run --coverage