GeneratedHydratorTest\ConfigurationTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	testGetSetHydratedClassName()	0	6	1
A	testCreateFactory()	0	4	1
A	testGetSetAutoGenerateProxies()	0	10	1
A	testGetSetProxiesNamespace()	0	11	1
A	testSetGetClassNameInflector()	0	10	1
A	testSetGetGeneratorStrategy()	0	10	1
A	testSetGetProxiesTargetDir()	0	7	1
A	testSetGetGeneratedClassAutoloader()	0	10	1
A	testSetGetHydratorGenerator()	0	10	1

<?php

declare(strict_types=1);

namespace GeneratedHydratorTest;

use CodeGenerationUtils\Autoloader\AutoloaderInterface;
use CodeGenerationUtils\GeneratorStrategy\GeneratorStrategyInterface;
use CodeGenerationUtils\Inflector\ClassNameInflectorInterface;
use GeneratedHydrator\ClassGenerator\HydratorGenerator;
use GeneratedHydrator\Configuration;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use function is_dir;

/**
 * Tests for {@see \GeneratedHydrator\Configuration}
 */
class ConfigurationTest extends TestCase
{
    /** @var Configuration */
    protected $configuration;

    /**
     * {@inheritDoc}
     *
     * @covers \GeneratedHydrator\Configuration::__construct
     */
    public function setUp() : void
    {
        $this->configuration = new Configuration('test');
    }

    /**
     * @covers \GeneratedHydrator\Configuration::setHydratedClassName
     * @covers \GeneratedHydrator\Configuration::getHydratedClassName
     */
    public function testGetSetHydratedClassName() : void
    {
        self::assertSame('test', $this->configuration->getHydratedClassName());
        $this->configuration->setHydratedClassName('bar');
        self::assertSame('bar', $this->configuration->getHydratedClassName());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::createFactory
     */
    public function testCreateFactory() : void
    {
        self::assertInstanceOf('GeneratedHydrator\Factory\HydratorFactory', $this->configuration->createFactory());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::doesAutoGenerateProxies
     * @covers \GeneratedHydrator\Configuration::setAutoGenerateProxies
     */
    public function testGetSetAutoGenerateProxies() : void
    {
        self::assertTrue($this->configuration->doesAutoGenerateProxies(), 'Default setting check for BC');

        $this->configuration->setAutoGenerateProxies(false);
        self::assertFalse($this->configuration->doesAutoGenerateProxies());

        $this->configuration->setAutoGenerateProxies(true);
        self::assertTrue($this->configuration->doesAutoGenerateProxies());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getGeneratedClassesNamespace
     * @covers \GeneratedHydrator\Configuration::setGeneratedClassesNamespace
     */
    public function testGetSetProxiesNamespace() : void
    {
        self::assertSame(
            'GeneratedHydratorGeneratedClass',
            $this->configuration->getGeneratedClassesNamespace(),
            'Default setting check for BC'
        );

        $this->configuration->setGeneratedClassesNamespace('foo');
        self::assertSame('foo', $this->configuration->getGeneratedClassesNamespace());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getClassNameInflector
     * @covers \GeneratedHydrator\Configuration::setClassNameInflector
     */
    public function testSetGetClassNameInflector() : void
    {
        self::assertInstanceOf(ClassNameInflectorInterface::class, $this->configuration->getClassNameInflector());

        /** @var ClassNameInflectorInterface|MockObject $inflector */
        $inflector = $this->createMock(ClassNameInflectorInterface::class);

        $this->configuration->setClassNameInflector($inflector);

It seems like $inflector defined by $this->createMock(\CodeGenerationUtils\Inflector\ClassNameInflectorInterface::class) on line 93 can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, GeneratedHydrator\Configuration::setClassNameInflector() does only seem to accept object<CodeGenerationUtils\Inflector\ClassNameInflectorInterface>, maybe add an additional type check?

        self::assertSame($inflector, $this->configuration->getClassNameInflector());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getGeneratorStrategy
     * @covers \GeneratedHydrator\Configuration::setGeneratorStrategy
     */
    public function testSetGetGeneratorStrategy() : void
    {
        self::assertInstanceOf(GeneratorStrategyInterface::class, $this->configuration->getGeneratorStrategy());

        /** @var GeneratorStrategyInterface|MockObject $strategy */
        $strategy = $this->createMock(GeneratorStrategyInterface::class);

        $this->configuration->setGeneratorStrategy($strategy);

It seems like $strategy defined by $this->createMock(\CodeGenerationUtils\GeneratorStrategy\GeneratorStrategyInterface::class) on line 108 can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, GeneratedHydrator\Configuration::setGeneratorStrategy() does only seem to accept object<CodeGenerationUtils\GeneratorStrategy\GeneratorStrategyInterface>, maybe add an additional type check?

        self::assertSame($strategy, $this->configuration->getGeneratorStrategy());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getGeneratedClassesTargetDir
     * @covers \GeneratedHydrator\Configuration::setGeneratedClassesTargetDir
     */
    public function testSetGetProxiesTargetDir() : void
    {
        self::assertTrue(is_dir($this->configuration->getGeneratedClassesTargetDir()));

        $this->configuration->setGeneratedClassesTargetDir(__DIR__);
        self::assertSame(__DIR__, $this->configuration->getGeneratedClassesTargetDir());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getGeneratedClassAutoloader
     * @covers \GeneratedHydrator\Configuration::setGeneratedClassAutoloader
     */
    public function testSetGetGeneratedClassAutoloader() : void
    {
        self::assertInstanceOf(AutoloaderInterface::class, $this->configuration->getGeneratedClassAutoloader());

        /** @var AutoloaderInterface|MockObject $autoloader */
        $autoloader = $this->createMock(AutoloaderInterface::class);

        $this->configuration->setGeneratedClassAutoloader($autoloader);

It seems like $autoloader defined by $this->createMock(\CodeGenerationUtils\Autoloader\AutoloaderInterface::class) on line 135 can also be of type object<PHPUnit\Framework\MockObject\MockObject>; however, GeneratedHydrator\Configuration::setGeneratedClassAutoloader() does only seem to accept object<CodeGenerationUtils\Autoloader\AutoloaderInterface>, maybe add an additional type check?

        self::assertSame($autoloader, $this->configuration->getGeneratedClassAutoloader());
    }

    /**
     * @covers \GeneratedHydrator\Configuration::getHydratorGenerator
     * @covers \GeneratedHydrator\Configuration::setHydratorGenerator
     */
    public function testSetGetHydratorGenerator() : void
    {
        self::assertInstanceOf(HydratorGenerator::class, $this->configuration->getHydratorGenerator());

        /** @var HydratorGenerator $generator*/
        $generator = $this->createMock(HydratorGenerator::class);

        $this->configuration->setHydratorGenerator($generator);

$generator is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<GeneratedHydrator\ClassGenerator\HydratorGenerator>.

        self::assertSame($generator, $this->configuration->getHydratorGenerator());
    }
}