ProphecyTrait.php

<?php

declare (strict_types=1);
namespace Prophecy\PhpUnit;

use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\Attributes\After;
use PHPUnit\Framework\Attributes\PostCondition;
use PHPUnit\Framework\TestCase;
use Prophecy\Exception\Doubler\DoubleException;
use Prophecy\Exception\Doubler\InterfaceNotFoundException;
use Prophecy\Exception\Prediction\PredictionException;
use Prophecy\Prophecy\MethodProphecy;
use Prophecy\Prophecy\ObjectProphecy;
use Prophecy\Prophet;

/**
 * @mixin TestCase
 */
trait ProphecyTrait {
    
    /**
     * @var Prophet|null
     *
     * @internal
     */
    private $prophet;
    
    /**
     * @var bool
     *
     * @internal
     */
    private $prophecyAssertionsCounted = false;
    
    /**
     * @throws DoubleException
     * @throws InterfaceNotFoundException
     *
     * @template T of object
     * @phpstan-param class-string<T>|null $classOrInterface
     * @phpstan-return ($classOrInterface is null ? ObjectProphecy<object> : ObjectProphecy<T>)
     *
     * @not-deprecated
     */
    protected function prophesize(?string $classOrInterface = null) : ObjectProphecy {
        static $isPhpUnit9;
        $isPhpUnit9 = $isPhpUnit9 ?? method_exists($this, 'recordDoubledType');
        if (!$isPhpUnit9) {
            // PHPUnit 10.1
            $this->registerFailureType(PredictionException::class);
        }
        elseif (\is_string($classOrInterface)) {
            // PHPUnit 9
            \assert($this instanceof TestCase);
            $this->recordDoubledType($classOrInterface);
        }
        return $this->getProphet()
            ->prophesize($classOrInterface);
    }
    
    /**
     * @postCondition
     */
    protected function verifyProphecyDoubles() : void {
        if ($this->prophet === null) {
            return;
        }
        try {
            $this->prophet
                ->checkPredictions();
        } catch (PredictionException $e) {
            throw new AssertionFailedError($e->getMessage());
        } finally {
            $this->countProphecyAssertions();
        }
    }
    
    /**
     * @after
     */
    protected function tearDownProphecy() : void {
        if (null !== $this->prophet && !$this->prophecyAssertionsCounted) {
            // Some Prophecy assertions may have been done in tests themselves even when a failure happened before checking mock objects.
            $this->countProphecyAssertions();
        }
        $this->prophet = null;
    }
    
    /**
     * @internal
     */
    private function countProphecyAssertions() : void {
        \assert($this instanceof TestCase);
        \assert($this->prophet !== null);
        $this->prophecyAssertionsCounted = true;
        foreach ($this->prophet
            ->getProphecies() as $objectProphecy) {
            foreach ($objectProphecy->getMethodProphecies() as $methodProphecies) {
                foreach ($methodProphecies as $methodProphecy) {
                    \assert($methodProphecy instanceof MethodProphecy);
                    $this->addToAssertionCount(\count($methodProphecy->getCheckedPredictions()));
                }
            }
        }
    }
    
    /**
     * @internal
     */
    private function getProphet() : Prophet {
        if ($this->prophet === null) {
            $this->prophet = new Prophet();
        }
        return $this->prophet;
    }

}