www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/validator/Tests/Mapping/Factory/LazyLoadingMetadataFactoryTest.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\Validator\Tests\Mapping\Factory;
  13
  14 use PHPUnit\Framework\TestCase;
  15 use Symfony\Component\Validator\Constraints\Callback;
  16 use Symfony\Component\Validator\Mapping\ClassMetadata;
  17 use Symfony\Component\Validator\Mapping\Factory\LazyLoadingMetadataFactory;
  18 use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
  19 use Symfony\Component\Validator\Tests\Fixtures\ConstraintA;
  20
  21 class LazyLoadingMetadataFactoryTest extends TestCase
  22 {
  23     const CLASS_NAME = 'Symfony\Component\Validator\Tests\Fixtures\Entity';
  24     const PARENT_CLASS = 'Symfony\Component\Validator\Tests\Fixtures\EntityParent';
  25     const INTERFACE_A_CLASS = 'Symfony\Component\Validator\Tests\Fixtures\EntityInterfaceA';
  26     const INTERFACE_B_CLASS = 'Symfony\Component\Validator\Tests\Fixtures\EntityInterfaceB';
  27     const PARENT_INTERFACE_CLASS = 'Symfony\Component\Validator\Tests\Fixtures\EntityParentInterface';
  28
  29     public function testLoadClassMetadataWithInterface()
  30     {
  31         $factory = new LazyLoadingMetadataFactory(new TestLoader());
  32         $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
  33
  34         $constraints = array(
  35             new ConstraintA(array('groups' => array('Default', 'EntityParent'))),
  36             new ConstraintA(array('groups' => array('Default', 'EntityInterfaceA', 'EntityParent'))),
  37         );
  38
  39         $this->assertEquals($constraints, $metadata->getConstraints());
  40     }
  41
  42     public function testMergeParentConstraints()
  43     {
  44         $factory = new LazyLoadingMetadataFactory(new TestLoader());
  45         $metadata = $factory->getMetadataFor(self::CLASS_NAME);
  46
  47         $constraints = array(
  48             new ConstraintA(array('groups' => array(
  49                 'Default',
  50                 'Entity',
  51             ))),
  52             new ConstraintA(array('groups' => array(
  53                 'Default',
  54                 'EntityParent',
  55                 'Entity',
  56             ))),
  57             new ConstraintA(array('groups' => array(
  58                 'Default',
  59                 'EntityInterfaceA',
  60                 'EntityParent',
  61                 'Entity',
  62             ))),
  63             new ConstraintA(array('groups' => array(
  64                 'Default',
  65                 'EntityInterfaceB',
  66                 'Entity',
  67             ))),
  68             new ConstraintA(array('groups' => array(
  69                 'Default',
  70                 'EntityParentInterface',
  71                 'EntityInterfaceB',
  72                 'Entity',
  73             ))),
  74         );
  75
  76         $this->assertEquals($constraints, $metadata->getConstraints());
  77     }
  78
  79     public function testWriteMetadataToCache()
  80     {
  81         $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
  82         $factory = new LazyLoadingMetadataFactory(new TestLoader(), $cache);
  83
  84         $parentClassConstraints = array(
  85             new ConstraintA(array('groups' => array('Default', 'EntityParent'))),
  86             new ConstraintA(array('groups' => array('Default', 'EntityInterfaceA', 'EntityParent'))),
  87         );
  88         $interfaceAConstraints = array(
  89             new ConstraintA(array('groups' => array('Default', 'EntityInterfaceA'))),
  90         );
  91
  92         $cache->expects($this->never())
  93               ->method('has');
  94         $cache->expects($this->exactly(2))
  95               ->method('read')
  96               ->withConsecutive(
  97                   array($this->equalTo(self::PARENT_CLASS)),
  98                   array($this->equalTo(self::INTERFACE_A_CLASS))
  99               )
 100               ->will($this->returnValue(false));
 101         $cache->expects($this->exactly(2))
 102               ->method('write')
 103               ->withConsecutive(
 104                   $this->callback(function ($metadata) use ($interfaceAConstraints) {
 105                       return $interfaceAConstraints == $metadata->getConstraints();
 106                   }),
 107                   $this->callback(function ($metadata) use ($parentClassConstraints) {
 108                       return $parentClassConstraints == $metadata->getConstraints();
 109                   })
 110               );
 111
 112         $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
 113
 114         $this->assertEquals(self::PARENT_CLASS, $metadata->getClassName());
 115         $this->assertEquals($parentClassConstraints, $metadata->getConstraints());
 116     }
 117
 118     public function testReadMetadataFromCache()
 119     {
 120         $loader = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Loader\LoaderInterface')->getMock();
 121         $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
 122         $factory = new LazyLoadingMetadataFactory($loader, $cache);
 123
 124         $metadata = new ClassMetadata(self::PARENT_CLASS);
 125         $metadata->addConstraint(new ConstraintA());
 126
 127         $parentClass = self::PARENT_CLASS;
 128         $interfaceClass = self::INTERFACE_A_CLASS;
 129
 130         $loader->expects($this->never())
 131                ->method('loadClassMetadata');
 132
 133         $cache->expects($this->never())
 134               ->method('has');
 135         $cache->expects($this->exactly(2))
 136               ->method('read')
 137               ->withConsecutive(
 138                   array(self::PARENT_CLASS),
 139                   array(self::INTERFACE_A_CLASS)
 140               )
 141               ->willReturnCallback(function ($name) use ($metadata, $parentClass, $interfaceClass) {
 142                   if ($parentClass == $name) {
 143                       return $metadata;
 144                   }
 145
 146                   return new ClassMetadata($interfaceClass);
 147               });
 148
 149         $this->assertEquals($metadata, $factory->getMetadataFor(self::PARENT_CLASS));
 150     }
 151
 152     public function testMetadataCacheWithRuntimeConstraint()
 153     {
 154         $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
 155         $factory = new LazyLoadingMetadataFactory(new TestLoader(), $cache);
 156
 157         $cache
 158             ->expects($this->any())
 159             ->method('write')
 160             ->will($this->returnCallback(function ($metadata) { serialize($metadata); }))
 161         ;
 162
 163         $cache->expects($this->any())
 164             ->method('read')
 165             ->will($this->returnValue(false));
 166
 167         $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
 168         $metadata->addConstraint(new Callback(function () {}));
 169
 170         $this->assertCount(3, $metadata->getConstraints());
 171
 172         $metadata = $factory->getMetadataFor(self::CLASS_NAME);
 173
 174         $this->assertCount(6, $metadata->getConstraints());
 175     }
 176
 177     public function testGroupsFromParent()
 178     {
 179         $reader = new \Symfony\Component\Validator\Mapping\Loader\StaticMethodLoader();
 180         $factory = new LazyLoadingMetadataFactory($reader);
 181         $metadata = $factory->getMetadataFor('Symfony\Component\Validator\Tests\Fixtures\EntityStaticCarTurbo');
 182         $groups = array();
 183
 184         foreach ($metadata->getPropertyMetadata('wheels') as $propertyMetadata) {
 185             $constraints = $propertyMetadata->getConstraints();
 186             $groups = array_replace($groups, $constraints[0]->groups);
 187         }
 188
 189         $this->assertCount(4, $groups);
 190         $this->assertContains('Default', $groups);
 191         $this->assertContains('EntityStaticCarTurbo', $groups);
 192         $this->assertContains('EntityStaticCar', $groups);
 193         $this->assertContains('EntityStaticVehicle', $groups);
 194     }
 195 }
 196
 197 class TestLoader implements LoaderInterface
 198 {
 199     public function loadClassMetadata(ClassMetadata $metadata)
 200     {
 201         $metadata->addConstraint(new ConstraintA());
 202     }
 203 }