[Summary view] [Print] [Text view]

   1  <?php
   2  /*
   3   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14   *
  15   * This software consists of voluntary contributions made by many individuals
  16   * and is licensed under the MIT license.
  17   */
  18  
  19  namespace ProxyManagerTest\Factory;
  20  
  21  use PHPUnit_Framework_TestCase;
  22  use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
  23  use ReflectionMethod;
  24  
  25  /**
  26   * Tests for {@see \ProxyManager\Factory\AbstractBaseFactory}
  27   *
  28   * @author Marco Pivetta <ocramius@gmail.com>
  29   * @license MIT
  30   *
  31   * @covers \ProxyManager\Factory\AbstractBaseFactory
  32   * @group Coverage
  33   */
  34  class AbstractBaseFactoryTest extends PHPUnit_Framework_TestCase
  35  {
  36      /**
  37       * @var \ProxyManager\Factory\AbstractBaseFactory
  38       */
  39      private $factory;
  40  
  41      /**
  42       * @var \ProxyManager\ProxyGenerator\ProxyGeneratorInterface|\PHPUnit_Framework_MockObject_MockObject
  43       */
  44      private $generator;
  45  
  46      /**
  47       * @var \ProxyManager\Inflector\ClassNameInflectorInterface|\PHPUnit_Framework_MockObject_MockObject
  48       */
  49      private $classNameInflector;
  50  
  51      /**
  52       * @var \ProxyManager\GeneratorStrategy\GeneratorStrategyInterface|\PHPUnit_Framework_MockObject_MockObject
  53       */
  54      private $generatorStrategy;
  55  
  56      /**
  57       * @var \ProxyManager\Autoloader\AutoloaderInterface|\PHPUnit_Framework_MockObject_MockObject
  58       */
  59      private $proxyAutoloader;
  60  
  61      /**
  62       * @var \ProxyManager\Signature\SignatureCheckerInterface|\PHPUnit_Framework_MockObject_MockObject
  63       */
  64      private $signatureChecker;
  65  
  66      /**
  67       * @var \ProxyManager\Signature\ClassSignatureGeneratorInterface|\PHPUnit_Framework_MockObject_MockObject
  68       */
  69      private $classSignatureGenerator;
  70  
  71      /**
  72       * {@inheritDoc}
  73       */
  74      public function setUp()
  75      {
  76          $configuration                 = $this->getMock('ProxyManager\\Configuration');
  77          $this->generator               = $this->getMock('ProxyManager\\ProxyGenerator\\ProxyGeneratorInterface');
  78          $this->classNameInflector      = $this->getMock('ProxyManager\\Inflector\\ClassNameInflectorInterface');
  79          $this->generatorStrategy       = $this->getMock('ProxyManager\\GeneratorStrategy\\GeneratorStrategyInterface');
  80          $this->proxyAutoloader         = $this->getMock('ProxyManager\\Autoloader\\AutoloaderInterface');
  81          $this->signatureChecker        = $this->getMock('ProxyManager\\Signature\\SignatureCheckerInterface');
  82          $this->classSignatureGenerator = $this->getMock('ProxyManager\\Signature\\ClassSignatureGeneratorInterface');
  83  
  84          $configuration
  85              ->expects($this->any())
  86              ->method('getClassNameInflector')
  87              ->will($this->returnValue($this->classNameInflector));
  88  
  89          $configuration
  90              ->expects($this->any())
  91              ->method('getGeneratorStrategy')
  92              ->will($this->returnValue($this->generatorStrategy));
  93  
  94          $configuration
  95              ->expects($this->any())
  96              ->method('getProxyAutoloader')
  97              ->will($this->returnValue($this->proxyAutoloader));
  98  
  99          $configuration
 100              ->expects($this->any())
 101              ->method('getSignatureChecker')
 102              ->will($this->returnValue($this->signatureChecker));
 103  
 104          $configuration
 105              ->expects($this->any())
 106              ->method('getClassSignatureGenerator')
 107              ->will($this->returnValue($this->classSignatureGenerator));
 108  
 109          $this
 110              ->classNameInflector
 111              ->expects($this->any())
 112              ->method('getUserClassName')
 113              ->will($this->returnValue('stdClass'));
 114  
 115          $this->factory = $this->getMockForAbstractClass(
 116              'ProxyManager\\Factory\\AbstractBaseFactory',
 117              array($configuration)
 118          );
 119  
 120          $this->factory->expects($this->any())->method('getGenerator')->will($this->returnValue($this->generator));
 121      }
 122  
 123      public function testGeneratesClass()
 124      {
 125          $generateProxy = new ReflectionMethod($this->factory, 'generateProxy');
 126  
 127          $generateProxy->setAccessible(true);
 128          $generatedClass = UniqueIdentifierGenerator::getIdentifier('fooBar');
 129  
 130          $this
 131              ->classNameInflector
 132              ->expects($this->any())
 133              ->method('getProxyClassName')
 134              ->with('stdClass')
 135              ->will($this->returnValue($generatedClass));
 136  
 137          $this
 138              ->generatorStrategy
 139              ->expects($this->once())
 140              ->method('generate')
 141              ->with($this->isInstanceOf('Zend\\Code\\Generator\\ClassGenerator'));
 142          $this
 143              ->proxyAutoloader
 144              ->expects($this->once())
 145              ->method('__invoke')
 146              ->with($generatedClass)
 147              ->will($this->returnCallback(function ($className) {
 148                  eval('class ' . $className . ' {}');
 149              }));
 150  
 151          $this->signatureChecker->expects($this->atLeastOnce())->method('checkSignature');
 152          $this->classSignatureGenerator->expects($this->once())->method('addSignature')->will($this->returnArgument(0));
 153  
 154          $this->assertSame($generatedClass, $generateProxy->invoke($this->factory, 'stdClass'));
 155          $this->assertTrue(class_exists($generatedClass, false));
 156          $this->assertSame($generatedClass, $generateProxy->invoke($this->factory, 'stdClass'));
 157      }
 158  }