Support for Property Hooks in Test Doubles

.github/workflows/ci.yaml

@@ -201,7 +201,7 @@ jobs:
       - name: Install PHP with extensions
         uses: shivammathur/setup-php@v2
         with:
-          php-version: 8.3
+          php-version: 8.4
           coverage: xdebug
           extensions: none, ctype, curl, dom, json, libxml, mbstring, phar, soap, tokenizer, xml, xmlwriter
           ini-values: assert.exception=1, zend.assertions=1, error_reporting=-1, log_errors_max_len=0, display_errors=On

.php-cs-fixer.dist.php

@@ -14,6 +14,11 @@
     ->in(__DIR__ . '/tests/_files')
     ->in(__DIR__ . '/tests/end-to-end')
     ->in(__DIR__ . '/tests/unit')
+    // *WithPropertyWith*Hook.php use PHP 8.4 syntax that currently leads to PHP-CS-Fixer errors
+    ->notName('ExtendableClassWithPropertyWithGetHook.php')
+    ->notName('ExtendableClassWithPropertyWithSetHook.php')
+    ->notName('InterfaceWithPropertyWithGetHook.php')
+    ->notName('InterfaceWithPropertyWithSetHook.php')
     // DeprecatedPhpFeatureTest.php must not use declare(strict_types=1);
     ->notName('DeprecatedPhpFeatureTest.php')
     // Issue5795Test.php contains required whitespace that would be cleaned up

src/Framework/MockObject/Generator/Generator.php

@@ -28,6 +28,7 @@
 use function is_array;
 use function is_object;
 use function md5;
+use function method_exists;
 use function mt_rand;
 use function preg_match;
 use function preg_match_all;
@@ -63,9 +64,13 @@
 use PHPUnit\Framework\MockObject\StubApi;
 use PHPUnit\Framework\MockObject\StubInternal;
 use PHPUnit\Framework\MockObject\TestDoubleState;
+use PropertyHookType;
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionObject;
+use ReflectionProperty;
+use SebastianBergmann\Type\ReflectionMapper;
+use SebastianBergmann\Type\Type;
 use SoapClient;
 use SoapFault;
 use Throwable;
@@ -796,18 +801,13 @@ private function generateCodeForTestDoubleClass(string $type, bool $mockObject,
             }
         }
 
+        $propertiesWithHooks = $this->properties($class);
+        $configurableMethods = $this->configurableMethods($mockMethods, $propertiesWithHooks);
+
         $mockedMethods = '';
-        $configurable  = [];
 
         foreach ($mockMethods->asArray() as $mockMethod) {
             $mockedMethods .= $mockMethod->generateCode();
-
-            $configurable[] = new ConfigurableMethod(
-                $mockMethod->methodName(),
-                $mockMethod->defaultParameterValues(),
-                $mockMethod->numberOfParameters(),
-                $mockMethod->returnType(),
-            );
         }
 
         /** @var trait-string[] $traits */
@@ -890,14 +890,15 @@ private function generateCodeForTestDoubleClass(string $type, bool $mockObject,
                 ),
                 'use_statements'  => $useStatements,
                 'mock_class_name' => $_mockClassName['className'],
-                'mocked_methods'  => $mockedMethods,
+                'methods'         => $mockedMethods,
+                'property_hooks'  => $this->codeForPropertyHooks($propertiesWithHooks, $_mockClassName['className']),
             ],
         );
 
         return new MockClass(
             $classTemplate->render(),
             $_mockClassName['className'],
-            $configurable,
+            $configurableMethods,
         );
     }
 
@@ -1159,4 +1160,186 @@ private function interfaceMethods(string $interfaceName, bool $cloneArguments):
 
         return $methods;
     }
+
+    /**
+     * @param list<Property> $propertiesWithHooks
+     *
+     * @return list<ConfigurableMethod>
+     */
+    private function configurableMethods(MockMethodSet $methods, array $propertiesWithHooks): array
+    {
+        $configurable = [];
+
+        foreach ($methods->asArray() as $method) {
+            $configurable[] = new ConfigurableMethod(
+                $method->methodName(),
+                $method->defaultParameterValues(),
+                $method->numberOfParameters(),
+                $method->returnType(),
+            );
+        }
+
+        foreach ($propertiesWithHooks as $property) {
+            if ($property->hasGetHook()) {
+                $configurable[] = new ConfigurableMethod(
+                    sprintf(
+                        '$%s::get',
+                        $property->name(),
+                    ),
+                    [],
+                    0,
+                    $property->type(),
+                );
+            }
+
+            if ($property->hasSetHook()) {
+                $configurable[] = new ConfigurableMethod(
+                    sprintf(
+                        '$%s::set',
+                        $property->name(),
+                    ),
+                    [],
+                    1,
+                    Type::fromName('void', false),
+                );
+            }
+        }
+
+        return $configurable;
+    }
+
+    /**
+     * @param ?ReflectionClass<object> $class
+     *
+     * @return list<Property>
+     */
+    private function properties(?ReflectionClass $class): array
+    {
+        if (!method_exists(ReflectionProperty::class, 'isFinal')) {
+            // @codeCoverageIgnoreStart
+            return [];
+            // @codeCoverageIgnoreEnd
+        }
+
+        if ($class === null) {
+            return [];
+        }
+
+        $mapper     = new ReflectionMapper;
+        $properties = [];
+
+        foreach ($class->getProperties() as $property) {
+            assert(method_exists($property, 'getHook'));
+            assert(method_exists($property, 'hasHooks'));
+            assert(method_exists($property, 'hasHook'));
+            assert(method_exists($property, 'isFinal'));
+            assert(class_exists(PropertyHookType::class));
+
+            if (!$property->isPublic()) {
+                continue;
+            }
+
+            if ($property->isFinal()) {
+                continue;
+            }
+
+            if (!$property->hasHooks()) {
+                continue;
+            }
+
+            $hasGetHook = false;
+            $hasSetHook = false;
+
+            if ($property->hasHook(PropertyHookType::Get) &&
+                !$property->getHook(PropertyHookType::Get)->isFinal()) {
+                $hasGetHook = true;
+            }
+
+            if ($property->hasHook(PropertyHookType::Set) &&
+                !$property->getHook(PropertyHookType::Set)->isFinal()) {
+                $hasSetHook = true;
+            }
+
+            if (!$hasGetHook && !$hasSetHook) {
+                continue;
+            }
+
+            $properties[] = new Property(
+                $property->getName(),
+                $mapper->fromPropertyType($property),
+                $hasGetHook,
+                $hasSetHook,
+            );
+        }
+
+        return $properties;
+    }
+
+    /**
+     * @param list<Property> $propertiesWithHooks
+     * @param class-string   $className
+     *
+     * @return non-empty-string
+     */
+    private function codeForPropertyHooks(array $propertiesWithHooks, string $className): string
+    {
+        $propertyHooks = '';
+
+        foreach ($propertiesWithHooks as $property) {
+            $propertyHooks .= sprintf(
+                <<<'EOT'
+
+    public %s $%s {
+EOT,
+                $property->type()->asString(),
+                $property->name(),
+            );
+
+            if ($property->hasGetHook()) {
+                $propertyHooks .= sprintf(
+                    <<<'EOT'
+
+        get {
+            return $this->__phpunit_getInvocationHandler()->invoke(
+                new \PHPUnit\Framework\MockObject\Invocation(
+                    '%s', '$%s::get', [], '%s', $this, false
+                )
+            );
+        }
+
+EOT,
+                    $className,
+                    $property->name(),
+                    $property->type()->asString(),
+                );
+            }
+
+            if ($property->hasSetHook()) {
+                $propertyHooks .= sprintf(
+                    <<<'EOT'
+
+        set (%s $value) {
+            $this->__phpunit_getInvocationHandler()->invoke(
+                new \PHPUnit\Framework\MockObject\Invocation(
+                    '%s', '$%s::set', [$value], 'void', $this, false
+                )
+            );
+        }
+
+EOT,
+                    $property->type()->asString(),
+                    $className,
+                    $property->name(),
+                );
+            }
+
+            $propertyHooks .= <<<'EOT'
+    }
+
+EOT;
+
+        }
+
+        return $propertyHooks;
+    }
 }

src/Framework/MockObject/Generator/Property.php

@@ -0,0 +1,59 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Generator;
+
+use SebastianBergmann\Type\Type;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class Property
+{
+    /**
+     * @var non-empty-string
+     */
+    private string $name;
+    private Type $type;
+    private bool $getHook;
+    private bool $setHook;
+
+    /**
+     * @param non-empty-string $name
+     */
+    public function __construct(string $name, Type $type, bool $getHook, bool $setHook)
+    {
+        $this->name    = $name;
+        $this->type    = $type;
+        $this->getHook = $getHook;
+        $this->setHook = $setHook;
+    }
+
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    public function type(): Type
+    {
+        return $this->type;
+    }
+
+    public function hasGetHook(): bool
+    {
+        return $this->getHook;
+    }
+
+    public function hasSetHook(): bool
+    {
+        return $this->setHook;
+    }
+}

src/Framework/MockObject/Generator/templates/test_double_class.tpl

@@ -2,4 +2,4 @@ declare(strict_types=1);
 
 {prologue}{class_declaration}
 {
-{use_statements}{mocked_methods}}{epilogue}
+{use_statements}{property_hooks}{methods}}{epilogue}

src/Framework/MockObject/Runtime/Builder/InvocationMocker.php

@@ -31,6 +31,7 @@
 use PHPUnit\Framework\MockObject\MethodNameNotConfiguredException;
 use PHPUnit\Framework\MockObject\MethodParametersAlreadyConfiguredException;
 use PHPUnit\Framework\MockObject\Rule;
+use PHPUnit\Framework\MockObject\Runtime\PropertyHook;
 use PHPUnit\Framework\MockObject\Stub\ConsecutiveCalls;
 use PHPUnit\Framework\MockObject\Stub\Exception;
 use PHPUnit\Framework\MockObject\Stub\ReturnArgument;
@@ -246,12 +247,16 @@ public function withAnyParameters(): self
      *
      * @return $this
      */
-    public function method(Constraint|string $constraint): self
+    public function method(Constraint|PropertyHook|string $constraint): self
     {
         if ($this->matcher->hasMethodNameRule()) {
             throw new MethodNameAlreadyConfiguredException;
         }
 
+        if ($constraint instanceof PropertyHook) {
+            $constraint = $constraint->asString();
+        }
+
         if (is_string($constraint)) {
             $this->configurableMethodNames ??= array_flip(
                 array_map(

src/Framework/MockObject/Runtime/PropertyHook/PropertyGetHook.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Runtime;
+
+use function sprintf;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ */
+final readonly class PropertyGetHook extends PropertyHook
+{
+    /**
+     * @return non-empty-string
+     *
+     * @internal This method is not covered by the backward compatibility promise for PHPUnit
+     */
+    public function asString(): string
+    {
+        return sprintf(
+            '$%s::get',
+            $this->propertyName(),
+        );
+    }
+}