9.5/_json_view_test_8php_source.html

<?php

declare(strict_types = 1);


namespace ‪TYPO3\CMS\Extbase\Tests\Unit\Mvc\View;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Extbase\Mvc\Controller\ControllerContext;

use ‪TYPO3\CMS\Extbase\Mvc\View\JsonView;

use ‪TYPO3\CMS\Extbase\Mvc\Web\Response;

use ‪TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;

use TYPO3\TestingFramework\Core\Unit\UnitTestCase;


class ‪JsonViewTest extends UnitTestCase

{

    protected ‪$view;


    protected ‪$controllerContext;


    protected ‪$response;


    protected function ‪setUp(): void

    {

        $this->view = $this->getMockBuilder(JsonView::class)

            ->setMethods(['loadConfigurationFromYamlFile'])

            ->getMock();

        $this->controllerContext = $this->createMock(ControllerContext::class);

        $this->response = $this->createMock(Response::class);

        $this->controllerContext->expects($this->any())->method('getResponse')->will($this->returnValue($this->response));

        $this->view->setControllerContext($this->controllerContext);

    }


    public function ‪jsonViewTestData(): array

    {

        ‪$output = [];


        $object = new \stdClass();

        $object->value1 = 'foo';

        $object->value2 = 1;

        $configuration = [];

        $expected = ['value1' => 'foo', 'value2' => 1];

        ‪$output[] = [$object, $configuration, $expected, 'all direct child properties should be serialized'];


        $configuration = ['_only' => ['value1']];

        $expected = ['value1' => 'foo'];

        ‪$output[] = [$object, $configuration, $expected, 'if "only" properties are specified, only these should be serialized'];


        $configuration = ['_exclude' => ['value1']];

        $expected = ['value2' => 1];

        ‪$output[] = [$object, $configuration, $expected, 'if "exclude" properties are specified, they should not be serialized'];


        $object = new \stdClass();

        $object->value1 = new \stdClass();

        $object->value1->subvalue1 = 'Foo';

        $object->value2 = 1;

        $configuration = [];

        $expected = ['value2' => 1];

        ‪$output[] = [$object, $configuration, $expected, 'by default, sub objects of objects should not be serialized.'];


        $object = new \stdClass();

        $object->value1 = ['subarray' => 'value'];

        $object->value2 = 1;

        $configuration = [];

        $expected = ['value2' => 1];

        ‪$output[] = [$object, $configuration, $expected, 'by default, sub arrays of objects should not be serialized.'];


        $object = ['foo' => 'bar', 1 => 'baz', 'deep' => ['test' => 'value']];

        $configuration = [];

        $expected = ['foo' => 'bar', 1 => 'baz', 'deep' => ['test' => 'value']];

        ‪$output[] = [$object, $configuration, $expected, 'associative arrays should be serialized deeply'];


        $object = ['foo', 'bar'];

        $configuration = [];

        $expected = ['foo', 'bar'];

        ‪$output[] = [$object, $configuration, $expected, 'numeric arrays should be serialized'];


        $nestedObject = new \stdClass();

        $nestedObject->value1 = 'foo';

        $object = [$nestedObject];

        $configuration = [];

        $expected = [['value1' => 'foo']];

        ‪$output[] = [$object, $configuration, $expected, 'array of objects should be serialized'];


        $properties = ['foo' => 'bar', 'prohibited' => 'xxx'];

        $nestedObject = $this->getMockBuilder($this->getUniqueId('Test'))

            ->setMethods(['getName', 'getPath', 'getProperties', 'getOther'])

            ->getMock();

        $nestedObject->expects($this->any())->method('getName')->will($this->returnValue('name'));

        $nestedObject->expects($this->any())->method('getPath')->will($this->returnValue('path'));

        $nestedObject->expects($this->any())->method('getProperties')->will($this->returnValue($properties));

        $nestedObject->expects($this->never())->method('getOther');

        $object = $nestedObject;

        $configuration = [

            '_only' => ['name', 'path', 'properties'],

            '_descend' => [

                 'properties' => [

                      '_exclude' => ['prohibited'],

                 ],

            ],

        ];

        $expected = [

            'name' => 'name',

            'path' => 'path',

            'properties' => ['foo' => 'bar'],

        ];

        ‪$output[] = [$object, $configuration, $expected, 'descending into arrays should be possible'];


        $nestedObject = new \stdClass();

        $nestedObject->value1 = 'foo';

        $value = new \SplObjectStorage();

        $value->attach($nestedObject);

        $configuration = [];

        $expected = [['value1' => 'foo']];

        ‪$output[] = [$value, $configuration, $expected, 'SplObjectStorage with objects should be serialized'];


        $dateTimeObject = new \DateTime('2011-02-03T03:15:23', new \DateTimeZone('UTC'));

        $configuration = [];

        $expected = '2011-02-03T03:15:23+00:00';

        ‪$output[] = [$dateTimeObject, $configuration, $expected, 'DateTime object in UTC time zone could not be serialized.'];


        $dateTimeObject = new \DateTime('2013-08-15T15:25:30', new \DateTimeZone('America/Los_Angeles'));

        $configuration = [];

        $expected = '2013-08-15T15:25:30-07:00';

        ‪$output[] = [$dateTimeObject, $configuration, $expected, 'DateTime object in America/Los_Angeles time zone could not be serialized.'];


        return ‪$output;

    }


    public function ‪testTransformValue($object, array $configuration, $expected, string $description): void

    {

        $jsonView = $this->getAccessibleMock(JsonView::class, ['dummy'], [], '', false);


        $actual = $jsonView->_call('transformValue', $object, $configuration);


        $this->assertSame($expected, $actual, $description);

    }


    public function ‪objectIdentifierExposureTestData(): array

    {

        ‪$output = [];


        $dummyIdentifier = 'e4f40dfc-8c6e-4414-a5b1-6fd3c5cf7a53';


        $object = new \stdClass();

        $object->value1 = new \stdClass();

        $configuration = [

            '_descend' => [

                 'value1' => [

                      '_exposeObjectIdentifier' => true,

                 ],

            ],

        ];


        $expected = ['value1' => ['__identity' => $dummyIdentifier]];

        ‪$output[] = [$object, $configuration, $expected, $dummyIdentifier, 'boolean TRUE should result in __identity key'];


        $configuration['_descend']['value1']['_exposedObjectIdentifierKey'] = 'guid';

        $expected = ['value1' => ['guid' => $dummyIdentifier]];

        ‪$output[] = [$object, $configuration, $expected, $dummyIdentifier, 'string value should result in string-equal key'];


        return ‪$output;

    }


    public function ‪testTransformValueWithObjectIdentifierExposure(

        object $object,

        array $configuration,

        array $expected,

        string $dummyIdentifier,

        string $description

    ): void {

        $persistenceManagerMock = $this->getMockBuilder(PersistenceManager::class)

            ->setMethods(['getIdentifierByObject'])

            ->getMock();

        $jsonView = $this->getAccessibleMock(JsonView::class, ['dummy'], [], '', false);

        $jsonView->_set('persistenceManager', $persistenceManagerMock);


        $persistenceManagerMock->expects($this->once())->method('getIdentifierByObject')->with($object->value1)->will($this->returnValue($dummyIdentifier));


        $actual = $jsonView->_call('transformValue', $object, $configuration);


        $this->assertSame($expected, $actual, $description);

    }


    public function ‪exposeClassNameSettingsAndResults(): array

    {

        $className = $this->getUniqueId('DummyClass');

        $namespace = 'TYPO3\CMS\Extbase\Tests\Unit\Mvc\View\\' . $className;

        return [

            [

                ‪JsonView::EXPOSE_CLASSNAME_FULLY_QUALIFIED,

                $className,

                $namespace,

                ['value1' => ['__class' => $namespace . '\\' . $className]],

            ],

            [

                ‪JsonView::EXPOSE_CLASSNAME_UNQUALIFIED,

                $className,

                $namespace,

                ['value1' => ['__class' => $className]],

            ],

            [

                null,

                $className,

                $namespace,

                ['value1' => []],

            ]

        ];

    }


    public function ‪viewExposesClassNameFullyIfConfiguredSo(

        ?int $exposeClassNameSetting,

        string $className,

        string $namespace,

        array $expected

    ): void {

        $fullyQualifiedClassName = $namespace . '\\' . $className;

        if (class_exists($fullyQualifiedClassName) === false) {

            eval('namespace ' . $namespace . '; class ' . $className . ' {}');

        }


        $object = new \stdClass();

        $object->value1 = new $fullyQualifiedClassName();

        $configuration = [

            '_descend' => [

                'value1' => [

                    '_exposeClassName' => $exposeClassNameSetting,

                ],

            ],

        ];

        $reflectionService = $this->getMockBuilder(\‪TYPO3\CMS\‪Extbase\Reflection\ReflectionService::class)

            ->setMethods([ 'getClassNameByObject' ])

            ->getMock();

        $reflectionService->expects($this->any())->method('getClassNameByObject')->will($this->returnCallback(function ($object) {

            return get_class($object);

        }));


        $jsonView = $this->getAccessibleMock(\‪TYPO3\CMS\‪Extbase\Mvc\View\JsonView::class, ['dummy'], [], '', false);

        $this->inject($jsonView, 'reflectionService', $reflectionService);

        $actual = $jsonView->_call('transformValue', $object, $configuration);

        $this->assertSame($expected, $actual);

    }


    public function ‪renderSetsContentTypeHeader(): void

    {

        $this->response->expects($this->once())->method('setHeader')->with('Content-Type', 'application/json');


        $this->view->render();

    }


    public function ‪renderReturnsJsonRepresentationOfAssignedObject(): void

    {

        $object = new \stdClass();

        $object->foo = 'Foo';

        $this->view->assign('value', $object);


        $expectedResult = '{"foo":"Foo"}';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderReturnsJsonRepresentationOfAssignedArray(): void

    {

        $array = ['foo' => 'Foo', 'bar' => 'Bar'];

        $this->view->assign('value', $array);


        $expectedResult = '{"foo":"Foo","bar":"Bar"}';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderReturnsJsonRepresentationOfAssignedSimpleValue(): void

    {

        $value = 'Foo';

        $this->view->assign('value', $value);


        $expectedResult = '"Foo"';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderKeepsUtf8CharactersUnescaped(): void

    {

        $value = 'Gürkchen';

        $this->view->assign('value', $value);


        $actualResult = $this->view->render();


        $expectedResult = '"' . $value . '"';

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪escapeCharacterDataProvider(): array

    {

        return [

            'backslash' => ['\\'],

            'double quote' => ['"'],

        ];

    }


    public function ‪renderEscapesEscapeCharacters(string $character): void

    {

        $this->view->assign('value', $character);


        $actualResult = $this->view->render();


        $expectedResult = '"\\' . $character . '"';

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderReturnsNullIfNameOfAssignedVariableIsNotEqualToValue(): void

    {

        $value = 'Foo';

        $this->view->assign('foo', $value);


        $expectedResult = 'null';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderOnlyRendersVariableWithTheNameValue(): void

    {

        $this->view

            ->assign('value', 'Value')

            ->assign('someOtherVariable', 'Foo');


        $expectedResult = '"Value"';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪setVariablesToRenderOverridesValueToRender(): void

    {

        $value = 'Foo';

        $this->view->assign('foo', $value);

        $this->view->setVariablesToRender(['foo']);


        $expectedResult = '"Foo"';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderRendersMultipleValuesIfTheyAreSpecifiedAsVariablesToRender(): void

    {

        $this->view

            ->assign('value', 'Value1')

            ->assign('secondValue', 'Value2')

            ->assign('someOtherVariable', 'Value3');

        $this->view->setVariablesToRender(['value', 'secondValue']);


        $expectedResult = '{"value":"Value1","secondValue":"Value2"}';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderCanRenderMultipleComplexObjects(): void

    {

        $array = ['foo' => ['bar' => 'Baz']];

        $object = new \stdClass();

        $object->foo = 'Foo';


        $this->view

            ->assign('array', $array)

            ->assign('object', $object)

            ->assign('someOtherVariable', 'Value3');

        $this->view->setVariablesToRender(['array', 'object']);


        $expectedResult = '{"array":{"foo":{"bar":"Baz"}},"object":{"foo":"Foo"}}';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderCanRenderPlainArray(): void

    {

        $array = [['name' => 'Foo', 'secret' => true], ['name' => 'Bar', 'secret' => true]];


        $this->view->assign('value', $array);

        $this->view->setConfiguration([

            'value' => [

                '_descendAll' => [

                    '_only' => ['name'],

                ],

            ],

        ]);


        $expectedResult = '[{"name":"Foo"},{"name":"Bar"}]';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }


    public function ‪renderCanRenderPlainArrayWithNumericKeys(): void

    {

        $array = [

            'items' => [

                ['name' => 'Foo'],

                ['name' => 'Bar']

            ],

        ];


        $this->view->assign('value', $array);

        $this->view->setConfiguration([

            'value' => [

                'items' => [

                    // note: this exclude is just here, and should have no effect as the items have numeric keys

                    '_exclude' => ['secret']

                ]

            ],

        ]);


        $expectedResult = '{"items":[{"name":"Foo"},{"name":"Bar"}]}';

        $actualResult = $this->view->render();

        self::assertSame($expectedResult, $actualResult);

    }


    public function ‪descendAllKeepsArrayIndexes(): void

    {

        $array = [['name' => 'Foo', 'secret' => true], ['name' => 'Bar', 'secret' => true]];


        $this->view->assign('value', $array);

        $this->view->setConfiguration([

            'value' => [

                '_descendAll' => [

                    '_descendAll' => [],

                ],

            ],

        ]);


        $expectedResult = '[{"name":"Foo","secret":true},{"name":"Bar","secret":true}]';

        $actualResult = $this->view->render();

        $this->assertSame($expectedResult, $actualResult);

    }

}