SergeyMakinen\Tests\TestCase

Complexity

Total Complexity

21

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

72.72%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	5	1
A	isParentMethod()	0	4	1
A	createMock()	0	13	2
A	expectException()	0	18	4
B	expectExceptionCode()	0	17	5
A	getProperty()	0	8	2
A	getInaccessibleProperty()	0	6	2
A	setInaccessibleProperty()	0	6	2
A	invokeInaccessibleMethod()	0	6	2

<?php
/**
 * Common tests stuff
 *
 * @see       https://github.com/sergeymakinen/tests
 * @copyright Copyright (c) 2017 Sergey Makinen (https://makinen.ru)
 * @license   https://github.com/sergeymakinen/tests/blob/master/LICENSE MIT License
 */

namespace SergeyMakinen\Tests;

use PHPUnit\Framework\Exception;
use PHPUnit\Util\InvalidArgumentHelper;

abstract class TestCase extends \PHPUnit\Framework\TestCase
{
    /**
     * @var string
     */
    private $expectedException;

Consider using a different property name as you override a private property of the parent class.

    /**
     * @inheritDoc
     */
    protected function tearDown()
    {
        parent::tearDown();
        $this->expectedException = null;
    }

    /**
     * Returns whether the class' parent method exists.
     *
     * @param string $name
     * @return bool
     *
     * @internal
     */
    protected function isParentMethod($name)
    {
        return is_callable('parent::' . $name);
    }

    /**
     * Returns a test double for the specified class.
     *
     * @param string $originalClassName
     * @return \PHPUnit_Framework_MockObject_MockObject
     */
    protected function createMock($originalClassName)
    {
        if ($this->isParentMethod(__FUNCTION__)) {
            return parent::createMock($originalClassName);
        }

        return $this
            ->getMockBuilder($originalClassName)
            ->disableOriginalConstructor()
            ->disableOriginalClone()
            ->disableArgumentCloning()
            ->getMock();
    }

    /**
     * Sets an exception expected.
     *
     * @param string $exception
     * @throws Exception|\PHPUnit_Framework_Exception
     */
    public function expectException($exception)
    {
        if ($this->isParentMethod(__FUNCTION__)) {
            parent::expectException($exception);
            return;
        }

        if (!is_string($exception)) {
            if (class_exists('PHPUnit\Util\InvalidArgumentHelper')) {
                throw InvalidArgumentHelper::factory(1, 'string');
            } else {
                throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
            }
        }

        $this->expectedException = $exception;
        $this->setExpectedException($this->expectedException);

The method setExpectedException() does not exist on SergeyMakinen\Tests\TestCase. Did you maybe mean setExpectedExceptionFromAnnotation()?

    }

    /**
     * Sets an exception code expected.
     *
     * @param int|string $code
     * @throws Exception|\PHPUnit_Framework_Exception
     */
    public function expectExceptionCode($code)
    {
        if ($this->isParentMethod(__FUNCTION__)) {
            parent::expectExceptionCode($code);
            return;
        }

        if (!is_int($code) && !is_string($code)) {
            if (class_exists('PHPUnit\Util\InvalidArgumentHelper')) {
                throw InvalidArgumentHelper::factory(1, 'integer or string');
            } else {
                throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer or string');
            }
        }

        $this->setExpectedException($this->expectedException, '', $code);

The method setExpectedException() does not exist on SergeyMakinen\Tests\TestCase. Did you maybe mean setExpectedExceptionFromAnnotation()?

    }

    /**
     * Returns the reflected property.
     *
     * @param object|string $object
     * @param string $name
     * @return \ReflectionProperty
     */
    protected function getProperty($object, $name)
    {
        $class = new \ReflectionClass($object);
        while (!$class->hasProperty($name)) {
            $class = $class->getParentClass();
        }
        return $class->getProperty($name);
    }

    /**
     * Returns the private/protected property by its name.
     *
     * @param object|string $object
     * @param string $name
     * @return mixed
     */
    protected function getInaccessibleProperty($object, $name)
    {
        $property = $this->getProperty($object, $name);
        $property->setAccessible(true);
        return $property->getValue(is_object($object) ? $object : null);
    }

    /**
     * Sets the private/protected property value by its name.
     *
     * @param object|string $object
     * @param string $name
     * @param mixed $value
     */
    protected function setInaccessibleProperty($object, $name, $value)
    {
        $property = $this->getProperty($object, $name);
        $property->setAccessible(true);
        $property->setValue(is_object($object) ? $object : null, $value);
    }

    /**
     * Invokes the private/protected method by its name and returns its result.
     *
     * @param object|string $object
     * @param string $name
     * @param array $args
     * @return mixed
     */
    protected function invokeInaccessibleMethod($object, $name, array $args = [])
    {
        $method = new \ReflectionMethod($object, $name);
        $method->setAccessible(true);
        return $method->invokeArgs(is_object($object) ? $object : null, $args);
    }
}