Testing and Debugging

45 min

Testing is essential for building reliable, maintainable PHP applications. Tests verify that code works correctly, prevent regressions, enable confident refactoring, and serve as documentation. PHPUnit is the de facto standard testing framework for PHP, providing assertions, test organization, mocking, and code coverage tools. Understanding testing helps you build applications with confidence and maintain code quality over time.

PHPUnit provides a comprehensive testing framework with assertions (`assertEquals`, `assertTrue`, `assertFalse`, `assertNull`, etc.), test organization (test classes and methods), fixtures (`setUp` and `tearDown`), data providers (testing with multiple data sets), and mocking (creating fake objects for testing). Tests are organized into test classes that extend `PHPUnitFrameworkTestCase`. Understanding PHPUnit enables you to write effective tests.

Unit tests test individual units of code (functions, methods, classes) in isolation. They should be fast, isolated, repeatable, and test one thing at a time. Unit tests use mocks to isolate the unit under test from dependencies. Integration tests test how multiple units work together. End-to-end tests test complete application workflows. Understanding different test types helps you build comprehensive test coverage.

Debugging involves identifying and fixing issues in code. PHP provides debugging tools including `var_dump()`, `print_r()`, `error_log()`, `debug_backtrace()`, and Xdebug (advanced debugger with breakpoints, step-through debugging, and profiling). IDEs provide integrated debugging with breakpoints, variable inspection, and call stack navigation. Understanding debugging tools helps you identify and fix issues efficiently.

Writing testable code involves designing code that's easy to test. This includes dependency injection (passing dependencies rather than creating them), avoiding global state, keeping functions focused, and separating concerns. Testable code is usually better-designed code. Understanding testability helps you write maintainable, reliable applications.

Best practices include writing tests before or alongside code (TDD), testing behavior not implementation, keeping tests simple and focused, using descriptive test names, maintaining high test coverage, and running tests frequently. Tests should be fast, reliable, and maintainable. Understanding testing enables you to build robust PHP applications with confidence.

Key Concepts

Testing verifies code works correctly and prevents regressions.
PHPUnit is the standard testing framework for PHP.
Unit tests test individual units in isolation.
Debugging tools help identify and fix issues.
Writing testable code improves application quality.

Learning Objectives

Master

Writing unit tests with PHPUnit
Using assertions and test organization
Working with mocks and test fixtures
Using debugging tools effectively

Develop

Test-driven development thinking
Understanding testing strategies and coverage
Designing testable, maintainable code

Tips

Write tests before or alongside code (TDD approach).
Test behavior, not implementation details.
Use PHPUnit assertions for clear, readable tests.
Use Xdebug or IDE debuggers for step-through debugging.

Common Pitfalls

Not writing tests, making refactoring risky.
Testing implementation details instead of behavior.
Not using mocks, making tests slow and brittle.
Writing tests that are too complex, making them hard to maintain.

Summary

Testing is essential for reliable PHP applications.
PHPUnit provides comprehensive testing framework.
Unit tests verify individual units in isolation.
Debugging tools help identify and fix issues.
Understanding testing enables confident development.

Exercise

Write unit tests for PHP classes and implement debugging techniques.

<?php
// Install PHPUnit: composer require --dev phpunit/phpunit

// Class to test
class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
    
    public function subtract($a, $b) {
        return $a - $b;
    }
    
    public function multiply($a, $b) {
        return $a * $b;
    }
    
    public function divide($a, $b) {
        if ($b == 0) {
            throw new InvalidArgumentException("Division by zero");
        }
        return $a / $b;
    }
}

// PHPUnit test class
use PHPUnitFrameworkTestCase;

class CalculatorTest extends TestCase {
    private $calculator;
    
    protected function setUp(): void {
        $this->calculator = new Calculator();
    }
    
    public function testAdd() {
        $this->assertEquals(4, $this->calculator->add(2, 2));
        $this->assertEquals(0, $this->calculator->add(-1, 1));
        $this->assertEquals(10.5, $this->calculator->add(5.5, 5));
    }
    
    public function testSubtract() {
        $this->assertEquals(0, $this->calculator->subtract(2, 2));
        $this->assertEquals(-2, $this->calculator->subtract(1, 3));
        $this->assertEquals(2.5, $this->calculator->subtract(5.5, 3));
    }
    
    public function testMultiply() {
        $this->assertEquals(4, $this->calculator->multiply(2, 2));
        $this->assertEquals(-6, $this->calculator->multiply(2, -3));
        $this->assertEquals(0, $this->calculator->multiply(0, 5));
    }
    
    public function testDivide() {
        $this->assertEquals(1, $this->calculator->divide(2, 2));
        $this->assertEquals(0.5, $this->calculator->divide(1, 2));
        $this->assertEquals(-2, $this->calculator->divide(-6, 3));
    }
    
    public function testDivideByZero() {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Division by zero");
        $this->calculator->divide(5, 0);
    }
}

// Debugging techniques
class DebugHelper {
    public static function dump($var, $label = '') {
        echo "<pre>";
        if ($label) {
            echo "<strong>$label:</strong>
";
        }
        var_dump($var);
        echo "</pre>";
    }
    
    public static function log($message, $level = 'INFO') {
        $timestamp = date('Y-m-d H:i:s');
        $logMessage = "[$timestamp] [$level] $message" . PHP_EOL;
        error_log($logMessage, 3, 'debug.log');
    }
    
    public static function trace() {
        $trace = debug_backtrace();
        echo "<pre>Call Stack:
";
        foreach ($trace as $i => $call) {
            echo "#$i " . $call['function'] . "() called at [" . 
                 $call['file'] . ":" . $call['line'] . "]
";
        }
        echo "</pre>";
    }
}

// Usage examples
$calculator = new Calculator();

// Debug output
DebugHelper::dump($calculator, 'Calculator Object');
DebugHelper::log('Calculator instance created');

// Test calculations
try {
    $result = $calculator->divide(10, 2);
    DebugHelper::log("Division result: $result");
} catch (Exception $e) {
    DebugHelper::log("Error: " . $e->getMessage(), 'ERROR');
    DebugHelper::trace();
}

// Performance debugging
$startTime = microtime(true);
for ($i = 0; $i < 1000; $i++) {
    $calculator->add($i, $i);
}
$endTime = microtime(true);
$executionTime = ($endTime - $startTime) * 1000;

DebugHelper::log("Loop execution time: {$executionTime}ms");

Testing and Debugging