class ObjectProphecy in Zircon Profile 8.0

Object prophecy.

@author Konstantin Kudryashov <[e-mail]>

Hierarchy

• class \Prophecy\Prophecy\ObjectProphecy implements ProphecyInterface

16 files declare their use of ObjectProphecy

AggregateException.php in vendor/phpspec/prophecy/src/Prophecy/Exception/Prediction/AggregateException.php

CallbackPrediction.php in vendor/phpspec/prophecy/src/Prophecy/Prediction/CallbackPrediction.php

CallbackPromise.php in vendor/phpspec/prophecy/src/Prophecy/Promise/CallbackPromise.php

CallCenter.php in vendor/phpspec/prophecy/src/Prophecy/Call/CallCenter.php

CallCenterSpec.php in vendor/phpspec/prophecy/spec/Prophecy/Call/CallCenterSpec.php

... See full list

File

vendor/phpspec/prophecy/src/Prophecy/Prophecy/ObjectProphecy.php, line 30

Namespace

Prophecy\Prophecy

class ObjectProphecy implements ProphecyInterface {
  private $lazyDouble;
  private $callCenter;
  private $revealer;
  private $comparatorFactory;

  /**
   * @var MethodProphecy[][]
   */
  private $methodProphecies = array();

  /**
   * Initializes object prophecy.
   *
   * @param LazyDouble        $lazyDouble
   * @param CallCenter        $callCenter
   * @param RevealerInterface $revealer
   * @param ComparatorFactory $comparatorFactory
   */
  public function __construct(LazyDouble $lazyDouble, CallCenter $callCenter = null, RevealerInterface $revealer = null, ComparatorFactory $comparatorFactory = null) {
    $this->lazyDouble = $lazyDouble;
    $this->callCenter = $callCenter ?: new CallCenter();
    $this->revealer = $revealer ?: new Revealer();
    $this->comparatorFactory = $comparatorFactory ?: ComparatorFactory::getInstance();
  }

  /**
   * Forces double to extend specific class.
   *
   * @param string $class
   *
   * @return $this
   */
  public function willExtend($class) {
    $this->lazyDouble
      ->setParentClass($class);
    return $this;
  }

  /**
   * Forces double to implement specific interface.
   *
   * @param string $interface
   *
   * @return $this
   */
  public function willImplement($interface) {
    $this->lazyDouble
      ->addInterface($interface);
    return $this;
  }

  /**
   * Sets constructor arguments.
   *
   * @param array $arguments
   *
   * @return $this
   */
  public function willBeConstructedWith(array $arguments = null) {
    $this->lazyDouble
      ->setArguments($arguments);
    return $this;
  }

  /**
   * Reveals double.
   *
   * @return object
   *
   * @throws \Prophecy\Exception\Prophecy\ObjectProphecyException If double doesn't implement needed interface
   */
  public function reveal() {
    $double = $this->lazyDouble
      ->getInstance();
    if (null === $double || !$double instanceof ProphecySubjectInterface) {
      throw new ObjectProphecyException("Generated double must implement ProphecySubjectInterface, but it does not.\n" . 'It seems you have wrongly configured doubler without required ClassPatch.', $this);
    }
    $double
      ->setProphecy($this);
    return $double;
  }

  /**
   * Adds method prophecy to object prophecy.
   *
   * @param MethodProphecy $methodProphecy
   *
   * @throws \Prophecy\Exception\Prophecy\MethodProphecyException If method prophecy doesn't
   *                                                              have arguments wildcard
   */
  public function addMethodProphecy(MethodProphecy $methodProphecy) {
    $argumentsWildcard = $methodProphecy
      ->getArgumentsWildcard();
    if (null === $argumentsWildcard) {
      throw new MethodProphecyException(sprintf("Can not add prophecy for a method `%s::%s()`\n" . "as you did not specify arguments wildcard for it.", get_class($this
        ->reveal()), $methodProphecy
        ->getMethodName()), $methodProphecy);
    }
    $methodName = $methodProphecy
      ->getMethodName();
    if (!isset($this->methodProphecies[$methodName])) {
      $this->methodProphecies[$methodName] = array();
    }
    $this->methodProphecies[$methodName][] = $methodProphecy;
  }

  /**
   * Returns either all or related to single method prophecies.
   *
   * @param null|string $methodName
   *
   * @return MethodProphecy[]
   */
  public function getMethodProphecies($methodName = null) {
    if (null === $methodName) {
      return $this->methodProphecies;
    }
    if (!isset($this->methodProphecies[$methodName])) {
      return array();
    }
    return $this->methodProphecies[$methodName];
  }

  /**
   * Makes specific method call.
   *
   * @param string $methodName
   * @param array  $arguments
   *
   * @return mixed
   */
  public function makeProphecyMethodCall($methodName, array $arguments) {
    $arguments = $this->revealer
      ->reveal($arguments);
    $return = $this->callCenter
      ->makeCall($this, $methodName, $arguments);
    return $this->revealer
      ->reveal($return);
  }

  /**
   * Finds calls by method name & arguments wildcard.
   *
   * @param string            $methodName
   * @param ArgumentsWildcard $wildcard
   *
   * @return Call[]
   */
  public function findProphecyMethodCalls($methodName, ArgumentsWildcard $wildcard) {
    return $this->callCenter
      ->findCalls($methodName, $wildcard);
  }

  /**
   * Checks that registered method predictions do not fail.
   *
   * @throws \Prophecy\Exception\Prediction\AggregateException If any of registered predictions fail
   */
  public function checkProphecyMethodsPredictions() {
    $exception = new AggregateException(sprintf("%s:\n", get_class($this
      ->reveal())));
    $exception
      ->setObjectProphecy($this);
    foreach ($this->methodProphecies as $prophecies) {
      foreach ($prophecies as $prophecy) {
        try {
          $prophecy
            ->checkPrediction();
        } catch (PredictionException $e) {
          $exception
            ->append($e);
        }
      }
    }
    if (count($exception
      ->getExceptions())) {
      throw $exception;
    }
  }

  /**
   * Creates new method prophecy using specified method name and arguments.
   *
   * @param string $methodName
   * @param array  $arguments
   *
   * @return MethodProphecy
   */
  public function __call($methodName, array $arguments) {
    $arguments = new ArgumentsWildcard($this->revealer
      ->reveal($arguments));
    foreach ($this
      ->getMethodProphecies($methodName) as $prophecy) {
      $argumentsWildcard = $prophecy
        ->getArgumentsWildcard();
      $comparator = $this->comparatorFactory
        ->getComparatorFor($argumentsWildcard, $arguments);
      try {
        $comparator
          ->assertEquals($argumentsWildcard, $arguments);
        return $prophecy;
      } catch (ComparisonFailure $failure) {
      }
    }
    return new MethodProphecy($this, $methodName, $arguments);
  }

  /**
   * Tries to get property value from double.
   *
   * @param string $name
   */
  public function __get($name) {
    return $this
      ->reveal()->{$name};
  }

  /**
   * Tries to set property value to double.
   *
   * @param string $name
   * @param string $value
   */
  public function __set($name, $value) {
    $this
      ->reveal()->{$name} = $this->revealer
      ->reveal($value);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ObjectProphecy::$callCenter	private	property
ObjectProphecy::$comparatorFactory	private	property
ObjectProphecy::$lazyDouble	private	property
ObjectProphecy::$methodProphecies	private	property
ObjectProphecy::$revealer	private	property
ObjectProphecy::addMethodProphecy	public	function	Adds method prophecy to object prophecy.
ObjectProphecy::checkProphecyMethodsPredictions	public	function	Checks that registered method predictions do not fail.
ObjectProphecy::findProphecyMethodCalls	public	function	Finds calls by method name & arguments wildcard.
ObjectProphecy::getMethodProphecies	public	function	Returns either all or related to single method prophecies.
ObjectProphecy::makeProphecyMethodCall	public	function	Makes specific method call.
ObjectProphecy::reveal	public	function	Reveals double. Overrides ProphecyInterface::reveal
ObjectProphecy::willBeConstructedWith	public	function	Sets constructor arguments.
ObjectProphecy::willExtend	public	function	Forces double to extend specific class.
ObjectProphecy::willImplement	public	function	Forces double to implement specific interface.
ObjectProphecy::__call	public	function	Creates new method prophecy using specified method name and arguments.
ObjectProphecy::__construct	public	function	Initializes object prophecy.
ObjectProphecy::__get	public	function	Tries to get property value from double.
ObjectProphecy::__set	public	function	Tries to set property value to double.