Skip to main content

Testing Requirements

In This Document​

Testing Philosophy​

Our team believes that comprehensive testing is essential for maintaining a reliable, high-quality codebase. Our testing philosophy is guided by these principles:

  1. Test Early, Test Often: Testing should be integrated throughout the development process
  2. Appropriate Coverage: Different code requires different levels of testing
  3. Automation First: Automate tests wherever possible
  4. Test Readability: Tests should be clear and serve as documentation
  5. Continuous Improvement: Testing practices should evolve with the codebase

Required Testing Types​

Unit Testing Requirements​

  • Coverage Target: Minimum 80% code coverage for business logic
  • Framework: PHPUnit for PHP, Jest for JavaScript
  • Scope: Individual classes and functions
  • Isolation: Use mocks and stubs to isolate the unit under test
  • Naming Convention: test[MethodName]_[Scenario]_[ExpectedResult]

Example unit test:

public function testCalculateTotal_WithValidItems_ReturnsCorrectSum()
{
    // Arrange
    $calculator = new PriceCalculator();
    $items = [
        ['price' => 10, 'quantity' => 2],
        ['price' => 15, 'quantity' => 1],
    ];
    
    // Act
    $result = $calculator->calculateTotal($items);
    
    // Assert
    $this->assertEquals(35, $result);
}

Test Environment Setup​

Local Testing Environment​

  • Use Docker for consistent test environments
  • Configure separate test database
  • Seed test data using factories
  • Use .env.testing configuration
  • Reset state between test runs

CI Testing Environment​

  • Run tests on every pull request
  • Use GitHub Actions or similar CI service
  • Test against multiple PHP/Node.js versions
  • Cache dependencies to speed up builds
  • Generate and store test reports

Test Data Management​

Test Data Principles​

  • Use factories to generate test data
  • Create specific data for edge cases
  • Clean up test data after tests
  • Don't rely on existing database state
  • Use realistic but anonymized data

Factory Usage​

// Example of using factories for test data
public function testUserList_WithMultipleUsers_ReturnsPaginatedResults()
{
    // Create 25 test users
    User::factory()->count(25)->create();
    
    // Act
    $response = $this->getJson('/api/users?page=1&per_page=10');
    
    // Assert
    $response->assertStatus(200)
             ->assertJsonCount(10, 'data')
             ->assertJsonPath('meta.total', 25)
             ->assertJsonPath('meta.last_page', 3);
}

Testing Standards​

Test Structure​

All tests should follow the Arrange-Act-Assert (AAA) pattern:

  1. Arrange: Set up the test conditions
  2. Act: Perform the action being tested
  3. Assert: Verify the expected outcome

Test Naming​

  • Use descriptive names that explain the test's purpose
  • Follow the pattern: test[MethodName]_[Scenario]_[ExpectedResult]
  • Examples:
    • testLogin_WithValidCredentials_RedirectsToDashboard
    • testCalculateTotal_WithNegativeValues_ThrowsException

Test Organization​

  • Group related tests in test classes
  • Mirror the application's structure in test organization
  • Use test suites to categorize tests
  • Separate slow tests from fast tests

Code Coverage​

Coverage Targets​

  • Business Logic: 80% minimum coverage
  • Controllers: 90% minimum coverage
  • Models: 70% minimum coverage
  • Utilities: 90% minimum coverage

Coverage Reporting​

  • Generate coverage reports in CI pipeline
  • Review coverage on pull requests
  • Track coverage trends over time
  • Address coverage gaps in critical areas

Test-Driven Development​

When practicing TDD, follow this workflow:

  1. Write a failing test for the required functionality
  2. Implement the minimum code to pass the test
  3. Refactor the code while keeping tests passing
  4. Repeat for the next piece of functionality

Testing Legacy Code​

For untested legacy code:

  1. Add tests before making changes
  2. Focus on characterization tests first
  3. Gradually improve coverage with each change
  4. Prioritize testing based on risk and change frequency

Performance Testing​

Performance Test Types​

  • Load Testing: Verify system behavior under expected load
  • Stress Testing: Find breaking points under extreme load
  • Endurance Testing: Check for issues over extended periods
  • Spike Testing: Test sudden increases in load

Performance Metrics​

  • Response time
  • Throughput
  • Error rate
  • Resource utilization
  • Database query performance

Security Testing​

Include these security tests:

  • Input validation and sanitization
  • Authentication and authorization
  • SQL injection prevention
  • Cross-site scripting (XSS) prevention
  • CSRF protection
  • API security

Test Documentation​

Each test suite should include:

  • Purpose of the tests
  • Setup requirements
  • Data dependencies
  • Expected outcomes
  • Known limitations

Continuous Improvement​

Regularly review and improve testing practices:

  • Analyze test failures for patterns
  • Refactor brittle or flaky tests
  • Update tests when requirements change
  • Share testing knowledge across the team
  • Experiment with new testing tools and approaches
Last updated on by Behnam Moradi