JsonDefinitionFieldTest::testGetDefAsArray() - Code Metrics - Inspection of "extend tests for new definition elements" - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/EVO-6307-record-origin... ( 797eb1...d3f12f )

by Narcotic

created 2016-07-21 14:07 UTC

JsonDefinitionFieldTest::testGetDefAsArray() B

↳ Parent: JsonDefinitionFieldTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	24
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	24
rs	8.9713
cc	1
eloc	17
nc	1
nop	0

<?php
/**
 * JsonDefinitionFieldTest class file
 */

namespace Graviton\GeneratorBundle\Tests\Definition;

use Graviton\DocumentBundle\Entity\ExtReference;
use Graviton\DocumentBundle\Entity\Hash;
use Graviton\GeneratorBundle\Definition\JsonDefinitionField;
use Graviton\GeneratorBundle\Definition\Schema;

/**
 * JsonDefinitionField test
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class JsonDefinitionFieldTest extends BaseJsonDefinitionFieldTest
{
    /**
     * Test JsonDefinitionField::getDef()
     *
     * @return void
     */
    public function testGetDef()
    {
        $definition = new Schema\Field();

        $field = new JsonDefinitionField('name', $definition);
        $this->assertSame($definition, $field->getDef());
    }

    /**
     * Test JsonDefinitionField::getName()
     *
     * @return void
     */
    public function testGetName()
    {
        $name = __METHOD__;
        $definition = new Schema\Field();

        $field = new JsonDefinitionField($name, $definition);
        $this->assertEquals($name, $field->getName());
    }

    /**
     * Test JsonDefinitionField::getType()
     *
     * @return void
     */
    public function testGetType()
    {
        $definition = (new Schema\Field())->setType(__METHOD__);

        $field = new JsonDefinitionField('name', $definition);
        $this->assertEquals(strtolower($definition->getType()), $field->getType());
    }

    /**
     * Test JsonDefinitionField::getTypeDoctrine()
     *
     * @param string $defType      Definition type
     * @param string $doctrineType Doctrine type
     * @return void
     * @dataProvider dataGetTypeDoctrine
     */
    public function testGetTypeDoctrine($defType, $doctrineType)
    {
        $definition = (new Schema\Field())->setType($defType);

        $field = new JsonDefinitionField('name', $definition);
        $this->assertEquals($doctrineType, $field->getTypeDoctrine());
    }

    /**
     * Data provider for JsonDefinitionField::getTypeDoctrine()
     *
     * @return array
     */
    public function dataGetTypeDoctrine()
    {
        $map = [
            JsonDefinitionField::TYPE_STRING => 'string',
            JsonDefinitionField::TYPE_INTEGER => 'int',
            JsonDefinitionField::TYPE_LONG => 'int',
            JsonDefinitionField::TYPE_DOUBLE => 'float',
            JsonDefinitionField::TYPE_DECIMAL => 'float',
            JsonDefinitionField::TYPE_DATETIME => 'date',
            JsonDefinitionField::TYPE_BOOLEAN => 'boolean',
            JsonDefinitionField::TYPE_OBJECT => 'hash',
            JsonDefinitionField::TYPE_EXTREF => 'extref',
        ];
        return array_map(
            function ($defType, $doctrineType) {
                return [$defType, $doctrineType];
            },
            array_keys($map),
            array_values($map)
        );
    }

    /**
     * Test JsonDefinitionField::getTypeSerializer()
     *
     * @param string $defType        Definition type
     * @param string $serializerType Serializer type
     * @return void
     * @dataProvider dataGetTypeSerializer
     */
    public function testGetTypeSerializer($defType, $serializerType)
    {
        $definition = (new Schema\Field())->setType($defType);

        $field = new JsonDefinitionField('name', $definition);
        $this->assertEquals($serializerType, $field->getTypeSerializer());
    }

    /**
     * Data provider for JsonDefinitionField::getTypeSerializer()
     *
     * @return array
     */
    public function dataGetTypeSerializer()
    {
        $map = [
            JsonDefinitionField::TYPE_STRING => 'string',
            JsonDefinitionField::TYPE_INTEGER => 'integer',
            JsonDefinitionField::TYPE_LONG => 'integer',
            JsonDefinitionField::TYPE_DOUBLE => 'double',
            JsonDefinitionField::TYPE_DECIMAL => 'double',
            JsonDefinitionField::TYPE_DATETIME => 'DateTime',
            JsonDefinitionField::TYPE_BOOLEAN => 'boolean',
            JsonDefinitionField::TYPE_OBJECT => Hash::class,
            JsonDefinitionField::TYPE_EXTREF => ExtReference::class,
        ];
        return array_map(
            function ($defType, $serializerType) {
                return [$defType, $serializerType];
            },
            array_keys($map),
            array_values($map)
        );
    }

    /**
     * Test JsonDefinitionField::getDefAsArray()
     *
     * @return void
     */
    public function testGetDefAsArray()
    {
        $definition = $this->getBaseField();

        $field = new JsonDefinitionField('name', $definition);
        $this->assertEquals(
            array_replace(
                $this->getBaseDefAsArray($definition),
                [
                    'name'                 => $field->getName(),
                    'type'                 => $field->getType(),
                    'exposedName'          => $definition->getExposeAs(),
                    'doctrineType'         => $field->getTypeDoctrine(),
                    'serializerType'       => $field->getTypeSerializer(),
                    'relType'              => null,
                    'isClassType'          => false,
                    'xDynamicKey'          => null,
                    'searchable'           => 0,
                    'recordOriginException' => false
                ]
            ),
            $field->getDefAsArray()
        );
    }

    /**
     * Test JsonDefinitionField::getXDynamicKey()
     *
     * @return void
     */
    public function testGetXDynamicKey()
    {
        $key = (new Schema\XDynamicKey())
            ->setDocumentId(__CLASS__)
            ->setRepositoryMethod(__LINE__)
            ->setRefField(__FILE__);

        $definition = (new Schema\Field())
            ->setXDynamicKey($key);

        $field = new JsonDefinitionField('name', $definition);

        $this->assertEquals(
            array_replace(
                $this->getBaseDefAsArray($definition),
                [
                    'name'                  => $field->getName(),
                    'type'                  => $field->getType(),
                    'exposedName'           => $field->getName(),
                    'doctrineType'          => $field->getTypeDoctrine(),
                    'serializerType'        => $field->getTypeSerializer(),
                    'relType'               => null,
                    'isClassType'           => false,
                    'xDynamicKey'           => $key,
                    'searchable'            => 0,
                    'recordOriginException' => false
                ]
            ),
            $field->getDefAsArray()
        );
    }
}


1		<?php
2		/**
3		* JsonDefinitionFieldTest class file
4		*/
5
6		namespace Graviton\GeneratorBundle\Tests\Definition;
7
8		use Graviton\DocumentBundle\Entity\ExtReference;
9		use Graviton\DocumentBundle\Entity\Hash;
10		use Graviton\GeneratorBundle\Definition\JsonDefinitionField;
11		use Graviton\GeneratorBundle\Definition\Schema;
12
13		/**
14		* JsonDefinitionField test
15		*
16		* @author List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
17		* @license http://opensource.org/licenses/gpl-license.php GNU Public License
18		* @link http://swisscom.ch
19		*/
20		class JsonDefinitionFieldTest extends BaseJsonDefinitionFieldTest
21		{
22		/**
23		* Test JsonDefinitionField::getDef()
24		*
25		* @return void
26		*/
27		public function testGetDef()
28		{
29		$definition = new Schema\Field();
30
31		$field = new JsonDefinitionField('name', $definition);
32		$this->assertSame($definition, $field->getDef());
33		}
34
35		/**
36		* Test JsonDefinitionField::getName()
37		*
38		* @return void
39		*/
40	View Code Duplication	public function testGetName()
41		{
42		$name = __METHOD__;
43		$definition = new Schema\Field();
44
45		$field = new JsonDefinitionField($name, $definition);
46		$this->assertEquals($name, $field->getName());
47		}
48
49		/**
50		* Test JsonDefinitionField::getType()
51		*
52		* @return void
53		*/
54		public function testGetType()
55		{
56		$definition = (new Schema\Field())->setType(__METHOD__);
57
58		$field = new JsonDefinitionField('name', $definition);
59		$this->assertEquals(strtolower($definition->getType()), $field->getType());
60		}
61
62		/**
63		* Test JsonDefinitionField::getTypeDoctrine()
64		*
65		* @param string $defType Definition type
66		* @param string $doctrineType Doctrine type
67		* @return void
68		* @dataProvider dataGetTypeDoctrine
69		*/
70		public function testGetTypeDoctrine($defType, $doctrineType)
71		{
72		$definition = (new Schema\Field())->setType($defType);
73
74		$field = new JsonDefinitionField('name', $definition);
75		$this->assertEquals($doctrineType, $field->getTypeDoctrine());
76		}
77
78		/**
79		* Data provider for JsonDefinitionField::getTypeDoctrine()
80		*
81		* @return array
82		*/
83		public function dataGetTypeDoctrine()
84		{
85		$map = [
86		JsonDefinitionField::TYPE_STRING => 'string',
87		JsonDefinitionField::TYPE_INTEGER => 'int',
88		JsonDefinitionField::TYPE_LONG => 'int',
89		JsonDefinitionField::TYPE_DOUBLE => 'float',
90		JsonDefinitionField::TYPE_DECIMAL => 'float',
91		JsonDefinitionField::TYPE_DATETIME => 'date',
92		JsonDefinitionField::TYPE_BOOLEAN => 'boolean',
93		JsonDefinitionField::TYPE_OBJECT => 'hash',
94		JsonDefinitionField::TYPE_EXTREF => 'extref',
95		];
96		return array_map(
97		function ($defType, $doctrineType) {
98		return [$defType, $doctrineType];
99		},
100		array_keys($map),
101		array_values($map)
102		);
103		}
104
105		/**
106		* Test JsonDefinitionField::getTypeSerializer()
107		*
108		* @param string $defType Definition type
109		* @param string $serializerType Serializer type
110		* @return void
111		* @dataProvider dataGetTypeSerializer
112		*/
113		public function testGetTypeSerializer($defType, $serializerType)
114		{
115		$definition = (new Schema\Field())->setType($defType);
116
117		$field = new JsonDefinitionField('name', $definition);
118		$this->assertEquals($serializerType, $field->getTypeSerializer());
119		}
120
121		/**
122		* Data provider for JsonDefinitionField::getTypeSerializer()
123		*
124		* @return array
125		*/
126		public function dataGetTypeSerializer()
127		{
128		$map = [
129		JsonDefinitionField::TYPE_STRING => 'string',
130		JsonDefinitionField::TYPE_INTEGER => 'integer',
131		JsonDefinitionField::TYPE_LONG => 'integer',
132		JsonDefinitionField::TYPE_DOUBLE => 'double',
133		JsonDefinitionField::TYPE_DECIMAL => 'double',
134		JsonDefinitionField::TYPE_DATETIME => 'DateTime',
135		JsonDefinitionField::TYPE_BOOLEAN => 'boolean',
136		JsonDefinitionField::TYPE_OBJECT => Hash::class,
137		JsonDefinitionField::TYPE_EXTREF => ExtReference::class,
138		];
139		return array_map(
140		function ($defType, $serializerType) {
141		return [$defType, $serializerType];
142		},
143		array_keys($map),
144		array_values($map)
145		);
146		}
147
148		/**
149		* Test JsonDefinitionField::getDefAsArray()
150		*
151		* @return void
152		*/
153		public function testGetDefAsArray()
154		{
155		$definition = $this->getBaseField();
156
157		$field = new JsonDefinitionField('name', $definition);
158		$this->assertEquals(
159		array_replace(
160		$this->getBaseDefAsArray($definition),
161		[
162		'name' => $field->getName(),
163		'type' => $field->getType(),
164		'exposedName' => $definition->getExposeAs(),
165		'doctrineType' => $field->getTypeDoctrine(),
166		'serializerType' => $field->getTypeSerializer(),
167		'relType' => null,
168		'isClassType' => false,
169		'xDynamicKey' => null,
170		'searchable' => 0,
171		'recordOriginException' => false
172		]
173		),
174		$field->getDefAsArray()
175		);
176		}
177
178		/**
179		* Test JsonDefinitionField::getXDynamicKey()
180		*
181		* @return void
182		*/
183		public function testGetXDynamicKey()
184		{
185		$key = (new Schema\XDynamicKey())
186		->setDocumentId(__CLASS__)
187		->setRepositoryMethod(__LINE__)
188		->setRefField(__FILE__);
189
190		$definition = (new Schema\Field())
191		->setXDynamicKey($key);
192
193		$field = new JsonDefinitionField('name', $definition);
194
195		$this->assertEquals(
196		array_replace(
197		$this->getBaseDefAsArray($definition),
198		[
199		'name' => $field->getName(),
200		'type' => $field->getType(),
201		'exposedName' => $field->getName(),
202		'doctrineType' => $field->getTypeDoctrine(),
203		'serializerType' => $field->getTypeSerializer(),
204		'relType' => null,
205		'isClassType' => false,
206		'xDynamicKey' => $key,
207		'searchable' => 0,
208		'recordOriginException' => false
209		]
210		),
211		$field->getDefAsArray()
212		);
213		}
214		}
215

libgraviton / graviton

Push — feature/EVO-6307-record-origin... ( 797eb1...d3f12f )

JsonDefinitionFieldTest::testGetDefAsArray() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like