Like I said in #301 this is only a temporary fix to avoid the deprecation error. The real work to do to prepare PHP 9.0 correctly is to infer the good return type, which is not OK with interfaces currently.

We have a legacy class with a method, which returns value via reference:

<?
public function &foo() {}

When we Phake::mock() it, we recieve: Strict Standards: Declaration of $mockedMethod should be compatible with that of $realMethod

Hi,

This PR add support to PHP8 (and drop support for PHP<7.1). I'm not familiar at all with the Phake internal code so it's very much appreciated if you could have a look at this PR to make sure I did nothing wrong.

The quick steps that I did were :

• Change the tests to work on both phpunit 7.0 and 8.0
• Update doctrine/common to use ^3.0
• Add new Phake_ClassGenerator_MockClass::implementType method that support both named and union Types

I did test on my local on php7.1 php7.3 php7.4 and 8.0 and everything works fine. I did not had the time to add more tests but feel free to add some or contribute to this PR :-)

Thanks

PHPUnit throws deprecation errors when Phake uses this method in PHP 7.4

ErrorException: Function ReflectionType::__toString() is deprecated

This patch replaces the instances of (string)$returnType with $returnType->getName(); allowing Phake to work on PHP 7.4 without deprecation warnings/errors.

Resolves issue #279

During my test, I wanted to mock a class with a final constructor like this one https://github.com/doctrine/annotations/blob/master/lib/Doctrine/Common/Annotations/Annotation.php which has a final constructor.

I have added a test for this case.

What are your thoughts about this issue?

Regards

We like to test our protected methods because some of them do contain logic. Now, if that method contain calls to other methods, we also want to verify that the call happened correctly. Verification though as far as I can tell only works with mock objects. We tried using PHPUnit_Extensions_Helper_AccessibleObject but it does not allow making the method public on these mocks. Can we add it, either by default or via a flag, the ability to automatically make a method public? So basically, we needed the ability to do the following (in very simple terms):

class MyClass {
    ...
    protected function doWork($raw) {
        $data = $this->processRaw($raw);
        return array('result' => $data);
    }
    ...
}

class MyClassTest {
    public function testDoWork() {
        $mock = Phake::partialMock('MyClass');
        self::assert(array('result' => 'BLAH'), $mock->doWork('blah'));

        Phake::verify($mock)->processRaw(...);
    }
}

Almost every modern IDE supports auto completion through PHPDoc annotations. But with the current Phake API it isn't possible to make use of this feature.

As example with PHPStorm:

Every time I write a Phake:when() call I must write a /** @noinspection PhpUndefinedMethodInspection */ to tell the IDE it should disable the inspection for this call. This clutters the source code with unnecessary @noinspection annotations.

Furthermore it isn't possible to use the auto completion feature.

<?php

class FooTest extends PHPUnit_Framework_TestCase {

    public function testSomeBehaviour() {

        /* @var Foo $mock */
        $mock = Phake::mock('Foo');
        when($mock)-> //No auto completion available
    }
}

So my question is why not using the Mockito syntax for Phake.

<?php

class FooTest extends PHPUnit_Framework_TestCase {

    public function testSomeBehaviour() {

        /* @var Foo $mock */
        $mock = Phake::mock('Foo');
        when($mock->doSomething())->thenReturn(1);
    }
}

Are there technical reasons or what was your decision to break with the Mockito syntax?

I am creating an RPM for Fedora and EPEL and this came up in the review progress: https://bugzilla.redhat.com/show_bug.cgi?id=818318#c3:

So you can request to add CHANGELOG, LICENSE and README with role="doc" and to add tests folder as role="test" (next step will be to add a %check in the spec to run this test suite), as this files are already there.

I can include them manually, but it would be nicer if they would be included in the pear package. Sometimes other packages also things like composer.json .

In this case, because the static:: keyword will cause the called class to be determined at runtime, you will be able to verify and stub calls to StaticFactory::factory().

Source

This doesn't seem accurate. Calls to StaticFactory::getInstance() are still bound to that class name and will still invoke the StaticFactory version of factory(). You can create a mock of StaticFactory and stub factory() on that object's class, in which case the use of static:: in getInstance() will resolve to the mock's version of factory(), but only if getInstance() is called using the mock's class name.

None of this seems like it would be useful unless one of these scenarios applies:

1. The class containing the static method being stubbed is also the class under test, in which case we're involving either partial mocks or the thenCallParent() answer, which the documentation notes are both intended for legacy code where the section on mocking static methods contains no similar reference to legacy code.
2. The static method being stubbed is invoked by the code under test where the class off of which that invocation takes place is variable and configurable.

Would appreciate any feedback you can provide. I'm completely open to the possibility that I'm just lost when it comes to using this feature as intended. :)

Packagist only has the dev-master branch available. It would be nice to be able to use the tags you've created.

If you set up a Packagist post-receive hook in GitHub, it should happen automatically in future.

I were not able to fix #64 without moving everything around. So here is an pull request doing just that. I quite understand if you don't like to do it.

This is an experimental branch to move all mocking storage (Mock\Info objects) out of the mock object. This will make it possible to mock readonly objects.

Noticed this while trying to upgrade from 2.1.1 to 3.1.6

class behaviorChange {
    public static function tryB() {
        return static::b();
    }
    public function b() {
        return "here";
    }
}

class behaviorChangeTest {
    public function testTryB() {
        $mock = Phake::mock('behaviorChange');
        Phake::whenStatic($mock)->tryB->thenCallParent();
        Phake::whenStatic($mock)->b->thenReturn('there');
       print_r($mock::tryB());
    }
} 

in 2.1.1 the created Phake class called directly into the parent, which kept the late static binding associated to the mock, resulting in the static::b call correctly being mocked as well (returning 'there')

however in 3.1.6 the Phake class calles ParentDelegateCallback->__invoke() which calls invokeArgs, which calls reflectionMethod with a null context. This means the late static binding will no longer be the mock, but instead be the SUT. static::b then does not hit the mock (returning 'here')

I suspect passing the mock as the context would fix it rather than null, but without looking it doesn't seem like an easy thing to do

I came across a bit of an edge-case in a test which touched the database. I was using a Phake mock as follows:

$mock = Phake::mock(MyClass::class);
Phake::when($mock)->myMethod->thenThrow(new MyException);

The issue was that later in the test, I was passing the mock as a constructor argument to the Class Under Test and then trying to serialize the CUT. I was getting the error: You cannot serialize or unserialize PDO instances

The thing is that MyClass did not have anything to do with the database, and neither did the CUT or any of its dependencies.

After a lot of debugging I found that the mock object had the instance of the exception stored as a data property a long way down the nested structure, and the exception itself had a trace property which included all of the global context from the test class, including the CakePHP fixture manager, which of course had a PDO instance inside it!

So this was really unexpected behaviour and after losing a few hours, in the end I could not use Phake to mock this class because of it.

I'm not sure if there is a solution to this. Perhaps Phake mocks could implement __sleep() in such a way as to exclude expected exceptions?

If a class declares a function with a nullable return type

public function find(int $id): ?Foo
{
    return $this->repository->find($id);
}

Then, when mocking this object without specifying behaviour for this method (Phake::when(...) ), Phake will automatically return a Phaked object of this type instead of null

Just running:

<?php
require_once('vendor/autoload.php');
Phake::mock('Memcache');

With Memcache installed results in:

[root@4bc9bbc433aa tests]# php debug.php
PHP Parse error:  syntax error, unexpected '$', expecting variable (T_VARIABLE) in /var/www/tests/vendor/phake/phake/src/Phake/ClassGenerator/EvalLoader.php(59) : eval()'d code on line 477

Here's the class definition that's trying to eval: classDef.php.txt

The problem seems to be that it's failing to extract the parameter names for the get method and so the signature is not valid php:

	public function get($, &$, &$)

This works fine under PHP 5.4 & 5.6, it's only failing for me under PHP 7.1 - using Phake v2.3.2 across all 3.