javascript-testing

Write and run JavaScript/TypeScript tests using Vitest or Jest with mocking, component testing, and coverage. Use when writing JS/TS tests, testing Svelte/React components, or setting up test configuration.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

This Claude skill empowers developers to master JavaScript and TypeScript testing by providing expert guidance on Vitest and Jest frameworks. It streamlines the creation of robust test suites, covering everything from unit testing and the AAA pattern to advanced component testing for Svelte and React, comprehensive mocking strategies, and automated test configuration to ensure high-quality, bug-free codebases.

Use Cases

  • Unit Testing: Implementing the Arrange-Act-Assert (AAA) pattern to validate core business logic and utility functions in JS/TS.
  • Component Testing: Using Testing Library to verify the behavior and accessibility of Svelte, React, or Vue components.
  • Mocking & Spying: Isolating code by mocking API calls and external dependencies using Vitest's 'vi' or Jest's mocking utilities.
  • Test Configuration: Setting up and optimizing Vitest or Jest environments, including coverage reporting, jsdom integration, and setup files.
  • Framework-Specific Testing: Validating complex SvelteKit features such as server-side load functions and form actions with specialized test patterns.
namejavascript-testing
descriptionWrite and run JavaScript/TypeScript tests using Vitest or Jest with mocking, component testing, and coverage. Use when writing JS/TS tests, testing Svelte/React components, or setting up test configuration.

JavaScript/TypeScript Testing Skill

When to Activate

Activate this skill when:

  • Writing JavaScript or TypeScript tests
  • Testing Svelte, React, or Vue components
  • Setting up Vitest or Jest configuration
  • Working with mocks, spies, or test utilities
  • Running tests or checking coverage

Framework Selection

Use Case Framework
SvelteKit, Vite projects Vitest (recommended)
Non-Vite projects, React Native Jest

Quick Commands

Vitest

npx vitest              # Watch mode
npx vitest run          # Single run (CI)
npx vitest run --coverage
npx vitest --ui         # Visual UI

Jest

pnpm test
pnpm test --watch
pnpm test --coverage

Test Structure: AAA Pattern

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

describe('UserService', () => {
    let userService: UserService;

    beforeEach(() => {
        userService = new UserService();
    });

    it('should create a new user with valid data', () => {
        // Arrange
        const email = 'test@example.com';
        const password = 'secure_pass123';

        // Act
        const result = userService.register(email, password);

        // Assert
        expect(result.success).toBe(true);
        expect(result.user.email).toBe(email);
    });
});

Vitest Setup (SvelteKit)

// vite.config.ts
import { defineConfig } from 'vitest/config';
import { sveltekit } from '@sveltejs/kit/vite';

export default defineConfig({
    plugins: [sveltekit()],
    test: {
        include: ['src/**/*.{test,spec}.{js,ts}'],
        globals: true,
        environment: 'jsdom',
        setupFiles: ['./src/tests/setup.ts'],
    }
});

Mocking

Vitest

import { vi } from 'vitest';

vi.mock('./api', () => ({
    fetchUser: vi.fn()
}));

vi.mocked(fetchUser).mockResolvedValue({ id: 1, name: 'John' });

Jest

jest.mock('./api', () => ({
    fetchUser: jest.fn()
}));

Component Testing (Svelte)

import { render, screen, fireEvent } from '@testing-library/svelte';
import Counter from './Counter.svelte';

it('should increment count on click', async () => {
    render(Counter, { props: { initialCount: 0 } });

    const button = screen.getByRole('button', { name: /increment/i });
    await fireEvent.click(button);

    expect(screen.getByText('Count: 1')).toBeInTheDocument();
});

Common Assertions

// Equality
expect(value).toBe(expected);           // Strict ===
expect(value).toEqual(expected);        // Deep equality

// Truthiness
expect(value).toBeTruthy();
expect(value).toBeNull();

// Arrays/Objects
expect(array).toContain(item);
expect(obj).toHaveProperty('key');

// Exceptions
expect(() => fn()).toThrow('error');

// Async
await expect(promise).resolves.toBe(value);
await expect(promise).rejects.toThrow();

Query Priority (Testing Library)

  1. getByRole - Accessible queries (best)
  2. getByLabelText - Form fields
  3. getByPlaceholderText - Inputs
  4. getByText - Non-interactive elements
  5. getByTestId - Last resort

Directory Structure

src/
├── lib/
│   ├── components/
│   │   ├── Button.svelte
│   │   └── Button.test.ts
│   └── utils/
│       ├── format.ts
│       └── format.test.ts
└── tests/
    ├── setup.ts
    └── integration/

SvelteKit Testing

Load Functions

import { load } from './+page.server';

it('should fetch posts', async () => {
    const mockFetch = vi.fn().mockResolvedValue({
        json: () => Promise.resolve([{ id: 1 }])
    });

    const result = await load({ fetch: mockFetch } as any);
    expect(result.posts).toHaveLength(1);
});

Form Actions

import { actions } from './+page.server';

it('should validate login', async () => {
    const formData = new FormData();
    formData.set('email', 'test@example.com');

    const request = new Request('http://localhost', {
        method: 'POST',
        body: formData
    });

    const result = await actions.default({ request } as any);
    expect(result.success).toBe(true);
});

See AgentUsage/testing_javascript.md for complete documentation including:

  • Jest configuration
  • Async testing patterns
  • SvelteKit-specific patterns
  • CI/CD integration