job-forge/.claude/templates/testing_template.md

Testing Guide: [Feature Name]

Overview

Brief description of what feature/component is being tested and its main functionality.

Test Strategy

Testing Scope

• In Scope: What will be tested
• Out of Scope: What won't be tested in this phase
• Dependencies: External services or components needed

Test Types

• Unit Tests
• Integration Tests
• API Tests
• End-to-End Tests
• Performance Tests
• Security Tests
• Accessibility Tests

Test Scenarios

✅ Happy Path Scenarios

• Scenario 1: User successfully [performs main action]

  • Given: [Initial conditions]
  • When: [User action]
  • Then: [Expected result]

• Scenario 2: System handles valid input correctly

  • Given: [Setup conditions]
  • When: [Input provided]
  • Then: [Expected behavior]

⚠️ Edge Cases

• Empty/Null Data: System handles empty or null inputs
• Boundary Values: Maximum/minimum allowed values
• Special Characters: Unicode, SQL injection attempts
• Large Data Sets: Performance with large amounts of data
• Concurrent Users: Multiple users accessing same resource

❌ Error Scenarios

• Invalid Input: System rejects invalid data with proper errors
• Network Failures: Handles network timeouts gracefully
• Server Errors: Displays appropriate error messages
• Authentication Failures: Proper handling of auth errors
• Permission Denied: Appropriate access control

Automated Test Implementation

Unit Tests

// Jest unit test example
describe('[ComponentName]', () => {
  beforeEach(() => {
    // Setup before each test
  });

  afterEach(() => {
    // Cleanup after each test
  });

  describe('Happy Path', () => {
    it('should [expected behavior] when [condition]', () => {
      // Arrange
      const input = { /* test data */ };
      
      // Act
      const result = functionUnderTest(input);
      
      // Assert
      expect(result).toEqual(expectedOutput);
    });
  });

  describe('Error Handling', () => {
    it('should throw error when [invalid condition]', () => {
      const invalidInput = { /* invalid data */ };
      
      expect(() => {
        functionUnderTest(invalidInput);
      }).toThrow('Expected error message');
    });
  });
});

API Integration Tests

// API test example
describe('API: [Endpoint Name]', () => {
  beforeAll(async () => {
    // Setup test database
    await setupTestDb();
  });

  afterAll(async () => {
    // Cleanup test database
    await cleanupTestDb();
  });

  it('should return success with valid data', async () => {
    const testData = {
      field1: 'test value',
      field2: 123
    };

    const response = await request(app)
      .post('/api/endpoint')
      .send(testData)
      .expect(200);

    expect(response.body).toMatchObject({
      success: true,
      data: expect.objectContaining(testData)
    });
  });

  it('should return 400 for invalid data', async () => {
    const invalidData = {
      field1: '', // Invalid
      field2: 'not a number' // Invalid
    };

    const response = await request(app)
      .post('/api/endpoint')
      .send(invalidData)
      .expect(400);

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

End-to-End Tests

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

test.describe('[Feature Name] E2E Tests', () => {
  test.beforeEach(async ({ page }) => {
    // Setup: Login user, navigate to feature
    await page.goto('/login');
    await page.fill('[data-testid="email"]', 'test@example.com');
    await page.fill('[data-testid="password"]', 'password123');
    await page.click('[data-testid="login-button"]');
    await page.waitForURL('/dashboard');
  });

  test('should complete full user workflow', async ({ page }) => {
    // Navigate to feature
    await page.goto('/feature-page');
    
    // Perform main user action
    await page.fill('[data-testid="input-field"]', 'test input');
    await page.click('[data-testid="submit-button"]');
    
    // Verify result
    await expect(page.locator('[data-testid="success-message"]')).toBeVisible();
    await expect(page.locator('[data-testid="result"]')).toContainText('Expected result');
  });

  test('should show validation errors', async ({ page }) => {
    await page.goto('/feature-page');
    
    // Submit without required data
    await page.click('[data-testid="submit-button"]');
    
    // Verify error messages
    await expect(page.locator('[data-testid="error-message"]')).toBeVisible();
    await expect(page.locator('[data-testid="error-message"]')).toContainText('Required field');
  });
});

Manual Testing Checklist

Functional Testing

• All required fields are properly validated
• Optional fields work correctly when empty
• Form submissions work as expected
• Navigation between screens functions properly
• Data persistence works correctly
• Error messages are clear and helpful

User Experience Testing

• Interface is intuitive and easy to use
• Loading states are displayed appropriately
• Success/error feedback is clear
• Responsive design works on different screen sizes
• Performance is acceptable (< 3 seconds load time)

Cross-Browser Testing

Browser	Version	Status	Notes
Chrome	Latest	⏳
Firefox	Latest	⏳
Safari	Latest	⏳
Edge	Latest	⏳

Mobile Testing

Device	Browser	Status	Notes
iPhone	Safari	⏳
Android	Chrome	⏳
Tablet	Safari/Chrome	⏳

Accessibility Testing

• Keyboard Navigation: All interactive elements accessible via keyboard
• Screen Reader: Content readable with screen reader software
• Color Contrast: Sufficient contrast ratios (4.5:1 minimum)
• Focus Indicators: Clear focus indicators for all interactive elements
• Alternative Text: Images have appropriate alt text
• Form Labels: All form fields have associated labels

Performance Testing

Load Testing Scenarios

# k6 load test configuration
scenarios:
  normal_load:
    users: 10
    duration: 5m
    expected_response_time: < 200ms
    
  stress_test:
    users: 100  
    duration: 2m
    expected_response_time: < 500ms
    
  spike_test:
    users: 500
    duration: 30s
    acceptable_error_rate: < 5%

Performance Acceptance Criteria

• Page load time < 3 seconds
• API response time < 200ms (95th percentile)
• Database query time < 50ms (average)
• No memory leaks during extended use
• Graceful degradation under high load

Security Testing

Security Test Cases

• Input Validation: SQL injection prevention
• XSS Protection: Cross-site scripting prevention
• CSRF Protection: Cross-site request forgery prevention
• Authentication: Proper login/logout functionality
• Authorization: Access control working correctly
• Session Management: Secure session handling
• Password Security: Strong password requirements
• Data Encryption: Sensitive data encrypted

Security Testing Tools

# OWASP ZAP security scan
zap-baseline.py -t http://localhost:3000

# Dependency vulnerability scan
npm audit

# Static security analysis
semgrep --config=auto src/

Test Data Management

Test Data Requirements

test_users:
  - email: test@example.com
    password: password123
    role: user
    status: active
    
  - email: admin@example.com
    password: admin123
    role: admin
    status: active

test_data:
  - valid_records: 10
  - invalid_records: 5
  - edge_case_records: 3

Data Cleanup

// Test data cleanup utilities
export const cleanupTestData = async () => {
  await TestUser.destroy({ where: { email: { [Op.like]: '%@test.com' } } });
  await TestRecord.destroy({ where: { isTestData: true } });
};

Test Execution

Test Suite Execution

# Run all tests
npm test

# Run specific test types
npm run test:unit
npm run test:integration
npm run test:e2e

# Run tests with coverage
npm run test:coverage

# Run performance tests
npm run test:performance

Continuous Integration

# CI test pipeline
stages:
  - unit_tests
  - integration_tests
  - security_scan
  - e2e_tests
  - performance_tests

quality_gates:
  - test_coverage: > 80%
  - security_scan: no_critical_issues
  - performance: response_time < 500ms

Test Reports

Coverage Report

• Target: 80% code coverage minimum
• Critical Paths: 100% coverage required
• Report Location: coverage/lcov-report/index.html

Test Results Summary

Test Type	Total	Passed	Failed	Skipped	Coverage
Unit	-	-	-	-	-%
Integration	-	-	-	-	-%
E2E	-	-	-	-	-%
Total	-	-	-	-	-%

Issue Tracking

Bug Report Template

**Bug Title**: [Brief description]

**Environment**: [Development/Staging/Production]

**Steps to Reproduce**:
1. [Step 1]
2. [Step 2]
3. [Step 3]

**Expected Result**: [What should happen]

**Actual Result**: [What actually happened]

**Screenshots/Logs**: [Attach if applicable]

**Priority**: [Critical/High/Medium/Low]

**Assigned To**: [Team member]

Sign-off Criteria

Definition of Done

• All test scenarios executed and passed
• Code coverage meets minimum requirements
• Security testing completed with no critical issues
• Performance requirements met
• Cross-browser testing completed
• Accessibility requirements verified
• Documentation updated
• Stakeholder acceptance received

Test Sign-off

• Tested By: [Name]
• Date: [Date]
• Test Environment: [Environment details]
• Overall Status: [PASS/FAIL]
• Recommendation: [GO/NO-GO for deployment]

---

Test Plan Version: 1.0
Last Updated: [Date]
Next Review: [Date]