ScalarSerializationTest::testSerializesOutputFloatCannotRepresentEmptyString() - Code Metrics - Inspection of "BREAKING/BUGFIX: Strict coercion of scalar types (..." - webonyx/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a27dd3...975c9f )

by Vladimir

created 2019-08-29 09:21 UTC

testSerializesOutputFloatCannotRepresentEmptyString() A

↳ Parent: ScalarSerializationTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

namespace GraphQL\Tests\Type;

use GraphQL\Error\Error;
use GraphQL\Tests\Type\TestClasses\CanCastToString;
use GraphQL\Tests\Type\TestClasses\ObjectIdStub;
use GraphQL\Type\Definition\Type;
use PHPUnit\Framework\TestCase;
use stdClass;
use function acos;
use function log;

class ScalarSerializationTest extends TestCase
{
    // Type System: Scalar coercion
    /**
     * @see it('serializes output as Int')
     */
    public function testSerializesOutputAsInt() : void
    {
        $intType = Type::int();

        self::assertSame(1, $intType->serialize(1));
        self::assertSame(123, $intType->serialize('123'));
        self::assertSame(0, $intType->serialize(0));
        self::assertSame(-1, $intType->serialize(-1));
        self::assertSame(100000, $intType->serialize(1e5));
        self::assertSame(0, $intType->serialize(0e5));
        self::assertSame(0, $intType->serialize(false));
        self::assertSame(1, $intType->serialize(true));
    }

    public function badIntValues()
    {
        return [
            [0.1, 'Int cannot represent non-integer value: 0.1'],
            [1.1, 'Int cannot represent non-integer value: 1.1'],
            [-1.1, 'Int cannot represent non-integer value: -1.1'],
            ['-1.1', 'Int cannot represent non-integer value: -1.1'],
            [9876504321, 'Int cannot represent non 32-bit signed integer value: 9876504321'],
            [-9876504321, 'Int cannot represent non 32-bit signed integer value: -9876504321'],
            [1e100, 'Int cannot represent non 32-bit signed integer value: 1.0E+100'],
            [-1e100, 'Int cannot represent non 32-bit signed integer value: -1.0E+100'],
            [log(0), 'Int cannot represent non 32-bit signed integer value: -INF'],
            [acos(8), 'Int cannot represent non-integer value: NAN'],
            ['one', 'Int cannot represent non-integer value: one'],
            ['', 'Int cannot represent non-integer value: (empty string)'],
            [[5], 'Int cannot represent non-integer value: [5]'],
        ];
    }

    /**
     * @throws Error
     *
     * @dataProvider badIntValues
     */
    public function testSerializesOutputAsIntErrors($value, $expectedError) : void
    {
        // The GraphQL specification does not allow serializing non-integer values
        // as Int to avoid accidental data loss.
        $intType = Type::int();
        $this->expectException(Error::class);
        $this->expectExceptionMessage($expectedError);
        $intType->serialize($value);
    }

    /**
     * @see it('serializes output as Float')
     */
    public function testSerializesOutputAsFloat() : void
    {
        $floatType = Type::float();

        self::assertSame(1.0, $floatType->serialize(1));
        self::assertSame(0.0, $floatType->serialize(0));
        self::assertSame(123.5, $floatType->serialize('123.5'));
        self::assertSame(-1.0, $floatType->serialize(-1));
        self::assertSame(0.1, $floatType->serialize(0.1));
        self::assertSame(1.1, $floatType->serialize(1.1));
        self::assertSame(-1.1, $floatType->serialize(-1.1));
        self::assertSame(-1.1, $floatType->serialize('-1.1'));
        self::assertSame(0.0, $floatType->serialize(false));
        self::assertSame(1.0, $floatType->serialize(true));
    }

    public function badFloatValues()
    {
        return [
            ['one', 'Float cannot represent non numeric value: one'],
            ['', 'Float cannot represent non numeric value: (empty string)'],
            [log(0), 'Float cannot represent non numeric value: -INF'],
            [acos(8), 'Float cannot represent non numeric value: NAN'],
            [[5], 'Float cannot represent non numeric value: [5]'],
        ];
    }

    /**
     * @throws Error
     *
     * @dataProvider badFloatValues
     */
    public function testSerializesOutputFloatErrors($value, $expectedError) : void
    {
        $floatType = Type::float();
        $this->expectException(Error::class);
        $this->expectExceptionMessage($expectedError);
        $floatType->serialize($value);
    }

    /**
     * @see it('serializes output as String')
     */
    public function testSerializesOutputAsString() : void
    {
        $stringType = Type::string();
        self::assertSame('string', $stringType->serialize('string'));
        self::assertSame('1', $stringType->serialize(1));
        self::assertSame('-1.1', $stringType->serialize(-1.1));
        self::assertSame('1', $stringType->serialize(true));
        self::assertSame('', $stringType->serialize(false));
        self::assertSame('', $stringType->serialize(null));
        self::assertSame('foo', $stringType->serialize(new CanCastToString('foo')));
    }

    public function badStringValues()
    {
        return [
            [[1], 'String cannot represent value: [1]'],
            [new stdClass(), 'String cannot represent value: instance of stdClass'],
        ];
    }

    /**
     * @throws Error
     *
     * @dataProvider badStringValues
     */
    public function testSerializesOutputStringErrors($value, $expectedError) : void
    {
        $stringType = Type::string();
        $this->expectException(Error::class);
        $this->expectExceptionMessage($expectedError);
        $stringType->serialize($value);
    }

    /**
     * @see it('serializes output as Boolean')
     */
    public function testSerializesOutputAsBoolean() : void
    {
        $boolType = Type::boolean();

        self::assertTrue($boolType->serialize(true));
        self::assertTrue($boolType->serialize(1));
        self::assertTrue($boolType->serialize('1'));
        self::assertTrue($boolType->serialize('string'));

        self::assertFalse($boolType->serialize(false));
        self::assertFalse($boolType->serialize(0));
        self::assertFalse($boolType->serialize('0'));
        self::assertFalse($boolType->serialize(''));
    }

    /**
     * @see it('serializes output as ID')
     */
    public function testSerializesOutputAsID() : void
    {
        $idType = Type::id();

        self::assertSame('string', $idType->serialize('string'));
        self::assertSame('false', $idType->serialize('false'));
        self::assertSame('', $idType->serialize(''));
        self::assertSame('1', $idType->serialize('1'));
        self::assertSame('0', $idType->serialize('0'));
        self::assertSame('1', $idType->serialize(1));
        self::assertSame('0', $idType->serialize(0));
        self::assertSame('2', $idType->serialize(new ObjectIdStub(2)));
    }

    public function badIDValues()
    {
        return [
            [new stdClass(), 'ID cannot represent value: instance of stdClass'],
            [true, 'ID cannot represent value: true'],
            [false, 'ID cannot represent value: false'],
            [-1.1, 'ID cannot represent value: -1.1'],
            [['abc'], 'ID cannot represent value: ["abc"]'],
        ];
    }

    /**
     * @dataProvider badIDValues
     */
    public function testSerializesOutputAsIDError($value, $expectedError)
    {
        $idType = Type::id();
        $this->expectException(Error::class);
        $this->expectExceptionMessage($expectedError);
        $idType->serialize($value);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace GraphQL\Tests\Type;
6
7			use GraphQL\Error\Error;
8			use GraphQL\Tests\Type\TestClasses\CanCastToString;
9			use GraphQL\Tests\Type\TestClasses\ObjectIdStub;
10			use GraphQL\Type\Definition\Type;
11			use PHPUnit\Framework\TestCase;
12			use stdClass;
13			use function acos;
14			use function log;
15
16			class ScalarSerializationTest extends TestCase
17			{
18			// Type System: Scalar coercion
19			/**
20			* @see it('serializes output as Int')
21			*/
22			public function testSerializesOutputAsInt() : void
23			{
24			$intType = Type::int();
25
26			self::assertSame(1, $intType->serialize(1));
27			self::assertSame(123, $intType->serialize('123'));
28			self::assertSame(0, $intType->serialize(0));
29			self::assertSame(-1, $intType->serialize(-1));
30			self::assertSame(100000, $intType->serialize(1e5));
31			self::assertSame(0, $intType->serialize(0e5));
32			self::assertSame(0, $intType->serialize(false));
33			self::assertSame(1, $intType->serialize(true));
34			}
35
36			public function badIntValues()
37			{
38			return [
39			[0.1, 'Int cannot represent non-integer value: 0.1'],
40			[1.1, 'Int cannot represent non-integer value: 1.1'],
41			[-1.1, 'Int cannot represent non-integer value: -1.1'],
42			['-1.1', 'Int cannot represent non-integer value: -1.1'],
43			[9876504321, 'Int cannot represent non 32-bit signed integer value: 9876504321'],
44			[-9876504321, 'Int cannot represent non 32-bit signed integer value: -9876504321'],
45			[1e100, 'Int cannot represent non 32-bit signed integer value: 1.0E+100'],
46			[-1e100, 'Int cannot represent non 32-bit signed integer value: -1.0E+100'],
47			[log(0), 'Int cannot represent non 32-bit signed integer value: -INF'],
48			[acos(8), 'Int cannot represent non-integer value: NAN'],
49			['one', 'Int cannot represent non-integer value: one'],
50			['', 'Int cannot represent non-integer value: (empty string)'],
51			[[5], 'Int cannot represent non-integer value: [5]'],
52			];
53			}
54
55			/**
56			* @throws Error
57			*
58			* @dataProvider badIntValues
59			*/
60			public function testSerializesOutputAsIntErrors($value, $expectedError) : void
61			{
62			// The GraphQL specification does not allow serializing non-integer values
63			// as Int to avoid accidental data loss.
64			$intType = Type::int();
65			$this->expectException(Error::class);
66			$this->expectExceptionMessage($expectedError);
67			$intType->serialize($value);
68			}
69
70			/**
71			* @see it('serializes output as Float')
72			*/
73			public function testSerializesOutputAsFloat() : void
74			{
75			$floatType = Type::float();
76
77			self::assertSame(1.0, $floatType->serialize(1));
78			self::assertSame(0.0, $floatType->serialize(0));
79			self::assertSame(123.5, $floatType->serialize('123.5'));
80			self::assertSame(-1.0, $floatType->serialize(-1));
81			self::assertSame(0.1, $floatType->serialize(0.1));
82			self::assertSame(1.1, $floatType->serialize(1.1));
83			self::assertSame(-1.1, $floatType->serialize(-1.1));
84			self::assertSame(-1.1, $floatType->serialize('-1.1'));
85			self::assertSame(0.0, $floatType->serialize(false));
86			self::assertSame(1.0, $floatType->serialize(true));
87			}
88
89			public function badFloatValues()
90			{
91			return [
92			['one', 'Float cannot represent non numeric value: one'],
93			['', 'Float cannot represent non numeric value: (empty string)'],
94			[log(0), 'Float cannot represent non numeric value: -INF'],
95			[acos(8), 'Float cannot represent non numeric value: NAN'],
96			[[5], 'Float cannot represent non numeric value: [5]'],
97			];
98			}
99
100			/**
101			* @throws Error
102			*
103			* @dataProvider badFloatValues
104			*/
105			public function testSerializesOutputFloatErrors($value, $expectedError) : void
106			{
107			$floatType = Type::float();
108			$this->expectException(Error::class);
109			$this->expectExceptionMessage($expectedError);
110			$floatType->serialize($value);
111			}
112
113			/**
114			* @see it('serializes output as String')
115			*/
116			public function testSerializesOutputAsString() : void
117			{
118			$stringType = Type::string();
119			self::assertSame('string', $stringType->serialize('string'));
120			self::assertSame('1', $stringType->serialize(1));
121			self::assertSame('-1.1', $stringType->serialize(-1.1));
122			self::assertSame('1', $stringType->serialize(true));
123			self::assertSame('', $stringType->serialize(false));
124			self::assertSame('', $stringType->serialize(null));
125			self::assertSame('foo', $stringType->serialize(new CanCastToString('foo')));
126			}
127
128			public function badStringValues()
129			{
130			return [
131			[[1], 'String cannot represent value: [1]'],
132			[new stdClass(), 'String cannot represent value: instance of stdClass'],
133			];
134			}
135
136			/**
137			* @throws Error
138			*
139			* @dataProvider badStringValues
140			*/
141			public function testSerializesOutputStringErrors($value, $expectedError) : void
142			{
143			$stringType = Type::string();
144			$this->expectException(Error::class);
145			$this->expectExceptionMessage($expectedError);
146			$stringType->serialize($value);
147			}
148
149			/**
150			* @see it('serializes output as Boolean')
151			*/
152			public function testSerializesOutputAsBoolean() : void
153			{
154			$boolType = Type::boolean();
155
156			self::assertTrue($boolType->serialize(true));
157			self::assertTrue($boolType->serialize(1));
158			self::assertTrue($boolType->serialize('1'));
159			self::assertTrue($boolType->serialize('string'));
160
161			self::assertFalse($boolType->serialize(false));
162			self::assertFalse($boolType->serialize(0));
163			self::assertFalse($boolType->serialize('0'));
164			self::assertFalse($boolType->serialize(''));
165			}
166
167			/**
168			* @see it('serializes output as ID')
169			*/
170			public function testSerializesOutputAsID() : void
171			{
172			$idType = Type::id();
173
174			self::assertSame('string', $idType->serialize('string'));
175			self::assertSame('false', $idType->serialize('false'));
176			self::assertSame('', $idType->serialize(''));
177			self::assertSame('1', $idType->serialize('1'));
178			self::assertSame('0', $idType->serialize('0'));
179			self::assertSame('1', $idType->serialize(1));
180			self::assertSame('0', $idType->serialize(0));
181			self::assertSame('2', $idType->serialize(new ObjectIdStub(2)));
182			}
183
184			public function badIDValues()
185			{
186			return [
187			[new stdClass(), 'ID cannot represent value: instance of stdClass'],
188			[true, 'ID cannot represent value: true'],
189			[false, 'ID cannot represent value: false'],
190			[-1.1, 'ID cannot represent value: -1.1'],
191			[['abc'], 'ID cannot represent value: ["abc"]'],
192			];
193			}
194
195			/**
196			* @dataProvider badIDValues
197			*/
198			public function testSerializesOutputAsIDError($value, $expectedError)
199			{
200			$idType = Type::id();
201			$this->expectException(Error::class);
202			$this->expectExceptionMessage($expectedError);
203			$idType->serialize($value);
204			}
205			}
206

webonyx / graphql-php

Push — master ( a27dd3...975c9f )

testSerializesOutputFloatCannotRepresentEmptyString() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like