Moka\Proxy\ProxyTrait

Complexity

Total Complexity

8

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__moka_getMock()	0	4	1
A	__moka_setMock()	0	6	1
A	__moka_setMockingStrategy()	0	6	1
A	stub()	0	7	1
A	doCall()	0	10	2
A	doGet()	0	8	2

<?php
declare(strict_types=1);

namespace Moka\Proxy;

use Moka\Exception\InvalidArgumentException;
use Moka\Exception\MockNotCreatedException;
use Moka\Strategy\MockingStrategyInterface;

/**
 * Trait ProxyTrait
 * @package Moka\Proxy
 */
trait ProxyTrait
{
    /**
     * @var object
     */
    private $__moka_mock;

    /**
     * @var MockingStrategyInterface
     */
    private $__moka_mockingStrategy;

    /**
     * @return object
     */
    public function __moka_getMock()
    {
        return $this->__moka_mock;
    }

    /**
     * @param object $mock
     * @return ProxyInterface|ProxyTrait
     */
    public function __moka_setMock($mock): self
    {
        $this->__moka_mock = $mock;

        return $this;
    }

    /**
     * @param MockingStrategyInterface $mockingStrategy
     * @return ProxyInterface|ProxyTrait
     */
    public function __moka_setMockingStrategy(MockingStrategyInterface $mockingStrategy): self
    {
        $this->__moka_mockingStrategy = $mockingStrategy;

        return $this;
    }

    /**
     * @param array $namesWithValues
     * @return ProxyInterface
     *
     * @throws InvalidArgumentException
     * @throws MockNotCreatedException
     */
    public function stub(array $namesWithValues): ProxyInterface
    {
        /** @var $this ProxyInterface */
        $this->__moka_mockingStrategy->decorate($this->__moka_mock, $namesWithValues);

Accessing __moka_mockingStrategy on the interface Moka\Proxy\ProxyInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing __moka_mock on the interface Moka\Proxy\ProxyInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        return $this;
    }

    /**
     * @param string $name
     * @param array $arguments
     * @return mixed
     */
    protected function doCall(string $name, array $arguments)
    {
        if (!$this->__moka_mockingStrategy instanceof MockingStrategyInterface) {
            return null;
        }

        $target = $this->__moka_mockingStrategy->get($this->__moka_mock);

        return $target->$name(...$arguments);
    }

    /**
     * @param string $name
     * @return mixed
     */
    protected function doGet(string $name)
    {
        if (!$this->__moka_mockingStrategy instanceof MockingStrategyInterface) {
            return null;
        }

        return $this->__moka_mockingStrategy->call($this->__moka_mock, $name);
    }
}