testing-fundamentals

Testing Fundamentals Skill

Overview

This skill provides comprehensive testing strategies following TDD principles with 80%+ coverage requirements. It ensures quality assurance through systematic testing approaches.

When to Use This Skill

• Implementing new features (TDD approach)
• Creating comprehensive test suites
• Analyzing test coverage gaps
• Pre-production quality validation
• Refactoring with safety net

TDD Workflow (Level 1 - Always Loaded)

🔴 Red → 🟢 Green → 🔵 Refactor

Step 1: Red - Write Failing Test First

// Write the test BEFORE implementation
describe('UserService', () => {
  it('should create a new user with valid data', async () => {
    // Arrange
    const userData = {
      email: '[email protected]',
      password: 'SecurePass123!',
      name: 'Test User'
    };

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

    // Assert
    expect(result).toHaveProperty('id');
    expect(result.email).toBe(userData.email);
    expect(result.name).toBe(userData.name);
    expect(result).not.toHaveProperty('password'); // Password should not be returned
  });
});

// Test should FAIL initially (Red)

Step 2: Green - Write Minimal Code to Pass

class UserService {
  async createUser(data: CreateUserDto): Promise<User> {
    // Minimal implementation to make test pass
    const user = {
      id: generateId(),
      email: data.email,
      name: data.name,
      // password is hashed and not returned
    };

    await this.userRepository.save(user);
    return user;
  }
}

// Test should PASS now (Green)

Step 3: Refactor - Improve Code Quality

class UserService {
  async createUser(data: CreateUserDto): Promise<User> {
    // Refactor with better structure
    this.validateUserData(data);

    const hashedPassword = await this.hashPassword(data.password);

    const user = User.create({
      email: data.email,
      name: data.name,
      passwordHash: hashedPassword,
    });

    return this.userRepository.save(user);
  }

  private validateUserData(data: CreateUserDto): void {
    if (!validator.isEmail(data.email)) {
      throw new ValidationError('Invalid email');
    }
    if (data.password.length < 8) {
      throw new ValidationError('Password too short');
    }
  }

  private async hashPassword(password: string): Promise<string> {
    return bcrypt.hash(password, 12);
  }
}

// Tests still PASS after refactoring