Mehr Spaß beim Testen mit der eigenen Testing-API: Die "setUp()"-Methode in PHPUnit-Tests eliminieren

    
    /** @covers \App\Client */
class ClientTest extends TestCase
{
    private ServiceA $serviceA;

    private ServiceB $serviceB;

    private ServiceC $serviceC;

    private Client $unit;

    protected function setUp(): void
    {
        parent::setUp();

        $this->serviceA = $this->createMock(ServiceA::class);
        $this->serviceB = $this->createMock(ServiceB::class);
        $this->serviceC = $this->createMock(ServiceC::class);
        $this->unit     = new Client(
            $this->serviceA,
            $this->serviceB,
            $this->serviceC
        );
    }

    public function testDoSomething(): void
    {
        $this->serviceA
             ->expects(self::once())
             ->method('doA')
             ->willReturn('A');

        $this->serviceB
             ->expects(self::once())
             ->method('doB')
             ->willReturn('B');

        $this->serviceC
             ->expects(self::once())
             ->method('doC')
             ->willReturn('C');

        $expected = 'ABC';
        $actual   = $this->unit->doSomething();

        self::assertSame($expected, $actual);
    }
}
    

    
    use Exception;
use phpDocumentor\Reflection\DocBlock\Tags\Covers;
use phpDocumentor\Reflection\DocBlockFactory;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionAttribute;
use ReflectionClass;
use Webmozart\Assert\InvalidArgumentException;

/**
 * @template UNIT of object
 */
trait UnitCreatorTrait
{
    /** @return class-string<UNIT> */
    protected function getUnitClass(): string
    {
        $fqcn = $this->getUnitClassByDocBlock() ?? $this->getUnitClassByAttribute();

        if ($fqcn) {
            return $fqcn;
        }

        throw new Exception('Provide a unit class by @covers annotation, #[CoversClass] attribute or getUnitClass() method.');
    }

    /** @return null|class-string<UNIT> */
    private function getUnitClassByDocBlock(): ?string
    {
        try {
            $testCase        = new ReflectionClass($this);
            $docBlockFactory = DocBlockFactory::createInstance();
            $docBlock        = $docBlockFactory->create($testCase);
            $coversTag       = $docBlock->getTagsByName('covers')[0] ?? null;

            if ($coversTag instanceof Covers === false) {
                return null;
            }

            return (string)$coversTag->getReference();
        } catch (InvalidArgumentException) {
            return null;
        }
    }

    /** @return null|class-string<UNIT> */
    private function getUnitClassByAttribute(): ?string
    {
        $testCase        = new ReflectionClass($this);
        $coversAttribute = $testCase->getAttributes(CoversClass::class)[0] ?? null;

        if ($coversAttribute instanceof ReflectionAttribute === false) {
            return null;
        }

        return $coversAttribute->newInstance()->className();
    }
}
    

    
    use Exception;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionClass;

/**
 * @template UNIT of object
 */
trait UnitCreatorTrait
{
    /** @var array<string, MockObject> */
    private array $mocks = [];

    /** @return array<string, mixed> */
    protected function getUnitConstructorParameters(): array
    {
        return [];
    }

    /**
     * @template MOCK of object
     * @param class-string<MOCK> $class
     * @return MOCK&MockObject
     */
    protected function mock(string $class): object
    {
        if (isset($this->mocks[$class]) === false) {
            $this->mocks[$class] = $this->createMock($class);
        }

        return $this->mocks[$class];
    }

    /**
     * @param ReflectionClass<UNIT> $unitReflection
     * @return array<string, mixed>
     */
    private function buildParameters(ReflectionClass $unitReflection): array
    {
        $parameters               = $this->getUnitConstructorParameters();
        $parameterReflections     = $unitReflection->getConstructor()?->getParameters() ?? [];
        $missingBuiltinParameters = [];

        foreach ($parameterReflections as $parameterReflection) {
            $parameterReflectionType = $parameterReflection->getType();
            $parameterName           = $parameterReflection->getName();
            $parameterType           = $parameterReflectionType->getName();

            if (array_key_exists($parameterName, $parameters)) {
                continue;
            }

            if ($parameterReflectionType->isBuiltin() === true) {
                $missingBuiltinParameters[] = $parameterName;
                continue;
            }

            $parameters[$parameterName]  = $this->mock($parameterType);
            $this->mocks[$parameterType] = $parameters[$parameterName];
        }

        if ($missingBuiltinParameters !== []) {
            throw new Exception(
                sprintf(
                    'Missing parameters for constructor of `%s`: %s',
                    $unitReflection->getName(),
                    implode(', ', $missingBuiltinParameters)
                )
            );
        }

        return $parameters;
    }
}
    

    
    use ReflectionClass;

/**
 * @template UNIT of object
 */
trait UnitCreatorTrait
{
    /** @var UNIT|null */
    private ?object $unit = null;

    /** @return UNIT */
    protected function getUnit(): object
    {
        if ($this->unit === null) {
            $unitClass      = $this->getUnitClass();
            $unitReflection = new ReflectionClass($unitClass);
            $parameters     = $this->buildParameters($unitReflection);
            $this->unit     = new $unitClass(...$parameters);
        }

        return $this->unit;
    }
}
    

    
    use e3n\Test\UnitCreatorTrait;
use PHPUnit\Framework\TestCase;

/**
 * @covers \App\Client
 */
class ClientTest extends TestCase
{
    /** @use UnitCreatorTrait<Client> */
    use UnitCreatorTrait;

    public function testDoSomething(): void
    {
        $this->mock(ServiceA::class)
             ->expects(self::once())
             ->method('doA')
             ->willReturn('A');

        $this->mock(ServiceB::class)
             ->expects(self::once())
             ->method('doB')
             ->willReturn('B');

        $this->mock(ServiceC::class)
             ->expects(self::once())
             ->method('doC')
             ->willReturn('C');

        $expected = 'ABC';
        $actual   = $this->getUnit()->doSomething();

        self::assertSame($expected, $actual);
    }
}
    

    
    composer require e3n/testing-unit-creator --dev