ParameterTest::testJsonSerializeWithEmptyStringDefault() - Code Metrics - Inspection of "add APL support (#97)" - maxbeckers/amazon-alexa-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a53d55...43aca1 )

by Maximilian

created 2025-10-06 14:16 UTC

testJsonSerializeWithEmptyStringDefault() A

↳ Parent: ParameterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php

declare(strict_types=1);

namespace MaxBeckers\AmazonAlexa\Test\Response\Directives\APL\Document;

use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\Parameter;
use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\ParameterType;
use PHPUnit\Framework\TestCase;

class ParameterTest extends TestCase
{
    public function testConstructorWithAllParameters(): void
    {
        $name = 'testParameter';
        $default = 'defaultValue';
        $description = 'Test parameter description';
        $type = ParameterType::STRING;

        $parameter = new Parameter($name, $default, $description, $type);

        $this->assertSame($name, $parameter->name);
        $this->assertSame($default, $parameter->default);
        $this->assertSame($description, $parameter->description);
        $this->assertSame($type, $parameter->type);
    }

    public function testConstructorWithDefaultParameters(): void
    {
        $name = 'myParameter';

        $parameter = new Parameter($name);

        $this->assertSame($name, $parameter->name);
        $this->assertNull($parameter->default);
        $this->assertNull($parameter->description);
        $this->assertNull($parameter->type);
    }

    public function testJsonSerializeWithAllProperties(): void
    {
        $name = 'fullParameter';
        $default = 42;
        $description = 'Numeric parameter';
        $type = ParameterType::NUMBER;

        $parameter = new Parameter($name, $default, $description, $type);
        $result = $parameter->jsonSerialize();

        $this->assertSame($name, $result['name']);
        $this->assertSame($type, $result['type']);
        $this->assertSame($default, $result['default']);
        $this->assertSame($description, $result['description']);
    }

    public function testJsonSerializeWithMinimalProperties(): void
    {
        $name = 'minimalParameter';

        $parameter = new Parameter($name);
        $result = $parameter->jsonSerialize();

        $this->assertSame($name, $result['name']);
        $this->assertArrayNotHasKey('type', $result);
        $this->assertArrayNotHasKey('default', $result);
        $this->assertArrayNotHasKey('description', $result);
    }

    public function testJsonSerializeWithNullType(): void
    {
        $parameter = new Parameter('test', 'value', 'description', null);
        $result = $parameter->jsonSerialize();

        $this->assertSame('test', $result['name']);
        $this->assertSame('value', $result['default']);
        $this->assertSame('description', $result['description']);
        $this->assertArrayNotHasKey('type', $result);
    }

    public function testJsonSerializeWithNullDefault(): void
    {
        $parameter = new Parameter('test', null, 'description', ParameterType::BOOLEAN);
        $result = $parameter->jsonSerialize();

        $this->assertSame('test', $result['name']);
        $this->assertSame(ParameterType::BOOLEAN, $result['type']);
        $this->assertSame('description', $result['description']);
        $this->assertArrayNotHasKey('default', $result);
    }

    public function testJsonSerializeWithNullDescription(): void
    {
        $parameter = new Parameter('test', 'value', null, ParameterType::STRING);
        $result = $parameter->jsonSerialize();

        $this->assertSame('test', $result['name']);
        $this->assertSame(ParameterType::STRING, $result['type']);
        $this->assertSame('value', $result['default']);
        $this->assertArrayNotHasKey('description', $result);
    }

    public function testJsonSerializeWithDifferentDefaultTypes(): void
    {
        $testCases = [
            ['string value', ParameterType::STRING],
            [123, ParameterType::NUMBER],
            [45.67, ParameterType::NUMBER],
            [true, ParameterType::BOOLEAN],
            [['array', 'value'], ParameterType::ANY],
        ];

        foreach ($testCases as [$default, $type]) {
            $parameter = new Parameter('test', $default, null, $type);
            $result = $parameter->jsonSerialize();

            $this->assertSame($default, $result['default']);
            $this->assertSame($type, $result['type']);
        }
    }

    public function testJsonSerializeWithDifferentParameterTypes(): void
    {
        $types = [
            ParameterType::ANY,
            ParameterType::STRING,
            ParameterType::NUMBER,
            ParameterType::BOOLEAN,
        ];

        foreach ($types as $type) {
            $parameter = new Parameter('test', null, null, $type);
            $result = $parameter->jsonSerialize();

            $this->assertSame($type, $result['type']);
        }
    }

    public function testJsonSerializeWithZeroDefault(): void
    {
        $parameter = new Parameter('test', 0);
        $result = $parameter->jsonSerialize();

        $this->assertArrayHasKey('default', $result);
        $this->assertSame(0, $result['default']);
    }

    public function testJsonSerializeWithFalseDefault(): void
    {
        $parameter = new Parameter('test', false);
        $result = $parameter->jsonSerialize();

        $this->assertArrayHasKey('default', $result);
        $this->assertFalse($result['default']);
    }

    public function testJsonSerializeWithEmptyStringDefault(): void
    {
        $parameter = new Parameter('test', '');
        $result = $parameter->jsonSerialize();

        $this->assertArrayHasKey('default', $result);
        $this->assertSame('', $result['default']);
    }

    public function testJsonSerializePropertyOrder(): void
    {
        $parameter = new Parameter('test', 'value', 'description', ParameterType::STRING);
        $result = $parameter->jsonSerialize();

        $keys = array_keys($result);
        $this->assertSame('name', $keys[0]);
        $this->assertSame('type', $keys[1]);
        $this->assertSame('default', $keys[2]);
        $this->assertSame('description', $keys[3]);
    }

    public function testImplementsJsonSerializable(): void
    {
        $parameter = new Parameter('test');

        $this->assertInstanceOf(\JsonSerializable::class, $parameter);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace MaxBeckers\AmazonAlexa\Test\Response\Directives\APL\Document;
6
7			use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\Parameter;
8			use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\ParameterType;
9			use PHPUnit\Framework\TestCase;
10
11			class ParameterTest extends TestCase
12			{
13			public function testConstructorWithAllParameters(): void
14			{
15			$name = 'testParameter';
16			$default = 'defaultValue';
17			$description = 'Test parameter description';
18			$type = ParameterType::STRING;
19
20			$parameter = new Parameter($name, $default, $description, $type);
21
22			$this->assertSame($name, $parameter->name);
23			$this->assertSame($default, $parameter->default);
24			$this->assertSame($description, $parameter->description);
25			$this->assertSame($type, $parameter->type);
26			}
27
28			public function testConstructorWithDefaultParameters(): void
29			{
30			$name = 'myParameter';
31
32			$parameter = new Parameter($name);
33
34			$this->assertSame($name, $parameter->name);
35			$this->assertNull($parameter->default);
36			$this->assertNull($parameter->description);
37			$this->assertNull($parameter->type);
38			}
39
40			public function testJsonSerializeWithAllProperties(): void
41			{
42			$name = 'fullParameter';
43			$default = 42;
44			$description = 'Numeric parameter';
45			$type = ParameterType::NUMBER;
46
47			$parameter = new Parameter($name, $default, $description, $type);
48			$result = $parameter->jsonSerialize();
49
50			$this->assertSame($name, $result['name']);
51			$this->assertSame($type, $result['type']);
52			$this->assertSame($default, $result['default']);
53			$this->assertSame($description, $result['description']);
54			}
55
56			public function testJsonSerializeWithMinimalProperties(): void
57			{
58			$name = 'minimalParameter';
59
60			$parameter = new Parameter($name);
61			$result = $parameter->jsonSerialize();
62
63			$this->assertSame($name, $result['name']);
64			$this->assertArrayNotHasKey('type', $result);
65			$this->assertArrayNotHasKey('default', $result);
66			$this->assertArrayNotHasKey('description', $result);
67			}
68
69			public function testJsonSerializeWithNullType(): void
70			{
71			$parameter = new Parameter('test', 'value', 'description', null);
72			$result = $parameter->jsonSerialize();
73
74			$this->assertSame('test', $result['name']);
75			$this->assertSame('value', $result['default']);
76			$this->assertSame('description', $result['description']);
77			$this->assertArrayNotHasKey('type', $result);
78			}
79
80			public function testJsonSerializeWithNullDefault(): void
81			{
82			$parameter = new Parameter('test', null, 'description', ParameterType::BOOLEAN);
83			$result = $parameter->jsonSerialize();
84
85			$this->assertSame('test', $result['name']);
86			$this->assertSame(ParameterType::BOOLEAN, $result['type']);
87			$this->assertSame('description', $result['description']);
88			$this->assertArrayNotHasKey('default', $result);
89			}
90
91			public function testJsonSerializeWithNullDescription(): void
92			{
93			$parameter = new Parameter('test', 'value', null, ParameterType::STRING);
94			$result = $parameter->jsonSerialize();
95
96			$this->assertSame('test', $result['name']);
97			$this->assertSame(ParameterType::STRING, $result['type']);
98			$this->assertSame('value', $result['default']);
99			$this->assertArrayNotHasKey('description', $result);
100			}
101
102			public function testJsonSerializeWithDifferentDefaultTypes(): void
103			{
104			$testCases = [
105			['string value', ParameterType::STRING],
106			[123, ParameterType::NUMBER],
107			[45.67, ParameterType::NUMBER],
108			[true, ParameterType::BOOLEAN],
109			[['array', 'value'], ParameterType::ANY],
110			];
111
112			foreach ($testCases as [$default, $type]) {
113			$parameter = new Parameter('test', $default, null, $type);
114			$result = $parameter->jsonSerialize();
115
116			$this->assertSame($default, $result['default']);
117			$this->assertSame($type, $result['type']);
118			}
119			}
120
121			public function testJsonSerializeWithDifferentParameterTypes(): void
122			{
123			$types = [
124			ParameterType::ANY,
125			ParameterType::STRING,
126			ParameterType::NUMBER,
127			ParameterType::BOOLEAN,
128			];
129
130			foreach ($types as $type) {
131			$parameter = new Parameter('test', null, null, $type);
132			$result = $parameter->jsonSerialize();
133
134			$this->assertSame($type, $result['type']);
135			}
136			}
137
138			public function testJsonSerializeWithZeroDefault(): void
139			{
140			$parameter = new Parameter('test', 0);
141			$result = $parameter->jsonSerialize();
142
143			$this->assertArrayHasKey('default', $result);
144			$this->assertSame(0, $result['default']);
145			}
146
147			public function testJsonSerializeWithFalseDefault(): void
148			{
149			$parameter = new Parameter('test', false);
150			$result = $parameter->jsonSerialize();
151
152			$this->assertArrayHasKey('default', $result);
153			$this->assertFalse($result['default']);
154			}
155
156			public function testJsonSerializeWithEmptyStringDefault(): void
157			{
158			$parameter = new Parameter('test', '');
159			$result = $parameter->jsonSerialize();
160
161			$this->assertArrayHasKey('default', $result);
162			$this->assertSame('', $result['default']);
163			}
164
165			public function testJsonSerializePropertyOrder(): void
166			{
167			$parameter = new Parameter('test', 'value', 'description', ParameterType::STRING);
168			$result = $parameter->jsonSerialize();
169
170			$keys = array_keys($result);
171			$this->assertSame('name', $keys[0]);
172			$this->assertSame('type', $keys[1]);
173			$this->assertSame('default', $keys[2]);
174			$this->assertSame('description', $keys[3]);
175			}
176
177			public function testImplementsJsonSerializable(): void
178			{
179			$parameter = new Parameter('test');
180
181			$this->assertInstanceOf(\JsonSerializable::class, $parameter);
182			}
183			}
184

maxbeckers / amazon-alexa-php

Push — master ( a53d55...43aca1 )

testJsonSerializeWithEmptyStringDefault() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like