[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\Factory\AccessInterceptorValueHolderFactory;
  23  use ProxyManager\Generator\ClassGenerator;
  24  use ProxyManager\Generator\Util\UniqueIdentifierGenerator;
  25  use stdClass;
  26  
  27  /**
  28   * Tests for {@see \ProxyManager\Factory\AccessInterceptorValueHolderFactory}
  29   *
  30   * @author Marco Pivetta <ocramius@gmail.com>
  31   * @license MIT
  32   *
  33   * @group Coverage
  34   */
  35  class AccessInterceptorValueHolderFactoryTest extends PHPUnit_Framework_TestCase
  36  {
  37      /**
  38       * @var \PHPUnit_Framework_MockObject_MockObject
  39       */
  40      protected $inflector;
  41  
  42      /**
  43       * @var \PHPUnit_Framework_MockObject_MockObject
  44       */
  45      protected $signatureChecker;
  46  
  47      /**
  48       * @var \ProxyManager\Signature\ClassSignatureGeneratorInterface|\PHPUnit_Framework_MockObject_MockObject
  49       */
  50      private $classSignatureGenerator;
  51  
  52      /**
  53       * @var \ProxyManager\Configuration|\PHPUnit_Framework_MockObject_MockObject
  54       */
  55      protected $config;
  56  
  57      /**
  58       * {@inheritDoc}
  59       */
  60      public function setUp()
  61      {
  62          $this->config                  = $this->getMock('ProxyManager\\Configuration');
  63          $this->inflector               = $this->getMock('ProxyManager\\Inflector\\ClassNameInflectorInterface');
  64          $this->signatureChecker        = $this->getMock('ProxyManager\\Signature\\SignatureCheckerInterface');
  65          $this->classSignatureGenerator = $this->getMock('ProxyManager\\Signature\\ClassSignatureGeneratorInterface');
  66  
  67          $this
  68              ->config
  69              ->expects($this->any())
  70              ->method('getClassNameInflector')
  71              ->will($this->returnValue($this->inflector));
  72  
  73          $this
  74              ->config
  75              ->expects($this->any())
  76              ->method('getSignatureChecker')
  77              ->will($this->returnValue($this->signatureChecker));
  78  
  79          $this
  80              ->config
  81              ->expects($this->any())
  82              ->method('getClassSignatureGenerator')
  83              ->will($this->returnValue($this->classSignatureGenerator));
  84      }
  85  
  86      /**
  87       * {@inheritDoc}
  88       *
  89       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::__construct
  90       */
  91      public function testWithOptionalFactory()
  92      {
  93          $factory = new AccessInterceptorValueHolderFactory();
  94          $this->assertAttributeNotEmpty('configuration', $factory);
  95          $this->assertAttributeInstanceOf('ProxyManager\Configuration', 'configuration', $factory);
  96      }
  97  
  98      /**
  99       * {@inheritDoc}
 100       *
 101       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::__construct
 102       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::createProxy
 103       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::getGenerator
 104       */
 105      public function testWillSkipAutoGeneration()
 106      {
 107          $instance = new stdClass();
 108  
 109          $this
 110              ->inflector
 111              ->expects($this->once())
 112              ->method('getProxyClassName')
 113              ->with('stdClass')
 114              ->will($this->returnValue('ProxyManagerTestAsset\\AccessInterceptorValueHolderMock'));
 115  
 116          $factory     = new AccessInterceptorValueHolderFactory($this->config);
 117          /* @var $proxy \ProxyManagerTestAsset\AccessInterceptorValueHolderMock */
 118          $proxy       = $factory->createProxy($instance, array('foo'), array('bar'));
 119  
 120          $this->assertInstanceOf('ProxyManagerTestAsset\\AccessInterceptorValueHolderMock', $proxy);
 121          $this->assertSame($instance, $proxy->instance);
 122          $this->assertSame(array('foo'), $proxy->prefixInterceptors);
 123          $this->assertSame(array('bar'), $proxy->suffixInterceptors);
 124      }
 125  
 126      /**
 127       * {@inheritDoc}
 128       *
 129       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::__construct
 130       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::createProxy
 131       * @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::getGenerator
 132       *
 133       * NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
 134       */
 135      public function testWillTryAutoGeneration()
 136      {
 137          $instance       = new stdClass();
 138          $proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
 139          $generator      = $this->getMock('ProxyManager\GeneratorStrategy\\GeneratorStrategyInterface');
 140          $autoloader     = $this->getMock('ProxyManager\\Autoloader\\AutoloaderInterface');
 141  
 142          $this->config->expects($this->any())->method('getGeneratorStrategy')->will($this->returnValue($generator));
 143          $this->config->expects($this->any())->method('getProxyAutoloader')->will($this->returnValue($autoloader));
 144  
 145          $generator
 146              ->expects($this->once())
 147              ->method('generate')
 148              ->with(
 149                  $this->callback(
 150                      function (ClassGenerator $targetClass) use ($proxyClassName) {
 151                          return $targetClass->getName() === $proxyClassName;
 152                      }
 153                  )
 154              );
 155  
 156          // simulate autoloading
 157          $autoloader
 158              ->expects($this->once())
 159              ->method('__invoke')
 160              ->with($proxyClassName)
 161              ->will(
 162                  $this->returnCallback(
 163                      function () use ($proxyClassName) {
 164                          eval(
 165                              'class ' . $proxyClassName
 166                              . ' extends \\ProxyManagerTestAsset\\AccessInterceptorValueHolderMock {}'
 167                          );
 168                      }
 169                  )
 170              );
 171  
 172          $this
 173              ->inflector
 174              ->expects($this->once())
 175              ->method('getProxyClassName')
 176              ->with('stdClass')
 177              ->will($this->returnValue($proxyClassName));
 178  
 179          $this
 180              ->inflector
 181              ->expects($this->once())
 182              ->method('getUserClassName')
 183              ->with('stdClass')
 184              ->will($this->returnValue('ProxyManagerTestAsset\\LazyLoadingMock'));
 185  
 186          $this->signatureChecker->expects($this->atLeastOnce())->method('checkSignature');
 187          $this->classSignatureGenerator->expects($this->once())->method('addSignature')->will($this->returnArgument(0));
 188  
 189          $factory     = new AccessInterceptorValueHolderFactory($this->config);
 190          /* @var $proxy \ProxyManagerTestAsset\AccessInterceptorValueHolderMock */
 191          $proxy       = $factory->createProxy($instance, array('foo'), array('bar'));
 192  
 193          $this->assertInstanceOf($proxyClassName, $proxy);
 194          $this->assertSame($instance, $proxy->instance);
 195          $this->assertSame(array('foo'), $proxy->prefixInterceptors);
 196          $this->assertSame(array('bar'), $proxy->suffixInterceptors);
 197      }
 198  }