KingsonDe\Marshal\MarshalXmlTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	2
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
B	testSerializeXml()	0	28	1
A	testSerializeRootNodeWithScalarValue()	0	17	1
A	testXmlMapper()	0	5	1
A	testBuildDataStructureIsNull()	0	7	1
A	testSerializationFailed()	0	9	1
A	testSerializeWithCollection()	0	5	1
A	testCollectionAtRootLevel()	0	3	1
A	testCollectionCallableAtRootLevel()	0	7	1
A	testSettingProlog()	0	14	1
A	createUser()	0	9	1
A	getServices()	0	19	1

<?php

declare(strict_types = 1);

namespace KingsonDe\Marshal;

use KingsonDe\Marshal\Data\Collection;
use KingsonDe\Marshal\Data\CollectionCallable;
use KingsonDe\Marshal\Example\Mapper\ArgumentMapper;
use KingsonDe\Marshal\Example\Mapper\ContainerMapper;
use KingsonDe\Marshal\Example\Mapper\ServiceMapper;
use KingsonDe\Marshal\Example\Model\Service;
use PHPUnit\Framework\TestCase;

class MarshalXmlTest extends TestCase {

    public function testSerializeXml() {
        $xml = MarshalXml::serializeItemCallable(function(\stdClass $user) {
            return [
                'root' => [
                    MarshalXml::ATTRIBUTES_KEY => [
                        'year' => 2017,
                    ],
                    'id'        => $user->id,
                    'score'     => [
                        MarshalXml::ATTRIBUTES_KEY => [
                            'public' => true,
                            'highscore' => 'yes',
                        ],
                        MarshalXml::DATA_KEY => $user->score,
                    ],
                    'email'     => $user->email,
                    'null'      => null,
                    'nicknames' => new CollectionCallable(function ($nickname) {
                        return [
                            'nickname' => $nickname,
                        ];
                    }, $user->nicknames),
                ],
            ];
        }, $this->createUser());

        $this->assertXmlStringEqualsXmlFile(__DIR__ . '/Fixtures/User.xml', $xml);
    }

    public function testSerializeRootNodeWithScalarValue() {
        $xml = MarshalXml::serializeItemCallable(function() {

The call to serializeItemCallable() misses a required argument $...$data.

            return [
                'root' => [
                    MarshalXml::ATTRIBUTES_KEY => [
                        'id' => 123,
                    ],
                    MarshalXml::DATA_KEY => 'Hello World!',
                ],
            ];
        });

        $this->assertXmlStringEqualsXmlString(
            '<?xml version="1.0" encoding="UTF-8"?><root id="123">Hello World!</root>',
            $xml
        );
    }

    public function testXmlMapper() {
        $xml = MarshalXml::serializeItem(new ContainerMapper(), ...$this->getServices());

        $this->assertXmlStringEqualsXmlFile(__DIR__ . '/Fixtures/Services.xml', $xml);
    }

    public function testBuildDataStructureIsNull() {
        $xml = MarshalXml::serializeItemCallable(function () {

The call to serializeItemCallable() misses a required argument $...$data.

            return null;
        });

        $this->assertXmlStringEqualsXmlString('<?xml version="1.0" encoding="UTF-8"?><root/>', $xml);
    }

    /**
     * @expectedException \KingsonDe\Marshal\Exception\XmlSerializeException
     */
    public function testSerializationFailed() {
        MarshalXml::serializeItemCallable(function () {

The call to serializeItemCallable() misses a required argument $...$data.

            return [
                'malformedXml' => [
                    '@node' => 'some value',
                ],
            ];
        });
    }

    /**
     * @expectedException \KingsonDe\Marshal\Exception\XmlSerializeException
     */
    public function testSerializeWithCollection() {
        $collection = new Collection(new ArgumentMapper(), [new Service('marshal.mapper.dummy')]);

        MarshalXml::serialize($collection);
    }

    /**
     * @expectedException \KingsonDe\Marshal\Exception\XmlSerializeException
     */
    public function testCollectionAtRootLevel() {
        MarshalXml::serializeCollection(new ArgumentMapper(), [new Service('marshal.mapper.dummy')]);
    }

    /**
     * @expectedException \KingsonDe\Marshal\Exception\XmlSerializeException
     */
    public function testCollectionCallableAtRootLevel() {
        MarshalXml::serializeCollectionCallable(function (Service $service) {
            return [
                'id' => $service->getId(),
            ];
        }, [new Service('marshal.mapper.dummy')]);
    }

    public function testSettingProlog() {
        MarshalXml::setVersion('1.1');
        MarshalXml::setEncoding('ISO-8859-15');

        $xml = MarshalXml::serializeItemCallable(function () {

The call to serializeItemCallable() misses a required argument $...$data.

            return [
                'root' => [
                    'currency' => '€',
                ]
            ];
        });

        $this->assertXmlStringEqualsXmlFile(__DIR__ . '/Fixtures/Currency.xml', $xml);
    }

    private function createUser() {
        $user            = new \stdClass();
        $user->id        = 123;
        $user->score     = 3.0;
        $user->email     = 'kingson@example.org';
        $user->nicknames = ['pfefferkuchenmann', 'lululu'];

        return $user;
    }

    private function getServices() {
        $argumentMapperService  = new Service(
            'marshal.mapper.argument',
            ArgumentMapper::class
        );
        $serviceMapperService   = new Service(
            'marshal.mapper.service',
            ServiceMapper::class,
            $argumentMapperService
        );
        $containerMapperService = new Service(
            'marshal.mapper.container',
            ContainerMapper::class,
            $argumentMapperService,
            $serviceMapperService
        );

        return [$containerMapperService, $serviceMapperService, $argumentMapperService];
    }
}