Using AI to Assist Unit Testing: From Manual Writing to Automated Generation

Goal

This article aims to help developers master methods and techniques for using AI tools to generate unit tests, understand the advantages and limitations of AI-generated tests, and establish efficient testing workflows.

Background

Unit testing is an important means of ensuring code quality, but writing tests manually is time-consuming and labor-intensive. The emergence of AI tools has changed this situation -- they can automatically generate test cases, cover edge cases, and significantly improve development efficiency.

Why Use AI to Write Tests?

1. Improve Efficiency: AI can generate test cases in seconds
2. Comprehensive Coverage: AI can think of edge cases that humans easily overlook
3. Reduce Repetition: Similar tests can be generated in batches
4. Stay Focused: Developers can focus on core business logic

Limitations of AI-Generated Tests

1. Business Logic: AI may not understand complex business rules
2. Integration Tests: Test scenarios require human design
3. Assertion Selection: AI may choose inappropriate assertions
4. Maintenance Cost: Generated tests may need adjustment

1. AI Test Generation Tools

GitHub Copilot

// Type function signature and comment
// Copilot will automatically generate tests

// Source code
function calculateDiscount(price: number, discount: number): number {
  if (price < 0) throw new Error('Price cannot be negative');
  if (discount < 0 || discount > 100) throw new Error('Invalid discount');
  return price * (1 - discount / 100);
}

// Tests generated by Copilot
describe('calculateDiscount', () => {
  it('should calculate discount correctly', () => {
    expect(calculateDiscount(100, 10)).toBe(90);
  });

  it('should return full price for 0% discount', () => {
    expect(calculateDiscount(100, 0)).toBe(100);
  });

  it('should return 0 for 100% discount', () => {
    expect(calculateDiscount(100, 100)).toBe(0);
  });

  it('should throw error for negative price', () => {
    expect(() => calculateDiscount(-100, 10)).toThrow('Price cannot be negative');
  });

  it('should throw error for invalid discount', () => {
    expect(() => calculateDiscount(100, -10)).toThrow('Invalid discount');
    expect(() => calculateDiscount(100, 110)).toThrow('Invalid discount');
  });
});

Cursor

// Cursor's @test command
// Select function -> Cmd+K -> "Generate tests"

// Source code
async function fetchUserData(userId: string): Promise<User> {
  const response = await fetch(`/api/users/${userId}`);
  if (!response.ok) {
    throw new Error('Failed to fetch user');
  }
  return response.json();
}

// Tests generated by Cursor
describe('fetchUserData', () => {
  const mockFetch = jest.fn();
  global.fetch = mockFetch;

  beforeEach(() => {
    mockFetch.mockClear();
  });

  it('should fetch user data successfully', async () => {
    const mockUser = { id: '1', name: 'John' };
    mockFetch.mockResolvedValue({
      ok: true,
      json: () => Promise.resolve(mockUser),
    });

    const user = await fetchUserData('1');

    expect(user).toEqual(mockUser);
    expect(mockFetch).toHaveBeenCalledWith('/api/users/1');
  });

  it('should throw error when response is not ok', async () => {
    mockFetch.mockResolvedValue({
      ok: false,
      status: 404,
    });

    await expect(fetchUserData('1')).rejects.toThrow('Failed to fetch user');
  });

  it('should handle network error', async () => {
    mockFetch.mockRejectedValue(new Error('Network error'));

    await expect(fetchUserData('1')).rejects.toThrow('Network error');
  });
});

Claude Code

# Using Claude Code to generate tests
> Write unit tests for all functions in src/utils/math.ts

# Claude Code will:
# 1. Analyze source code
# 2. Understand function behavior
# 3. Generate complete test file

2. AI Test Generation Best Practices

1. Provide Clear Context

// Good prompt
/**
 * Generate test cases covering:
 * 1. Normal cases
 * 2. Boundary values (0, 100)
 * 3. Invalid inputs (negative, exceeding 100)
 * 4. Async operations success and failure
 */

// Bad prompt
// "Write tests"

2. Iterative Generation

## Iteration Steps

### Round 1
> Generate basic tests for UserService class

### Round 2
> Add more edge case tests

### Round 3
> Add async operation and error handling tests

### Round 4
> Optimize test code, add setup/teardown

3. Review and Adjust

// AI-generated tests may need adjustment

// Original generation
it('should work', () => {
  expect(result).toBeTruthy();
});

// Adjusted
it('should return user with valid id', () => {
  const user = service.getUser('valid-id');
  expect(user).toBeDefined();
  expect(user.id).toBe('valid-id');
  expect(user.name).toBe('John');
});

4. Maintain Test Independence

// Good tests: Independent execution
describe('UserService', () => {
  let service: UserService;
  let mockDb: MockDatabase;

  beforeEach(() => {
    mockDb = new MockDatabase();
    service = new UserService(mockDb);
  });

  it('test 1', async () => {
    // Each test independent
  });

  it('test 2', async () => {
    // Doesn't depend on other tests
  });
});

3. Practical Examples

Example 1: React Component Tests

// AI-generated React component tests
import { render, screen, fireEvent } from '@testing-library/react';
import { UserCard } from './UserCard';

describe('UserCard', () => {
  const mockUser = {
    id: '1',
    name: 'John Doe',
    email: 'john@example.com',
    avatar: '/avatar.jpg',
  };

  const mockOnEdit = jest.fn();
  const mockOnDelete = jest.fn();

  it('should render user information', () => {
    render(
      <UserCard
        user={mockUser}
        onEdit={mockOnEdit}
        onDelete={mockOnDelete}
      />
    );

    expect(screen.getByText('John Doe')).toBeInTheDocument();
    expect(screen.getByText('john@example.com')).toBeInTheDocument();
    expect(screen.getByAltText('John Doe')).toHaveAttribute(
      'src',
      '/avatar.jpg'
    );
  });

  it('should call onEdit when edit button is clicked', () => {
    render(
      <UserCard
        user={mockUser}
        onEdit={mockOnEdit}
        onDelete={mockOnDelete}
      />
    );

    fireEvent.click(screen.getByText('Edit'));
    expect(mockOnEdit).toHaveBeenCalledWith(mockUser.id);
  });

  it('should call onDelete when delete button is clicked', () => {
    render(
      <UserCard
        user={mockUser}
        onEdit={mockOnEdit}
        onDelete={mockOnDelete}
      />
    );

    fireEvent.click(screen.getByText('Delete'));
    expect(mockOnDelete).toHaveBeenCalledWith(mockUser.id);
  });

  it('should show confirmation dialog before delete', async () => {
    window.confirm = jest.fn(() => true);

    render(
      <UserCard
        user={mockUser}
        onEdit={mockOnEdit}
        onDelete={mockOnDelete}
      />
    );

    fireEvent.click(screen.getByText('Delete'));
    expect(window.confirm).toHaveBeenCalled();
    expect(mockOnDelete).toHaveBeenCalledWith(mockUser.id);
  });
});

Example 2: API Tests

// AI-generated API tests
import request from 'supertest';
import app from '../app';
import { db } from '../database';

describe('User API', () => {
  beforeEach(async () => {
    await db.truncate();
  });

  describe('GET /api/users', () => {
    it('should return empty array when no users', async () => {
      const response = await request(app).get('/api/users');
      expect(response.status).toBe(200);
      expect(response.body).toEqual([]);
    });

    it('should return users', async () => {
      await db.users.create({ name: 'John', email: 'john@example.com' });

      const response = await request(app).get('/api/users');
      expect(response.status).toBe(200);
      expect(response.body).toHaveLength(1);
      expect(response.body[0].name).toBe('John');
    });

    it('should support pagination', async () => {
      // Create 15 users
      for (let i = 0; i < 15; i++) {
        await db.users.create({ name: `User ${i}`, email: `user${i}@example.com` });
      }

      const response = await request(app)
        .get('/api/users')
        .query({ page: 1, limit: 10 });

      expect(response.status).toBe(200);
      expect(response.body).toHaveLength(10);
      expect(response.body.total).toBe(15);
    });
  });

  describe('POST /api/users', () => {
    it('should create user', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({ name: 'John', email: 'john@example.com' });

      expect(response.status).toBe(201);
      expect(response.body.name).toBe('John');
    });

    it('should validate required fields', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({ name: 'John' });

      expect(response.status).toBe(400);
      expect(response.body.errors).toContain('email is required');
    });

    it('should validate email format', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({ name: 'John', email: 'invalid-email' });

      expect(response.status).toBe(400);
      expect(response.body.errors).toContain('invalid email format');
    });
  });
});

Example 3: Utility Function Tests

// AI-generated utility function tests
import {
  formatDate,
  validateEmail,
  calculateAge,
  debounce,
  deepClone,
} from './utils';

describe('formatDate', () => {
  it('should format date correctly', () => {
    const date = new Date('2024-01-15');
    expect(formatDate(date)).toBe('2024-01-15');
  });

  it('should handle invalid date', () => {
    expect(() => formatDate(new Date('invalid'))).toThrow('Invalid date');
  });
});

describe('validateEmail', () => {
  it('should validate correct email', () => {
    expect(validateEmail('test@example.com')).toBe(true);
  });

  it('should reject invalid email', () => {
    expect(validateEmail('invalid')).toBe(false);
    expect(validateEmail('test@')).toBe(false);
    expect(validateEmail('@example.com')).toBe(false);
  });
});

describe('calculateAge', () => {
  it('should calculate age correctly', () => {
    const birthDate = new Date('1990-01-01');
    const age = calculateAge(birthDate);
    expect(age).toBeGreaterThan(30);
  });

  it('should handle future date', () => {
    const futureDate = new Date('2030-01-01');
    expect(() => calculateAge(futureDate)).toThrow('Invalid birth date');
  });
});

describe('debounce', () => {
  beforeEach(() => {
    jest.useFakeTimers();
  });

  afterEach(() => {
    jest.useRealTimers();
  });

  it('should debounce function calls', () => {
    const mockFn = jest.fn();
    const debouncedFn = debounce(mockFn, 500);

    debouncedFn();
    debouncedFn();
    debouncedFn();

    expect(mockFn).not.toHaveBeenCalled();

    jest.advanceTimersByTime(500);

    expect(mockFn).toHaveBeenCalledTimes(1);
  });
});

describe('deepClone', () => {
  it('should deep clone objects', () => {
    const original = {
      a: 1,
      b: { c: 2 },
      d: [1, 2, 3],
    };

    const cloned = deepClone(original);

    expect(cloned).toEqual(original);
    expect(cloned).not.toBe(original);
    expect(cloned.b).not.toBe(original.b);
  });

  it('should handle circular references', () => {
    const obj: any = { a: 1 };
    obj.self = obj;

    const cloned = deepClone(obj);
    expect(cloned.a).toBe(1);
    expect(cloned.self).toBe(cloned);
  });
});

4. Improving Test Quality

1. Test Coverage Analysis

# Generate coverage report
npm test -- --coverage

# View report
open coverage/lcov-report/index.html

2. Mutation Testing

// Using Stryker for mutation testing
// stryker.conf.js
module.exports = {
  mutate: ['src/**/*.ts'],
  testRunner: 'jest',
  coverageAnalysis: 'perTest',
};

3. Test Review Checklist

## Test Review Checklist

### Test Structure
- [ ] Test name clearly describes test content
- [ ] Correctly organized using describe/it
- [ ] Each test tests only one functionality

### Test Data
- [ ] Uses meaningful test data
- [ ] Covers edge cases
- [ ] Cleans up test data

### Assertions
- [ ] Uses specific assertions
- [ ] Tests expected behavior
- [ ] Verifies side effects

### Maintainability
- [ ] Avoids test duplication
- [ ] Uses setup/teardown
- [ ] Keeps tests independent

5. Workflow Optimization

1. TDD + AI

## TDD + AI Workflow

### Step 1: Write Tests (Human)
- Define test scenarios
- Write test cases

### Step 2: AI Generates Implementation
> Generate implementation code based on tests

### Step 3: Review and Adjust
- Check code quality
- Optimize implementation

### Step 4: Supplement Tests
> Add more tests for edge cases

2. Code Review + AI

## Code Review + AI Workflow

### Step 1: Code Review
- Identify potential issues
- Mark areas needing tests

### Step 2: AI Generates Tests
> Generate tests for marked code

### Step 3: Human Review
- Check test quality
- Adjust test scenarios

### Step 4: Merge Code

3. Refactoring + AI

## Refactoring + AI Workflow

### Step 1: Ensure Existing Tests Pass
npm test

### Step 2: Refactor Code
- Modify implementation
- Keep interface unchanged

### Step 3: AI Supplements Tests
> Generate tests for new code

### Step 4: Verify All Tests Pass
npm test

6. Common Problems and Solutions

Problem 1: Generated Tests Not Deep Enough

// Solution: Provide more detailed prompts
/**
 * Generate tests covering:
 * 1. Normal cases
 * 2. Boundary values (0, MAX_VALUE)
 * 3. Invalid inputs (null, undefined, empty string)
 * 4. Async operation timeout
 * 5. Concurrent calls
 */

Problem 2: Tests Depend on External Services

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

it('should handle API error', async () => {
  (api.fetchUser as jest.Mock).mockRejectedValue(new Error('Network error'));
  
  await expect(service.getUser('1')).rejects.toThrow('Network error');
});

Problem 3: Test Code Duplication

// Solution: Extract common helpers
function createTestUser(overrides = {}) {
  return {
    id: '1',
    name: 'Test User',
    email: 'test@example.com',
    ...overrides,
  };
}

it('should process user', () => {
  const user = createTestUser({ name: 'Custom Name' });
  // ...
});

7. Efficiency Comparison

## Efficiency Comparison Data

### Traditional Approach
- Understand code: 10 minutes
- Design test scenarios: 15 minutes
- Write test code: 30 minutes
- Debug tests: 10 minutes
- Total: 65 minutes

### AI-Assisted Approach
- Provide context: 5 minutes
- AI generates tests: 1 minute
- Review and adjust: 15 minutes
- Debug tests: 5 minutes
- Total: 26 minutes

### Efficiency Improvement: 60%

Summary

AI-assisted testing is an effective way to improve development efficiency, but requires correct usage.

| Aspect | Advantage | Consideration | |--------|-----------|---------------| | Efficiency | Significant improvement | Requires review | | Coverage | More comprehensive | May have redundancy | | Quality | Basic guarantee | Requires human optimization | | Maintenance | Reduces repetition | May need adjustment |

Recommendations:

1. AI is Assistance: Test design still requires human thinking
2. Review is Essential: AI-generated tests need review
3. Iterative Generation: Start simple, gradually go deeper
4. Maintain Independence: Tests should run independently
5. Continuous Optimization: Regularly review and improve tests

AI-assisted testing can free you from repetitive work and focus on more valuable tasks. This guide will help you establish an efficient testing workflow.