1# Testing & Quality Assurance
2 
3## PHPUnit with Strict Types
4 
5```php
6<?php
7 
8declare(strict_types=1);
9 
10namespace Tests\Unit\Service;
11 
12use App\Repository\UserRepositoryInterface;
13use App\Service\UserService;
14use App\Service\EmailService;
15use PHPUnit\Framework\TestCase;
16use PHPUnit\Framework\MockObject\MockObject;
17 
18final class UserServiceTest extends TestCase
19{
20    private UserRepositoryInterface&MockObject $userRepository;
21    private EmailService&MockObject $emailService;
22    private UserService $userService;
23 
24    protected function setUp(): void
25    {
26        $this->userRepository = $this->createMock(UserRepositoryInterface::class);
27        $this->emailService = $this->createMock(EmailService::class);
28        $this->userService = new UserService(
29            $this->userRepository,
30            $this->emailService
31        );
32    }
33 
34    public function testCreateUserSuccessfully(): void
35    {
36        $email = '[email protected]';
37        $password = 'SecurePass123!';
38 
39        $this->userRepository
40            ->expects($this->once())
41            ->method('findByEmail')
42            ->with($email)
43            ->willReturn(null);
44 
45        $this->userRepository
46            ->expects($this->once())
47            ->method('create')
48            ->willReturn($this->createUser($email));
49 
50        $this->emailService
51            ->expects($this->once())
52            ->method('sendWelcomeEmail');
53 
54        $user = $this->userService->createUser($email, $password);
55 
56        $this->assertSame($email, $user->email);
57    }
58 
59    public function testCreateUserThrowsExceptionWhenEmailExists(): void
60    {
61        $this->expectException(\DomainException::class);
62        $this->expectExceptionMessage('Email already exists');
63 
64        $this->userRepository
65            ->method('findByEmail')
66            ->willReturn($this->createUser('[email protected]'));
67 
68        $this->userService->createUser('[email protected]', 'password');
69    }
70 
71    private function createUser(string $email): User
72    {
73        return new User(
74            id: 1,
75            email: $email,
76            password: password_hash('password', PASSWORD_ARGON2ID),
77        );
78    }
79}
80```
81 
82## Data Providers
83 
84```php
85<?php
86 
87declare(strict_types=1);
88 
89namespace Tests\Unit\Validator;
90 
91use App\Validator\EmailValidator;
92use PHPUnit\Framework\Attributes\DataProvider;
93use PHPUnit\Framework\Attributes\Test;
94use PHPUnit\Framework\TestCase;
95 
96final class EmailValidatorTest extends TestCase
97{
98    #[Test]
99    #[DataProvider('validEmailProvider')]
100    public function itValidatesCorrectEmails(string $email): void
101    {
102        $validator = new EmailValidator();
103        $this->assertTrue($validator->isValid($email));
104    }
105 
106    #[Test]
107    #[DataProvider('invalidEmailProvider')]
108    public function itRejectsInvalidEmails(string $email): void
109    {
110        $validator = new EmailValidator();
111        $this->assertFalse($validator->isValid($email));
112    }
113 
114    public static function validEmailProvider(): array
115    {
116        return [
117            ['[email protected]'],
118            ['[email protected]'],
119            ['[email protected]'],
120        ];
121    }
122 
123    public static function invalidEmailProvider(): array
124    {
125        return [
126            ['invalid'],
127            ['@example.com'],
128            ['user@'],
129            ['user [email protected]'],
130        ];
131    }
132}
133```
134 
135## Laravel Feature Tests
136 
137```php
138<?php
139 
140declare(strict_types=1);
141 
142namespace Tests\Feature;
143 
144use App\Models\User;
145use Illuminate\Foundation\Testing\RefreshDatabase;
146use Illuminate\Foundation\Testing\WithFaker;
147use Tests\TestCase;
148 
149final class UserControllerTest extends TestCase
150{
151    use RefreshDatabase, WithFaker;
152 
153    public function testUserCanViewTheirProfile(): void
154    {
155        $user = User::factory()->create();
156 
157        $response = $this->actingAs($user)->get('/api/users/me');
158 
159        $response->assertOk()
160            ->assertJson([
161                'data' => [
162                    'id' => $user->id,
163                    'email' => $user->email,
164                ],
165            ]);
166    }
167 
168    public function testUserCanUpdateTheirProfile(): void
169    {
170        $user = User::factory()->create();
171        $newName = $this->faker->name();
172 
173        $response = $this->actingAs($user)->putJson('/api/users/me', [
174            'name' => $newName,
175        ]);
176 
177        $response->assertOk();
178 
179        $this->assertDatabaseHas('users', [
180            'id' => $user->id,
181            'name' => $newName,
182        ]);
183    }
184 
185    public function testUnauthorizedUserCannotAccessProfile(): void
186    {
187        $response = $this->getJson('/api/users/me');
188 
189        $response->assertUnauthorized();
190    }
191 
192    public function testValidationFailsWithInvalidData(): void
193    {
194        $user = User::factory()->create();
195 
196        $response = $this->actingAs($user)->putJson('/api/users/me', [
197            'email' => 'not-an-email',
198        ]);
199 
200        $response->assertUnprocessable()
201            ->assertJsonValidationErrors(['email']);
202    }
203}
204```
205 
206## Pest Testing (Modern Alternative)
207 
208```php
209<?php
210 
211declare(strict_types=1);
212 
213use App\Models\User;
214use App\Services\UserService;
215 
216beforeEach(function () {
217    $this->userService = app(UserService::class);
218});
219 
220it('creates a user successfully', function () {
221    $user = $this->userService->createUser(
222        email: '[email protected]',
223        password: 'SecurePass123!'
224    );
225 
226    expect($user)
227        ->toBeInstanceOf(User::class)
228        ->email->toBe('[email protected]');
229});
230 
231it('validates email format', function (string $email, bool $valid) {
232    $validator = new EmailValidator();
233 
234    expect($validator->isValid($email))->toBe($valid);
235})->with([
236    ['[email protected]', true],
237    ['invalid', false],
238    ['@example.com', false],
239]);
240 
241test('authenticated user can view profile', function () {
242    $user = User::factory()->create();
243 
244    $this->actingAs($user)
245        ->get('/api/users/me')
246        ->assertOk()
247        ->assertJson(['data' => ['email' => $user->email]]);
248});
249 
250test('guest cannot access protected routes', function () {
251    $this->getJson('/api/users/me')
252        ->assertUnauthorized();
253});
254```
255 
256## PHPStan Configuration
257 
258```neon
259# phpstan.neon
260parameters:
261    level: 9
262    paths:
263        - src
264        - tests
265    excludePaths:
266        - src/bootstrap.php
267        - vendor
268    checkMissingIterableValueType: true
269    checkGenericClassInNonGenericObjectType: true
270    reportUnmatchedIgnoredErrors: true
271    tmpDir: var/cache/phpstan
272 
273    ignoreErrors:
274        # Ignore specific Laravel magic
275        - '#Call to an undefined method Illuminate\\Database\\Eloquent\\Builder#'
276 
277    type_coverage:
278        return_type: 100
279        param_type: 100
280        property_type: 100
281 
282includes:
283    - vendor/phpstan/phpstan-strict-rules/rules.neon
284    - vendor/phpstan/phpstan-deprecation-rules/rules.neon
285```
286 
287## PHPStan Annotations
288 
289```php
290<?php
291 
292declare(strict_types=1);
293 
294namespace App\Repository;
295 
296use App\Entity\User;
297use Doctrine\ORM\EntityRepository;
298 
299/**
300 * @extends EntityRepository<User>
301 */
302final class UserRepository extends EntityRepository
303{
304    /**
305     * @return User[]
306     */
307    public function findActive(): array
308    {
309        return $this->createQueryBuilder('u')
310            ->where('u.status = :status')
311            ->setParameter('status', 'active')
312            ->getQuery()
313            ->getResult();
314    }
315 
316    /**
317     * @param int[] $ids
318     * @return User[]
319     */
320    public function findByIds(array $ids): array
321    {
322        return $this->createQueryBuilder('u')
323            ->where('u.id IN (:ids)')
324            ->setParameter('ids', $ids)
325            ->getQuery()
326            ->getResult();
327    }
328}
329 
330/**
331 * @template T
332 */
333final readonly class Result
334{
335    /**
336     * @param T $data
337     */
338    public function __construct(
339        public mixed $data,
340        public bool $success,
341    ) {}
342 
343    /**
344     * @return T
345     */
346    public function getData(): mixed
347    {
348        return $this->data;
349    }
350}
351```
352 
353## Mockery (Advanced Mocking)
354 
355```php
356<?php
357 
358declare(strict_types=1);
359 
360namespace Tests\Unit\Service;
361 
362use App\Repository\UserRepository;
363use App\Service\NotificationService;
364use Mockery;
365use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
366use PHPUnit\Framework\TestCase;
367 
368final class NotificationServiceTest extends TestCase
369{
370    use MockeryPHPUnitIntegration;
371 
372    public function testSendsNotificationToActiveUsers(): void
373    {
374        $repository = Mockery::mock(UserRepository::class);
375        $repository->shouldReceive('findActive')
376            ->once()
377            ->andReturn([
378                $this->createUser('[email protected]'),
379                $this->createUser('[email protected]'),
380            ]);
381 
382        $service = new NotificationService($repository);
383        $result = $service->notifyActiveUsers('Important message');
384 
385        $this->assertSame(2, $result->count());
386    }
387 
388    public function testHandlesEmailServiceFailure(): void
389    {
390        $emailService = Mockery::mock(EmailService::class);
391        $emailService->shouldReceive('send')
392            ->once()
393            ->andThrow(new \RuntimeException('Email service down'));
394 
395        $service = new NotificationService($emailService);
396 
397        $this->expectException(\RuntimeException::class);
398        $service->sendNotification('[email protected]', 'Hello');
399    }
400 
401    private function createUser(string $email): User
402    {
403        return new User(id: 1, email: $email, password: 'hashed');
404    }
405}
406```
407 
408## Code Coverage
409 
410```xml
411<!-- phpunit.xml -->
412<?xml version="1.0" encoding="UTF-8"?>
413<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
414         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
415         bootstrap="vendor/autoload.php"
416         colors="true"
417         failOnRisky="true"
418         failOnWarning="true"
419         stopOnFailure="false">
420    <testsuites>
421        <testsuite name="Unit">
422            <directory>tests/Unit</directory>
423        </testsuite>
424        <testsuite name="Feature">
425            <directory>tests/Feature</directory>
426        </testsuite>
427    </testsuites>
428    <coverage>
429        <include>
430            <directory suffix=".php">src</directory>
431        </include>
432        <exclude>
433            <directory>src/bootstrap</directory>
434            <file>src/Kernel.php</file>
435        </exclude>
436        <report>
437            <html outputDirectory="coverage/html"/>
438            <clover outputFile="coverage/clover.xml"/>
439        </report>
440    </coverage>
441    <php>
442        <env name="APP_ENV" value="testing"/>
443        <env name="DB_CONNECTION" value="sqlite"/>
444        <env name="DB_DATABASE" value=":memory:"/>
445    </php>
446</phpunit>
447```
448 
449## Quick Reference
450 
451| Tool | Purpose | Command |
452|------|---------|---------|
453| PHPUnit | Unit/Feature tests | `./vendor/bin/phpunit` |
454| Pest | Modern testing | `./vendor/bin/pest` |
455| PHPStan | Static analysis | `./vendor/bin/phpstan analyse` |
456| Psalm | Alternative static analysis | `./vendor/bin/psalm` |
457| PHP-CS-Fixer | Code style | `./vendor/bin/php-cs-fixer fix` |
458| PHPMD | Mess detector | `./vendor/bin/phpmd src text cleancode` |
459 
460| Assertion | PHPUnit | Pest |
461|-----------|---------|------|
462| Equality | `$this->assertSame()` | `expect()->toBe()` |
463| Type | `$this->assertInstanceOf()` | `expect()->toBeInstanceOf()` |
464| Array | `$this->assertContains()` | `expect()->toContain()` |
465| Exception | `$this->expectException()` | `expect()->toThrow()` |
466| Count | `$this->assertCount()` | `expect()->toHaveCount()` |
467