ConfigurationTest::setUp() - Code Metrics - Ocramius/GeneratedHydrator - Measure and Improve Code Quality continuously with Scrutinizer

ConfigurationTest::setUp() A
last analyzed 2020-07-14 10:25 UTC

↳ Parent: ConfigurationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?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);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        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);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        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);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        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);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        self::assertSame($generator, $this->configuration->getHydratorGenerator());
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace GeneratedHydratorTest;
6
7			use CodeGenerationUtils\Autoloader\AutoloaderInterface;
8			use CodeGenerationUtils\GeneratorStrategy\GeneratorStrategyInterface;
9			use CodeGenerationUtils\Inflector\ClassNameInflectorInterface;
10			use GeneratedHydrator\ClassGenerator\HydratorGenerator;
11			use GeneratedHydrator\Configuration;
12			use PHPUnit\Framework\MockObject\MockObject;
13			use PHPUnit\Framework\TestCase;
14			use function is_dir;
15
16			/**
17			* Tests for {@see \GeneratedHydrator\Configuration}
18			*/
19			class ConfigurationTest extends TestCase
20			{
21			/** @var Configuration */
22			protected $configuration;
23
24			/**
25			* {@inheritDoc}
26			*
27			* @covers \GeneratedHydrator\Configuration::__construct
28			*/
29			public function setUp() : void
30			{
31			$this->configuration = new Configuration('test');
32			}
33
34			/**
35			* @covers \GeneratedHydrator\Configuration::setHydratedClassName
36			* @covers \GeneratedHydrator\Configuration::getHydratedClassName
37			*/
38			public function testGetSetHydratedClassName() : void
39			{
40			self::assertSame('test', $this->configuration->getHydratedClassName());
41			$this->configuration->setHydratedClassName('bar');
42			self::assertSame('bar', $this->configuration->getHydratedClassName());
43			}
44
45			/**
46			* @covers \GeneratedHydrator\Configuration::createFactory
47			*/
48			public function testCreateFactory() : void
49			{
50			self::assertInstanceOf('GeneratedHydrator\Factory\HydratorFactory', $this->configuration->createFactory());
51			}
52
53			/**
54			* @covers \GeneratedHydrator\Configuration::doesAutoGenerateProxies
55			* @covers \GeneratedHydrator\Configuration::setAutoGenerateProxies
56			*/
57			public function testGetSetAutoGenerateProxies() : void
58			{
59			self::assertTrue($this->configuration->doesAutoGenerateProxies(), 'Default setting check for BC');
60
61			$this->configuration->setAutoGenerateProxies(false);
62			self::assertFalse($this->configuration->doesAutoGenerateProxies());
63
64			$this->configuration->setAutoGenerateProxies(true);
65			self::assertTrue($this->configuration->doesAutoGenerateProxies());
66			}
67
68			/**
69			* @covers \GeneratedHydrator\Configuration::getGeneratedClassesNamespace
70			* @covers \GeneratedHydrator\Configuration::setGeneratedClassesNamespace
71			*/
72			public function testGetSetProxiesNamespace() : void
73			{
74			self::assertSame(
75			'GeneratedHydratorGeneratedClass',
76			$this->configuration->getGeneratedClassesNamespace(),
77			'Default setting check for BC'
78			);
79
80			$this->configuration->setGeneratedClassesNamespace('foo');
81			self::assertSame('foo', $this->configuration->getGeneratedClassesNamespace());
82			}
83
84			/**
85			* @covers \GeneratedHydrator\Configuration::getClassNameInflector
86			* @covers \GeneratedHydrator\Configuration::setClassNameInflector
87			*/
88			public function testSetGetClassNameInflector() : void
89			{
90			self::assertInstanceOf(ClassNameInflectorInterface::class, $this->configuration->getClassNameInflector());
91
92			/** @var ClassNameInflectorInterface\|MockObject $inflector */
93			$inflector = $this->createMock(ClassNameInflectorInterface::class);
94
95			$this->configuration->setClassNameInflector($inflector);
			0 ignored issues – show Bug introduced 2019-07-17 06:05 UTC by Report Bug Copy Issue Report It seems like `$inflector` defined by `$this->createMock(\CodeG...lectorInterface::class)` on line `93` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `GeneratedHydrator\Config...setClassNameInflector()` does only seem to accept `object<CodeGenerationUti...NameInflectorInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
96			self::assertSame($inflector, $this->configuration->getClassNameInflector());
97			}
98
99			/**
100			* @covers \GeneratedHydrator\Configuration::getGeneratorStrategy
101			* @covers \GeneratedHydrator\Configuration::setGeneratorStrategy
102			*/
103			public function testSetGetGeneratorStrategy() : void
104			{
105			self::assertInstanceOf(GeneratorStrategyInterface::class, $this->configuration->getGeneratorStrategy());
106
107			/** @var GeneratorStrategyInterface\|MockObject $strategy */
108			$strategy = $this->createMock(GeneratorStrategyInterface::class);
109
110			$this->configuration->setGeneratorStrategy($strategy);
			0 ignored issues – show Bug introduced 2019-07-17 06:05 UTC by Report Bug Copy Issue Report It seems like `$strategy` defined by `$this->createMock(\CodeG...rategyInterface::class)` on line `108` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `GeneratedHydrator\Config...:setGeneratorStrategy()` does only seem to accept `object<CodeGenerationUti...ratorStrategyInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
111			self::assertSame($strategy, $this->configuration->getGeneratorStrategy());
112			}
113
114			/**
115			* @covers \GeneratedHydrator\Configuration::getGeneratedClassesTargetDir
116			* @covers \GeneratedHydrator\Configuration::setGeneratedClassesTargetDir
117			*/
118			public function testSetGetProxiesTargetDir() : void
119			{
120			self::assertTrue(is_dir($this->configuration->getGeneratedClassesTargetDir()));
121
122			$this->configuration->setGeneratedClassesTargetDir(__DIR__);
123			self::assertSame(__DIR__, $this->configuration->getGeneratedClassesTargetDir());
124			}
125
126			/**
127			* @covers \GeneratedHydrator\Configuration::getGeneratedClassAutoloader
128			* @covers \GeneratedHydrator\Configuration::setGeneratedClassAutoloader
129			*/
130			public function testSetGetGeneratedClassAutoloader() : void
131			{
132			self::assertInstanceOf(AutoloaderInterface::class, $this->configuration->getGeneratedClassAutoloader());
133
134			/** @var AutoloaderInterface\|MockObject $autoloader */
135			$autoloader = $this->createMock(AutoloaderInterface::class);
136
137			$this->configuration->setGeneratedClassAutoloader($autoloader);
			0 ignored issues – show Bug introduced 2019-07-17 06:05 UTC by Report Bug Copy Issue Report It seems like `$autoloader` defined by `$this->createMock(\CodeG...loaderInterface::class)` on line `135` can also be of type `object<PHPUnit\Framework\MockObject\MockObject>`; however, `GeneratedHydrator\Config...eratedClassAutoloader()` does only seem to accept `object<CodeGenerationUti...er\AutoloaderInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
138			self::assertSame($autoloader, $this->configuration->getGeneratedClassAutoloader());
139			}
140
141			/**
142			* @covers \GeneratedHydrator\Configuration::getHydratorGenerator
143			* @covers \GeneratedHydrator\Configuration::setHydratorGenerator
144			*/
145			public function testSetGetHydratorGenerator() : void
146			{
147			self::assertInstanceOf(HydratorGenerator::class, $this->configuration->getHydratorGenerator());
148
149			/** @var HydratorGenerator $generator*/
150			$generator = $this->createMock(HydratorGenerator::class);
151
152			$this->configuration->setHydratorGenerator($generator);
			0 ignored issues – show Documentation introduced 2019-07-17 06:05 UTC by Report Bug Copy Issue Report `$generator` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `object<GeneratedHydrator...ator\HydratorGenerator>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
153			self::assertSame($generator, $this->configuration->getHydratorGenerator());
154			}
155			}
156

Ocramius / GeneratedHydrator

ConfigurationTest::setUp() A last analyzed 2020-07-14 10:25 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ConfigurationTest::setUp() A
last analyzed 2020-07-14 10:25 UTC