RenderDocumentDirectiveTest::testJsonSerializeWithEmptySourcesAndDatasources() - Code Metrics - maxbeckers/amazon-alexa-php - Measure and Improve Code Quality continuously with Scrutinizer

testJsonSerializeWithEmptySourcesAndDatasources() A
last analyzed 2025-10-15 07:24 UTC

↳ Parent: RenderDocumentDirectiveTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	1
eloc	10
nc	1
nop	0
dl	0
loc	17
rs	9.9332
c	1
b	0
f	1

<?php

declare(strict_types=1);

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

use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\APLDocument;
use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\MainTemplate;
use MaxBeckers\AmazonAlexa\Response\Directives\APL\RenderDocumentDirective;
use PHPUnit\Framework\TestCase;

class RenderDocumentDirectiveTest extends TestCase
{
    public function testRenderDocumentDirectiveBasic(): void
    {
        $mainTemplate = new MainTemplate(
            parameters: ['payload'],
            items: []
        );

        $document = new APLDocument(
            mainTemplate: $mainTemplate,
            type: 'APL',
            version: '2024.3'
        );

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token-123'
        );

        $this->assertEquals('Alexa.Presentation.APL.RenderDocument', $directive::TYPE);
        $this->assertInstanceOf(APLDocument::class, $directive->document);
        $this->assertEquals('test-token-123', $directive->token);
        $this->assertEquals([], $directive->sources);
        $this->assertEquals([], $directive->datasources);
    }

    public function testRenderDocumentDirectiveWithSourcesAndDatasources(): void
    {
        $mainTemplate = new MainTemplate(
            parameters: ['payload'],
            items: []
        );

        $document = new APLDocument(
            mainTemplate: $mainTemplate
        );

        $sources = [
            'headlineTemplateDoc' => [
                'type' => 'Link',
                'url' => 'doc://alexa/apl/documents/headline',
            ],
        ];

        $datasources = [
            'headlineTemplateData' => [
                'type' => 'object',
                'objectId' => 'headlineSample',
                'title' => 'Sample Headline',
                'subtitle' => 'Sample subtitle',
            ],
        ];

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token-456',
            sources: $sources,
            datasources: $datasources
        );

        $this->assertEquals($sources, $directive->sources);
        $this->assertEquals($datasources, $directive->datasources);
    }

    public function testSetSource(): void
    {
        $mainTemplate = new MainTemplate();
        $document = new APLDocument(mainTemplate: $mainTemplate);
        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token'
        );

        $sourceData = [
            'type' => 'Link',
            'url' => 'doc://alexa/apl/documents/sample',
        ];

        $directive->setSource('sampleDoc', $sourceData);

        $this->assertArrayHasKey('sampleDoc', $directive->sources);
        $this->assertEquals($sourceData, $directive->sources['sampleDoc']);
    }

    public function testSetDatasource(): void
    {
        $mainTemplate = new MainTemplate();
        $document = new APLDocument(mainTemplate: $mainTemplate);
        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token'
        );

        $datasourceData = [
            'type' => 'object',
            'title' => 'Test Title',
            'items' => ['item1', 'item2'],
        ];

        $directive->setDatasource('testData', $datasourceData);

        $this->assertArrayHasKey('testData', $directive->datasources);
        $this->assertEquals($datasourceData, $directive->datasources['testData']);
    }

    public function testJsonSerializeBasic(): void
    {
        $mainTemplate = new MainTemplate(
            parameters: ['payload']
        );

        $document = new APLDocument(
            mainTemplate: $mainTemplate,
            type: 'APL',
            version: '2024.3',
            description: 'Test document'
        );

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'serialize-test-token'
        );

        $json = $directive->jsonSerialize();

        $this->assertArrayHasKey('type', $json);
        $this->assertEquals('Alexa.Presentation.APL.RenderDocument', $json['type']);
        $this->assertArrayHasKey('token', $json);
        $this->assertEquals('serialize-test-token', $json['token']);
        $this->assertArrayHasKey('document', $json);
        $this->assertInstanceOf(APLDocument::class, $json['document']);
        $this->assertArrayNotHasKey('sources', $json);
        $this->assertArrayNotHasKey('datasources', $json);
    }

    public function testJsonSerializeWithSourcesAndDatasources(): void
    {
        $mainTemplate = new MainTemplate();
        $document = new APLDocument(mainTemplate: $mainTemplate);

        $sources = ['doc1' => ['type' => 'Link']];
        $datasources = ['data1' => ['type' => 'object']];

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token',
            sources: $sources,
            datasources: $datasources
        );

        $json = $directive->jsonSerialize();

        $this->assertArrayHasKey('sources', $json);
        $this->assertArrayHasKey('datasources', $json);
        $this->assertEquals($sources, $json['sources']);
        $this->assertEquals($datasources, $json['datasources']);
    }

    public function testJsonSerializeWithEmptySourcesAndDatasources(): void
    {
        $mainTemplate = new MainTemplate();
        $document = new APLDocument(mainTemplate: $mainTemplate);

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'test-token',
            sources: [],
            datasources: []
        );

        $json = $directive->jsonSerialize();

        // Empty arrays should not be included in JSON
        $this->assertArrayNotHasKey('sources', $json);
        $this->assertArrayNotHasKey('datasources', $json);
    }

    public function testComplexDocumentStructure(): void
    {
        // Create a complex APL document with multiple components
        $mainTemplate = new MainTemplate(
            parameters: ['payload', 'datasource'],
            items: []
        );

        $document = new APLDocument(
            mainTemplate: $mainTemplate,
            type: 'APL',
            version: '2024.3',
            description: 'Complex test document',
            theme: 'dark'
        );

        $complexSources = [
            'headlineTemplate' => [
                'type' => 'Link',
                'url' => 'doc://alexa/apl/documents/headline',
            ],
            'listTemplate' => [
                'type' => 'Link',
                'url' => 'doc://alexa/apl/documents/list',
            ],
        ];

        $complexDatasources = [
            'listData' => [
                'type' => 'dynamicIndexList',
                'listId' => 'vQdpOESlok',
                'startIndex' => 0,
                'minimumInclusiveIndex' => 0,
                'maximumExclusiveIndex' => 100,
                'items' => [
                    [
                        'primaryText' => 'Item 1',
                        'secondaryText' => 'Description 1',
                    ],
                    [
                        'primaryText' => 'Item 2',
                        'secondaryText' => 'Description 2',
                    ],
                ],
            ],
            'headlineData' => [
                'type' => 'object',
                'objectId' => 'headline1',
                'properties' => [
                    'backgroundImage' => [
                        'contentDescription' => null,
                        'smallSourceUrl' => null,
                        'largeSourceUrl' => null,
                        'sources' => [
                            [
                                'url' => 'https://example.com/image.jpg',
                                'size' => 'large',
                            ],
                        ],
                    ],
                    'title' => 'Welcome to APL',
                    'subtitle' => 'Alexa Presentation Language',
                ],
            ],
        ];

        $directive = new RenderDocumentDirective(
            document: $document,
            token: 'complex-document-token',
            sources: $complexSources,
            datasources: $complexDatasources
        );

        $json = $directive->jsonSerialize();

        $this->assertEquals('complex-document-token', $json['token']);
        $this->assertArrayHasKey('sources', $json);
        $this->assertArrayHasKey('datasources', $json);
        $this->assertCount(2, $json['sources']);
        $this->assertCount(2, $json['datasources']);
        $this->assertArrayHasKey('listData', $json['datasources']);
        $this->assertArrayHasKey('headlineData', $json['datasources']);
        $this->assertEquals('dynamicIndexList', $json['datasources']['listData']['type']);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace MaxBeckers\AmazonAlexa\Test\Response\Directives\APL;
6
7			use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\APLDocument;
8			use MaxBeckers\AmazonAlexa\Response\Directives\APL\Document\MainTemplate;
9			use MaxBeckers\AmazonAlexa\Response\Directives\APL\RenderDocumentDirective;
10			use PHPUnit\Framework\TestCase;
11
12			class RenderDocumentDirectiveTest extends TestCase
13			{
14			public function testRenderDocumentDirectiveBasic(): void
15			{
16			$mainTemplate = new MainTemplate(
17			parameters: ['payload'],
18			items: []
19			);
20
21			$document = new APLDocument(
22			mainTemplate: $mainTemplate,
23			type: 'APL',
24			version: '2024.3'
25			);
26
27			$directive = new RenderDocumentDirective(
28			document: $document,
29			token: 'test-token-123'
30			);
31
32			$this->assertEquals('Alexa.Presentation.APL.RenderDocument', $directive::TYPE);
33			$this->assertInstanceOf(APLDocument::class, $directive->document);
34			$this->assertEquals('test-token-123', $directive->token);
35			$this->assertEquals([], $directive->sources);
36			$this->assertEquals([], $directive->datasources);
37			}
38
39			public function testRenderDocumentDirectiveWithSourcesAndDatasources(): void
40			{
41			$mainTemplate = new MainTemplate(
42			parameters: ['payload'],
43			items: []
44			);
45
46			$document = new APLDocument(
47			mainTemplate: $mainTemplate
48			);
49
50			$sources = [
51			'headlineTemplateDoc' => [
52			'type' => 'Link',
53			'url' => 'doc://alexa/apl/documents/headline',
54			],
55			];
56
57			$datasources = [
58			'headlineTemplateData' => [
59			'type' => 'object',
60			'objectId' => 'headlineSample',
61			'title' => 'Sample Headline',
62			'subtitle' => 'Sample subtitle',
63			],
64			];
65
66			$directive = new RenderDocumentDirective(
67			document: $document,
68			token: 'test-token-456',
69			sources: $sources,
70			datasources: $datasources
71			);
72
73			$this->assertEquals($sources, $directive->sources);
74			$this->assertEquals($datasources, $directive->datasources);
75			}
76
77			public function testSetSource(): void
78			{
79			$mainTemplate = new MainTemplate();
80			$document = new APLDocument(mainTemplate: $mainTemplate);
81			$directive = new RenderDocumentDirective(
82			document: $document,
83			token: 'test-token'
84			);
85
86			$sourceData = [
87			'type' => 'Link',
88			'url' => 'doc://alexa/apl/documents/sample',
89			];
90
91			$directive->setSource('sampleDoc', $sourceData);
92
93			$this->assertArrayHasKey('sampleDoc', $directive->sources);
94			$this->assertEquals($sourceData, $directive->sources['sampleDoc']);
95			}
96
97			public function testSetDatasource(): void
98			{
99			$mainTemplate = new MainTemplate();
100			$document = new APLDocument(mainTemplate: $mainTemplate);
101			$directive = new RenderDocumentDirective(
102			document: $document,
103			token: 'test-token'
104			);
105
106			$datasourceData = [
107			'type' => 'object',
108			'title' => 'Test Title',
109			'items' => ['item1', 'item2'],
110			];
111
112			$directive->setDatasource('testData', $datasourceData);
113
114			$this->assertArrayHasKey('testData', $directive->datasources);
115			$this->assertEquals($datasourceData, $directive->datasources['testData']);
116			}
117
118			public function testJsonSerializeBasic(): void
119			{
120			$mainTemplate = new MainTemplate(
121			parameters: ['payload']
122			);
123
124			$document = new APLDocument(
125			mainTemplate: $mainTemplate,
126			type: 'APL',
127			version: '2024.3',
128			description: 'Test document'
129			);
130
131			$directive = new RenderDocumentDirective(
132			document: $document,
133			token: 'serialize-test-token'
134			);
135
136			$json = $directive->jsonSerialize();
137
138			$this->assertArrayHasKey('type', $json);
139			$this->assertEquals('Alexa.Presentation.APL.RenderDocument', $json['type']);
140			$this->assertArrayHasKey('token', $json);
141			$this->assertEquals('serialize-test-token', $json['token']);
142			$this->assertArrayHasKey('document', $json);
143			$this->assertInstanceOf(APLDocument::class, $json['document']);
144			$this->assertArrayNotHasKey('sources', $json);
145			$this->assertArrayNotHasKey('datasources', $json);
146			}
147
148			public function testJsonSerializeWithSourcesAndDatasources(): void
149			{
150			$mainTemplate = new MainTemplate();
151			$document = new APLDocument(mainTemplate: $mainTemplate);
152
153			$sources = ['doc1' => ['type' => 'Link']];
154			$datasources = ['data1' => ['type' => 'object']];
155
156			$directive = new RenderDocumentDirective(
157			document: $document,
158			token: 'test-token',
159			sources: $sources,
160			datasources: $datasources
161			);
162
163			$json = $directive->jsonSerialize();
164
165			$this->assertArrayHasKey('sources', $json);
166			$this->assertArrayHasKey('datasources', $json);
167			$this->assertEquals($sources, $json['sources']);
168			$this->assertEquals($datasources, $json['datasources']);
169			}
170
171			public function testJsonSerializeWithEmptySourcesAndDatasources(): void
172			{
173			$mainTemplate = new MainTemplate();
174			$document = new APLDocument(mainTemplate: $mainTemplate);
175
176			$directive = new RenderDocumentDirective(
177			document: $document,
178			token: 'test-token',
179			sources: [],
180			datasources: []
181			);
182
183			$json = $directive->jsonSerialize();
184
185			// Empty arrays should not be included in JSON
186			$this->assertArrayNotHasKey('sources', $json);
187			$this->assertArrayNotHasKey('datasources', $json);
188			}
189
190			public function testComplexDocumentStructure(): void
191			{
192			// Create a complex APL document with multiple components
193			$mainTemplate = new MainTemplate(
194			parameters: ['payload', 'datasource'],
195			items: []
196			);
197
198			$document = new APLDocument(
199			mainTemplate: $mainTemplate,
200			type: 'APL',
201			version: '2024.3',
202			description: 'Complex test document',
203			theme: 'dark'
204			);
205
206			$complexSources = [
207			'headlineTemplate' => [
208			'type' => 'Link',
209			'url' => 'doc://alexa/apl/documents/headline',
210			],
211			'listTemplate' => [
212			'type' => 'Link',
213			'url' => 'doc://alexa/apl/documents/list',
214			],
215			];
216
217			$complexDatasources = [
218			'listData' => [
219			'type' => 'dynamicIndexList',
220			'listId' => 'vQdpOESlok',
221			'startIndex' => 0,
222			'minimumInclusiveIndex' => 0,
223			'maximumExclusiveIndex' => 100,
224			'items' => [
225			[
226			'primaryText' => 'Item 1',
227			'secondaryText' => 'Description 1',
228			],
229			[
230			'primaryText' => 'Item 2',
231			'secondaryText' => 'Description 2',
232			],
233			],
234			],
235			'headlineData' => [
236			'type' => 'object',
237			'objectId' => 'headline1',
238			'properties' => [
239			'backgroundImage' => [
240			'contentDescription' => null,
241			'smallSourceUrl' => null,
242			'largeSourceUrl' => null,
243			'sources' => [
244			[
245			'url' => 'https://example.com/image.jpg',
246			'size' => 'large',
247			],
248			],
249			],
250			'title' => 'Welcome to APL',
251			'subtitle' => 'Alexa Presentation Language',
252			],
253			],
254			];
255
256			$directive = new RenderDocumentDirective(
257			document: $document,
258			token: 'complex-document-token',
259			sources: $complexSources,
260			datasources: $complexDatasources
261			);
262
263			$json = $directive->jsonSerialize();
264
265			$this->assertEquals('complex-document-token', $json['token']);
266			$this->assertArrayHasKey('sources', $json);
267			$this->assertArrayHasKey('datasources', $json);
268			$this->assertCount(2, $json['sources']);
269			$this->assertCount(2, $json['datasources']);
270			$this->assertArrayHasKey('listData', $json['datasources']);
271			$this->assertArrayHasKey('headlineData', $json['datasources']);
272			$this->assertEquals('dynamicIndexList', $json['datasources']['listData']['type']);
273			}
274			}
275

maxbeckers / amazon-alexa-php

testJsonSerializeWithEmptySourcesAndDatasources() A last analyzed 2025-10-15 07:24 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testJsonSerializeWithEmptySourcesAndDatasources() A
last analyzed 2025-10-15 07:24 UTC