Hi,

I know that the purpose of this library is mainly for PHPSpec and therefore tries to satifsy another purpose. I still use it in regular tests, because the API is so easy to use, especially compared to PHPUnit mocks. Unfortunately there is one downside: Prophecy is not able to create partial mocks. Sometimes I want to test a method that gets Data from the same object but from another method. And I don't want to set up all data for the other method, because I want to unit test only one. In such a scenario, I would need to mock only one method, which I understand is currently not possible neither intended to be possible in prophecy.

I just think that this tool is to useful to limit it just for PHPSpec. My question therefore is, if it would be possible to implement partial mocks in the future?

resolves: https://github.com/phpspec/prophecy/issues/280

• Allows void return type
• Allows iterable type
• Allows nullable arguments
• Allows nullable return types

…y usage

With this PR we resolve https://github.com/phpspec/prophecy/issues/96 and https://github.com/phpspec/phpspec/issues/884.

Our empirical tests:

~ 6000 PHPSpec examples

Before patch:

• 1GB 900MB memory consumption
• 31676 declared classes
• 105 seconds per suite execution

After patch:

• 146MB (-1.301 %)
• 3148 declared classes (-1.006 %)
• 9 seconds per suite execution (- 1.166 %)

Only thing that should be considered here is the static-ness nature of CachedDoubler. Is this fine or is it improvable?

Hi there.

Sorry to open this issue, seems that it was already discussed, here, here and here.

But, right now there is no solution to mock object that didn't define public API using PHP implementations. And sadly, many libraries uses magic calls, just talk about the example : AWS. I Guess that I can find other popular examples.

AWS use PHPDoc to describe API when doing magic functions, see PhpDoc @method.

So, what about using this information to read public API ? PHPStorm use this information to build auto-completion.

Regards,

When a php7 return type is self, like so:

class Foo {
  public function setBar(Bar $bar) : self
  {
      ...
      return $this;
  }
}

Extending Foo::setBar like so

class Baz extends Foo {
  public function setBar(Bar $bar) : self
  {
      ...
  }
}

will result in

Compile Error: Declaration of Baz::setBar(Bar $bar): Baz must be compatible with Foo::setBar(Bar $bar): Foo

So the extending class must respect the return type:

class Baz extends Foo {
  public function setBar(Bar $bar) : Foo
  {
      ...
  }
}

Hi guys, There is any news about Partial Mocking supported in v1 ? Here is an example:

function it_will_call_b_and_delegate_to_a() {
  $this->a('foo', 'bar')->shouldBeCalled();
  $this->b('bar');
}

public function a($foo, $bar) {
  // do a
}

public function b($bar) {
  // do something to create foo
  $this->a($foo, $bar);
}

With partial mocks will be possible to mocking $this public methods.

Hello,

I'm having trouble mocking a Doctrine\ODM\MongoDB\Query\Builder object. In fact, this class uses an optionnal dependency "GeoJson" to perform geo-related operation.

Problem appends when this package is not installed, prophecy will generate a non PHP standard compliant class (because one of the QB method is typehinted with a GeoJson class).

You can see the problem happening here: https://travis-ci.org/akeneo/pim-community-dev/jobs/21412381#L510

I'm not really convinced this is a prophecy issue, maybe it's more a mongodb-odm issue that should not bring hard-coupling between an optionnal dependency.

Anyway, I've found an easy fix in https://github.com/phpspec/prophecy/blob/master/src/Prophecy/Doubler/Generator/ClassCodeGenerator.php#L77 which consits in always prepending \\ to the argument's class, but I'm not sure I totally get the purpose of this line 77.

Could you enlight me, please?

Regards

For better integration with PHPUnit, for instance, it would be nice if a Prophet::getNumberOfPredictions() method existed that returns the number of predictions (expectations in PHPUnit terminilogy).

In https://github.com/sebastianbergmann/phpunit/commit/6c21c66567031c863f207fb46b3c1c545d5589d1 I added the following workaround for now:

foreach ($this->prophet->getProphecies() as $objectProphecy) {
    foreach ($objectProphecy->getMethodProphecies() as $methodProphecies) {
        foreach ($methodProphecies as $methodProphecy) {
            if ($methodProphecy->getPrediction() !== null) {
                $this->numAssertions++;
            }
        }
    }
}

The above seems to work but this functionality should be part of Prophecy. This was already discussed in https://github.com/phpspec/prophecy-phpunit/pull/6 and https://github.com/phpspec/prophecy-phpunit/issues/13.

With the release of 1.10.0 we noticed some of our tests breaking. After some digging this is because the behavior has slightly changed. Maybe it's best explained with an example:

require __DIR__ . '/vendor/autoload.php';

class A {
    public function someMethod() {
        return 42;
    }
    public function otherMethod() {
    }
}

class Regression {
    public function test(A $a) {
        try {
            $a->someMethod();
        } catch (\Throwable $e) {
            return false;
        }
        return true;
    }
}

$prophet = new Prophecy\Prophet();
$prophecy = $prophet->prophesize(A::class);
$prophecy->otherMethod()->shouldNotBeCalled();

var_dump((new Regression())->test($prophecy->reveal()));

With 1.9.0 this outputs: bool(false) With 1.10.0 this outputs: bool(true)

This is because the prophecy no longer throws an error when dealing with methods which have not been prophesied. And while I admit this is a poor test, it means that some of our tests are breaking and need fixing with a feature release.

Is this an intended side effect?

I'm trying to mock magic methods, and it's impossible. Specically __get and __set. I've written some work arounds to the problem, but the tests are unwieldy.

Is there any simple way that I can mock ArrayAccess or Magic Methods?

I have a trait on a class which shouldBeCalled how ever this prophecy is fine but when the tested code runs it says it doesn't exist on the object.

My trait

trait AppliesEvents
{
  public function apply(AggregateChanged $event);
}

My class (gets mocked)

class Deal
{
  use AppliesEvents;
}

My test code:

    public function it_will_apply_unlist_deal_event_on_deal($deals, UnlistDealCommand $command, Deal $deal)
    {
        $deals->findByKey('123')->willReturn($deal);
        $command->dealId()->willReturn('123');
        $deal->apply(Argument::type(UnlistDeal::class))->shouldBeCalled();

        $this->handle($command);
    }

The code being tested:

    /**
     * @param UnlistDealCommand $command
     */
    public function handle(UnlistDealCommand $command)
    {
        $deal = $this->deals->findByKey($command->dealId());

        if (is_null($deal)) {
            throw new \RuntimeException('Unable to locate deal.');
        }

        $deal->apply(new UnlistDeal);

        $this->deals->persist($deal);
    }

If I var_dump($deal) I can see $methodProphecies contaons apply but when I call it I get

it will apply unlist deal event on deal
method `Double\Deal\P4::apply()` not found.

Any ideas?

$ ./bin/phpunit --filter ExampleTest
PHPUnit 9.5.27 by Sebastian Bergmann and contributors.

E                                                                   1 / 1 (100%)

Time: 00:00.023, Memory: 30.00 MB

There was 1 error:

1) CoreTest\ExampleTest::testShouldRegisterException
ErrorException: Notice: Object of class Exception could not be converted to int

tests/CoreTest/ExampleTest.php:26

Example of testcase:

<?php

namespace CoreTest;

use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\PhpUnit\ProphecyTrait;
use Psr\Log\LoggerInterface;

class ExampleTest extends TestCase
{
    use ProphecyTrait;

    public function testShouldRegisterException()
    {
        $logger = $this->prophesize(LoggerInterface::class);

        $logger->error(Argument::type('string'), Argument::allOf(
            Argument::withEntry('id', 10),
            Argument::withEntry('exception', new \Exception('wrong')),
        ))
            ->shouldBeCalled();

        $logger->reveal()->error('message', [
            'id' => 10,
            'exception' => new \Exception('wrong'),
            'other' => rand(0, 1000),
        ]);
    }
}

The error is thrown because the ExactValueToken checks if the value or argument maybe a object, and if only one of them is, it checks for a __toString in the object.

But PHP does not convert the object to string, before comparing it to a int|float.

When one of them (value or argument) is a object and the other is a int|float it needs to cast the object to string before comparing OR return false because they do not have the same type.

I already opened a PR to fix it: #583

Whenever we run tests using CallbackToken's and the CallbackToken fails to match, we get unhelpful assertion failures. When the specific test case does not use a lot of CallbackToken's, it is pretty easy to track which assertion has failed. This is aimed at the scenario where there are multiple identical function signatures with different CallbackToken's, so the following example becomes more readable:

    [exec]  Test  tests/unit/Example/ExampleTest.php:testItDoesSomething
     [exec] Expected exactly 1 calls that match:
     [exec]   Double\ExampleInterface\P2->doSomething(callback())
     [exec] but none were made.
     [exec] Recorded `doSomething(...)` calls:

should become

    [exec]  Test  tests/unit/Example/ExampleTest.php:testItDoesSomething
     [exec] Expected exactly 1 calls that match:
     [exec]   Double\ExampleInterface\P2->doSomething(Clear description)
     [exec] but none were made.
     [exec] Recorded `doSomething(...)` calls:

If you would like a separate issue for discussion, please let me know so I can create one.

Hi, since 8.1, PHP supports the usage of the new operator in initializers (https://php.watch/rfcs/new_in_initializers).

Given this dummy class:

class DummyClass {}

And an interface with a method using a DummyClass instance as default argument of a method:

interface BarService
{
    public function doIt(DummyClass $myClass = new DummyClass()): void;
}

And a service using the interface as a dependency:

class FooService
{
    public function __construct(
        private readonly BarService $bar
    ) {
    }

    public function execute(): void
    {
        $this->bar->doIt();
    }
}

The following test fails with a fatal PHP error in the phpspec/prophecy code:

namespace Tests;

use PHPUnit\Framework\TestCase;
use Prophecy\PhpUnit\ProphecyTrait;

class DummyClass {...}
interface BarService {...}
class FooService {...}

class FooServiceTest extends TestCase
{
    use ProphecyTrait;

    /**
     * @test
     */
    public function it_fails(): void
    {
        $someService = $this->prophesize(BarService::class);
        $someService
            ->doIt()
            ->shouldBeCalled();

        $fooService = new FooService($someService->reveal());
        $fooService->execute();
    }
}

The error message is:

PHP Fatal error:  Constant expression contains invalid operations in /vendor/phpspec/prophecy/src/Prophecy/Doubler/Generator/ClassCreator.php(49) : eval()'d code on line 5

Hi, given this enum (PHP 8.1+):

enum AppType
{
    case IOS;
    case ANDROID;
}

And an interface with a method using the enum as default argument of a method:

interface BarService
{
    public function doIt(AppType $appType = AppType::ANDROID): void;
}

And a service using the interface as a dependency:

class FooService
{
    public function __construct(
        readonly private BarService $bar
    ) {
    }

    public function execute(): void
    {
        $this->bar->doIt();
    }
}

The following test fails:

namespace Tests;

use PHPUnit\Framework\TestCase;
use Prophecy\PhpUnit\ProphecyTrait;

enum AppType {...}
interface BarService {...}
class FooService {...}

class FooServiceTest extends TestCase
{
    use ProphecyTrait;

    /**
     * @test
     */
    public function it_fails(): void
    {
        $someService = $this->prophesize(BarService::class);
        $someService
            ->doIt()
            ->shouldBeCalled();

        $fooService = new FooService($someService->reveal());
        $fooService->execute();
    }
}

The error message is:

Error : Class "Double\BarService\Tests\AppType" not found

When passing the default value explicitly works though.