repository·main·Indexed 22 days ago
https://github.com/carlosas/phpatA PHPStan extension that allows developers to define and enforce architectural rules using a natural language abstraction. PHPat provides a fluent assertion API to verify class types, properties, inheritance, and dependencies, enabling the enforcement of layered architectures, MVC decoupling, and restricted vendor coupling through the use of Selectors and Rules.
Because PHP Architecture Tester is a PHPStan extension, it inherits all of PHPStan's core capabilities. You can use standard PHPStan features to manage your architecture testing workflow, including:
PHPat (PHP Architecture Tester) is a PHPStan extension used to define and enforce architectural rules in PHP codebases.
phpstan.neon configuration file using the phpat.test tag.Statement objects, and executes corresponding assertion rules against the AST (Abstract Syntax Tree) nodes of your codebase.dependOn, extend, implement, include).isAbstract, isFinal, isReadonly).Selectors are the mechanism used to define the scope of a PHPat rule. They tell the engine which classes should be evaluated against a specific architectural constraint.
Selectors can be simple (targeting a single class name) or complex (using logical composition to target groups of classes based on inheritance, namespace, or file structure). By using logical operators like AllOf, AnyOf, and Not, you can build highly granular rules that target specific layers or architectural patterns in your application.
Use these commands for local development and maintaining the PHPat repository:
# Fix coding standards
vendor/bin/php-cs-fixer fix --config ./ci/php-cs-fixer.php
# Run PHPStan with PHPat architecture tests (validates src/ + tests/architecture/)
vendor/bin/phpstan analyse -c ci/phpstan-phpat.neon
# Run Psalm static analysis
vendor/bin/psalm -c ci/psalm.xml
# Run tests
vendor/bin/phpunit tests/unit/ tests/integration/
# Run a single test file
vendor/bin/phpunit tests/unit/rules/SomeTest.phpYou can restrict a specific namespace to only allow dependencies within itself, effectively isolating it from the rest of the application or third-party vendors.
>Classes in namespace App\Domain can only depend on classes in namespace App\DomainPHPat tests are executed as part of your standard PHPStan analysis. Run PHPStan as usual:
php vendor/bin/phpstan analyse -c phpstan.neonYou can mandate that classes within a specific namespace must implement a particular interface. This is a common way to ensure that all Entities or Value Objects adhere to a specific contract.
>Classes in namespace App\Domain\Entity should implement class with name App\Domain\Entity\EntityInterfaceA rule is a statement composed of Selectors and Assertions that must be true for a test to pass. In a test class, rules must be defined as public methods that either:
test_.#[TestRule] attribute.Rules are constructed using the \PHPat\Test\PHPat::rule() method, which provides a fluent builder interface to select classes and assert their properties or dependencies.
namespace App ests\Architecture;
use PHPat\Selector\Selector;
use PHPat\Test\Attributes\TestRule;
use PHPat\Test\Builder\Rule;
use PHPat\Test\PHPat;
final class ConfigurationTest
{
public function test_domain_independence(): Rule
{
return PHPat::rule()
->classes(Selector::inNamespace('App\Domain'))
->canOnlyDependOn()
->classes(Selector::inNamespace('App\Domain'));
}
#[TestRule]
public function entities_are_final(): Rule
{
return PHPat::rule()
->classes(Selector::extends(Entity::class))
->shouldBeFinal();
}
}You can use PHPAT to ensure that architectural layers remain decoupled. For example, in an onion or layered architecture, you can write rules to prevent inner layers (like App\Domain) from depending on outer layers (like App\Application or App\Infrastructure).
>Classes in namespace App\Domain should not depend on classes in namespace App\Application and classes in namespace App\Infrastructure
>Classes in namespace App\Application should not depend on classes in namespace App\Infrastructure