Issues in JMSSerializerExtensionTest.php - New Issues - Inspection of "Merge pull request #604 from schmittjoh/do-not-dep..." - schmittjoh/JMSSerializerBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a61272...cb5e47 )

by Asmir

created 2017-09-28 15:37 UTC

DependencyInjection/JMSSerializerExtensionTest.php (1 issue)

Labels

Documentation 1

Severity

Minor 1

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

/*
 * Copyright 2011 Johannes M. Schmitt <[email protected]>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace JMS\SerializerBundle\Tests\DependencyInjection;

use Doctrine\Common\Annotations\AnnotationReader;
use JMS\Serializer\SerializationContext;
use JMS\SerializerBundle\JMSSerializerBundle;
use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionLanguage;
use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionProperties;
use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\SimpleObject;
use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\VersionedObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;

class JMSSerializerExtensionTest extends TestCase
{
    protected function setUp()
    {
        $this->clearTempDir();
    }

    protected function tearDown()
    {
        $this->clearTempDir();
    }

    private function clearTempDir()
    {
        // clear temporary directory
        $dir = sys_get_temp_dir() . '/serializer';
        if (is_dir($dir)) {
            foreach (new \RecursiveDirectoryIterator($dir) as $file) {
                $filename = $file->getFileName();
                if ('.' === $filename || '..' === $filename) {
                    continue;
                }

                @unlink($file->getPathName());
            }

            @rmdir($dir);
        }
    }

    public function testHasContextFactories()
    {
        $container = $this->getContainerForConfig(array(array()));

        $factory = $container->get('jms_serializer.serialization_context_factory');
        $this->assertInstanceOf('JMS\Serializer\ContextFactory\SerializationContextFactoryInterface', $factory);

        $factory = $container->get('jms_serializer.deserialization_context_factory');
        $this->assertInstanceOf('JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface', $factory);
    }

    public function testSerializerContextFactoriesAreSet()
    {
        $container = $this->getContainerForConfig(array(array()));

        $def = $container->getDefinition('jms_serializer');
        $calls = $def->getMethodCalls();

        $this->assertCount(2, $calls);

        $serializationCall = $calls[0];
        $this->assertEquals('setSerializationContextFactory', $serializationCall[0]);
        $this->assertEquals('jms_serializer.serialization_context_factory', (string)$serializationCall[1][0]);

        $serializationCall = $calls[1];
        $this->assertEquals('setDeserializationContextFactory', $serializationCall[0]);
        $this->assertEquals('jms_serializer.deserialization_context_factory', (string)$serializationCall[1][0]);
    }

    public function testSerializerContextFactoriesWithId()
    {
        $config = array(
            'default_context' => array(
                'serialization' => array(
                    'id' => 'foo'
                ),
                'deserialization' => array(
                    'id' => 'bar'
                )
            )
        );

        $container = $this->getContainerForConfig(array($config), function(ContainerBuilder $containerBuilder){
            $containerBuilder->setDefinition('foo', new Definition('stdClass'));
            $containerBuilder->setDefinition('bar', new Definition('stdClass'));
        });

        $def = $container->getDefinition('jms_serializer');
        $calls = $def->getMethodCalls();

        $this->assertCount(2, $calls);

        $serializationCall = $calls[0];
        $this->assertEquals('setSerializationContextFactory', $serializationCall[0]);
        $this->assertEquals('foo', (string)$serializationCall[1][0]);

        $serializationCall = $calls[1];
        $this->assertEquals('setDeserializationContextFactory', $serializationCall[0]);
        $this->assertEquals('bar', (string)$serializationCall[1][0]);

        $this->assertEquals('bar', (string)$container->getAlias('jms_serializer.deserialization_context_factory'));
        $this->assertEquals('foo', (string)$container->getAlias('jms_serializer.serialization_context_factory'));
    }

    public function testLoadWithoutTranslator()
    {
        $container = $this->getContainerForConfig(array(array()), function(ContainerBuilder $containerBuilder){
            $containerBuilder->set('translator', null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        });

        $def = $container->getDefinition('jms_serializer.form_error_handler');
        $this->assertSame(null, $def->getArgument(0));
    }

    public function testConfiguringContextFactories()
    {
        $container = $this->getContainerForConfig(array(array()));

        $def = $container->getDefinition('jms_serializer.serialization_context_factory');
        $this->assertCount(0, $def->getMethodCalls());

        $def = $container->getDefinition('jms_serializer.deserialization_context_factory');
        $this->assertCount(0, $def->getMethodCalls());
    }

    public function testConfiguringContextFactoriesWithParams()
    {
        $config = array(
            'default_context' => array(
                'serialization' => array(
                    'version' => 1600,
                    'serialize_null' => true,
                    'attributes' => array('x' => 1720),
                    'groups' => array('Default', 'Registration'),
                    'enable_max_depth_checks' => true,
                ),
                'deserialization' => array(
                    'version' => 1640,
                    'serialize_null' => false,
                    'attributes' => array('x' => 1740),
                    'groups' => array('Default', 'Profile'),
                    'enable_max_depth_checks' => true,
                )
            )
        );

        $container = $this->getContainerForConfig(array($config));
        $services = [
            'serialization' => 'jms_serializer.serialization_context_factory',
            'deserialization' => 'jms_serializer.deserialization_context_factory',
        ];
        foreach ($services as $configKey => $serviceId) {
            $def = $container->getDefinition($serviceId);
            $values = $config['default_context'][$configKey];

            $this->assertSame($values['version'], $this->getDefinitionMethodCall($def, 'setVersion')[0]);
            $this->assertSame($values['serialize_null'], $this->getDefinitionMethodCall($def, 'setSerializeNulls')[0]);
            $this->assertSame($values['attributes'], $this->getDefinitionMethodCall($def, 'setAttributes')[0]);
            $this->assertSame($values['groups'], $this->getDefinitionMethodCall($def, 'setGroups')[0]);
            $this->assertSame($values['groups'], $this->getDefinitionMethodCall($def, 'setGroups')[0]);
            $this->assertSame(array(), $this->getDefinitionMethodCall($def, 'enableMaxDepthChecks'));
        }
    }

    public function testConfiguringContextFactoriesWithNullDefaults()
    {
        $config = array(
            'default_context' => array(
                'serialization' => array(
                    'version' => null,
                    'serialize_null' => null,
                    'attributes' => [],
                    'groups' => null,
                ),
                'deserialization' => array(
                    'version' => null,
                    'serialize_null' => null,
                    'attributes' => null,
                    'groups' => null,
                )
            )
        );

        $container = $this->getContainerForConfig(array($config));
        $services = [
            'serialization' => 'jms_serializer.serialization_context_factory',
            'deserialization' => 'jms_serializer.deserialization_context_factory',
        ];
        foreach ($services as $configKey => $serviceId) {
            $def = $container->getDefinition($serviceId);
            $this->assertCount(0, $def->getMethodCalls());
        }
    }

    private function getDefinitionMethodCall(Definition $def, $method)
    {
        foreach ($def->getMethodCalls() as $call) {
            if ($call[0] === $method) {
                return $call[1];
            }
        }
        return false;
    }

    public function testLoad()
    {
        $container = $this->getContainerForConfig(array(array()), function(ContainerBuilder $container) {
            $container->getDefinition('jms_serializer.doctrine_object_constructor')->setPublic(true);
            $container->getAlias('JMS\Serializer\SerializerInterface')->setPublic(true);
            $container->getAlias('JMS\Serializer\ArrayTransformerInterface')->setPublic(true);
        });

        $simpleObject = new SimpleObject('foo', 'bar');
        $versionedObject = new VersionedObject('foo', 'bar');
        $serializer = $container->get('jms_serializer');

        $this->assertTrue($container->has('JMS\Serializer\SerializerInterface'), 'Alias should be defined to allow autowiring');
        $this->assertTrue($container->has('JMS\Serializer\ArrayTransformerInterface'), 'Alias should be defined to allow autowiring');

        $this->assertFalse($container->getDefinition('jms_serializer.array_collection_handler')->getArgument(0));

        // the logic is inverted because arg 0 on doctrine_proxy_subscriber is $skipVirtualTypeInit = false
        $this->assertTrue($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(0));
        $this->assertFalse($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(1));

        $this->assertEquals("null", $container->getDefinition('jms_serializer.doctrine_object_constructor')->getArgument(2));

        // test that all components have been wired correctly
        $this->assertEquals(json_encode(array('name' => 'bar')), $serializer->serialize($versionedObject, 'json'));
        $this->assertEquals($simpleObject, $serializer->deserialize($serializer->serialize($simpleObject, 'json'), get_class($simpleObject), 'json'));
        $this->assertEquals($simpleObject, $serializer->deserialize($serializer->serialize($simpleObject, 'xml'), get_class($simpleObject), 'xml'));

        $this->assertEquals(json_encode(array('name' => 'foo')), $serializer->serialize($versionedObject, 'json', SerializationContext::create()->setVersion('0.0.1')));

        $this->assertEquals(json_encode(array('name' => 'bar')), $serializer->serialize($versionedObject, 'json', SerializationContext::create()->setVersion('1.1.1')));
    }

    public function testLoadWithOptions()
    {
        $container = $this->getContainerForConfig(array(array(
            'subscribers' => [
                'doctrine_proxy' => [
                    'initialize_virtual_types' => true,
                    'initialize_excluded' => true,
                ],
            ],
            'object_constructors' => [
                'doctrine' => [
                    'fallback_strategy' => "exception",
                ],
            ],
            'handlers' => [
                'array_collection' => [
                    'initialize_excluded' => true,
                ],
            ],
        )), function($container){
            $container->getDefinition('jms_serializer.doctrine_object_constructor')->setPublic(true);
        });

        $this->assertTrue($container->getDefinition('jms_serializer.array_collection_handler')->getArgument(0));

        // the logic is inverted because arg 0 on doctrine_proxy_subscriber is $skipVirtualTypeInit = false
        $this->assertFalse($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(0));
        $this->assertTrue($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(1));

        $this->assertEquals("exception", $container->getDefinition('jms_serializer.doctrine_object_constructor')->getArgument(2));
    }

    public function testLoadExistentMetadataDir()
    {
        $container = $this->getContainerForConfig(array(array(
            'metadata' => [
                'directories' => [
                    'foo' => [
                        'namespace_prefix' => 'foo_ns',
                        'path' => __DIR__,
                    ]
                ]
            ]
        )), function ($container){
            $container->getDefinition('jms_serializer.metadata.file_locator')->setPublic(true);
        });

        $fileLocatorDef = $container->getDefinition('jms_serializer.metadata.file_locator');
        $directories = $fileLocatorDef->getArgument(0);
        $this->assertEquals(['foo_ns' => __DIR__], $directories);
    }

    /**
     * @expectedException \JMS\Serializer\Exception\RuntimeException
     * @expectedExceptionMessage  The metadata directory "foo_dir" does not exist for the namespace "foo_ns"
     */
    public function testLoadNotExistentMetadataDir()
    {
        $this->getContainerForConfig(array(array(
            'metadata' => [
                'directories' => [
                    'foo' => [
                        'namespace_prefix' => 'foo_ns',
                        'path' => 'foo_dir',
                    ]
                ]
            ]
        )));
    }

    /**
     * @dataProvider getJsonVisitorConfigs
     */
    public function testJsonVisitorOptions($expectedOptions, $config)
    {
        $container = $this->getContainerForConfig(array($config));
        $this->assertSame($expectedOptions, $container->get('jms_serializer.json_serialization_visitor')->getOptions());
    }

    public function getJsonVisitorConfigs()
    {
        $configs = array();

        if (version_compare(PHP_VERSION, '5.4', '>=')) {
            $configs[] = array(JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT, array(
                'visitors' => array(
                    'json' => array(
                        'options' => array('JSON_UNESCAPED_UNICODE', 'JSON_PRETTY_PRINT')
                    )
                )
            ));

            $configs[] = array(JSON_UNESCAPED_UNICODE, array(
                'visitors' => array(
                    'json' => array(
                        'options' => 'JSON_UNESCAPED_UNICODE'
                    )
                )
            ));
        }

        $configs[] = array(128, array(
            'visitors' => array(
                'json' => array(
                    'options' => 128
                )
            )
        ));

        $configs[] = array(0, array());

        return $configs;
    }

    public function testExpressionLanguage()
    {
        if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
            $this->markTestSkipped("The Symfony Expression Language is not available");
        }
        $container = $this->getContainerForConfig(array(array()));
        $serializer = $container->get('jms_serializer');
        // test that all components have been wired correctly
        $object = new ObjectUsingExpressionLanguage('foo', true);
        $this->assertEquals('{"name":"foo"}', $serializer->serialize($object, 'json'));
        $object = new ObjectUsingExpressionLanguage('foo', false);
        $this->assertEquals('{}', $serializer->serialize($object, 'json'));
    }

    public function testExpressionLanguageVirtualProperties()
    {
        if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
            $this->markTestSkipped("The Symfony Expression Language is not available");
        }
        $container = $this->getContainerForConfig(array(array()));
        $serializer = $container->get('jms_serializer');
        // test that all components have been wired correctly
        $object = new ObjectUsingExpressionProperties('foo');
        $this->assertEquals('{"v_prop_name":"foo"}', $serializer->serialize($object, 'json'));
    }

    /**
     * @expectedException \JMS\Serializer\Exception\ExpressionLanguageRequiredException
     */
    public function testExpressionLanguageDisabledVirtualProperties()
    {
        if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
            $this->markTestSkipped("The Symfony Expression Language is not available");
        }
        $container = $this->getContainerForConfig(array(array('expression_evaluator' => array('id' => null))));
        $serializer = $container->get('jms_serializer');
        // test that all components have been wired correctly
        $object = new ObjectUsingExpressionProperties('foo');
        $serializer->serialize($object, 'json');
    }

    /**
     * @expectedException \JMS\Serializer\Exception\ExpressionLanguageRequiredException
     * @expectedExceptionMessage  To use conditional exclude/expose in JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionLanguage you must configure the expression language.
     */
    public function testExpressionLanguageNotLoaded()
    {
        $container = $this->getContainerForConfig(array(array('expression_evaluator' => array('id' => null))));
        $serializer = $container->get('jms_serializer');
        // test that all components have been wired correctly
        $object = new ObjectUsingExpressionLanguage('foo', true);
        $serializer->serialize($object, 'json');
    }

    /**
     * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
     * @expectedExceptionMessage Invalid configuration for path "jms_serializer.expression_evaluator.id": You need at least symfony/expression language v2.6 or v3.0 to use the expression evaluator features
     */
    public function testExpressionInvalidEvaluator()
    {
        if (interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
            $this->markTestSkipped('To pass this test the "symfony/expression-language" component should be available');
        }
        $this->getContainerForConfig(array(array('expression_evaluator' => array('id' => 'foo'))));
    }

    /**
     * @dataProvider getXmlVisitorWhitelists
     */
    public function testXmlVisitorOptions($expectedOptions, $config)
    {
        $container = $this->getContainerForConfig(array($config));
        $this->assertSame($expectedOptions, $container->get('jms_serializer.xml_deserialization_visitor')->getDoctypeWhitelist());
    }

    public function getXmlVisitorWhitelists()
    {
        $configs = array();

        $configs[] = array(array('good document', 'other good document'), array(
            'visitors' => array(
                'xml' => array(
                    'doctype_whitelist' => array('good document', 'other good document'),
                )
            )
        ));

        $configs[] = array(array(), array());

        return $configs;
    }

    public function testXmlVisitorFormatOutput()
    {
        $config = array(
            'visitors' => array(
                'xml' => array(
                    'format_output' => false,
                )
            )
        );
        $container = $this->getContainerForConfig(array($config));

        $this->assertFalse($container->get('jms_serializer.xml_serialization_visitor')->isFormatOutput());
    }

    public function testXmlVisitorDefaultValueToFormatOutput()
    {
        $container = $this->getContainerForConfig(array());
        $this->assertTrue($container->get('jms_serializer.xml_serialization_visitor')->isFormatOutput());
    }

    private function getContainerForConfig(array $configs, callable $configurator = null)
    {
        $bundle = new JMSSerializerBundle();
        $extension = $bundle->getContainerExtension();

        $container = new ContainerBuilder();
        $container->setParameter('kernel.debug', true);
        $container->setParameter('kernel.cache_dir', sys_get_temp_dir() . '/serializer');
        $container->setParameter('kernel.bundles', array());
        $container->set('annotation_reader', new AnnotationReader());
        $container->setDefinition('doctrine', new Definition(Registry::class));
        $container->set('translator', $this->getMockBuilder('Symfony\\Component\\Translation\\TranslatorInterface')->getMock());
        $container->set('debug.stopwatch', $this->getMockBuilder('Symfony\\Component\\Stopwatch\\Stopwatch')->getMock());
        $container->registerExtension($extension);
        $extension->load($configs, $container);

        $bundle->build($container);

        if ($configurator) {
            call_user_func($configurator, $container);
        }

        $container->compile();

        return $container;
    }
}


1			<?php
2
3			/*
4			* Copyright 2011 Johannes M. Schmitt <[email protected]>
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			namespace JMS\SerializerBundle\Tests\DependencyInjection;
20
21			use Doctrine\Common\Annotations\AnnotationReader;
22			use JMS\Serializer\SerializationContext;
23			use JMS\SerializerBundle\JMSSerializerBundle;
24			use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionLanguage;
25			use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionProperties;
26			use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\SimpleObject;
27			use JMS\SerializerBundle\Tests\DependencyInjection\Fixture\VersionedObject;
28			use PHPUnit\Framework\TestCase;
29			use Symfony\Component\DependencyInjection\ContainerBuilder;
30			use Symfony\Component\DependencyInjection\Definition;
31
32			class JMSSerializerExtensionTest extends TestCase
33			{
34			protected function setUp()
35			{
36			$this->clearTempDir();
37			}
38
39			protected function tearDown()
40			{
41			$this->clearTempDir();
42			}
43
44			private function clearTempDir()
45			{
46			// clear temporary directory
47			$dir = sys_get_temp_dir() . '/serializer';
48			if (is_dir($dir)) {
49			foreach (new \RecursiveDirectoryIterator($dir) as $file) {
50			$filename = $file->getFileName();
51			if ('.' === $filename \|\| '..' === $filename) {
52			continue;
53			}
54
55			@unlink($file->getPathName());
56			}
57
58			@rmdir($dir);
59			}
60			}
61
62			public function testHasContextFactories()
63			{
64			$container = $this->getContainerForConfig(array(array()));
65
66			$factory = $container->get('jms_serializer.serialization_context_factory');
67			$this->assertInstanceOf('JMS\Serializer\ContextFactory\SerializationContextFactoryInterface', $factory);
68
69			$factory = $container->get('jms_serializer.deserialization_context_factory');
70			$this->assertInstanceOf('JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface', $factory);
71			}
72
73			public function testSerializerContextFactoriesAreSet()
74			{
75			$container = $this->getContainerForConfig(array(array()));
76
77			$def = $container->getDefinition('jms_serializer');
78			$calls = $def->getMethodCalls();
79
80			$this->assertCount(2, $calls);
81
82			$serializationCall = $calls[0];
83			$this->assertEquals('setSerializationContextFactory', $serializationCall[0]);
84			$this->assertEquals('jms_serializer.serialization_context_factory', (string)$serializationCall[1][0]);
85
86			$serializationCall = $calls[1];
87			$this->assertEquals('setDeserializationContextFactory', $serializationCall[0]);
88			$this->assertEquals('jms_serializer.deserialization_context_factory', (string)$serializationCall[1][0]);
89			}
90
91			public function testSerializerContextFactoriesWithId()
92			{
93			$config = array(
94			'default_context' => array(
95			'serialization' => array(
96			'id' => 'foo'
97			),
98			'deserialization' => array(
99			'id' => 'bar'
100			)
101			)
102			);
103
104			$container = $this->getContainerForConfig(array($config), function(ContainerBuilder $containerBuilder){
105			$containerBuilder->setDefinition('foo', new Definition('stdClass'));
106			$containerBuilder->setDefinition('bar', new Definition('stdClass'));
107			});
108
109			$def = $container->getDefinition('jms_serializer');
110			$calls = $def->getMethodCalls();
111
112			$this->assertCount(2, $calls);
113
114			$serializationCall = $calls[0];
115			$this->assertEquals('setSerializationContextFactory', $serializationCall[0]);
116			$this->assertEquals('foo', (string)$serializationCall[1][0]);
117
118			$serializationCall = $calls[1];
119			$this->assertEquals('setDeserializationContextFactory', $serializationCall[0]);
120			$this->assertEquals('bar', (string)$serializationCall[1][0]);
121
122			$this->assertEquals('bar', (string)$container->getAlias('jms_serializer.deserialization_context_factory'));
123			$this->assertEquals('foo', (string)$container->getAlias('jms_serializer.serialization_context_factory'));
124			}
125
126			public function testLoadWithoutTranslator()
127			{
128			$container = $this->getContainerForConfig(array(array()), function(ContainerBuilder $containerBuilder){
129			$containerBuilder->set('translator', null);
			0 ignored issues – show Documentation introduced 2017-09-28 14:48 UTC by Report Bug Copy Issue Report Show Similar Issues like this `null` is of type `null`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
130			});
131
132			$def = $container->getDefinition('jms_serializer.form_error_handler');
133			$this->assertSame(null, $def->getArgument(0));
134			}
135
136			public function testConfiguringContextFactories()
137			{
138			$container = $this->getContainerForConfig(array(array()));
139
140			$def = $container->getDefinition('jms_serializer.serialization_context_factory');
141			$this->assertCount(0, $def->getMethodCalls());
142
143			$def = $container->getDefinition('jms_serializer.deserialization_context_factory');
144			$this->assertCount(0, $def->getMethodCalls());
145			}
146
147			public function testConfiguringContextFactoriesWithParams()
148			{
149			$config = array(
150			'default_context' => array(
151			'serialization' => array(
152			'version' => 1600,
153			'serialize_null' => true,
154			'attributes' => array('x' => 1720),
155			'groups' => array('Default', 'Registration'),
156			'enable_max_depth_checks' => true,
157			),
158			'deserialization' => array(
159			'version' => 1640,
160			'serialize_null' => false,
161			'attributes' => array('x' => 1740),
162			'groups' => array('Default', 'Profile'),
163			'enable_max_depth_checks' => true,
164			)
165			)
166			);
167
168			$container = $this->getContainerForConfig(array($config));
169			$services = [
170			'serialization' => 'jms_serializer.serialization_context_factory',
171			'deserialization' => 'jms_serializer.deserialization_context_factory',
172			];
173			foreach ($services as $configKey => $serviceId) {
174			$def = $container->getDefinition($serviceId);
175			$values = $config['default_context'][$configKey];
176
177			$this->assertSame($values['version'], $this->getDefinitionMethodCall($def, 'setVersion')[0]);
178			$this->assertSame($values['serialize_null'], $this->getDefinitionMethodCall($def, 'setSerializeNulls')[0]);
179			$this->assertSame($values['attributes'], $this->getDefinitionMethodCall($def, 'setAttributes')[0]);
180			$this->assertSame($values['groups'], $this->getDefinitionMethodCall($def, 'setGroups')[0]);
181			$this->assertSame($values['groups'], $this->getDefinitionMethodCall($def, 'setGroups')[0]);
182			$this->assertSame(array(), $this->getDefinitionMethodCall($def, 'enableMaxDepthChecks'));
183			}
184			}
185
186			public function testConfiguringContextFactoriesWithNullDefaults()
187			{
188			$config = array(
189			'default_context' => array(
190			'serialization' => array(
191			'version' => null,
192			'serialize_null' => null,
193			'attributes' => [],
194			'groups' => null,
195			),
196			'deserialization' => array(
197			'version' => null,
198			'serialize_null' => null,
199			'attributes' => null,
200			'groups' => null,
201			)
202			)
203			);
204
205			$container = $this->getContainerForConfig(array($config));
206			$services = [
207			'serialization' => 'jms_serializer.serialization_context_factory',
208			'deserialization' => 'jms_serializer.deserialization_context_factory',
209			];
210			foreach ($services as $configKey => $serviceId) {
211			$def = $container->getDefinition($serviceId);
212			$this->assertCount(0, $def->getMethodCalls());
213			}
214			}
215
216			private function getDefinitionMethodCall(Definition $def, $method)
217			{
218			foreach ($def->getMethodCalls() as $call) {
219			if ($call[0] === $method) {
220			return $call[1];
221			}
222			}
223			return false;
224			}
225
226			public function testLoad()
227			{
228			$container = $this->getContainerForConfig(array(array()), function(ContainerBuilder $container) {
229			$container->getDefinition('jms_serializer.doctrine_object_constructor')->setPublic(true);
230			$container->getAlias('JMS\Serializer\SerializerInterface')->setPublic(true);
231			$container->getAlias('JMS\Serializer\ArrayTransformerInterface')->setPublic(true);
232			});
233
234			$simpleObject = new SimpleObject('foo', 'bar');
235			$versionedObject = new VersionedObject('foo', 'bar');
236			$serializer = $container->get('jms_serializer');
237
238			$this->assertTrue($container->has('JMS\Serializer\SerializerInterface'), 'Alias should be defined to allow autowiring');
239			$this->assertTrue($container->has('JMS\Serializer\ArrayTransformerInterface'), 'Alias should be defined to allow autowiring');
240
241			$this->assertFalse($container->getDefinition('jms_serializer.array_collection_handler')->getArgument(0));
242
243			// the logic is inverted because arg 0 on doctrine_proxy_subscriber is $skipVirtualTypeInit = false
244			$this->assertTrue($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(0));
245			$this->assertFalse($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(1));
246
247			$this->assertEquals("null", $container->getDefinition('jms_serializer.doctrine_object_constructor')->getArgument(2));
248
249			// test that all components have been wired correctly
250			$this->assertEquals(json_encode(array('name' => 'bar')), $serializer->serialize($versionedObject, 'json'));
251			$this->assertEquals($simpleObject, $serializer->deserialize($serializer->serialize($simpleObject, 'json'), get_class($simpleObject), 'json'));
252			$this->assertEquals($simpleObject, $serializer->deserialize($serializer->serialize($simpleObject, 'xml'), get_class($simpleObject), 'xml'));
253
254			$this->assertEquals(json_encode(array('name' => 'foo')), $serializer->serialize($versionedObject, 'json', SerializationContext::create()->setVersion('0.0.1')));
255
256			$this->assertEquals(json_encode(array('name' => 'bar')), $serializer->serialize($versionedObject, 'json', SerializationContext::create()->setVersion('1.1.1')));
257			}
258
259			public function testLoadWithOptions()
260			{
261			$container = $this->getContainerForConfig(array(array(
262			'subscribers' => [
263			'doctrine_proxy' => [
264			'initialize_virtual_types' => true,
265			'initialize_excluded' => true,
266			],
267			],
268			'object_constructors' => [
269			'doctrine' => [
270			'fallback_strategy' => "exception",
271			],
272			],
273			'handlers' => [
274			'array_collection' => [
275			'initialize_excluded' => true,
276			],
277			],
278			)), function($container){
279			$container->getDefinition('jms_serializer.doctrine_object_constructor')->setPublic(true);
280			});
281
282			$this->assertTrue($container->getDefinition('jms_serializer.array_collection_handler')->getArgument(0));
283
284			// the logic is inverted because arg 0 on doctrine_proxy_subscriber is $skipVirtualTypeInit = false
285			$this->assertFalse($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(0));
286			$this->assertTrue($container->getDefinition('jms_serializer.doctrine_proxy_subscriber')->getArgument(1));
287
288			$this->assertEquals("exception", $container->getDefinition('jms_serializer.doctrine_object_constructor')->getArgument(2));
289			}
290
291			public function testLoadExistentMetadataDir()
292			{
293			$container = $this->getContainerForConfig(array(array(
294			'metadata' => [
295			'directories' => [
296			'foo' => [
297			'namespace_prefix' => 'foo_ns',
298			'path' => __DIR__,
299			]
300			]
301			]
302			)), function ($container){
303			$container->getDefinition('jms_serializer.metadata.file_locator')->setPublic(true);
304			});
305
306			$fileLocatorDef = $container->getDefinition('jms_serializer.metadata.file_locator');
307			$directories = $fileLocatorDef->getArgument(0);
308			$this->assertEquals(['foo_ns' => __DIR__], $directories);
309			}
310
311			/**
312			* @expectedException \JMS\Serializer\Exception\RuntimeException
313			* @expectedExceptionMessage The metadata directory "foo_dir" does not exist for the namespace "foo_ns"
314			*/
315			public function testLoadNotExistentMetadataDir()
316			{
317			$this->getContainerForConfig(array(array(
318			'metadata' => [
319			'directories' => [
320			'foo' => [
321			'namespace_prefix' => 'foo_ns',
322			'path' => 'foo_dir',
323			]
324			]
325			]
326			)));
327			}
328
329			/**
330			* @dataProvider getJsonVisitorConfigs
331			*/
332			public function testJsonVisitorOptions($expectedOptions, $config)
333			{
334			$container = $this->getContainerForConfig(array($config));
335			$this->assertSame($expectedOptions, $container->get('jms_serializer.json_serialization_visitor')->getOptions());
336			}
337
338			public function getJsonVisitorConfigs()
339			{
340			$configs = array();
341
342			if (version_compare(PHP_VERSION, '5.4', '>=')) {
343			$configs[] = array(JSON_UNESCAPED_UNICODE \| JSON_PRETTY_PRINT, array(
344			'visitors' => array(
345			'json' => array(
346			'options' => array('JSON_UNESCAPED_UNICODE', 'JSON_PRETTY_PRINT')
347			)
348			)
349			));
350
351			$configs[] = array(JSON_UNESCAPED_UNICODE, array(
352			'visitors' => array(
353			'json' => array(
354			'options' => 'JSON_UNESCAPED_UNICODE'
355			)
356			)
357			));
358			}
359
360			$configs[] = array(128, array(
361			'visitors' => array(
362			'json' => array(
363			'options' => 128
364			)
365			)
366			));
367
368			$configs[] = array(0, array());
369
370			return $configs;
371			}
372
373			public function testExpressionLanguage()
374			{
375			if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
376			$this->markTestSkipped("The Symfony Expression Language is not available");
377			}
378			$container = $this->getContainerForConfig(array(array()));
379			$serializer = $container->get('jms_serializer');
380			// test that all components have been wired correctly
381			$object = new ObjectUsingExpressionLanguage('foo', true);
382			$this->assertEquals('{"name":"foo"}', $serializer->serialize($object, 'json'));
383			$object = new ObjectUsingExpressionLanguage('foo', false);
384			$this->assertEquals('{}', $serializer->serialize($object, 'json'));
385			}
386
387			public function testExpressionLanguageVirtualProperties()
388			{
389			if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
390			$this->markTestSkipped("The Symfony Expression Language is not available");
391			}
392			$container = $this->getContainerForConfig(array(array()));
393			$serializer = $container->get('jms_serializer');
394			// test that all components have been wired correctly
395			$object = new ObjectUsingExpressionProperties('foo');
396			$this->assertEquals('{"v_prop_name":"foo"}', $serializer->serialize($object, 'json'));
397			}
398
399			/**
400			* @expectedException \JMS\Serializer\Exception\ExpressionLanguageRequiredException
401			*/
402			public function testExpressionLanguageDisabledVirtualProperties()
403			{
404			if (!interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
405			$this->markTestSkipped("The Symfony Expression Language is not available");
406			}
407			$container = $this->getContainerForConfig(array(array('expression_evaluator' => array('id' => null))));
408			$serializer = $container->get('jms_serializer');
409			// test that all components have been wired correctly
410			$object = new ObjectUsingExpressionProperties('foo');
411			$serializer->serialize($object, 'json');
412			}
413
414			/**
415			* @expectedException \JMS\Serializer\Exception\ExpressionLanguageRequiredException
416			* @expectedExceptionMessage To use conditional exclude/expose in JMS\SerializerBundle\Tests\DependencyInjection\Fixture\ObjectUsingExpressionLanguage you must configure the expression language.
417			*/
418			public function testExpressionLanguageNotLoaded()
419			{
420			$container = $this->getContainerForConfig(array(array('expression_evaluator' => array('id' => null))));
421			$serializer = $container->get('jms_serializer');
422			// test that all components have been wired correctly
423			$object = new ObjectUsingExpressionLanguage('foo', true);
424			$serializer->serialize($object, 'json');
425			}
426
427			/**
428			* @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
429			* @expectedExceptionMessage Invalid configuration for path "jms_serializer.expression_evaluator.id": You need at least symfony/expression language v2.6 or v3.0 to use the expression evaluator features
430			*/
431			public function testExpressionInvalidEvaluator()
432			{
433			if (interface_exists('Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface')) {
434			$this->markTestSkipped('To pass this test the "symfony/expression-language" component should be available');
435			}
436			$this->getContainerForConfig(array(array('expression_evaluator' => array('id' => 'foo'))));
437			}
438
439			/**
440			* @dataProvider getXmlVisitorWhitelists
441			*/
442			public function testXmlVisitorOptions($expectedOptions, $config)
443			{
444			$container = $this->getContainerForConfig(array($config));
445			$this->assertSame($expectedOptions, $container->get('jms_serializer.xml_deserialization_visitor')->getDoctypeWhitelist());
446			}
447
448			public function getXmlVisitorWhitelists()
449			{
450			$configs = array();
451
452			$configs[] = array(array('good document', 'other good document'), array(
453			'visitors' => array(
454			'xml' => array(
455			'doctype_whitelist' => array('good document', 'other good document'),
456			)
457			)
458			));
459
460			$configs[] = array(array(), array());
461
462			return $configs;
463			}
464
465			public function testXmlVisitorFormatOutput()
466			{
467			$config = array(
468			'visitors' => array(
469			'xml' => array(
470			'format_output' => false,
471			)
472			)
473			);
474			$container = $this->getContainerForConfig(array($config));
475
476			$this->assertFalse($container->get('jms_serializer.xml_serialization_visitor')->isFormatOutput());
477			}
478
479			public function testXmlVisitorDefaultValueToFormatOutput()
480			{
481			$container = $this->getContainerForConfig(array());
482			$this->assertTrue($container->get('jms_serializer.xml_serialization_visitor')->isFormatOutput());
483			}
484
485			private function getContainerForConfig(array $configs, callable $configurator = null)
486			{
487			$bundle = new JMSSerializerBundle();
488			$extension = $bundle->getContainerExtension();
489
490			$container = new ContainerBuilder();
491			$container->setParameter('kernel.debug', true);
492			$container->setParameter('kernel.cache_dir', sys_get_temp_dir() . '/serializer');
493			$container->setParameter('kernel.bundles', array());
494			$container->set('annotation_reader', new AnnotationReader());
495			$container->setDefinition('doctrine', new Definition(Registry::class));
496			$container->set('translator', $this->getMockBuilder('Symfony\\Component\\Translation\\TranslatorInterface')->getMock());
497			$container->set('debug.stopwatch', $this->getMockBuilder('Symfony\\Component\\Stopwatch\\Stopwatch')->getMock());
498			$container->registerExtension($extension);
499			$extension->load($configs, $container);
500
501			$bundle->build($container);
502
503			if ($configurator) {
504			call_user_func($configurator, $container);
505			}
506
507			$container->compile();
508
509			return $container;
510			}
511			}
512

schmittjoh / JMSSerializerBundle

Push — master ( a61272...cb5e47 )

DependencyInjection/JMSSerializerExtensionTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like