/**
* Constructor
*
* @param PropertyGenerator $initializerProperty
* @param PropertyGenerator $initTracker
* @param Properties $properties
*/
public function __construct(PropertyGenerator $initializerProperty, PropertyGenerator $initTracker, Properties $properties)
{
$docblock = <<<'DOCBLOCK'
Triggers initialization logic for this ghost object
@param string $methodName
@param mixed[] $parameters
@return mixed
DOCBLOCK;
parent::__construct(UniqueIdentifierGenerator::getIdentifier('callInitializer'), [new ParameterGenerator('methodName'), new ParameterGenerator('parameters', 'array')], static::VISIBILITY_PRIVATE, null, $docblock);
$initializer = $initializerProperty->getName();
$initialization = $initTracker->getName();
$bodyTemplate = <<<'PHP'
if ($this->%s || ! $this->%s) {
return;
}
$this->%s = true;
%s
%s
$result = $this->%s->__invoke($this, $methodName, $parameters, $this->%s, $properties);
$this->%s = false;
return $result;
PHP;
$this->setBody(sprintf($bodyTemplate, $initialization, $initializer, $initialization, $this->propertiesInitializationCode($properties), $this->propertiesReferenceArrayCode($properties), $initializer, $initializer, $initialization));
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('initializationTracker'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocblock('@var bool tracks initialization status - true while the object is initializing');
$this->setDefaultValue(false);
}
/**
* @dataProvider getTestedImplementations
*
* Verifies that generated code is valid and implements expected interfaces
*/
public function testGeneratesValidCode($className)
{
$generator = $this->getProxyGenerator();
$generatedClassName = UniqueIdentifierGenerator::getIdentifier('AbstractProxyGeneratorTest');
$generatedClass = new ClassGenerator($generatedClassName);
$originalClass = new ReflectionClass($className);
$generatorStrategy = new EvaluatingGeneratorStrategy();
$generator->generate($originalClass, $generatedClass);
$generatorStrategy->generate($generatedClass);
$generatedReflection = new ReflectionClass($generatedClassName);
if ($originalClass->isInterface()) {
$this->assertTrue($generatedReflection->implementsInterface($className));
} else {
$this->assertEmpty(array_diff($originalClass->getInterfaceNames(), $generatedReflection->getInterfaceNames()));
}
$this->assertSame($generatedClassName, $generatedReflection->getName());
foreach ($this->getExpectedImplementedInterfaces() as $interface) {
$this->assertTrue($generatedReflection->implementsInterface($interface));
}
$proxyGenerated = new $generatedClassName();
foreach ($generatedReflection->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
$this->assertNull($proxyGenerated->{$property});
}
/** @var \ReflectionMethod $method */
foreach ($generatedReflection->getMethods(ReflectionProperty::IS_PUBLIC) as $method) {
if ($method->getNumberOfParameters() == 0) {
$this->assertNull(call_user_func(array($proxyGenerated, $method->getName())));
}
}
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\Configuration\PropertyGenerator\ParameterValuesProperty}.
*
* @throws InvalidArgumentException
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('parameterValues'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDefaultValue([]);
$this->setDocBlock('@var array Collection of scalar values which can be injected into beans');
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\Configuration\MethodGenerator\GetParameter}.
*
* @param ReflectionClass $originalClass
* @param ParameterValuesProperty $parameterValueProperty
* @throws InvalidArgumentException
*/
public function __construct(ReflectionClass $originalClass, ParameterValuesProperty $parameterValueProperty)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('getParameter'));
$propertyNameParameter = new ParameterGenerator('propertyName');
$requiredParameter = new ParameterGenerator('required');
$requiredParameter->setDefaultValue(true);
$defaultValueParameter = new ParameterGenerator('defaultValue');
$defaultValueParameter->setDefaultValue(null);
$body = '$steps = explode(\'.\', $' . $propertyNameParameter->getName() . ');' . PHP_EOL;
$body .= '$value = $this->' . $parameterValueProperty->getName() . ';' . PHP_EOL;
$body .= '$currentPath = [];' . PHP_EOL;
$body .= 'foreach ($steps as $step) {' . PHP_EOL;
$body .= ' $currentPath[] = $step;' . PHP_EOL;
$body .= ' if (isset($value[$step])) {' . PHP_EOL;
$body .= ' $value = $value[$step];' . PHP_EOL;
$body .= ' } else {' . PHP_EOL;
$body .= ' $value = $' . $defaultValueParameter->getName() . ';' . PHP_EOL;
$body .= ' break;' . PHP_EOL;
$body .= ' }' . PHP_EOL;
$body .= '}' . PHP_EOL . PHP_EOL;
$body .= 'if ($' . $requiredParameter->getName() . ' && (null === $value)) {' . PHP_EOL;
$body .= ' if (null === $' . $defaultValueParameter->getName() . ') {' . PHP_EOL;
$body .= ' throw new \\RuntimeException(\'Parameter "\' .$' . $propertyNameParameter->getName() . '. \'" is required but not defined and no default value provided!\');' . PHP_EOL;
$body .= ' }' . PHP_EOL;
$body .= ' throw new \\RuntimeException(\'Parameter "\' .$' . $propertyNameParameter->getName() . '. \'" not defined!\');' . PHP_EOL;
$body .= '}' . PHP_EOL . PHP_EOL;
$body .= 'return $value;' . PHP_EOL;
$this->setParameter($propertyNameParameter);
$this->setParameter($requiredParameter);
$this->setParameter($defaultValueParameter);
$this->setVisibility(self::VISIBILITY_PROTECTED);
$this->setBody($body);
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\Configuration\PropertyGenerator\BeanPostProcessorsProperty}.
*
* @throws InvalidArgumentException
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('postProcessors'));
$this->setDefaultValue([]);
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocBlock('@var ' . \bitExpert\Disco\BeanFactoryPostProcessor::class . '[]');
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('methodPrefixInterceptors'));
$this->setDefaultValue(array());
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocblock('@var \\Closure[] map of interceptors to be called per-method before execution');
}
/**
* Constructor
*
* @param Properties $properties
*/
public function __construct(Properties $properties)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('protectedProperties'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setStatic(true);
$this->setDocblock('@var string[][] declaring class name of defined protected properties, indexed by property name');
$this->setDefaultValue($this->getMap($properties));
}
/**
* @covers \ProxyManager\GeneratorStrategy\BaseGeneratorStrategy::generate
*/
public function testGenerate()
{
$strategy = new BaseGeneratorStrategy();
$className = UniqueIdentifierGenerator::getIdentifier('Foo');
$classGenerator = new ClassGenerator($className);
$generated = $strategy->generate($classGenerator);
$this->assertGreaterThan(0, strpos($generated, $className));
}
/**
* Constructor
*
* @param Properties $properties
*/
public function __construct(Properties $properties)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('privateProperties'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setStatic(true);
$this->setDocBlock('@var array[][] visibility and default value of defined properties, indexed by property name and class name');
$this->setDefaultValue($this->getMap($properties));
}
/**
* @covers \ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy::generate
* @covers \ProxyManager\GeneratorStrategy\EvaluatingGeneratorStrategy::__construct
*/
public function testGenerate()
{
$strategy = new EvaluatingGeneratorStrategy();
$className = UniqueIdentifierGenerator::getIdentifier('Foo');
$classGenerator = new ClassGenerator($className);
$generated = $strategy->generate($classGenerator);
$this->assertGreaterThan(0, strpos($generated, $className));
$this->assertTrue(class_exists($className, false));
}
/**
* Constructor
*/
public function __construct(PropertyGenerator $initializerProperty, PropertyGenerator $publicPropertiesDefaults, PropertyGenerator $initializationTracker)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('callInitializer'));
$this->setDocblock("Triggers initialization logic for this ghost object");
$this->setParameters(array(new ParameterGenerator('methodName'), new ParameterGenerator('parameters', 'array')));
$this->setVisibility(static::VISIBILITY_PRIVATE);
$initializer = $initializerProperty->getName();
$initialization = $initializationTracker->getName();
$this->setBody('if ($this->' . $initialization . ' || ! $this->' . $initializer . ') {' . "\n return;\n}\n\n" . "\$this->" . $initialization . " = true;\n\n" . "foreach (self::\$" . $publicPropertiesDefaults->getName() . " as \$key => \$default) {\n" . " \$this->\$key = \$default;\n" . "}\n\n" . '$this->' . $initializer . '->__invoke' . '($this, $methodName, $parameters, $this->' . $initializer . ');' . "\n\n" . "\$this->" . $initialization . " = false;");
}
/**
* @param \ReflectionClass $originalClass
*/
public function __construct(ReflectionClass $originalClass)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('publicProperties'));
foreach ($originalClass->getProperties(ReflectionProperty::IS_PUBLIC) as $publicProperty) {
$this->publicProperties[$publicProperty->getName()] = true;
}
$this->setDefaultValue($this->publicProperties);
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setStatic(true);
$this->setDocblock('@var bool[] map of public properties of the parent class');
}
/**
* @param \Zend\Code\Reflection\MethodReflection $originalMethod
*
* @return self|static
*/
public static function generateMethod(MethodReflection $originalMethod) : self
{
/* @var $method self */
$method = static::fromReflection($originalMethod);
if ($originalMethod->returnsReference()) {
$reference = UniqueIdentifierGenerator::getIdentifier('ref');
$method->setBody("\${$reference} = null;\nreturn \${$reference};");
} else {
$method->setBody('');
}
return $method;
}
/**
* @covers \ProxyManager\Autoloader\Autoloader::__invoke
*/
public function testWillAutoloadExistingFile()
{
$namespace = 'Foo';
$className = UniqueIdentifierGenerator::getIdentifier('Bar');
$fqcn = $namespace . '\\' . $className;
$fileName = sys_get_temp_dir() . '/foo_' . uniqid() . '.php';
file_put_contents($fileName, '<?php namespace ' . $namespace . '; class ' . $className . '{}');
$this->classNameInflector->expects($this->once())->method('isProxyClassName')->with($fqcn)->will($this->returnValue(true));
$this->fileLocator->expects($this->once())->method('getProxyFileName')->will($this->returnValue($fileName));
$this->assertTrue($this->autoloader->__invoke($fqcn));
$this->assertTrue(class_exists($fqcn, false));
}
public function testGeneratesClass()
{
$generateProxy = new ReflectionMethod($this->factory, 'generateProxy');
$generateProxy->setAccessible(true);
$generatedClass = UniqueIdentifierGenerator::getIdentifier('fooBar');
$this->classNameInflector->expects($this->any())->method('getProxyClassName')->with('stdClass')->will($this->returnValue($generatedClass));
$this->generatorStrategy->expects($this->once())->method('generate')->with($this->isInstanceOf('Zend\\Code\\Generator\\ClassGenerator'));
$this->proxyAutoloader->expects($this->once())->method('__invoke')->with($generatedClass)->will($this->returnCallback(function ($className) {
eval('class ' . $className . ' {}');
}));
$this->assertSame($generatedClass, $generateProxy->invoke($this->factory, 'stdClass'));
$this->assertTrue(class_exists($generatedClass, false));
$this->assertSame($generatedClass, $generateProxy->invoke($this->factory, 'stdClass'));
}
/**
* @covers \ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy::__construct
* @covers \ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy::generate
*/
public function testGenerate()
{
$locator = $this->getMock('ProxyManager\\FileLocator\\FileLocatorInterface');
$generator = new FileWriterGeneratorStrategy($locator);
$tmpFile = sys_get_temp_dir() . '/FileWriterGeneratorStrategyTest' . uniqid() . '.php';
$namespace = 'Foo';
$className = UniqueIdentifierGenerator::getIdentifier('Bar');
$fqcn = $namespace . '\\' . $className;
$locator->expects($this->any())->method('getProxyFileName')->with($fqcn)->will($this->returnValue($tmpFile));
$body = $generator->generate(new ClassGenerator($fqcn));
$this->assertGreaterThan(0, strpos($body, $className));
$this->assertFalse(class_exists($fqcn, false));
$this->assertTrue(file_exists($tmpFile));
require $tmpFile;
$this->assertTrue(class_exists($fqcn, false));
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\LazyBean\MethodGenerator\Constructor}.
*
* @param ReflectionClass $originalClass
* @param BeanFactoryConfigurationProperty $beanFactoryConfigurationProperty
*/
public function __construct(ReflectionClass $originalClass, BeanFactoryConfigurationProperty $beanFactoryConfigurationProperty)
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('wrapBeanAsLazy'));
$this->setParameter(new ParameterGenerator('beanId'));
$this->setParameter(new ParameterGenerator('beanType'));
$this->setParameter(new ParameterGenerator('instance'));
$content = '$factory = new \\' . \bitExpert\Disco\Proxy\LazyBean\LazyBeanFactory::class . '($beanId, $this->' . $beanFactoryConfigurationProperty->getName() . '->getProxyManagerConfiguration());' . PHP_EOL;
$content .= '$initializer = function (&$wrappedObject, \\' . \ProxyManager\Proxy\LazyLoadingInterface::class . ' $proxy, $method, array $parameters, &$initializer) use($instance) {' . PHP_EOL;
$content .= ' $initializer = null;' . PHP_EOL;
$content .= ' $wrappedObject = $instance;' . PHP_EOL;
$content .= ' return true;' . PHP_EOL;
$content .= '};' . PHP_EOL;
$content .= PHP_EOL;
$content .= '$initializer->bindTo($this);' . PHP_EOL;
$content .= 'return $factory->createProxy($beanType, $initializer);' . PHP_EOL;
$this->setVisibility(self::VISIBILITY_PROTECTED);
$this->setBody($content);
}
/**
* @dataProvider getTestedImplementations
*
* Verifies that generated code is valid and implements expected interfaces
*/
public function testGeneratesValidCode($className)
{
$generator = $this->getProxyGenerator();
$generatedClassName = UniqueIdentifierGenerator::getIdentifier('AbstractProxyGeneratorTest');
$generatedClass = new ClassGenerator($generatedClassName);
$originalClass = new ReflectionClass($className);
$generatorStrategy = new EvaluatingGeneratorStrategy();
$generator->generate($originalClass, $generatedClass);
$generatorStrategy->generate($generatedClass);
$generatedReflection = new ReflectionClass($generatedClassName);
if ($originalClass->isInterface()) {
$this->assertTrue($generatedReflection->implementsInterface($className));
} else {
$this->assertEmpty(array_diff($originalClass->getInterfaceNames(), $generatedReflection->getInterfaceNames()));
}
$this->assertSame($generatedClassName, $generatedReflection->getName());
foreach ($this->getExpectedImplementedInterfaces() as $interface) {
$this->assertTrue($generatedReflection->implementsInterface($interface));
}
}
/**
* {@inheritDoc}
*
* @covers \ProxyManager\Factory\NullObjectFactory::__construct
* @covers \ProxyManager\Factory\NullObjectFactory::createProxy
* @covers \ProxyManager\Factory\NullObjectFactory::getGenerator
*
* NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
*/
public function testWillTryAutoGeneration()
{
$instance = new stdClass();
$proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
$generator = $this->getMock('ProxyManager\\GeneratorStrategy\\GeneratorStrategyInterface');
$autoloader = $this->getMock('ProxyManager\\Autoloader\\AutoloaderInterface');
$this->config->expects($this->any())->method('getGeneratorStrategy')->will($this->returnValue($generator));
$this->config->expects($this->any())->method('getProxyAutoloader')->will($this->returnValue($autoloader));
$generator->expects($this->once())->method('generate')->with($this->callback(function (ClassGenerator $targetClass) use($proxyClassName) {
return $targetClass->getName() === $proxyClassName;
}));
// simulate autoloading
$autoloader->expects($this->once())->method('__invoke')->with($proxyClassName)->will($this->returnCallback(function () use($proxyClassName) {
eval('class ' . $proxyClassName . ' extends \\ProxyManagerTestAsset\\NullObjectMock {}');
}));
$this->inflector->expects($this->once())->method('getProxyClassName')->with('stdClass')->will($this->returnValue($proxyClassName));
$this->inflector->expects($this->once())->method('getUserClassName')->with('stdClass')->will($this->returnValue('ProxyManagerTestAsset\\NullObjectMock'));
$factory = new NullObjectFactory($this->config);
/* @var $proxy \ProxyManagerTestAsset\NullObjectMock */
$proxy = $factory->createProxy($instance);
$this->assertInstanceOf($proxyClassName, $proxy);
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('adapter'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocblock('@var \\' . AdapterInterface::class . ' Remote web service adapter');
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\Configuration\PropertyGenerator\SessionBeansProperty}.
*
* @throws InvalidArgumentException
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('sessionBeans'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocBlock('@var ' . \bitExpert\Disco\Store\BeanStore::class);
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('initializer'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocblock('@var \\Closure|null initializer responsible for generating the wrapped object');
}
/**
* Constructor
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('adapter'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocblock('@var \\ProxyManager\\Factory\\RemoteObject\\AdapterInterface Remote web service adapter');
}
/**
* Generates a proxy for the given class name, and retrieves its class name
*
* @param string $parentClassName
*
* @return string
*/
private function generateProxy($parentClassName)
{
$generatedClassName = __NAMESPACE__ . '\\' . UniqueIdentifierGenerator::getIdentifier('Foo');
$generator = new LazyLoadingGhostGenerator();
$generatedClass = new ClassGenerator($generatedClassName);
$strategy = new EvaluatingGeneratorStrategy();
$generator->generate(new ReflectionClass($parentClassName), $generatedClass);
$strategy->generate($generatedClass);
return $generatedClassName;
}
public function testWhenFailingAllTemporaryFilesAreRemoved()
{
$tmpDirPath = sys_get_temp_dir() . '/' . uniqid('noTempFilesLeftBehind', true);
mkdir($tmpDirPath);
/* @var $locator \ProxyManager\FileLocator\FileLocatorInterface|\PHPUnit_Framework_MockObject_MockObject */
$locator = $this->getMock('ProxyManager\\FileLocator\\FileLocatorInterface');
$generator = new FileWriterGeneratorStrategy($locator);
$tmpFile = $tmpDirPath . '/' . uniqid('FileWriterGeneratorStrategyFailedFileMoveTest', true) . '.php';
$namespace = 'Foo';
$className = UniqueIdentifierGenerator::getIdentifier('Bar');
$fqcn = $namespace . '\\' . $className;
$locator->expects($this->any())->method('getProxyFileName')->with($fqcn)->will($this->returnValue($tmpFile));
mkdir($tmpFile);
try {
$generator->generate(new ClassGenerator($fqcn));
$this->fail('An exception was supposed to be thrown');
} catch (FileNotWritableException $exception) {
rmdir($tmpFile);
$this->assertEquals(array('.', '..'), scandir($tmpDirPath));
}
}
/**
* {@inheritDoc}
*
* @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::__construct
* @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::createProxy
* @covers \ProxyManager\Factory\AccessInterceptorValueHolderFactory::getGenerator
*
* NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
*/
public function testWillTryAutoGeneration()
{
$instance = new stdClass();
$proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
$generator = $this->getMock('ProxyManager\\GeneratorStrategy\\GeneratorStrategyInterface');
$autoloader = $this->getMock('ProxyManager\\Autoloader\\AutoloaderInterface');
$this->config->expects($this->any())->method('getGeneratorStrategy')->will($this->returnValue($generator));
$this->config->expects($this->any())->method('getProxyAutoloader')->will($this->returnValue($autoloader));
$generator->expects($this->once())->method('generate')->with($this->callback(function (ClassGenerator $targetClass) use($proxyClassName) {
return $targetClass->getName() === $proxyClassName;
}));
// simulate autoloading
$autoloader->expects($this->once())->method('__invoke')->with($proxyClassName)->will($this->returnCallback(function () use($proxyClassName) {
eval('class ' . $proxyClassName . ' extends \\ProxyManagerTestAsset\\AccessInterceptorValueHolderMock {}');
}));
$this->inflector->expects($this->once())->method('getProxyClassName')->with('stdClass')->will($this->returnValue($proxyClassName));
$this->inflector->expects($this->once())->method('getUserClassName')->with('stdClass')->will($this->returnValue('ProxyManagerTestAsset\\LazyLoadingMock'));
$this->signatureChecker->expects($this->atLeastOnce())->method('checkSignature');
$this->classSignatureGenerator->expects($this->once())->method('addSignature')->will($this->returnArgument(0));
$factory = new AccessInterceptorValueHolderFactory($this->config);
/* @var $proxy \ProxyManagerTestAsset\AccessInterceptorValueHolderMock */
$proxy = $factory->createProxy($instance, array('foo'), array('bar'));
$this->assertInstanceOf($proxyClassName, $proxy);
$this->assertSame($instance, $proxy->instance);
$this->assertSame(array('foo'), $proxy->prefixInterceptors);
$this->assertSame(array('bar'), $proxy->suffixInterceptors);
}
/**
* Creates a new {@link \bitExpert\Disco\Proxy\Configuration\PropertyGenerator\BeanFactoryConfigurationProperty}.
*
* @throws InvalidArgumentException
*/
public function __construct()
{
parent::__construct(UniqueIdentifierGenerator::getIdentifier('config'));
$this->setVisibility(self::VISIBILITY_PRIVATE);
$this->setDocBlock('@var ' . BeanFactoryConfiguration::class);
}
/**
* {@inheritDoc}
*
* @covers \ProxyManager\Factory\RemoteObjectFactory::__construct
* @covers \ProxyManager\Factory\RemoteObjectFactory::createProxy
* @covers \ProxyManager\Factory\RemoteObjectFactory::getGenerator
*
* NOTE: serious mocking going on in here (a class is generated on-the-fly) - careful
*/
public function testWillTryAutoGeneration()
{
$proxyClassName = UniqueIdentifierGenerator::getIdentifier('bar');
$generator = $this->getMock('ProxyManager\\GeneratorStrategy\\GeneratorStrategyInterface');
$autoloader = $this->getMock('ProxyManager\\Autoloader\\AutoloaderInterface');
$this->config->expects($this->any())->method('getGeneratorStrategy')->will($this->returnValue($generator));
$this->config->expects($this->any())->method('getProxyAutoloader')->will($this->returnValue($autoloader));
$generator->expects($this->once())->method('generate')->with($this->callback(function (ClassGenerator $targetClass) use($proxyClassName) {
return $targetClass->getName() === $proxyClassName;
}));
// simulate autoloading
$autoloader->expects($this->once())->method('__invoke')->with($proxyClassName)->will($this->returnCallback(function () use($proxyClassName) {
eval('class ' . $proxyClassName . ' extends stdClass {}');
}));
$this->inflector->expects($this->once())->method('getProxyClassName')->with('ProxyManagerTestAsset\\BaseInterface')->will($this->returnValue($proxyClassName));
$this->inflector->expects($this->once())->method('getUserClassName')->with('ProxyManagerTestAsset\\BaseInterface')->will($this->returnValue('stdClass'));
$this->signatureChecker->expects($this->atLeastOnce())->method('checkSignature');
$this->classSignatureGenerator->expects($this->once())->method('addSignature')->will($this->returnArgument(0));
$adapter = $this->getMock('ProxyManager\\Factory\\RemoteObject\\AdapterInterface');
$factory = new RemoteObjectFactory($adapter, $this->config);
/* @var $proxy \stdClass */
$proxy = $factory->createProxy('ProxyManagerTestAsset\\BaseInterface', $adapter);
$this->assertInstanceOf($proxyClassName, $proxy);
}
/**
* @dataProvider getBaseIdentifierNames
*
* @covers \ProxyManager\Generator\Util\UniqueIdentifierGenerator::getIdentifier
*/
public function testGeneratesValidIdentifiers($name)
{
$this->assertRegExp('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]+$/', UniqueIdentifierGenerator::getIdentifier($name));
}
