OwlCyberSecurity - MANAGER

Edit File: FormRegistryTest.php

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Form\Tests;

use Symfony\Component\Form\FormRegistry;
use Symfony\Component\Form\FormTypeGuesserChain;
use Symfony\Component\Form\Tests\Fixtures\TestExtension;
use Symfony\Component\Form\Tests\Fixtures\FooSubTypeWithParentInstance;
use Symfony\Component\Form\Tests\Fixtures\FooSubType;
use Symfony\Component\Form\Tests\Fixtures\FooTypeBazExtension;
use Symfony\Component\Form\Tests\Fixtures\FooTypeBarExtension;
use Symfony\Component\Form\Tests\Fixtures\FooType;

/**
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class FormRegistryTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var FormRegistry
     */
    private $registry;

/**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $resolvedTypeFactory;

/**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $guesser1;

/**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $guesser2;

/**
     * @var TestExtension
     */
    private $extension1;

/**
     * @var TestExtension
     */
    private $extension2;

protected function setUp()
    {
        $this->resolvedTypeFactory = $this->getMock('Symfony\Component\Form\ResolvedFormTypeFactory');
        $this->guesser1 = $this->getMock('Symfony\Component\Form\FormTypeGuesserInterface');
        $this->guesser2 = $this->getMock('Symfony\Component\Form\FormTypeGuesserInterface');
        $this->extension1 = new TestExtension($this->guesser1);
        $this->extension2 = new TestExtension($this->guesser2);
        $this->registry = new FormRegistry(array(
            $this->extension1,
            $this->extension2,
        ), $this->resolvedTypeFactory);
    }

public function testGetTypeFromExtension()
    {
        $type = new FooType();
        $resolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');

$this->extension2->addType($type);

$this->resolvedTypeFactory->expects($this->once())
            ->method('createResolvedType')
            ->with($type)
            ->will($this->returnValue($resolvedType));

$resolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo'));

$resolvedType = $this->registry->getType('foo');

$this->assertSame($resolvedType, $this->registry->getType('foo'));
    }

public function testGetTypeWithTypeExtensions()
    {
        $type = new FooType();
        $ext1 = new FooTypeBarExtension();
        $ext2 = new FooTypeBazExtension();
        $resolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');

$this->extension2->addType($type);
        $this->extension1->addTypeExtension($ext1);
        $this->extension2->addTypeExtension($ext2);

$this->resolvedTypeFactory->expects($this->once())
            ->method('createResolvedType')
            ->with($type, array($ext1, $ext2))
            ->will($this->returnValue($resolvedType));

$resolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo'));

$this->assertSame($resolvedType, $this->registry->getType('foo'));
    }

public function testGetTypeConnectsParent()
    {
        $parentType = new FooType();
        $type = new FooSubType();
        $parentResolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');
        $resolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');

$this->extension1->addType($parentType);
        $this->extension2->addType($type);

$this->resolvedTypeFactory->expects($this->at(0))
            ->method('createResolvedType')
            ->with($parentType)
            ->will($this->returnValue($parentResolvedType));

$this->resolvedTypeFactory->expects($this->at(1))
            ->method('createResolvedType')
            ->with($type, array(), $parentResolvedType)
            ->will($this->returnValue($resolvedType));

$parentResolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo'));

$resolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo_sub_type'));

$this->assertSame($resolvedType, $this->registry->getType('foo_sub_type'));
    }

public function testGetTypeConnectsParentIfGetParentReturnsInstance()
    {
        $type = new FooSubTypeWithParentInstance();
        $parentResolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');
        $resolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');

$this->extension1->addType($type);

$this->resolvedTypeFactory->expects($this->at(0))
            ->method('createResolvedType')
            ->with($this->isInstanceOf('Symfony\Component\Form\Tests\Fixtures\FooType'))
            ->will($this->returnValue($parentResolvedType));

$parentResolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo'));

$resolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo_sub_type_parent_instance'));

$this->assertSame($resolvedType, $this->registry->getType('foo_sub_type_parent_instance'));
    }

/**
     * @expectedException \Symfony\Component\Form\Exception\UnexpectedTypeException
     */
    public function testGetTypeThrowsExceptionIfParentNotFound()
    {
        $type = new FooSubType();

$this->extension1->addType($type);

$this->registry->getType($type);
    }

/**
     * @expectedException \Symfony\Component\Form\Exception\InvalidArgumentException
     */
    public function testGetTypeThrowsExceptionIfTypeNotFound()
    {
        $this->registry->getType('bar');
    }

/**
     * @expectedException \Symfony\Component\Form\Exception\UnexpectedTypeException
     */
    public function testGetTypeThrowsExceptionIfNoString()
    {
        $this->registry->getType(array());
    }

public function testHasTypeAfterLoadingFromExtension()
    {
        $type = new FooType();
        $resolvedType = $this->getMock('Symfony\Component\Form\ResolvedFormTypeInterface');

$this->resolvedTypeFactory->expects($this->once())
            ->method('createResolvedType')
            ->with($type)
            ->will($this->returnValue($resolvedType));

$resolvedType->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo'));

$this->assertFalse($this->registry->hasType('foo'));

$this->extension2->addType($type);

$this->assertTrue($this->registry->hasType('foo'));
    }

public function testGetTypeGuesser()
    {
        $expectedGuesser = new FormTypeGuesserChain(array($this->guesser1, $this->guesser2));

$this->assertEquals($expectedGuesser, $this->registry->getTypeGuesser());

$registry = new FormRegistry(
            array($this->getMock('Symfony\Component\Form\FormExtensionInterface')),
            $this->resolvedTypeFactory);

$this->assertNull($registry->getTypeGuesser());
    }

public function testGetExtensions()
    {
        $expectedExtensions = array($this->extension1, $this->extension2);

$this->assertEquals($expectedExtensions, $this->registry->getExtensions());
    }
}