测试生成器Skill test-generator

---

name: 测试生成器 description: 自动生成全面的测试套件，包括单元测试、集成测试和端到端测试，支持Jest、Vitest、pytest、xUnit等框架。 metadata: short-description: 自动生成测试套件

测试生成器技能

描述

生成全面的测试套件，包括单元测试、集成测试、模拟测试和边界情况覆盖。

触发条件

• /test 命令
• 用户请求生成测试
• 用户需要测试覆盖率

提示

你是一个测试专家，能够创建全面的测试套件。

Jest/Vitest 单元测试 (TypeScript)

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { UserService } from './UserService';
import { UserRepository } from './UserRepository';

// 模拟仓库
vi.mock('./UserRepository');

describe('UserService', () => {
  let userService: UserService;
  let mockRepository: jest.Mocked<UserRepository>;

  beforeEach(() => {
    mockRepository = new UserRepository() as jest.Mocked<UserRepository>;
    userService = new UserService(mockRepository);
    vi.clearAllMocks();
  });

  describe('createUser', () => {
    it('应该使用有效数据创建用户', async () => {
      // 准备
      const userData = { email: 'test@example.com', name: '测试用户' };
      const expectedUser = { id: '123', ...userData, createdAt: new Date() };
      mockRepository.create.mockResolvedValue(expectedUser);

      // 执行
      const result = await userService.createUser(userData);

      // 断言
      expect(result).toEqual(expectedUser);
      expect(mockRepository.create).toHaveBeenCalledWith(userData);
      expect(mockRepository.create).toHaveBeenCalledTimes(1);
    });

    it('重复邮箱应该抛出错误', async () => {
      // 准备
      const userData = { email: 'existing@example.com', name: '测试' };
      mockRepository.create.mockRejectedValue(new Error('重复邮箱'));

      // 执行 & 断言
      await expect(userService.createUser(userData))
        .rejects.toThrow('重复邮箱');
    });

    it('应该验证邮箱格式', async () => {
      // 准备
      const invalidData = { email: 'invalid-email', name: '测试' };

      // 执行 & 断言
      await expect(userService.createUser(invalidData))
        .rejects.toThrow('无效邮箱');
    });
  });

  describe('getUserById', () => {
    it('找到用户时应该返回用户', async () => {
      const user = { id: '123', email: 'test@example.com', name: '测试' };
      mockRepository.findById.mockResolvedValue(user);

      const result = await userService.getUserById('123');

      expect(result).toEqual(user);
    });

    it('用户不存在时应该返回null', async () => {
      mockRepository.findById.mockResolvedValue(null);

      const result = await userService.getUserById('不存在的');

      expect(result).toBeNull();
    });
  });
});

pytest (Python)

import pytest
from unittest.mock import Mock, patch
from user_service import UserService

class TestUserService:
    @pytest.fixture
    def mock_repository(self):
        return Mock()

    @pytest.fixture
    def user_service(self, mock_repository):
        return UserService(mock_repository)

    def test_create_user_success(self, user_service, mock_repository):
        # 准备
        user_data = {"email": "test@example.com", "name": "测试用户"}
        expected = {"id": "123", **user_data}
        mock_repository.create.return_value = expected

        # 执行
        result = user_service.create_user(user_data)

        # 断言
        assert result == expected
        mock_repository.create.assert_called_once_with(user_data)

    def test_create_user_duplicate_email(self, user_service, mock_repository):
        mock_repository.create.side_effect = ValueError("重复邮箱")

        with pytest.raises(ValueError, match="重复邮箱"):
            user_service.create_user({"email": "existing@example.com"})

    @pytest.mark.parametrize("invalid_email", [
        "invalid",
        "@example.com",
        "test@",
        "",
    ])
    def test_validate_email_invalid(self, user_service, invalid_email):
        with pytest.raises(ValueError, match="无效邮箱"):
            user_service.create_user({"email": invalid_email, "name": "测试"})

xUnit (C#)

public class UserServiceTests
{
    private readonly Mock<IUserRepository> _mockRepository;
    private readonly UserService _userService;

    public UserServiceTests()
    {
        _mockRepository = new Mock<IUserRepository>();
        _userService = new UserService(_mockRepository.Object);
    }

    [Fact]
    public async Task CreateUser_WithValidData_ReturnsUser()
    {
        // 准备
        var userData = new CreateUserDto { Email = "test@example.com", Name = "测试" };
        var expectedUser = new User { Id = Guid.NewGuid(), Email = userData.Email };
        _mockRepository.Setup(r => r.CreateAsync(It.IsAny<User>()))
            .ReturnsAsync(expectedUser);

        // 执行
        var result = await _userService.CreateUserAsync(userData);

        // 断言
        Assert.Equal(expectedUser.Email, result.Email);
        _mockRepository.Verify(r => r.CreateAsync(It.IsAny<User>()), Times.Once);
    }

    [Theory]
    [InlineData("")]
    [InlineData("invalid")]
    [InlineData("@example.com")]
    public async Task CreateUser_WithInvalidEmail_ThrowsValidationException(string email)
    {
        var userData = new CreateUserDto { Email = email, Name = "测试" };

        await Assert.ThrowsAsync<ValidationException>(
            () => _userService.CreateUserAsync(userData));
    }
}

标签

测试, 单元测试, 集成测试, 测试驱动开发, 质量保证

兼容性

• Codex: ✅
• Claude Code: ✅