From aidotnet-moyucode
Generates comprehensive test suites with unit, integration, and E2E tests including mocks and edge cases for Jest, Vitest (TypeScript), pytest (Python), and xUnit. Useful for test coverage requests or /test command.
npx claudepluginhub joshuarweaver/cascade-data-analytics --plugin aidotnet-moyucodeThis skill uses the workspace's default tool permissions.
Generate comprehensive test suites with unit tests, integration tests, mocks, and edge case coverage.
Conducts multi-round deep research on GitHub repos via API and web searches, generating markdown reports with executive summaries, timelines, metrics, and Mermaid diagrams.
Dynamically discovers and combines enabled skills into cohesive, unexpected delightful experiences like interactive HTML or themed artifacts. Activates on 'surprise me', inspiration, or boredom cues.
Generates images from structured JSON prompts via Python script execution. Supports reference images and aspect ratios for characters, scenes, products, visuals.
Generate comprehensive test suites with unit tests, integration tests, mocks, and edge case coverage.
/test commandYou are a testing expert that creates comprehensive test suites.
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { UserService } from './UserService';
import { UserRepository } from './UserRepository';
// Mock the repository
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('should create a user with valid data', async () => {
// Arrange
const userData = { email: 'test@example.com', name: 'Test User' };
const expectedUser = { id: '123', ...userData, createdAt: new Date() };
mockRepository.create.mockResolvedValue(expectedUser);
// Act
const result = await userService.createUser(userData);
// Assert
expect(result).toEqual(expectedUser);
expect(mockRepository.create).toHaveBeenCalledWith(userData);
expect(mockRepository.create).toHaveBeenCalledTimes(1);
});
it('should throw error for duplicate email', async () => {
// Arrange
const userData = { email: 'existing@example.com', name: 'Test' };
mockRepository.create.mockRejectedValue(new Error('DUPLICATE_EMAIL'));
// Act & Assert
await expect(userService.createUser(userData))
.rejects.toThrow('DUPLICATE_EMAIL');
});
it('should validate email format', async () => {
// Arrange
const invalidData = { email: 'invalid-email', name: 'Test' };
// Act & Assert
await expect(userService.createUser(invalidData))
.rejects.toThrow('INVALID_EMAIL');
});
});
describe('getUserById', () => {
it('should return user when found', async () => {
const user = { id: '123', email: 'test@example.com', name: 'Test' };
mockRepository.findById.mockResolvedValue(user);
const result = await userService.getUserById('123');
expect(result).toEqual(user);
});
it('should return null when user not found', async () => {
mockRepository.findById.mockResolvedValue(null);
const result = await userService.getUserById('nonexistent');
expect(result).toBeNull();
});
});
});
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):
# Arrange
user_data = {"email": "test@example.com", "name": "Test User"}
expected = {"id": "123", **user_data}
mock_repository.create.return_value = expected
# Act
result = user_service.create_user(user_data)
# Assert
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("DUPLICATE_EMAIL")
with pytest.raises(ValueError, match="DUPLICATE_EMAIL"):
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="INVALID_EMAIL"):
user_service.create_user({"email": invalid_email, "name": "Test"})
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()
{
// Arrange
var userData = new CreateUserDto { Email = "test@example.com", Name = "Test" };
var expectedUser = new User { Id = Guid.NewGuid(), Email = userData.Email };
_mockRepository.Setup(r => r.CreateAsync(It.IsAny<User>()))
.ReturnsAsync(expectedUser);
// Act
var result = await _userService.CreateUserAsync(userData);
// Assert
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 = "Test" };
await Assert.ThrowsAsync<ValidationException>(
() => _userService.CreateUserAsync(userData));
}
}
testing, unit-tests, integration-tests, tdd, quality-assurance