Install PHPUnit and configure the project environment; 2. Create a test directory structure and correspond to the source code; 3. Write independent test cases and verify the results using assertions; 4. Isolate external dependencies with mock objects; 5. Run tests frequently to ensure code quality. First, install PHPUnit through Composer and configure phpunit.xml file. Then create the tests directory to store the test class. Each test class inherits TestCase and writes a method at the beginning of test for testing. Use asserts such as assertEquals to verify the correctness of the logic. Use createMock to simulate behavior for external dependencies. Finally, execute vendor/bin/phpunit commands regularly to run the test and integrate it into the CI process to improve code stability.

You just start writing them — once you've got PHPUnit set up, it's about breaking your code into small testable pieces and checking they behave as expected. The key is to focus on one thing at a time, keep tests simple and fast, and make sure they fail before they pass (so you know they're actually testing something).

Set Up PHPUnit in Your Project

Before writing tests, you need PHPUnit installed. Most modern PHP projects use Composer, so run:

 composer requires --dev phpunit/phpunit

Then create a phpunit.xml file in your project root. A basic version might look like this:

 <phpunit bootstrap="vendor/autoload.php">
    <testsuites>
        <testsuite name="My Test Suite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
</phpunit>

This tells PHPUnit where to find your test files and how to autoload your classes.

If you're using a framework like Laravel or Symfony, they often come with PHPUnit already configured — so double-check before setting up manually.

Structure Your Tests Properly

Create a tests folder in your project, and inside it, mirror the structure of your source code. For example, if you have a class in src/Calculator.php , put its test in tests/CalculatorTest.php .

PHPUnit test classes should extend PHPUnit\Framework\TestCase . Each public method starting with test will be treated as a separate test case.

Here's what a basic test might look like:

 use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase
{
    public function testAddition()
    {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }
}

• Use $this->assertEquals() to check expected values.
• You can also use $this->assertTrue() , $this->assertNull() , etc., depending on what you're testing.

Try to write tests that are independent — one test failing shouldn't cause others to fail too.

Mock Dependencies to Keep Tests Focused

When your class uses external services (like a database or an API), you don't want your tests hitting real systems every time. That's where mocks come in.

PHPUnit has built-in support for creating mock objects. Here's an example:

 public function testFetchDataFromApi()
{
    $mockApi = $this->createMock(ApiClient::class);

    // Tell the mock to return a specific value when getData() is called
    $mockApi->method('getData')->willReturn(['id' => 1]);

    $service = new DataService($mockApi);
    $data = $service->fetchAndProcess();

    $this->assertEquals(1, $data['id']);
}

Some tips:

• Only mock what you need — don't overdo it.
• Avoid mocking too many methods; that usually means your class is doing too much.
• If you find yourself needing to test private methods, consider refactoring — unit tests should focus on public behavior.

Run Your Tests Often

Once your tests are written, run them regularly using:

 vendor/bin/phpunit

This helps catch regressions early. You can even integrate PHPUnit into your Git hooks or CI pipeline (like GitHub Actions or GitLab CI) to automate it.

If a test fails, read the output carefully — PHPUnit usually tells you exactly what went wrong and which line needs fixing.

That's basically it. Writing unit tests with PHPUnit isn't complicated, but it does take discipline. Start small, test the core logic first, and build from there.

The above is the detailed content of How do I write unit tests for PHP code using PHPUnit?. For more information, please follow other related articles on the PHP Chinese website!