Writing Strongly Typed PHP: Let Types Do the Testing

PHP has come a long way. Readonly properties, enums, property hooks, and a mature static analysis ecosystem now let us say much more about our code in types than before. A machine can check all of it for free, before a single test runs.

In this talk, I'll show how leaning on the type system can quietly remove whole groups of bugs — bugs developers still write unit tests for today. We'll look at small, everyday habits that make code easier to read, both for humans and for tools like PHPStan. Then we'll step back and ask a bigger question. Which parts of your application really need tests? And which parts can a static analyser guard for you instead?

You'll leave with a fresh way to think about where bugs hide, and a simple plan to write fewer tests while shipping more reliable PHP.

Transcript

1. Writing Strongly Typed PHP: Let Types Do the Testing Ondřej Mirtes Neos Con, June 2nd 2026
2. $ composer require --dev phpstan/phpstan What is PHPStan? $ vendor/bin/phpstan analyse src/ tests/
3. What is PHPStan?
4. if ($foo instanceof Foo) catch (FooException $e) Foo::class function foo(Bar $bar)
5. Type system “Are parts of a program connected in a consistent way?”
6. function foo(): string { return null; } function bar(): string { return 1; }
7. function foo(string $str): void { } foo(123);
8. $foo = new Foo(); $foo->unknownMethod();
9. private int $foo; ... $this->foo = 'string';
10. $foo = new Foo(); if ($foo instanceof Bar) { }
11. Bugs found by... Tests PHPStan
12. Bugs found by... Tests PHPStan
13. Bugs found by... Tests PHPStan
14. E_NOTICE
15. function foo(string $id, string $name, string $email, string $directory, string $filename, string $address, string $price, string $date, ) { } Stringly-typed code
16. public function foo( Email $email, SplFileInfo $directory, Address $address, Money $price, DateTimeImmutable $date, ): FooBar { } Objects for everything
17. “I can process anything” function foo(array|string $values) { if (is_array($values)) { … } else { … } }
18. “I do one thing well” function foo(array $values) { … } function bar(string $value) { … }
19. Boolean parameters function foo($values, bool $force) { if ($force) { … } else { … } }
20. Boolean parameters foo([1, 2, 3], false); foo([1, 2, 3], true);
21. Separate into multiple methods foo([1, 2, 3]); forceFoo([1, 2, 3]);
22. Nullable parameters function setValidity( \DateTimeImmutable $from, \DateTimeImmutable $to, ): void { }
23. Nullable parameters function setValidity( ?\DateTimeImmutable $from, ?\DateTimeImmutable $to, ): void { }
24. Nullable parameters $foo->setValidity($from, $to); $foo->setValidity(null, null); $foo->setValidity($from, null); $foo->setValidity(null, $to);
25. Nullable parameters function setValidity( \DateTimeImmutable $from, \DateTimeImmutable $to, ): void { } function removeValidity(): void { }
26. Dynamic code $$variable $this->$property $this->$method(); new $class();
29. empty() • "" • 0 • 0.0 • "0" • NULL • FALSE • an empty array()
30. phpstan/phpstan-strict-rules • No empty, no == • Only booleans in conditions: if, elseif, !, &&, || • $strict=true for: in_array(), array_search()... • Sames types in switch(X) and case X
31. PHPStan Rule Levels 0⃣ 1⃣ 2⃣ 3⃣ 4⃣ 5⃣ 6⃣ 7⃣ 8⃣ 9⃣ 1⃣0⃣
32. function foo($a, $b) { ... } Function foo() has parameter $a with no type speci fi ed. Function foo() has parameter $b with no type speci fi ed. Function foo() has no return type speci fi ed. Missing typehints 6⃣
33. What's in an array? /** * @param array<User> $a */ function foo(array $a) { … }
34. What's in an array? User[] array<User> array<int, User> list<User> non-empty-array<User> non-empty-array<int, User> non-empty-list<User>
35. Array shapes /** * @param array{foo: int, bar: string} $a */ function foo(array $a) { \PHPStan\dumpType($a['foo']); // int \PHPStan\dumpType($a['bar']); // string }
36. phpstan.org Documentation » Writing PHP Code » PHPDoc Types Documentation » Writing PHP Code » PHPDocs Basics ...and more, much more
37. Generics interface Query {} class FindCustomerById implements Query { ... } class QueryBus { public function dispatch(Query $query) { ... } } $customer = $bus->dispatch(new FindCustomerById($id)); // what is $customer?
38. Generics /** @template T */ interface Query {}
39. Generics class Customer { ... } /** @implements Query<Customer> */ class FindCustomerById implements Query { ... }
40. Generics class QueryBus { /** * @template T * @param Query<T> $query * @return T */ public function dispatch(Query $query) { ... } }
41. Generics $customer = $bus->dispatch( new FindCustomerById($id), ); // $customer is Customer \PHPStan\dumpType($customer);
42. Generics documentation phpstan.org Blog » Guides » Generics in PHP using PHPDocs Blog » Guides » Generics By Examples Blog » Guides » What’s Up With @template-covariant? Blog » Guides » A guide to call-site generic variance
43. Refactoring tip Break the types first! Rename/remove the method Change the returned type Add a required parameter
44. Controller Weak HTTP request Strong Model Controller HTTP response
45. Wiring • Controllers • Facades • Passing values somewhere else • Getters • Setters • Assigning to properties
46. Business logic • Value validation • Arithmetic operations, rounding • Filtering • Parsers • State machines • if conditions, loops...
47. What is a unit test? • Executed PHP code directly and only in memory • Does not connect to the database • Does not access the filesystem • Does not make network calls • Does not need a DI container
48. function doSomething(int $id): void { $foo = $this->someRepository ->getById($id); // business logic with $foo... $bars = $this->otherRepository ->getByFoo($foo); // business logic with $foo & $bars }
49. Repository Business logic Class
50. Facade Business logic Production data from Repository Unit test Manually created test data Repository
51. function doBusinessyStuff( Foo $foo, array $bars ): BusinessyResult { // ... } Business logic
52. function doSomething(int $id) { $foo = $this->someRepository ->getById($id); $this->calculator->calculate($foo); } Facade (wiring)
53. #[DataProvider('dataCalculate')] function testCalculate( Foo $foo, int $expectedResult, ): void { $result = $this->calculator ->calculate($foo); $this->assertSame($expectedResult, $result); }
54. $transaction = $this->em->beginTransaction(); try { $article = $this->em->find(Article::class, $id); $article->setTitle($title); $article->setAuthor($author); $article->setPublishDate($publishDate); $article->setText($text); // calculate author's fee // interesting logic here // … $this->em->flush(); $transaction->commit(); catch (\Throwable $e) { $transaction->rollback(); throw $e; } boring – statically verified boring – statically verified interesting - will test this! Approach to testing
55. $transaction = $this->em->beginTransaction(); try { $article = $this->em->find(Article::class, $id); $article->setTitle($title); $article->setAuthor($author); $article->setPublishDate($publishDate); $article->setText($text); $this->authorFeeCalculator->calculateFee($text); $this->em->flush(); $transaction->commit(); catch (\Throwable $e) { $transaction->rollback(); throw $e; } AuthorFeeCalculator AuthorFeeCalculatorTest Approach to testing
56. @OndrejMirtes@phpc.social phpstan/phpstan