Issues in SerializardTest.php (master) - Issues in master - thunderer/Serializard - Measure and Improve Code Quality continuously with Scrutinizer

Issues (34)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

tests/SerializardTest.php (8 issues)

Labels

Unused Code 8

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
namespace Thunder\Serializard\Tests;

use Thunder\Serializard\Exception\FormatNotFoundException;
use Thunder\Serializard\Exception\NormalizerNotFoundException;
use Thunder\Serializard\Exception\SerializationFailureException;
use Thunder\Serializard\Format\ArrayFormat;
use Thunder\Serializard\Format\JsonFormat;
use Thunder\Serializard\Format\XmlFormat;
use Thunder\Serializard\Format\YamlFormat;
use Thunder\Serializard\FormatContainer\FormatContainer;
use Thunder\Serializard\Hydrator\ReflectionHydrator;
use Thunder\Serializard\HydratorContainer\FallbackHydratorContainer;
use Thunder\Serializard\HydratorContainer\HydratorContainerInterface as Hydrators;
use Thunder\Serializard\HydratorContainer\HydratorContainerInterface;
use Thunder\Serializard\Normalizer\ReflectionNormalizer;
use Thunder\Serializard\NormalizerContainer\FallbackNormalizerContainer;
use Thunder\Serializard\NormalizerContext\NormalizerContextInterface;
use Thunder\Serializard\Serializard;
use Thunder\Serializard\Tests\Fake\Context\FakeNormalizerContext;
use Thunder\Serializard\Tests\Fake\FakeArticle;
use Thunder\Serializard\Tests\Fake\FakeTag;
use Thunder\Serializard\Tests\Fake\FakeUser;
use Thunder\Serializard\Tests\Fake\FakeUserParent;
use Thunder\Serializard\Tests\Fake\FakeUserParentParent;
use Thunder\Serializard\Tests\Fake\Interfaces\TypeA;
use Thunder\Serializard\Tests\Fake\Interfaces\TypeB;
use Thunder\Serializard\Tests\Fake\Interfaces\TypeInterface;
use Thunder\Serializard\Utility\RootElementProviderUtility;

/**
 * @author Tomasz Kowalczyk <[email protected]>
 */
final class SerializardTest extends AbstractTestCase
{
    /** @dataProvider provideExamples */
    public function testSerializard($prefix, $factory)
    {
        $object = $factory();

        $serializard = $this->getSerializard();

        $file = __DIR__.'/examples/'.$prefix;

        $json = $serializard->serialize($object, 'json');
        $yaml = $serializard->serialize($object, 'yaml');
        $xml = $serializard->serialize($object, 'xml');
        $array = $serializard->serialize($object, 'array');

        $this->assertStringEqualsFile($file.'.json', $json."\n");
        $this->assertStringEqualsFile($file.'.yaml', $yaml);
        $this->assertStringEqualsFile($file.'.xml', $xml);
        $this->assertSame(require $file.'.php', $array);

        $this->assertSame($json, $serializard->serialize($serializard->unserialize($json, FakeUser::class, 'json'), 'json'));
        $this->assertSame($yaml, $serializard->serialize($serializard->unserialize($yaml, FakeUser::class, 'yaml'), 'yaml'));
        $this->assertSame($xml, $serializard->serialize($serializard->unserialize($xml, FakeUser::class, 'xml'), 'xml'));
        $this->assertSame($array, $serializard->serialize($serializard->unserialize($array, FakeUser::class, 'array'), 'array'));
    }

    public function provideExamples()
    {
        return [
            ['simple', function() {
                $user = new FakeUser(1, 'Thomas', new FakeTag(100, 'various'));
                $user->addTag(new FakeTag(10, 'sth'));
                $user->addTag(new FakeTag(11, 'xyz'));
                $user->addTag(new FakeTag(12, 'rnd'));

                return $user;
            }],
        ];
    }

    public function testInterfaces()
    {
        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(TypeInterface::class, function(TypeInterface $type) {
            return [
                'type' => $type->getType(),
                'value' => $type->getValue(),
            ];
        });

        $hydrators = new FallbackHydratorContainer();

        $formats = new FormatContainer();
        $formats->add('array', new ArrayFormat());

        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $this->assertSame(['type' => 'typeA', 'value' => 'valueA'], $serializard->serialize(new TypeA(), 'array'));
        $this->assertSame(['type' => 'typeB', 'value' => 'valueB'], $serializard->serialize(new TypeB(), 'array'));
    }

    /** @dataProvider provideCycles */
    public function testCycleException($var, $format)
    {
        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(FakeUser::class, new ReflectionNormalizer());
        $normalizers->add(FakeTag::class, new ReflectionNormalizer());

        $hydrators = new FallbackHydratorContainer();

        $formats = new FormatContainer();
        $formats->add('xml', new XmlFormat(new RootElementProviderUtility([
            FakeUser::class => 'user',
            FakeTag::class => 'tag',
        ])));
        $formats->add('yaml', new YamlFormat());
        $formats->add('json', new JsonFormat());
        $formats->add('array', new ArrayFormat());

        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $this->expectExceptionClass(SerializationFailureException::class);
        $serializard->serialize($var, $format);
    }

    public function provideCycles()
    {
        $user = new FakeUser(1, 'Thomas', new FakeTag(100, 'various'));
        $user->addTag(new FakeTag(10, 'sth'));
        $user->addTag(new FakeTag(11, 'xyz'));
        $user->addTag(new FakeTag(12, 'rnd'));

        return [
            [$user, 'xml'],
            [$user, 'json'],
            [$user, 'yaml'],
            [$user, 'array'],
        ];
    }

    private function getSerializard()
    {
        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(FakeUser::class, new ReflectionNormalizer());
        $normalizers->add(FakeTag::class, function(FakeTag $tag) {
            return [
                'id' => $tag->getId(),
                'name' => $tag->getName(),
            ];
        });

        $hydrators = new FallbackHydratorContainer();
        $hydrators->add(FakeUser::class, function(array $data, Hydrators $handlers) {
            $tagHandler = $handlers->getHandler(FakeTag::class);

            $user = new FakeUser($data['id'], $data['name'], $tagHandler($data['tag'], $handlers));
            foreach($data['tags'] as $tag) {
                $user->addTag($tagHandler($tag, $handlers));
            }

            return $user;
        });
        $hydrators->add(FakeTag::class, function(array $data, Hydrators $handlers) {

            return new FakeTag($data['id'], $data['name']);
        });

        $formats = new FormatContainer();
        $formats->add('xml', new XmlFormat(new RootElementProviderUtility([
            FakeUser::class => 'user',
            FakeTag::class => 'tag',
        ])));
        $formats->add('yaml', new YamlFormat());
        $formats->add('json', new JsonFormat());
        $formats->add('array', new ArrayFormat());

        return new Serializard($formats, $normalizers, $hydrators);
    }

    public function testParent()
    {
        $user = new FakeUser(1, '[email protected]', new FakeTag(1, 'tag'));

        $formats = new FormatContainer();
        $formats->add('array', new ArrayFormat());
        $normalizers = new FallbackNormalizerContainer();
        $hydrators = new FallbackHydratorContainer();
        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $normalizers->add(FakeUserParentParent::class, function(FakeUserParentParent $user) { return 'ancestor'; });

        $this->assertSame('ancestor', $serializard->serialize($user, 'array'));

        $normalizers->add(FakeUserParent::class, function(FakeUserParent $user) { return 'parent'; });

        $this->assertSame('parent', $serializard->serialize($user, 'array'));

        $normalizers->add(FakeUser::class, function(FakeUser $user) { return 'user'; });

        $this->assertSame('user', $serializard->serialize($user, 'array'));
    }

    public function testContext()
    {
        $formats = new FormatContainer();
        $formats->add('format', new ArrayFormat());

        $hydrators = new FallbackHydratorContainer();
        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(FakeArticle::class, function(FakeArticle $article) {
            return $article->getTag();
        });
        $normalizers->add(FakeUser::class, function(FakeUser $user) {
            return $user->getTag();
        });
        $normalizers->add(FakeTag::class, function(FakeTag $tag, NormalizerContextInterface $context) {
            return get_class($context->getParent());
        });

        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $tag = new FakeTag(1, 'name');
        $user = new FakeUser(1, 'name', $tag);
        $article = new FakeArticle(1, 'title', $user, $tag);

        $this->assertSame(FakeUser::class, $serializard->serialize($user, 'format', new FakeNormalizerContext()));
        $context = new FakeNormalizerContext();
        $this->assertSame(FakeArticle::class, $serializard->serialize($article, 'format', $context));
        $this->assertSame(2, $context->getLevel());
    }

    public function testProcessWithCallbacks()
    {
        $formats = new FormatContainer();
        $formats->add('json', new JsonFormat());

        $hydrators = new FallbackHydratorContainer();
        $hydrators->add(FakeArticle::class, function(array $data, FallbackHydratorContainer $hydrators) {
            $user = $hydrators->hydrate(FakeUser::class, $data['user']);
            $tag = $hydrators->hydrate(FakeTag::class, $data['tag']);

            return new FakeArticle($data['id'], $data['title'], $user, $tag);
        });
        $hydrators->add(FakeUser::class, function(array $data, FallbackHydratorContainer $hydrators) {
            $tag = $hydrators->hydrate(FakeTag::class, $data['tag']);

            $user = new FakeUser($data['id'], $data['name'], $tag);
            foreach($data['tags'] as $tagData) {
                $user->addTag(call_user_func($hydrators->getHandler(FakeTag::class), $tagData, $hydrators));
            }

            return $user;
        });
        $hydrators->add(FakeTag::class, function(array $data, HydratorContainerInterface $hydrators) {

            return new FakeTag($data['id'], $data['name']);
        });

        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(FakeArticle::class, function(FakeArticle $article, NormalizerContextInterface $context) {

            return [
                'id' => $article->getId(),
                'title' => $article->getTitle(),
                'user' => $article->getUser(),
                'tag' => $article->getTag(),
            ];
        });
        $normalizers->add(FakeUser::class, function(FakeUser $user, NormalizerContextInterface $context) {

            return [
                'id' => $user->getId(),
                'name' => $user->getName(),
                'tag' => $user->getTag(),
                'tags' => $user->getTags(),
            ];
        });
        $normalizers->add(FakeTag::class, function(FakeTag $tag, NormalizerContextInterface $context) {

            return [
                'id' => $tag->getId(),
                'name' => $tag->getName(),
            ];
        });

        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $tag = new FakeTag(1, 'tag');
        $user = new FakeUser(1, 'user', $tag);
        $user->addTag(new FakeTag(1, 'tag'));
        $article = new FakeArticle(1, 'title', $user, $tag);

        $json = $serializard->serialize($article, 'json', new FakeNormalizerContext());

        $this->assertEquals($article, $serializard->unserialize($json, FakeArticle::class, 'json'));
    }

    public function testProcessWithReflection()
    {
        $formats = new FormatContainer();
        $formats->add('json', new JsonFormat());

        $hydrators = new FallbackHydratorContainer();
        $hydrators->add(FakeArticle::class, new ReflectionHydrator(FakeArticle::class, [
            'user' => FakeUser::class,
            'tag' => FakeTag::class,
        ]));
        $hydrators->add(FakeUser::class, new ReflectionHydrator(FakeUser::class, [
            'tag' => FakeTag::class,
            'tags' => FakeTag::class.'[]',
        ]));
        $hydrators->add(FakeTag::class, new ReflectionHydrator(FakeTag::class, []));

        $normalizers = new FallbackNormalizerContainer();
        $normalizers->add(FakeArticle::class, new ReflectionNormalizer());
        $normalizers->add(FakeUser::class, new ReflectionNormalizer());
        $normalizers->add(FakeTag::class, new ReflectionNormalizer(['user']));

        $serializard = new Serializard($formats, $normalizers, $hydrators);

        $tag = new FakeTag(1, 'tag');
        $user = new FakeUser(1, 'user', $tag);
        $user->addTag(new FakeTag(1, 'tag'));
        $tags = $user->getTags();
        $tags[0]->clearUser();
        $article = new FakeArticle(1, 'title', $user, $tag);

        $json = $serializard->serialize($article, 'json', new FakeNormalizerContext());

        $this->assertEquals($article, $serializard->unserialize($json, FakeArticle::class, 'json'));
    }

    public function testInvalidSerializationFormat()
    {
        $this->expectExceptionClass(FormatNotFoundException::class);
        $this->getSerializard()->serialize(new \stdClass(), 'invalid');
    }

    public function testInvalidUnserializationFormat()
    {
        $this->expectExceptionClass(FormatNotFoundException::class);
        $this->getSerializard()->unserialize(new \stdClass(), \stdClass::class, 'invalid');
    }

    public function testMissingClassSerializationHandler()
    {
        $this->expectExceptionClass(NormalizerNotFoundException::class);
        $this->getSerializard()->serialize(new \stdClass(), 'json');
    }
}


1		<?php
2		namespace Thunder\Serializard\Tests;
3
4		use Thunder\Serializard\Exception\FormatNotFoundException;
5		use Thunder\Serializard\Exception\NormalizerNotFoundException;
6		use Thunder\Serializard\Exception\SerializationFailureException;
7		use Thunder\Serializard\Format\ArrayFormat;
8		use Thunder\Serializard\Format\JsonFormat;
9		use Thunder\Serializard\Format\XmlFormat;
10		use Thunder\Serializard\Format\YamlFormat;
11		use Thunder\Serializard\FormatContainer\FormatContainer;
12		use Thunder\Serializard\Hydrator\ReflectionHydrator;
13		use Thunder\Serializard\HydratorContainer\FallbackHydratorContainer;
14		use Thunder\Serializard\HydratorContainer\HydratorContainerInterface as Hydrators;
15		use Thunder\Serializard\HydratorContainer\HydratorContainerInterface;
16		use Thunder\Serializard\Normalizer\ReflectionNormalizer;
17		use Thunder\Serializard\NormalizerContainer\FallbackNormalizerContainer;
18		use Thunder\Serializard\NormalizerContext\NormalizerContextInterface;
19		use Thunder\Serializard\Serializard;
20		use Thunder\Serializard\Tests\Fake\Context\FakeNormalizerContext;
21		use Thunder\Serializard\Tests\Fake\FakeArticle;
22		use Thunder\Serializard\Tests\Fake\FakeTag;
23		use Thunder\Serializard\Tests\Fake\FakeUser;
24		use Thunder\Serializard\Tests\Fake\FakeUserParent;
25		use Thunder\Serializard\Tests\Fake\FakeUserParentParent;
26		use Thunder\Serializard\Tests\Fake\Interfaces\TypeA;
27		use Thunder\Serializard\Tests\Fake\Interfaces\TypeB;
28		use Thunder\Serializard\Tests\Fake\Interfaces\TypeInterface;
29		use Thunder\Serializard\Utility\RootElementProviderUtility;
30
31		/**
32		* @author Tomasz Kowalczyk <[email protected]>
33		*/
34		final class SerializardTest extends AbstractTestCase
35		{
36		/** @dataProvider provideExamples */
37		public function testSerializard($prefix, $factory)
38		{
39		$object = $factory();
40
41		$serializard = $this->getSerializard();
42
43		$file = __DIR__.'/examples/'.$prefix;
44
45		$json = $serializard->serialize($object, 'json');
46		$yaml = $serializard->serialize($object, 'yaml');
47		$xml = $serializard->serialize($object, 'xml');
48		$array = $serializard->serialize($object, 'array');
49
50		$this->assertStringEqualsFile($file.'.json', $json."\n");
51		$this->assertStringEqualsFile($file.'.yaml', $yaml);
52		$this->assertStringEqualsFile($file.'.xml', $xml);
53		$this->assertSame(require $file.'.php', $array);
54
55		$this->assertSame($json, $serializard->serialize($serializard->unserialize($json, FakeUser::class, 'json'), 'json'));
56		$this->assertSame($yaml, $serializard->serialize($serializard->unserialize($yaml, FakeUser::class, 'yaml'), 'yaml'));
57		$this->assertSame($xml, $serializard->serialize($serializard->unserialize($xml, FakeUser::class, 'xml'), 'xml'));
58		$this->assertSame($array, $serializard->serialize($serializard->unserialize($array, FakeUser::class, 'array'), 'array'));
59		}
60
61		public function provideExamples()
62		{
63		return [
64		['simple', function() {
65		$user = new FakeUser(1, 'Thomas', new FakeTag(100, 'various'));
66		$user->addTag(new FakeTag(10, 'sth'));
67		$user->addTag(new FakeTag(11, 'xyz'));
68		$user->addTag(new FakeTag(12, 'rnd'));
69
70		return $user;
71		}],
72		];
73		}
74
75		public function testInterfaces()
76		{
77		$normalizers = new FallbackNormalizerContainer();
78		$normalizers->add(TypeInterface::class, function(TypeInterface $type) {
79		return [
80		'type' => $type->getType(),
81		'value' => $type->getValue(),
82		];
83		});
84
85		$hydrators = new FallbackHydratorContainer();
86
87		$formats = new FormatContainer();
88		$formats->add('array', new ArrayFormat());
89
90		$serializard = new Serializard($formats, $normalizers, $hydrators);
91
92		$this->assertSame(['type' => 'typeA', 'value' => 'valueA'], $serializard->serialize(new TypeA(), 'array'));
93		$this->assertSame(['type' => 'typeB', 'value' => 'valueB'], $serializard->serialize(new TypeB(), 'array'));
94		}
95
96		/** @dataProvider provideCycles */
97		public function testCycleException($var, $format)
98		{
99		$normalizers = new FallbackNormalizerContainer();
100		$normalizers->add(FakeUser::class, new ReflectionNormalizer());
101		$normalizers->add(FakeTag::class, new ReflectionNormalizer());
102
103		$hydrators = new FallbackHydratorContainer();
104
105		$formats = new FormatContainer();
106		$formats->add('xml', new XmlFormat(new RootElementProviderUtility([
107		FakeUser::class => 'user',
108		FakeTag::class => 'tag',
109		])));
110		$formats->add('yaml', new YamlFormat());
111		$formats->add('json', new JsonFormat());
112		$formats->add('array', new ArrayFormat());
113
114		$serializard = new Serializard($formats, $normalizers, $hydrators);
115
116		$this->expectExceptionClass(SerializationFailureException::class);
117		$serializard->serialize($var, $format);
118		}
119
120		public function provideCycles()
121		{
122		$user = new FakeUser(1, 'Thomas', new FakeTag(100, 'various'));
123		$user->addTag(new FakeTag(10, 'sth'));
124		$user->addTag(new FakeTag(11, 'xyz'));
125		$user->addTag(new FakeTag(12, 'rnd'));
126
127		return [
128		[$user, 'xml'],
129		[$user, 'json'],
130		[$user, 'yaml'],
131		[$user, 'array'],
132		];
133		}
134
135		private function getSerializard()
136		{
137		$normalizers = new FallbackNormalizerContainer();
138		$normalizers->add(FakeUser::class, new ReflectionNormalizer());
139		$normalizers->add(FakeTag::class, function(FakeTag $tag) {
140		return [
141		'id' => $tag->getId(),
142		'name' => $tag->getName(),
143		];
144		});
145
146		$hydrators = new FallbackHydratorContainer();
147	View Code Duplication	$hydrators->add(FakeUser::class, function(array $data, Hydrators $handlers) {
148		$tagHandler = $handlers->getHandler(FakeTag::class);
149
150		$user = new FakeUser($data['id'], $data['name'], $tagHandler($data['tag'], $handlers));
151		foreach($data['tags'] as $tag) {
152		$user->addTag($tagHandler($tag, $handlers));
153		}
154
155		return $user;
156		});
157		$hydrators->add(FakeTag::class, function(array $data, Hydrators $handlers) {
		0 ignored issues – show Unused Code introduced 2015-12-10 00:18 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$handlers` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
158		return new FakeTag($data['id'], $data['name']);
159		});
160
161		$formats = new FormatContainer();
162		$formats->add('xml', new XmlFormat(new RootElementProviderUtility([
163		FakeUser::class => 'user',
164		FakeTag::class => 'tag',
165		])));
166		$formats->add('yaml', new YamlFormat());
167		$formats->add('json', new JsonFormat());
168		$formats->add('array', new ArrayFormat());
169
170		return new Serializard($formats, $normalizers, $hydrators);
171		}
172
173		public function testParent()
174		{
175		$user = new FakeUser(1, '[email protected]', new FakeTag(1, 'tag'));
176
177		$formats = new FormatContainer();
178		$formats->add('array', new ArrayFormat());
179		$normalizers = new FallbackNormalizerContainer();
180		$hydrators = new FallbackHydratorContainer();
181		$serializard = new Serializard($formats, $normalizers, $hydrators);
182
183		$normalizers->add(FakeUserParentParent::class, function(FakeUserParentParent $user) { return 'ancestor'; });
		0 ignored issues – show Unused Code introduced 2018-02-16 22:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$user` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
184		$this->assertSame('ancestor', $serializard->serialize($user, 'array'));
185
186		$normalizers->add(FakeUserParent::class, function(FakeUserParent $user) { return 'parent'; });
		0 ignored issues – show Unused Code introduced 2018-02-16 22:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$user` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
187		$this->assertSame('parent', $serializard->serialize($user, 'array'));
188
189		$normalizers->add(FakeUser::class, function(FakeUser $user) { return 'user'; });
		0 ignored issues – show Unused Code introduced 2016-02-12 11:01 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$user` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
190		$this->assertSame('user', $serializard->serialize($user, 'array'));
191		}
192
193		public function testContext()
194		{
195		$formats = new FormatContainer();
196		$formats->add('format', new ArrayFormat());
197
198		$hydrators = new FallbackHydratorContainer();
199		$normalizers = new FallbackNormalizerContainer();
200		$normalizers->add(FakeArticle::class, function(FakeArticle $article) {
201		return $article->getTag();
202		});
203		$normalizers->add(FakeUser::class, function(FakeUser $user) {
204		return $user->getTag();
205		});
206		$normalizers->add(FakeTag::class, function(FakeTag $tag, NormalizerContextInterface $context) {
207		return get_class($context->getParent());
208		});
209
210		$serializard = new Serializard($formats, $normalizers, $hydrators);
211
212		$tag = new FakeTag(1, 'name');
213		$user = new FakeUser(1, 'name', $tag);
214		$article = new FakeArticle(1, 'title', $user, $tag);
215
216		$this->assertSame(FakeUser::class, $serializard->serialize($user, 'format', new FakeNormalizerContext()));
217		$context = new FakeNormalizerContext();
218		$this->assertSame(FakeArticle::class, $serializard->serialize($article, 'format', $context));
219		$this->assertSame(2, $context->getLevel());
220		}
221
222		public function testProcessWithCallbacks()
223		{
224		$formats = new FormatContainer();
225		$formats->add('json', new JsonFormat());
226
227		$hydrators = new FallbackHydratorContainer();
228		$hydrators->add(FakeArticle::class, function(array $data, FallbackHydratorContainer $hydrators) {
229		$user = $hydrators->hydrate(FakeUser::class, $data['user']);
230		$tag = $hydrators->hydrate(FakeTag::class, $data['tag']);
231
232		return new FakeArticle($data['id'], $data['title'], $user, $tag);
233		});
234	View Code Duplication	$hydrators->add(FakeUser::class, function(array $data, FallbackHydratorContainer $hydrators) {
235		$tag = $hydrators->hydrate(FakeTag::class, $data['tag']);
236
237		$user = new FakeUser($data['id'], $data['name'], $tag);
238		foreach($data['tags'] as $tagData) {
239		$user->addTag(call_user_func($hydrators->getHandler(FakeTag::class), $tagData, $hydrators));
240		}
241
242		return $user;
243		});
244		$hydrators->add(FakeTag::class, function(array $data, HydratorContainerInterface $hydrators) {
		0 ignored issues – show Unused Code introduced 2017-01-15 02:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$hydrators` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
245		return new FakeTag($data['id'], $data['name']);
246		});
247
248		$normalizers = new FallbackNormalizerContainer();
249		$normalizers->add(FakeArticle::class, function(FakeArticle $article, NormalizerContextInterface $context) {
		0 ignored issues – show Unused Code introduced 2017-01-15 02:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$context` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
250		return [
251		'id' => $article->getId(),
252		'title' => $article->getTitle(),
253		'user' => $article->getUser(),
254		'tag' => $article->getTag(),
255		];
256		});
257		$normalizers->add(FakeUser::class, function(FakeUser $user, NormalizerContextInterface $context) {
		0 ignored issues – show Unused Code introduced 2017-01-15 02:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$context` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
258		return [
259		'id' => $user->getId(),
260		'name' => $user->getName(),
261		'tag' => $user->getTag(),
262		'tags' => $user->getTags(),
263		];
264		});
265		$normalizers->add(FakeTag::class, function(FakeTag $tag, NormalizerContextInterface $context) {
		0 ignored issues – show Unused Code introduced 2017-01-15 02:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this The parameter `$context` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
266		return [
267		'id' => $tag->getId(),
268		'name' => $tag->getName(),
269		];
270		});
271
272		$serializard = new Serializard($formats, $normalizers, $hydrators);
273
274		$tag = new FakeTag(1, 'tag');
275		$user = new FakeUser(1, 'user', $tag);
276		$user->addTag(new FakeTag(1, 'tag'));
277		$article = new FakeArticle(1, 'title', $user, $tag);
278
279		$json = $serializard->serialize($article, 'json', new FakeNormalizerContext());
280
281		$this->assertEquals($article, $serializard->unserialize($json, FakeArticle::class, 'json'));
282		}
283
284		public function testProcessWithReflection()
285		{
286		$formats = new FormatContainer();
287		$formats->add('json', new JsonFormat());
288
289		$hydrators = new FallbackHydratorContainer();
290		$hydrators->add(FakeArticle::class, new ReflectionHydrator(FakeArticle::class, [
291		'user' => FakeUser::class,
292		'tag' => FakeTag::class,
293		]));
294		$hydrators->add(FakeUser::class, new ReflectionHydrator(FakeUser::class, [
295		'tag' => FakeTag::class,
296		'tags' => FakeTag::class.'[]',
297		]));
298		$hydrators->add(FakeTag::class, new ReflectionHydrator(FakeTag::class, []));
299
300		$normalizers = new FallbackNormalizerContainer();
301		$normalizers->add(FakeArticle::class, new ReflectionNormalizer());
302		$normalizers->add(FakeUser::class, new ReflectionNormalizer());
303		$normalizers->add(FakeTag::class, new ReflectionNormalizer(['user']));
304
305		$serializard = new Serializard($formats, $normalizers, $hydrators);
306
307		$tag = new FakeTag(1, 'tag');
308		$user = new FakeUser(1, 'user', $tag);
309		$user->addTag(new FakeTag(1, 'tag'));
310		$tags = $user->getTags();
311		$tags[0]->clearUser();
312		$article = new FakeArticle(1, 'title', $user, $tag);
313
314		$json = $serializard->serialize($article, 'json', new FakeNormalizerContext());
315
316		$this->assertEquals($article, $serializard->unserialize($json, FakeArticle::class, 'json'));
317		}
318
319		public function testInvalidSerializationFormat()
320		{
321		$this->expectExceptionClass(FormatNotFoundException::class);
322		$this->getSerializard()->serialize(new \stdClass(), 'invalid');
323		}
324
325		public function testInvalidUnserializationFormat()
326		{
327		$this->expectExceptionClass(FormatNotFoundException::class);
328		$this->getSerializard()->unserialize(new \stdClass(), \stdClass::class, 'invalid');
329		}
330
331		public function testMissingClassSerializationHandler()
332		{
333		$this->expectExceptionClass(NormalizerNotFoundException::class);
334		$this->getSerializard()->serialize(new \stdClass(), 'json');
335		}
336		}
337

thunderer / Serializard

Issues (34)

Security Analysis no request data

tests/SerializardTest.php (8 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like