Vendor update && Started using DoctrineMigrations

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Cache/FileCacheTest.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Metadata\Tests\Cache;
+
+use Metadata\ClassMetadata;
+
+use Metadata\Cache\FileCache;
+
+class FileCacheTest extends \PHPUnit_Framework_TestCase
+{
+    public function testLoadEvictPutClassMetadataFromInCache()
+    {
+        $cache = new FileCache(sys_get_temp_dir());
+
+        $this->assertNull($cache->loadClassMetadataFromCache($refl = new \ReflectionClass('Metadata\Tests\Fixtures\TestObject')));
+        $cache->putClassMetadataInCache($metadata = new ClassMetadata('Metadata\Tests\Fixtures\TestObject'));
+
+        $this->assertEquals($metadata, $cache->loadClassMetadataFromCache($refl));
+
+        $cache->evictClassMetadataFromCache($refl);
+        $this->assertNull($cache->loadClassMetadataFromCache($refl));
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/ClassMetadataTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Metadata\Tests;
+
+use Metadata\ClassMetadata;
+
+class ClassMetadataTest extends \PHPUnit_Framework_TestCase
+{
+    public function testConstructor()
+    {
+        $metadata = new ClassMetadata('Metadata\Tests\Fixtures\TestObject');
+
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $metadata->name);
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $metadata->reflection->getName());
+    }
+
+    public function testSerializeUnserialize()
+    {
+        $metadata = new ClassMetadata('Metadata\Tests\Fixtures\TestObject');
+
+        $this->assertEquals($metadata, unserialize(serialize($metadata)));
+    }
+
+    public function testIsFresh()
+    {
+        $ref = new \ReflectionClass('Metadata\Tests\Fixtures\TestObject');
+        touch($ref->getFilename());
+        sleep(2);
+
+        $metadata = new ClassMetadata($ref->getName());
+        $metadata->fileResources[] = $ref->getFilename();
+        $this->assertTrue($metadata->isFresh());
+
+        sleep(2);
+        clearstatcache($ref->getFilename());
+        touch($ref->getFilename());
+        $this->assertFalse($metadata->isFresh());
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Driver/DriverChainTest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Metadata\Tests\Driver;
+
+use Metadata\ClassMetadata;
+use Metadata\Driver\DriverChain;
+
+class DriverChainTest extends \PHPUnit_Framework_TestCase
+{
+    public function testLoadMetadataForClass()
+    {
+        $driver = $this->getMock('Metadata\\Driver\\DriverInterface');
+        $driver
+            ->expects($this->once())
+            ->method('loadMetadataForClass')
+            ->will($this->returnValue($metadata = new ClassMetadata('\stdClass')))
+        ;
+        $chain = new DriverChain(array($driver));
+
+        $this->assertSame($metadata, $chain->loadMetadataForClass(new \ReflectionClass('\stdClass')));
+    }
+
+    public function testLoadMetadataForClassReturnsNullWhenNoMetadataIsFound()
+    {
+        $driver = new DriverChain(array());
+        $this->assertNull($driver->loadMetadataForClass(new \ReflectionClass('\stdClass')));
+
+        $driver = $this->getMock('Metadata\\Driver\\DriverInterface');
+        $driver
+            ->expects($this->once())
+            ->method('loadMetadataForClass')
+            ->will($this->returnValue(null))
+        ;
+        $driverChain = new DriverChain(array($driver));
+        $this->assertNull($driver->loadMetadataForClass(new \ReflectionClass('\stdClass')));
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Driver/FileLocatorTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Metadata\Tests\Driver;
+
+use Metadata\Driver\FileLocator;
+
+class FileLocatorTest extends \PHPUnit_Framework_TestCase
+{
+    public function testFindFileForClass()
+    {
+        $locator = new FileLocator(array(
+            'Metadata\Tests\Driver\Fixture\A' => __DIR__.'/Fixture/A',
+            'Metadata\Tests\Driver\Fixture\B' => __DIR__.'/Fixture/B',
+            'Metadata\Tests\Driver\Fixture\C' => __DIR__.'/Fixture/C',
+        ));
+
+        $ref = new \ReflectionClass('Metadata\Tests\Driver\Fixture\A\A');
+        $this->assertEquals(realpath(__DIR__.'/Fixture/A/A.xml'), realpath($locator->findFileForClass($ref, 'xml')));
+
+        $ref = new \ReflectionClass('Metadata\Tests\Driver\Fixture\B\B');
+        $this->assertNull($locator->findFileForClass($ref, 'xml'));
+
+        $ref = new \ReflectionClass('Metadata\Tests\Driver\Fixture\C\SubDir\C');
+        $this->assertEquals(realpath(__DIR__.'/Fixture/C/SubDir.C.yml'), realpath($locator->findFileForClass($ref, 'yml')));
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Driver/Fixture/A/A.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Metadata\Tests\Driver\Fixture\A;
+
+class A {}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Driver/Fixture/B/B.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Metadata\Tests\Driver\Fixture\B;
+
+class B { }

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Driver/Fixture/C/SubDir/C.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace Metadata\Tests\Driver\Fixture\C\SubDir;
+
+class C { }

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/ComplexHierarchy/BaseClass.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Metadata\Tests\Fixtures\ComplexHierarchy;
+
+abstract class BaseClass implements InterfaceA
+{
+    private $foo;
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/ComplexHierarchy/InterfaceA.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Metadata\Tests\Fixtures\ComplexHierarchy;
+
+interface InterfaceA
+{
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/ComplexHierarchy/InterfaceB.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Metadata\Tests\Fixtures\ComplexHierarchy;
+
+interface InterfaceB
+{
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/ComplexHierarchy/SubClassA.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Metadata\Tests\Fixtures\ComplexHierarchy;
+
+class SubClassA extends BaseClass implements InterfaceA, InterfaceB
+{
+    private $bar;
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/ComplexHierarchy/SubClassB.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Metadata\Tests\Fixtures\ComplexHierarchy;
+
+class SubClassB extends BaseClass
+{
+    private $baz;
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/TestObject.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Metadata\Tests\Fixtures;
+
+class TestObject
+{
+    private $foo;
+
+    public function getFoo()
+    {
+        return $this->foo;
+    }
+
+    private function setFoo($foo)
+    {
+        $this->foo = $foo;
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/Fixtures/TestParent.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Metadata\Tests\Fixtures;
+
+class TestParent extends TestObject
+{
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/MergeableClassMetadataTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Metadata\Tests;
+
+use Metadata\MergeableClassMetadata;
+use Metadata\ClassMetadata;
+
+class MergeableClassMetadataTest extends \PHPUnit_Framework_TestCase
+{
+    public function testMerge()
+    {
+        $parentMetadata = new MergeableClassMetadata('Metadata\Tests\Fixtures\TestParent');
+        $parentMetadata->propertyMetadata['foo'] = 'bar';
+        $parentMetadata->propertyMetadata['baz'] = 'baz';
+        $parentMetadata->methodMetadata['foo'] = 'bar';
+        $parentMetadata->createdAt = 2;
+        $parentMetadata->fileResources[] = 'foo';
+
+        $childMetadata = new MergeableClassMetadata('Metadata\Tests\Fixtures\TestObject');
+        $childMetadata->propertyMetadata['foo'] = 'baz';
+        $childMetadata->methodMetadata['foo'] = 'baz';
+        $childMetadata->createdAt = 1;
+        $childMetadata->fileResources[] = 'bar';
+
+        $parentMetadata->merge($childMetadata);
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $parentMetadata->name);
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $parentMetadata->reflection->getName());
+        $this->assertEquals(array('foo' => 'baz', 'baz' => 'baz',), $parentMetadata->propertyMetadata);
+        $this->assertEquals(array('foo' => 'baz',), $parentMetadata->methodMetadata);
+        $this->assertEquals(1, $parentMetadata->createdAt);
+        $this->assertEquals(array('foo', 'bar'), $parentMetadata->fileResources);
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/MetadataFactoryTest.php

@@ -0,0 +1,184 @@
+<?php
+
+namespace Metadata\Tests;
+
+use Metadata\PropertyMetadata;
+
+use Metadata\MergeableClassMetadata;
+
+use Metadata\ClassMetadata;
+use Metadata\MetadataFactory;
+
+class MetadataFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testGetMetadataForClass()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+
+        $driver
+            ->expects($this->at(0))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\TestObject')))
+            ->will($this->returnCallback(function($class) {
+                return new ClassMetadata($class->getName());
+            }))
+        ;
+        $driver
+            ->expects($this->at(1))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\TestParent')))
+            ->will($this->returnCallback(function($class) {
+                return new ClassMetadata($class->getName());
+            }))
+        ;
+
+        $factory = new MetadataFactory($driver);
+        $metadata = $factory->getMetadataForClass('Metadata\Tests\Fixtures\TestParent');
+
+        $this->assertInstanceOf('Metadata\ClassHierarchyMetadata', $metadata);
+        $this->assertEquals(2, count($metadata->classMetadata));
+    }
+
+    public function testGetMetadataForClassWhenMergeable()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+
+        $driver
+            ->expects($this->at(0))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\TestObject')))
+            ->will($this->returnCallback(function($class) {
+                return new MergeableClassMetadata($class->getName());
+            }))
+        ;
+        $driver
+            ->expects($this->at(1))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\TestParent')))
+            ->will($this->returnCallback(function($class) {
+                return new MergeableClassMetadata($class->getName());
+            }))
+        ;
+
+        $factory = new MetadataFactory($driver);
+        $metadata = $factory->getMetadataForClass('Metadata\Tests\Fixtures\TestParent');
+
+        $this->assertInstanceOf('Metadata\MergeableClassMetadata', $metadata);
+        $this->assertEquals('Metadata\Tests\Fixtures\TestParent', $metadata->name);
+    }
+
+    public function testGetMetadataWithComplexHierarchy()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+
+        $driver
+            ->expects($this->any())
+            ->method('loadMetadataForClass')
+            ->will($this->returnCallback(function($class) {
+                $metadata = new MergeableClassMetadata($class->name);
+
+                switch ($class->name) {
+                    case 'Metadata\Tests\Fixtures\ComplexHierarchy\BaseClass':
+                        $metadata->propertyMetadata['foo'] = new PropertyMetadata($class->name, 'foo');
+                        break;
+
+                    case 'Metadata\Tests\Fixtures\ComplexHierarchy\SubClassA':
+                        $metadata->propertyMetadata['bar'] = new PropertyMetadata($class->name, 'bar');
+                        break;
+
+                    case 'Metadata\Tests\Fixtures\ComplexHierarchy\SubClassB':
+                        $metadata->propertyMetadata['baz'] = new PropertyMetadata($class->name, 'baz');
+                        break;
+
+                    default:
+                        throw new \RuntimeException(sprintf('Unsupported class "%s".', $class->name));
+                }
+
+                return $metadata;
+            }))
+        ;
+
+        $factory = new MetadataFactory($driver);
+
+        $subClassA = $factory->getMetadataForClass('Metadata\Tests\Fixtures\ComplexHierarchy\SubClassA');
+        $this->assertInstanceOf('Metadata\MergeableClassMetadata', $subClassA);
+        $this->assertEquals(array('foo', 'bar'), array_keys($subClassA->propertyMetadata));
+
+        $subClassB = $factory->getMetadataForClass('Metadata\Tests\Fixtures\ComplexHierarchy\SubClassB');
+        $this->assertInstanceOf('Metadata\MergeableClassMetadata', $subClassB);
+        $this->assertEquals(array('foo', 'baz'), array_keys($subClassB->propertyMetadata));
+    }
+
+    public function testGetMetadataWithCache()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+        $driver
+            ->expects($this->once())
+            ->method('loadMetadataForClass')
+            ->will($this->returnValue($metadata = new ClassMetadata('Metadata\Tests\Fixtures\TestObject')))
+        ;
+
+        $factory = new MetadataFactory($driver);
+
+        $cache = $this->getMock('Metadata\Cache\CacheInterface');
+        $cache
+            ->expects($this->once())
+            ->method('loadClassMetadataFromCache')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\TestObject')))
+            ->will($this->returnValue(null))
+        ;
+        $cache
+            ->expects($this->once())
+            ->method('putClassMetadataInCache')
+            ->with($this->equalTo($metadata))
+        ;
+        $factory->setCache($cache);
+
+        $this->assertSame($metadata, reset($factory->getMetadataForClass('Metadata\Tests\Fixtures\TestObject')->classMetadata));
+    }
+
+    public function testGetMetadataReturnsNullIfNoMetadataIsFound()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+        $driver
+            ->expects($this->once())
+            ->method('loadMetadataForClass')
+            ->will($this->returnValue(null))
+        ;
+
+        $factory = new MetadataFactory($driver);
+
+        $this->assertNull($factory->getMetadataForClass('stdClass'));
+    }
+
+    public function testGetMetadataWithInterfaces()
+    {
+        $driver = $this->getMock('Metadata\Driver\DriverInterface');
+
+        $driver
+            ->expects($this->at(3))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\ComplexHierarchy\SubClassA')))
+        ;
+        $driver
+            ->expects($this->at(2))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\ComplexHierarchy\InterfaceB')))
+        ;
+        $driver
+            ->expects($this->at(1))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\ComplexHierarchy\BaseClass')))
+        ;
+        $driver
+            ->expects($this->at(0))
+            ->method('loadMetadataForClass')
+            ->with($this->equalTo(new \ReflectionClass('Metadata\Tests\Fixtures\ComplexHierarchy\InterfaceA')))
+        ;
+
+        $factory = new MetadataFactory($driver);
+        $factory->setIncludeInterfaces(true);
+
+        $factory->getMetadataForClass('Metadata\Tests\Fixtures\ComplexHierarchy\SubClassA');
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/MethodMetadataTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Metadata\Tests;
+
+use Metadata\Tests\Fixtures\TestObject;
+
+use Metadata\MethodMetadata;
+
+class MethodMetadataTest extends \PHPUnit_Framework_TestCase
+{
+    public function testConstructor()
+    {
+        $metadata = new MethodMetadata('Metadata\Tests\Fixtures\TestObject', 'setFoo');
+
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $metadata->class);
+        $this->assertEquals('setFoo', $metadata->name);
+        $this->assertEquals(new \ReflectionMethod('Metadata\Tests\Fixtures\TestObject', 'setFoo'), $metadata->reflection);
+    }
+
+    public function testSerializeUnserialize()
+    {
+        $metadata = new MethodMetadata('Metadata\Tests\Fixtures\TestObject', 'setFoo');
+
+        $this->assertEquals($metadata, unserialize(serialize($metadata)));
+    }
+
+    public function testInvoke()
+    {
+        $obj = new TestObject();
+        $metadata = new MethodMetadata('Metadata\Tests\Fixtures\TestObject', 'setFoo');
+
+        $this->assertNull($obj->getFoo());
+        $metadata->invoke($obj, array('foo'));
+        $this->assertEquals('foo', $obj->getFoo());
+    }
+}

vendor/jms/metadata/schmittjoh-metadata-84088bc/tests/Metadata/Tests/PropertyMetadataTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Metadata\Tests;
+
+use Metadata\Tests\Fixtures\TestObject;
+
+use Metadata\PropertyMetadata;
+
+class PropertyMetadataTest extends \PHPUnit_Framework_TestCase
+{
+    public function testConstructor()
+    {
+        $metadata = new PropertyMetadata('Metadata\Tests\Fixtures\TestObject', 'foo');
+
+        $this->assertEquals('Metadata\Tests\Fixtures\TestObject', $metadata->class);
+        $this->assertEquals('foo', $metadata->name);
+        $this->assertEquals(new \ReflectionProperty('Metadata\Tests\Fixtures\TestObject', 'foo'), $metadata->reflection);
+    }
+
+    public function testSerializeUnserialize()
+    {
+        $metadata = new PropertyMetadata('Metadata\Tests\Fixtures\TestObject', 'foo');
+
+        $this->assertEquals($metadata, unserialize(serialize($metadata)));
+    }
+
+    public function testSetGetValue()
+    {
+        $obj = new TestObject();
+        $metadata = new PropertyMetadata('Metadata\Tests\Fixtures\TestObject', 'foo');
+
+        $this->assertNull($metadata->getValue($obj));
+        $metadata->setValue($obj, 'foo');
+        $this->assertEquals('foo', $metadata->getValue($obj));
+    }
+}