FieldTest::testReturnedArray() - Code Metrics - Inspection of "Scrutinizer config fix" - radowoj/yaah - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( fa975d...67ba18 )

by Radosław

created 2017-04-17 11:47 UTC

FieldTest::testReturnedArray() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	27
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	27
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	20
nc	1
nop	0

<?php

namespace Radowoj\Yaah;

use PHPUnit\Framework\TestCase;
use Radowoj\Yaah\Field;

class FieldTest extends TestCase
{
    protected $defaultValues = [
        'fid' => 1,
        'fvalueString' => '',
        'fvalueInt' => 0,
        'fvalueFloat' => 0,
        'fvalueImage' => '',
        'fvalueDatetime' => 0,
        'fvalueDate' => '',
        'fvalueRangeInt' => [
            'fvalueRangeIntMin' => 0,
            'fvalueRangeIntMax' => 0,
        ],
        'fvalueRangeFloat' => [
            'fvalueRangeFloatMin' => 0,
            'fvalueRangeFloatMax' => 0,
        ],
        'fvalueRangeDate' => [
            'fvalueRangeDateMin' => '',
            'fvalueRangeDateMax' => '',
        ],
    ];


    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage fid must be an integer
     */
    public function testNonIntegerFid()
    {
        new Field('some string');
    }


    /**
     * Tests that output of Field->toArray() has the exact keys expected by WebAPI
     * @return void
     */
    public function testReturnedArray()
    {
        $field = new Field(1, 'some string');

        $this->assertEquals([
            'fid' => 1,
            'fvalueString' => 'some string',
            'fvalueInt' => 0,
            'fvalueFloat' => 0,
            'fvalueImage' => '',
            'fvalueDatetime' => 0,
            'fvalueDate' => '',
            'fvalueRangeInt' => [
                'fvalueRangeIntMin' => 0,
                'fvalueRangeIntMax' => 0,
            ],
            'fvalueRangeFloat' => [
                'fvalueRangeFloatMin' => 0,
                'fvalueRangeFloatMax' => 0,
            ],
            'fvalueRangeDate' => [
                'fvalueRangeDateMin' => '',
                'fvalueRangeDateMax' => '',
            ],

        ], $field->toArray());
    }


    public function valueTypesProvider()
    {
        return [
            'string' => [
                'some string',
                'fvalueString'
            ],
            'integer' => [
                42,
                'fvalueInt'
            ],
            'float' => [
                13.5,
                'fvalueFloat'
            ],
            'date' => [
                '01-03-2017',
                'fvalueDate'
            ],

        ];
    }


    /**
     * Test if various value types are properly handled
     * @dataProvider valueTypesProvider
     */
    public function testValueTypes($testValue, $arrayKey)
    {
        $field = new Field(1, $testValue);
        $this->assertArrayHasKey($arrayKey, $field->toArray(), 'Key not present in result array');
        $this->assertSame($field->toArray()[$arrayKey], $testValue, 'Different value in result array');
        $this->assertSame($field->getValue(), $testValue, 'Different getValue() return value');
    }



    public function rangeValueTypesProvider()
    {
        return [
            'float range' => [
                [10.5, 13.5],
                'fvalueRangeFloat'
            ],
            'int range' => [
                [10, 11],
                'fvalueRangeInt'
            ],
            'date range' => [
                ['03-03-2016', '01-03-2017'],
                'fvalueRangeDate'
            ],
        ];
    }


    /**
     * Test if various range types are properly handled
     * @dataProvider rangeValueTypesProvider
     */
    public function testRangeValues($testRange, $rangeKey)
    {
        $expectedArrayKeys = [
            "{$rangeKey}Min",
            "{$rangeKey}Max"
        ];

        $field = new Field(2, $testRange);
        $this->assertArrayHasKey(
            $rangeKey,
            $field->toArray(),
            'key doesn\'t exist in array representation'
        );

        $this->assertSame(
            $field->toArray()[$rangeKey],
            array_combine($expectedArrayKeys, $testRange),
            'array representation contains wrong value'
        );

        $this->assertSame(
            $field->getValue(),
            $testRange,
            'getValue() returns wrong value'
        );
    }


    /**
     * Test if range types are properly handled when reversed
     * @dataProvider rangeValueTypesProvider
     */
    public function testRangeValuesReversed($testRange, $rangeKey)
    {
        $expectedArrayKeys = [
            "{$rangeKey}Min",
            "{$rangeKey}Max"
        ];

        $reverseRange = array_reverse($testRange);

        $field = new Field(2, $reverseRange);
        $this->assertArrayHasKey(
            $rangeKey,
            $field->toArray(),
            'key doesn\'t exist in array representation'
        );

        $this->assertSame(
            $field->toArray()[$rangeKey],
            array_combine($expectedArrayKeys, $testRange),
            'array representation contains wrong value'
        );

        $this->assertSame(
            $field->getValue(),
            $testRange,
            'getValue() returns wrong value'
        );
    }


    /**
     * Test forced value type - datetime
     * @return void
     */
    public function testDatetimeValue()
    {
        $datetime = time();
        $field = new Field(1, $datetime, 'fvalueDatetime');
        $this->assertArrayHasKey('fvalueDatetime', $field->toArray());
        $this->assertSame($field->toArray()['fvalueDatetime'], $datetime);
        $this->assertSame($field->getValue(), $datetime);
    }


    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage Not supported value type: object; fid=1
     */
    public function testExceptionOnInvalidValue()
    {
        new Field(1, (object)['foo' => 'bar']);
    }


    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage Class Radowoj\Yaah\Field does not have property: fvalueUnicorn
     */
    public function testExceptionOnInvalidForcedValue()
    {
        new Field(1, 'something', 'fvalueUnicorn');
    }


    /**
     * Test fid value
     * @return void
     */
    public function testFid()
    {
        $field = new Field(42, 'don\'t panic!');
        $this->assertSame($field->getFid(), 42);
    }


    /**
     * @dataProvider valueTypesProvider
     */
    public function testCreatingFromArray($value, $key)
    {
        $array = $this->defaultValues;
        $array[$key] = $value;
        $field = new Field(42);
        $field->fromArray($array);

        $this->assertSame($field->getValue(), $value);
        $this->assertSame($field->getFid(), $this->defaultValues['fid']);
    }

    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage Range array must have exactly 2 elements
     */
    public function testExceptionOnInvalidRangeArrayItemCount()
    {
        $field = new Field(12, [1, 2, 3]);
    }


    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage Fid is required
     */
    public function testExceptionOnFromArrayMissingFid()
    {
        $fieldArray = $this->defaultValues;
        unset($fieldArray['fid']);
        $field = new Field();
        $field->fromArray($fieldArray);
    }


    /**
     * @expectedException InvalidArgumentException
     * @expectedExceptionMessage Unknown Field property: thisKeyIsInvalid
     */
    public function testExceptionOnFromArrayInvalidArrayKey()
    {
        $fieldArray = $this->defaultValues;
        $fieldArray['thisKeyIsInvalid'] = 'whatever';
        $field = new Field();
        $field->fromArray($fieldArray);
    }


    public function testNullReturnValueWhenAllFieldsAreDefault()
    {
        $field = new Field();
        $field->fromArray($this->defaultValues);
        $this->assertNull($field->getValue());
    }


}


1			<?php
2
3			namespace Radowoj\Yaah;
4
5			use PHPUnit\Framework\TestCase;
6			use Radowoj\Yaah\Field;
7
8			class FieldTest extends TestCase
9			{
10			protected $defaultValues = [
11			'fid' => 1,
12			'fvalueString' => '',
13			'fvalueInt' => 0,
14			'fvalueFloat' => 0,
15			'fvalueImage' => '',
16			'fvalueDatetime' => 0,
17			'fvalueDate' => '',
18			'fvalueRangeInt' => [
19			'fvalueRangeIntMin' => 0,
20			'fvalueRangeIntMax' => 0,
21			],
22			'fvalueRangeFloat' => [
23			'fvalueRangeFloatMin' => 0,
24			'fvalueRangeFloatMax' => 0,
25			],
26			'fvalueRangeDate' => [
27			'fvalueRangeDateMin' => '',
28			'fvalueRangeDateMax' => '',
29			],
30			];
31
32
33			/**
34			* @expectedException InvalidArgumentException
35			* @expectedExceptionMessage fid must be an integer
36			*/
37			public function testNonIntegerFid()
38			{
39			new Field('some string');
40			}
41
42
43			/**
44			* Tests that output of Field->toArray() has the exact keys expected by WebAPI
45			* @return void
46			*/
47			public function testReturnedArray()
48			{
49			$field = new Field(1, 'some string');
50
51			$this->assertEquals([
52			'fid' => 1,
53			'fvalueString' => 'some string',
54			'fvalueInt' => 0,
55			'fvalueFloat' => 0,
56			'fvalueImage' => '',
57			'fvalueDatetime' => 0,
58			'fvalueDate' => '',
59			'fvalueRangeInt' => [
60			'fvalueRangeIntMin' => 0,
61			'fvalueRangeIntMax' => 0,
62			],
63			'fvalueRangeFloat' => [
64			'fvalueRangeFloatMin' => 0,
65			'fvalueRangeFloatMax' => 0,
66			],
67			'fvalueRangeDate' => [
68			'fvalueRangeDateMin' => '',
69			'fvalueRangeDateMax' => '',
70			],
71
72			], $field->toArray());
73			}
74
75
76			public function valueTypesProvider()
77			{
78			return [
79			'string' => [
80			'some string',
81			'fvalueString'
82			],
83			'integer' => [
84			42,
85			'fvalueInt'
86			],
87			'float' => [
88			13.5,
89			'fvalueFloat'
90			],
91			'date' => [
92			'01-03-2017',
93			'fvalueDate'
94			],
95
96			];
97			}
98
99
100			/**
101			* Test if various value types are properly handled
102			* @dataProvider valueTypesProvider
103			*/
104			public function testValueTypes($testValue, $arrayKey)
105			{
106			$field = new Field(1, $testValue);
107			$this->assertArrayHasKey($arrayKey, $field->toArray(), 'Key not present in result array');
108			$this->assertSame($field->toArray()[$arrayKey], $testValue, 'Different value in result array');
109			$this->assertSame($field->getValue(), $testValue, 'Different getValue() return value');
110			}
111
112
113
114			public function rangeValueTypesProvider()
115			{
116			return [
117			'float range' => [
118			[10.5, 13.5],
119			'fvalueRangeFloat'
120			],
121			'int range' => [
122			[10, 11],
123			'fvalueRangeInt'
124			],
125			'date range' => [
126			['03-03-2016', '01-03-2017'],
127			'fvalueRangeDate'
128			],
129			];
130			}
131
132
133			/**
134			* Test if various range types are properly handled
135			* @dataProvider rangeValueTypesProvider
136			*/
137			public function testRangeValues($testRange, $rangeKey)
138			{
139			$expectedArrayKeys = [
140			"{$rangeKey}Min",
141			"{$rangeKey}Max"
142			];
143
144			$field = new Field(2, $testRange);
145			$this->assertArrayHasKey(
146			$rangeKey,
147			$field->toArray(),
148			'key doesn\'t exist in array representation'
149			);
150
151			$this->assertSame(
152			$field->toArray()[$rangeKey],
153			array_combine($expectedArrayKeys, $testRange),
154			'array representation contains wrong value'
155			);
156
157			$this->assertSame(
158			$field->getValue(),
159			$testRange,
160			'getValue() returns wrong value'
161			);
162			}
163
164
165			/**
166			* Test if range types are properly handled when reversed
167			* @dataProvider rangeValueTypesProvider
168			*/
169			public function testRangeValuesReversed($testRange, $rangeKey)
170			{
171			$expectedArrayKeys = [
172			"{$rangeKey}Min",
173			"{$rangeKey}Max"
174			];
175
176			$reverseRange = array_reverse($testRange);
177
178			$field = new Field(2, $reverseRange);
179			$this->assertArrayHasKey(
180			$rangeKey,
181			$field->toArray(),
182			'key doesn\'t exist in array representation'
183			);
184
185			$this->assertSame(
186			$field->toArray()[$rangeKey],
187			array_combine($expectedArrayKeys, $testRange),
188			'array representation contains wrong value'
189			);
190
191			$this->assertSame(
192			$field->getValue(),
193			$testRange,
194			'getValue() returns wrong value'
195			);
196			}
197
198
199			/**
200			* Test forced value type - datetime
201			* @return void
202			*/
203			public function testDatetimeValue()
204			{
205			$datetime = time();
206			$field = new Field(1, $datetime, 'fvalueDatetime');
207			$this->assertArrayHasKey('fvalueDatetime', $field->toArray());
208			$this->assertSame($field->toArray()['fvalueDatetime'], $datetime);
209			$this->assertSame($field->getValue(), $datetime);
210			}
211
212
213			/**
214			* @expectedException InvalidArgumentException
215			* @expectedExceptionMessage Not supported value type: object; fid=1
216			*/
217			public function testExceptionOnInvalidValue()
218			{
219			new Field(1, (object)['foo' => 'bar']);
220			}
221
222
223			/**
224			* @expectedException InvalidArgumentException
225			* @expectedExceptionMessage Class Radowoj\Yaah\Field does not have property: fvalueUnicorn
226			*/
227			public function testExceptionOnInvalidForcedValue()
228			{
229			new Field(1, 'something', 'fvalueUnicorn');
230			}
231
232
233			/**
234			* Test fid value
235			* @return void
236			*/
237			public function testFid()
238			{
239			$field = new Field(42, 'don\'t panic!');
240			$this->assertSame($field->getFid(), 42);
241			}
242
243
244			/**
245			* @dataProvider valueTypesProvider
246			*/
247			public function testCreatingFromArray($value, $key)
248			{
249			$array = $this->defaultValues;
250			$array[$key] = $value;
251			$field = new Field(42);
252			$field->fromArray($array);
253
254			$this->assertSame($field->getValue(), $value);
255			$this->assertSame($field->getFid(), $this->defaultValues['fid']);
256			}
257
258			/**
259			* @expectedException InvalidArgumentException
260			* @expectedExceptionMessage Range array must have exactly 2 elements
261			*/
262			public function testExceptionOnInvalidRangeArrayItemCount()
263			{
264			$field = new Field(12, [1, 2, 3]);
265			}
266
267
268			/**
269			* @expectedException InvalidArgumentException
270			* @expectedExceptionMessage Fid is required
271			*/
272			public function testExceptionOnFromArrayMissingFid()
273			{
274			$fieldArray = $this->defaultValues;
275			unset($fieldArray['fid']);
276			$field = new Field();
277			$field->fromArray($fieldArray);
278			}
279
280
281			/**
282			* @expectedException InvalidArgumentException
283			* @expectedExceptionMessage Unknown Field property: thisKeyIsInvalid
284			*/
285			public function testExceptionOnFromArrayInvalidArrayKey()
286			{
287			$fieldArray = $this->defaultValues;
288			$fieldArray['thisKeyIsInvalid'] = 'whatever';
289			$field = new Field();
290			$field->fromArray($fieldArray);
291			}
292
293
294			public function testNullReturnValueWhenAllFieldsAreDefault()
295			{
296			$field = new Field();
297			$field->fromArray($this->defaultValues);
298			$this->assertNull($field->getValue());
299			}
300
301
302			}
303

radowoj / yaah

Push — master ( fa975d...67ba18 )

FieldTest::testReturnedArray() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like