Doubling properties with no or async hooks

[derrabus]

In the light of #6545, I was playing with doubling hooks on (non-virtual) properties and I noticed a limitation I'd like to discuss.

Basically:

• If the property has no hooks, I cannot define behavior for it on the stub.
• If the property has a set hook only, I can define behavior for the set hook, but not the get hook (and vice versa).

For example:

final class PropertyHookTest extends TestCase
{
    public function testGetHook(): void
    {
        $someClass = self::createStub(SomeClass::class);
        $someClass->method('$someProperty::get')->willReturn('Hello');

        $this->assertSame('Hello', $someClass->someProperty);
    }

    public function testSetHook(): void
    {
        $someClass = $this->createMock(SomeClass::class);
        $someClass
            ->expects(self::once())
            ->method('$someProperty::set')
            ->willReturnCallback(static function (mixed $value): void {
                self::assertSame('Hello', $value);
            });

        $someClass->someProperty = 'Hello';
    }
}

class SomeClass
{
    public string $someProperty;

    public function __construct()
    {
        $this->someProperty = 'some value';
    }
}

This limitation appears rather arbitrary to me, given that PHP allows you to add hooks to a property in a child class even though the parent class did not define any or only one hook on that property.

In the context of our example, the following declaration is perfectly valid:

class SomeChildClass extends SomeClass
{
    public string $someProperty {
        get => $this->someProperty;
        set => $this->someProperty = $value;
    }
}

In fact, if I change my original test to mock SomeChildClass instead of SomeClass, the test passes.

My questions:

• Are there technical reasons against allowing mocks to add hooks that the parent class did not have?
• Would you be open to a PR that allows adding hooks to mocked properties?

[sebastianbergmann]

Are there technical reasons against allowing mocks to add hooks that the parent class did not have?

I do not know.

Would you be open to a PR that allows adding hooks to mocked properties?

Thank you for taking the time to write this up so thoroughly, and for linking it to #6545. I can see you have thought carefully about this and I trust you that this is important.

I want to be upfront with you: I struggle with this one, and I want to explain why rather than just leave you without a response.

Property Hooks are a language feature I personally have significant reservations about. I do not think they should have been added to PHP, and admit that colors how I approach this. To me, a property is an implementation detail, something private and internal. The idea of properties being part of a class's public contract, or of properties having "behavior" that needs to be stubbed, feels fundamentally wrong to me. When I read a sentence like "if the property has no hooks, I cannot define behavior for it on the stub," I genuinely do not know what to do with that, because "property" and "behavior" do not belong together in my mental model of how objects work.

I realize this is my bias, and I am not trying to be dismissive of your use case. You have clearly demonstrated that this is a real limitation you are running into, and your reasoning about child classes being allowed to add hooks is sound from a language-semantics perspective.

But I want to be honest rather than string you along: I do not currently have a clear idea of how to move forward here, precisely because the underlying feature does not make sense to me. I need to sit with this for a while, please bear with me.

It would be helpful if you could provide a pull request implementing your idea, together with tests verifying the added functionality and showing use cases to help me better understand. However, at this point I cannot promise that I will merge the pull request.