composer require --dev phpunit/phpunit

<?php
// tests/Unit/CalculatorTest.php
declare(strict_types=1);

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Calculator;

class CalculatorTest extends TestCase
{
    private Calculator $calc;

    protected function setUp(): void
    {
        $this->calc = new Calculator();
    }

    public function testAdd(): void
    {
        $this->assertEquals(4, $this->calc->add(2, 2));
        $this->assertEquals(0, $this->calc->add(-1, 1));
    }

    public function testDivideByZeroThrows(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->calc->divide(10, 0);
    }

    #[\PHPUnit\Framework\Attributes\DataProvider('additionProvider')]
    public function testAddWithDataProvider(int $a, int $b, int $expected): void
    {
        $this->assertEquals($expected, $this->calc->add($a, $b));
    }

    public static function additionProvider(): array
    {
        return [
            'positive'  => [1, 2, 3],
            'negative'  => [-1, -2, -3],
            'zero'      => [0, 0, 0],
            'mixed'     => [-1, 1, 0],
        ];
    }
}

<?php
class ValidationTest extends TestCase
{
    #[\PHPUnit\Framework\Attributes\DataProvider('emailProvider')]
    public function testEmailValidation(string $email, bool $expected): void
    {
        $this->assertSame($expected, filter_var($email, FILTER_VALIDATE_EMAIL) !== false);
    }

    public static function emailProvider(): array
    {
        return [
            'valid simple'     => ['user@example.com', true],
            'valid subdomain'  => ['user@mail.example.com', true],
            'invalid no at'    => ['userexample.com', false],
            'invalid no domain' => ['user@', false],
            'empty'            => ['', false],
        ];
    }
}

<?php
class UserServiceTest extends TestCase
{
    public function testGetUserReturnsFormattedData(): void
    {
        // 创建 Mock
        $repository = $this->createMock(UserRepository::class);
        $repository->method('findById')
            ->with(1)
            ->willReturn(['id' => 1, 'name' => 'Alice']);

        $service = new UserService($repository);
        $user = $service->getUser(1);

        $this->assertEquals('Alice', $user['name']);
    }

    public function testSaveCallsRepository(): void
    {
        $repository = $this->createMock(UserRepository::class);
        $repository->expects($this->once())
            ->method('save')
            ->with($this->callback(fn($user) => $user['name'] === 'Alice'))
            ->willReturn(true);

        $service = new UserService($repository);
        $result = $service->createUser(['name' => 'Alice']);

        $this->assertTrue($result);
    }
}

composer require --dev mockery/mockery

<?php
use Mockery\Adapter\Phpunit\MockeryTestCase;

class OrderServiceTest extends MockeryTestCase
{
    public function testProcessOrder(): void
    {
        $payment = \Mockery::mock(PaymentGateway::class);
        $payment->shouldReceive('charge')
            ->once()
            ->with(99.99, 'USD')
            ->andReturn(['status' => 'success', 'transaction_id' => 'txn_123']);

        $mailer = \Mockery::mock(Mailer::class);
        $mailer->shouldReceive('send')
            ->once()
            ->with(\Mockery::on(fn($email) => $email->getTo() === 'alice@example.com'));

        $service = new OrderService($payment, $mailer);
        $result = $service->process(new Order(amount: 99.99, email: 'alice@example.com'));

        $this->assertTrue($result->isSuccessful());
    }
}

<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;
use PDO;

class UserRepositoryTest extends TestCase
{
    private PDO $db;

    protected function setUp(): void
    {
        $this->db = new PDO('sqlite::memory:');
        $this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->db->exec('
            CREATE TABLE users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                email TEXT UNIQUE NOT NULL,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ');
    }

    public function testInsertAndRetrieve(): void
    {
        $repo = new UserRepository($this->db);

        $user = new User('Alice', 'alice@example.com');
        $this->assertTrue($repo->save($user));

        $found = $repo->findByEmail('alice@example.com');
        $this->assertNotNull($found);
        $this->assertEquals('Alice', $found->getName());
    }

    public function testEmailUniqueness(): void
    {
        $repo = new UserRepository($this->db);

        $repo->save(new User('Alice', 'alice@example.com'));

        $this->expectException(\PDOException::class);
        $repo->save(new User('Bob', 'alice@example.com'));
    }
}

<!-- phpunit.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true">
    <testsuites>
        <testsuite name="Unit">
            <directory>tests/Unit</directory>
        </testsuite>
        <testsuite name="Feature">
            <directory>tests/Feature</directory>
        </testsuite>
    </testsuites>
    <source>
        <include>
            <directory>src</directory>
        </include>
    </source>
</phpunit>

# 运行测试
vendor/bin/phpunit

# 生成覆盖率报告
vendor/bin/phpunit --coverage-html=coverage/
vendor/bin/phpunit --coverage-clover=coverage.xml

<?php
class UserApiTest extends TestCase
{
    public function testCreateUser(): void
    {
        $response = $this->json('POST', '/api/users', [
            'name'  => 'Alice',
            'email' => 'alice@example.com',
        ]);

        $response->assertStatus(201);
        $response->assertJsonStructure(['id', 'name', 'email']);
        $response->assertJson(['name' => 'Alice']);
    }

    public function testCreateUserWithInvalidEmail(): void
    {
        $response = $this->json('POST', '/api/users', [
            'name'  => 'Alice',
            'email' => 'not-an-email',
        ]);

        $response->assertStatus(422);
        $response->assertJsonValidationErrors(['email']);
    }
}