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