Testing Expert | Bootspring Docs

The Testing Expert agent specializes in software testing strategies, test implementation, and quality assurance.

Expertise Areas#

Unit Testing - Jest, Vitest, Mocha
Integration Testing - API testing, database testing
E2E Testing - Playwright, Cypress, Puppeteer
Component Testing - React Testing Library, Vue Test Utils
Test Strategy - TDD, BDD, coverage goals
Mocking - Spies, stubs, mocks, fixtures
CI Integration - Test automation, reporting

Usage Examples#

Test Strategy#

Use the testing-expert agent to create a test strategy for a new e-commerce feature.

Response includes:

Test pyramid breakdown
Coverage goals
Critical paths
Test data strategy

Unit Tests#

Use the testing-expert agent to write unit tests for this utility function.

Response includes:

Test cases
Edge cases
Mock setup
Assertions

E2E Tests#

Use the testing-expert agent to write Playwright tests for the checkout flow.

Response includes:

Page objects
Test scenarios
Assertions
Error handling

Testing Patterns#

Test Structure (AAA Pattern)#

describe('UserService', () => {
  describe('createUser', () => {
    it('should create a user with valid data', async () => {
      // Arrange
      const userData = { email: 'test@example.com', name: 'Test' };
      const mockRepo = { create: vi.fn().mockResolvedValue({ id: '1', ...userData }) };
      const service = new UserService(mockRepo);

      // Act
      const result = await service.createUser(userData);

      // Assert
      expect(result).toEqual({ id: '1', ...userData });
      expect(mockRepo.create).toHaveBeenCalledWith(userData);
    });

    it('should throw on invalid email', async () => {
      // Arrange
      const userData = { email: 'invalid', name: 'Test' };
      const service = new UserService(mockRepo);

      // Act & Assert
      await expect(service.createUser(userData))
        .rejects.toThrow('Invalid email');
    });
  });
});

Component Testing#

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

describe('LoginForm', () => {
  it('should submit with valid credentials', async () => {
    const onSubmit = vi.fn();
    render(<LoginForm onSubmit={onSubmit} />);

    // Fill form
    await userEvent.type(screen.getByLabelText('Email'), 'test@example.com');
    await userEvent.type(screen.getByLabelText('Password'), 'password123');

    // Submit
    await userEvent.click(screen.getByRole('button', { name: 'Sign In' }));

    // Assert
    expect(onSubmit).toHaveBeenCalledWith({
      email: 'test@example.com',
      password: 'password123',
    });
  });

  it('should show validation errors', async () => {
    render(<LoginForm onSubmit={vi.fn()} />);

    // Submit empty form
    await userEvent.click(screen.getByRole('button', { name: 'Sign In' }));

    // Assert errors shown
    expect(screen.getByText('Email is required')).toBeInTheDocument();
    expect(screen.getByText('Password is required')).toBeInTheDocument();
  });
});

E2E Testing with Playwright#

import { test, expect } from '@playwright/test';

test.describe('Checkout Flow', () => {
  test.beforeEach(async ({ page }) => {
    // Login and add item to cart
    await page.goto('/login');
    await page.fill('[name="email"]', 'test@example.com');
    await page.fill('[name="password"]', 'password');
    await page.click('button[type="submit"]');
    await page.waitForURL('/dashboard');
  });

  test('should complete checkout', async ({ page }) => {
    // Navigate to cart
    await page.click('[data-testid="cart-icon"]');
    await expect(page.getByText('Your Cart')).toBeVisible();

    // Proceed to checkout
    await page.click('text=Checkout');
    await expect(page).toHaveURL('/checkout');

    // Fill shipping info
    await page.fill('[name="address"]', '123 Main St');
    await page.fill('[name="city"]', 'New York');
    await page.selectOption('[name="state"]', 'NY');
    await page.fill('[name="zip"]', '10001');

    // Complete order
    await page.click('text=Place Order');
    await expect(page.getByText('Order Confirmed')).toBeVisible();
  });
});

API Testing#

import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import request from 'supertest';
import { app } from '../app';
import { prisma } from '../lib/prisma';

describe('POST /api/users', () => {
  beforeAll(async () => {
    await prisma.$connect();
  });

  afterAll(async () => {
    await prisma.user.deleteMany();
    await prisma.$disconnect();
  });

  it('should create a user', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ email: 'test@example.com', name: 'Test User' })
      .expect(201);

    expect(response.body).toMatchObject({
      data: {
        email: 'test@example.com',
        name: 'Test User',
      },
    });
  });

  it('should return 400 for invalid data', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ email: 'invalid' })
      .expect(400);

    expect(response.body.error.code).toBe('VALIDATION_ERROR');
  });
});

Mocking Strategies#

Function Mocks#

// Simple mock
const mockFn = vi.fn();
mockFn.mockReturnValue('result');
mockFn.mockResolvedValue('async result');

// Spy on existing function
const spy = vi.spyOn(object, 'method');
spy.mockImplementation(() => 'mocked');

Module Mocks#

// Mock entire module
vi.mock('./api', () => ({
  fetchUser: vi.fn().mockResolvedValue({ id: '1', name: 'Test' }),
}));

// Partial mock
vi.mock('./utils', async () => {
  const actual = await vi.importActual('./utils');
  return {
    ...actual,
    formatDate: vi.fn().mockReturnValue('2024-01-01'),
  };
});

API Mocks with MSW#

import { rest } from 'msw';
import { setupServer } from 'msw/node';

const handlers = [
  rest.get('/api/users/:id', (req, res, ctx) => {
    return res(ctx.json({ id: req.params.id, name: 'Test User' }));
  }),
  rest.post('/api/users', (req, res, ctx) => {
    return res(ctx.status(201), ctx.json({ id: '1', ...req.body }));
  }),
];

const server = setupServer(...handlers);

beforeAll(() => server.listen());
afterEach(() => server.resetHandlers());
afterAll(() => server.close());

Test Coverage Strategy#

Test Type	Coverage Target	Focus Areas
Unit	80%+	Business logic, utilities
Integration	70%+	API endpoints, database
E2E	Critical paths	User journeys, checkout
Component	75%+	Interactive elements

Sample Prompts#

Task	Prompt
Unit tests	"Write unit tests for this reducer function"
Integration	"Create integration tests for the payment API"
E2E tests	"Write Playwright tests for user registration"
Mocking	"Set up mocks for this external API dependency"
Coverage	"Identify untested code paths in this module"

Configuration#

// bootspring.config.js
module.exports = {
  agents: {
    customInstructions: {
      'testing-expert': `
        - Use Vitest for unit/integration tests
        - Use Playwright for E2E tests
        - Follow AAA pattern
        - Include edge cases
        - Mock external dependencies
      `,
    },
  },
  quality: {
    thresholds: {
      coverage: 80,
    },
  },
};

Frontend Expert - Component testing
Backend Expert - API testing
Performance Expert - Performance testing