/vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/AbstractBinaryTest.php |
@@ -0,0 +1,300 @@ |
<?php |
|
namespace Alchemy\Tests\BinaryDriver; |
|
use Alchemy\BinaryDriver\AbstractBinary; |
use Alchemy\BinaryDriver\BinaryDriverTestCase; |
use Alchemy\BinaryDriver\Configuration; |
use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException; |
use Alchemy\BinaryDriver\Listeners\ListenerInterface; |
use Symfony\Component\Process\ExecutableFinder; |
|
class AbstractBinaryTest extends BinaryDriverTestCase |
{ |
protected function getPhpBinary() |
{ |
$finder = new ExecutableFinder(); |
$php = $finder->find('php'); |
|
if (null === $php) { |
$this->markTestSkipped('Unable to find a php binary'); |
} |
|
return $php; |
} |
|
public function testSimpleLoadWithBinaryPath() |
{ |
$php = $this->getPhpBinary(); |
$imp = Implementation::load($php); |
$this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp); |
|
$this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary()); |
} |
|
public function testMultipleLoadWithBinaryPath() |
{ |
$php = $this->getPhpBinary(); |
$imp = Implementation::load(array('/zz/path/to/unexisting/command', $php)); |
$this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp); |
|
$this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary()); |
} |
|
public function testSimpleLoadWithBinaryName() |
{ |
$php = $this->getPhpBinary(); |
$imp = Implementation::load('php'); |
$this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp); |
|
$this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary()); |
} |
|
public function testMultipleLoadWithBinaryName() |
{ |
$php = $this->getPhpBinary(); |
$imp = Implementation::load(array('bachibouzouk', 'php')); |
$this->assertInstanceOf('Alchemy\Tests\BinaryDriver\Implementation', $imp); |
|
$this->assertEquals($php, $imp->getProcessBuilderFactory()->getBinary()); |
} |
|
public function testLoadWithMultiplePathExpectingAFailure() |
{ |
$this->setExpectedException(ExecutableNotFoundException::class); |
|
Implementation::load(array('bachibouzouk', 'moribon')); |
} |
|
public function testLoadWithUniquePathExpectingAFailure() |
{ |
$this->setExpectedException(ExecutableNotFoundException::class); |
|
Implementation::load('bachibouzouk'); |
} |
|
public function testLoadWithCustomLogger() |
{ |
$logger = $this->getMock('Psr\Log\LoggerInterface'); |
$imp = Implementation::load('php', $logger); |
|
$this->assertEquals($logger, $imp->getProcessRunner()->getLogger()); |
} |
|
public function testLoadWithCustomConfigurationAsArray() |
{ |
$conf = array('timeout' => 200); |
$imp = Implementation::load('php', null, $conf); |
|
$this->assertEquals($conf, $imp->getConfiguration()->all()); |
} |
|
public function testLoadWithCustomConfigurationAsObject() |
{ |
$conf = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface'); |
$imp = Implementation::load('php', null, $conf); |
|
$this->assertEquals($conf, $imp->getConfiguration()); |
} |
|
public function testProcessBuilderFactoryGetterAndSetters() |
{ |
$imp = Implementation::load('php'); |
$factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface'); |
|
$imp->setProcessBuilderFactory($factory); |
$this->assertEquals($factory, $imp->getProcessBuilderFactory()); |
} |
|
public function testConfigurationGetterAndSetters() |
{ |
$imp = Implementation::load('php'); |
$conf = $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface'); |
|
$imp->setConfiguration($conf); |
$this->assertEquals($conf, $imp->getConfiguration()); |
} |
|
public function testTimeoutIsSetOnConstruction() |
{ |
$imp = Implementation::load('php', null, array('timeout' => 42)); |
$this->assertEquals(42, $imp->getProcessBuilderFactory()->getTimeout()); |
} |
|
public function testTimeoutIsSetOnConfigurationSetting() |
{ |
$imp = Implementation::load('php', null); |
$imp->setConfiguration(new Configuration(array('timeout' => 42))); |
$this->assertEquals(42, $imp->getProcessBuilderFactory()->getTimeout()); |
} |
|
public function testTimeoutIsSetOnProcessBuilderSetting() |
{ |
$imp = Implementation::load('php', null, array('timeout' => 42)); |
|
$factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface'); |
$factory->expects($this->once()) |
->method('setTimeout') |
->with(42); |
|
$imp->setProcessBuilderFactory($factory); |
} |
|
public function testListenRegistersAListener() |
{ |
$imp = Implementation::load('php'); |
|
$listeners = $this->getMockBuilder('Alchemy\BinaryDriver\Listeners\Listeners') |
->disableOriginalConstructor() |
->getMock(); |
|
$listener = $this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface'); |
|
$listeners->expects($this->once()) |
->method('register') |
->with($this->equalTo($listener), $this->equalTo($imp)); |
|
$reflexion = new \ReflectionClass('Alchemy\BinaryDriver\AbstractBinary'); |
$prop = $reflexion->getProperty('listenersManager'); |
$prop->setAccessible(true); |
$prop->setValue($imp, $listeners); |
|
$imp->listen($listener); |
} |
|
/** |
* @dataProvider provideCommandParameters |
*/ |
public function testCommandRunsAProcess($parameters, $bypassErrors, $expectedParameters, $output) |
{ |
$imp = Implementation::load('php'); |
$factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface'); |
$processRunner = $this->getMock('Alchemy\BinaryDriver\ProcessRunnerInterface'); |
|
$process = $this->getMockBuilder('Symfony\Component\Process\Process') |
->disableOriginalConstructor() |
->getMock(); |
|
$processRunner->expects($this->once()) |
->method('run') |
->with($this->equalTo($process), $this->isInstanceOf('SplObjectStorage'), $this->equalTo($bypassErrors)) |
->will($this->returnValue($output)); |
|
$factory->expects($this->once()) |
->method('create') |
->with($expectedParameters) |
->will($this->returnValue($process)); |
|
$imp->setProcessBuilderFactory($factory); |
$imp->setProcessRunner($processRunner); |
|
$this->assertEquals($output, $imp->command($parameters, $bypassErrors)); |
} |
|
/** |
* @dataProvider provideCommandWithListenersParameters |
*/ |
public function testCommandWithTemporaryListeners($parameters, $bypassErrors, $expectedParameters, $output, $count, $listeners) |
{ |
$imp = Implementation::load('php'); |
$factory = $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface'); |
$processRunner = $this->getMock('Alchemy\BinaryDriver\ProcessRunnerInterface'); |
|
$process = $this->getMockBuilder('Symfony\Component\Process\Process') |
->disableOriginalConstructor() |
->getMock(); |
|
$firstStorage = $secondStorage = null; |
|
$processRunner->expects($this->exactly(2)) |
->method('run') |
->with($this->equalTo($process), $this->isInstanceOf('SplObjectStorage'), $this->equalTo($bypassErrors)) |
->will($this->returnCallback(function ($process, $storage, $errors) use ($output, &$firstStorage, &$secondStorage) { |
if (null === $firstStorage) { |
$firstStorage = $storage; |
} else { |
$secondStorage = $storage; |
} |
|
return $output; |
})); |
|
$factory->expects($this->exactly(2)) |
->method('create') |
->with($expectedParameters) |
->will($this->returnValue($process)); |
|
$imp->setProcessBuilderFactory($factory); |
$imp->setProcessRunner($processRunner); |
|
$this->assertEquals($output, $imp->command($parameters, $bypassErrors, $listeners)); |
$this->assertCount($count, $firstStorage); |
$this->assertEquals($output, $imp->command($parameters, $bypassErrors)); |
$this->assertCount(0, $secondStorage); |
} |
|
public function provideCommandWithListenersParameters() |
{ |
return array( |
array('-a', false, array('-a'), 'loubda', 2, array($this->getMockListener(), $this->getMockListener())), |
array('-a', false, array('-a'), 'loubda', 1, array($this->getMockListener())), |
array('-a', false, array('-a'), 'loubda', 1, $this->getMockListener()), |
array('-a', false, array('-a'), 'loubda', 0, array()), |
); |
} |
|
public function provideCommandParameters() |
{ |
return array( |
array('-a', false, array('-a'), 'loubda'), |
array('-a', true, array('-a'), 'loubda'), |
array('-a -b', false, array('-a -b'), 'loubda'), |
array(array('-a'), false, array('-a'), 'loubda'), |
array(array('-a'), true, array('-a'), 'loubda'), |
array(array('-a', '-b'), false, array('-a', '-b'), 'loubda'), |
); |
} |
|
public function testUnlistenUnregistersAListener() |
{ |
$imp = Implementation::load('php'); |
|
$listeners = $this->getMockBuilder('Alchemy\BinaryDriver\Listeners\Listeners') |
->disableOriginalConstructor() |
->getMock(); |
|
$listener = $this->getMock('Alchemy\BinaryDriver\Listeners\ListenerInterface'); |
|
$listeners->expects($this->once()) |
->method('unregister') |
->with($this->equalTo($listener), $this->equalTo($imp)); |
|
$reflexion = new \ReflectionClass('Alchemy\BinaryDriver\AbstractBinary'); |
$prop = $reflexion->getProperty('listenersManager'); |
$prop->setAccessible(true); |
$prop->setValue($imp, $listeners); |
|
$imp->unlisten($listener); |
} |
|
/** |
* @return \PHPUnit_Framework_MockObject_MockObject |
*/ |
private function getMockListener() |
{ |
$listener = $this->getMock(ListenerInterface::class); |
$listener->expects($this->any()) |
->method('forwardedEvents') |
->willReturn(array()); |
|
return $listener; |
} |
} |
|
class Implementation extends AbstractBinary |
{ |
public function getName() |
{ |
return 'Implementation'; |
} |
} |
/vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/AbstractProcessBuilderFactoryTest.php |
@@ -0,0 +1,97 @@ |
<?php |
|
namespace Alchemy\Tests\BinaryDriver; |
|
use Symfony\Component\Process\ExecutableFinder; |
use Alchemy\BinaryDriver\ProcessBuilderFactory; |
|
abstract class AbstractProcessBuilderFactoryTest extends \PHPUnit_Framework_TestCase |
{ |
public static $phpBinary; |
|
private $original; |
/** |
* @return ProcessBuilderFactory |
*/ |
abstract protected function getProcessBuilderFactory($binary); |
|
public function setUp() |
{ |
ProcessBuilderFactory::$emulateSfLTS = null; |
if (null === static::$phpBinary) { |
$this->markTestSkipped('Unable to detect php binary, skipping'); |
} |
} |
|
public static function setUpBeforeClass() |
{ |
$finder = new ExecutableFinder(); |
static::$phpBinary = $finder->find('php'); |
} |
|
public function testThatBinaryIsSetOnConstruction() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$this->assertEquals(static::$phpBinary, $factory->getBinary()); |
} |
|
public function testGetSetBinary() |
{ |
$finder = new ExecutableFinder(); |
$phpUnit = $finder->find('phpunit'); |
|
if (null === $phpUnit) { |
$this->markTestSkipped('Unable to detect phpunit binary, skipping'); |
} |
|
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$factory->useBinary($phpUnit); |
$this->assertEquals($phpUnit, $factory->getBinary()); |
} |
|
/** |
* @expectedException Alchemy\BinaryDriver\Exception\InvalidArgumentException |
*/ |
public function testUseNonExistantBinary() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$factory->useBinary('itissureitdoesnotexist'); |
} |
|
public function testCreateShouldReturnAProcess() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$process = $factory->create(); |
|
$this->assertInstanceOf('Symfony\Component\Process\Process', $process); |
$this->assertEquals("'".static::$phpBinary."'", $process->getCommandLine()); |
} |
|
public function testCreateWithStringArgument() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$process = $factory->create('-v'); |
|
$this->assertInstanceOf('Symfony\Component\Process\Process', $process); |
$this->assertEquals("'".static::$phpBinary."' '-v'", $process->getCommandLine()); |
} |
|
public function testCreateWithArrayArgument() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$process = $factory->create(array('-r', 'echo "Hello !";')); |
|
$this->assertInstanceOf('Symfony\Component\Process\Process', $process); |
$this->assertEquals("'".static::$phpBinary."' '-r' 'echo \"Hello !\";'", $process->getCommandLine()); |
} |
|
public function testCreateWithTimeout() |
{ |
$factory = $this->getProcessBuilderFactory(static::$phpBinary); |
$factory->setTimeout(200); |
$process = $factory->create(array('-i')); |
|
$this->assertInstanceOf('Symfony\Component\Process\Process', $process); |
$this->assertEquals(200, $process->getTimeout()); |
} |
} |
/vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/Listeners/ListenersTest.php |
@@ -0,0 +1,92 @@ |
<?php |
|
namespace Alchemy\Tests\BinaryDriver\Listeners; |
|
use Alchemy\BinaryDriver\Listeners\Listeners; |
use Evenement\EventEmitter; |
use Alchemy\BinaryDriver\Listeners\ListenerInterface; |
|
class ListenersTest extends \PHPUnit_Framework_TestCase |
{ |
public function testRegister() |
{ |
$listener = new MockListener(); |
|
$listeners = new Listeners(); |
$listeners->register($listener); |
|
$n = 0; |
$listener->on('received', function ($type, $data) use (&$n, &$capturedType, &$capturedData) { |
$n++; |
$capturedData = $data; |
$capturedType = $type; |
}); |
|
$type = 'type'; |
$data = 'data'; |
|
$listener->handle($type, $data); |
$listener->handle($type, $data); |
|
$listeners->unregister($listener); |
|
$listener->handle($type, $data); |
|
$this->assertEquals(3, $n); |
$this->assertEquals($type, $capturedType); |
$this->assertEquals($data, $capturedData); |
} |
|
public function testRegisterAndForwardThenUnregister() |
{ |
$listener = new MockListener(); |
$target = new EventEmitter(); |
|
$n = 0; |
$target->on('received', function ($type, $data) use (&$n, &$capturedType, &$capturedData) { |
$n++; |
$capturedData = $data; |
$capturedType = $type; |
}); |
|
$m = 0; |
$listener->on('received', function ($type, $data) use (&$m, &$capturedType2, &$capturedData2) { |
$m++; |
$capturedData2 = $data; |
$capturedType2 = $type; |
}); |
|
$listeners = new Listeners(); |
$listeners->register($listener, $target); |
|
$type = 'type'; |
$data = 'data'; |
|
$listener->handle($type, $data); |
$listener->handle($type, $data); |
|
$listeners->unregister($listener, $target); |
|
$listener->handle($type, $data); |
|
$this->assertEquals(2, $n); |
$this->assertEquals(3, $m); |
$this->assertEquals($type, $capturedType); |
$this->assertEquals($data, $capturedData); |
$this->assertEquals($type, $capturedType2); |
$this->assertEquals($data, $capturedData2); |
} |
} |
|
class MockListener extends EventEmitter implements ListenerInterface |
{ |
public function handle($type, $data) |
{ |
$this->emit('received', array($type, $data)); |
} |
|
public function forwardedEvents() |
{ |
return array('received'); |
} |
} |
/vendor/alchemy/binary-driver/tests/Alchemy/Tests/BinaryDriver/ProcessRunnerTest.php |
@@ -0,0 +1,208 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\Tests\BinaryDriver; |
|
use Alchemy\BinaryDriver\ProcessRunner; |
use Alchemy\BinaryDriver\BinaryDriverTestCase; |
use Alchemy\BinaryDriver\Exception\ExecutionFailureException; |
use Alchemy\BinaryDriver\Listeners\ListenerInterface; |
use Evenement\EventEmitter; |
use Symfony\Component\Process\Exception\RuntimeException as ProcessRuntimeException; |
|
class ProcessRunnerTest extends BinaryDriverTestCase |
{ |
public function getProcessRunner($logger) |
{ |
return new ProcessRunner($logger, 'test-runner'); |
} |
|
public function testRunSuccessFullProcess() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true); |
|
$logger |
->expects($this->never()) |
->method('error'); |
$logger |
->expects($this->exactly(2)) |
->method('info'); |
|
$this->assertEquals('Kikoo Romain', $runner->run($process, new \SplObjectStorage(), false)); |
} |
|
public function testRunSuccessFullProcessBypassingErrors() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true); |
|
$logger |
->expects($this->never()) |
->method('error'); |
$logger |
->expects($this->exactly(2)) |
->method('info'); |
|
$this->assertEquals('Kikoo Romain', $runner->run($process, new \SplObjectStorage(), true)); |
} |
|
public function testRunFailingProcess() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$process = $this->createProcessMock(1, false, '--helloworld--', null, null, true); |
|
$logger |
->expects($this->once()) |
->method('error'); |
$logger |
->expects($this->once()) |
->method('info'); |
|
try { |
$runner->run($process, new \SplObjectStorage(), false); |
$this->fail('An exception should have been raised'); |
} catch (ExecutionFailureException $e) { |
|
} |
} |
|
public function testRunFailingProcessWithException() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$exception = new ProcessRuntimeException('Process Failed'); |
$process = $this->getMockBuilder('Symfony\Component\Process\Process') |
->disableOriginalConstructor() |
->getMock(); |
$process->expects($this->once()) |
->method('run') |
->will($this->throwException($exception)); |
|
$logger |
->expects($this->once()) |
->method('error'); |
$logger |
->expects($this->once()) |
->method('info'); |
|
try { |
$runner->run($process, new \SplObjectStorage(), false); |
$this->fail('An exception should have been raised'); |
} catch (ExecutionFailureException $e) { |
$this->assertEquals($exception, $e->getPrevious()); |
} |
} |
|
public function testRunfailingProcessBypassingErrors() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$process = $this->createProcessMock(1, false, '--helloworld--', 'Hello output', null, true); |
|
$logger |
->expects($this->once()) |
->method('error'); |
$logger |
->expects($this->once()) |
->method('info'); |
|
$this->assertNull($runner->run($process, new \SplObjectStorage(), true)); |
} |
|
public function testRunFailingProcessWithExceptionBypassingErrors() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$exception = new ProcessRuntimeException('Process Failed'); |
$process = $this->getMockBuilder('Symfony\Component\Process\Process') |
->disableOriginalConstructor() |
->getMock(); |
$process->expects($this->once()) |
->method('run') |
->will($this->throwException($exception)); |
|
$logger |
->expects($this->once()) |
->method('error'); |
$logger |
->expects($this->once()) |
->method('info'); |
|
$this->assertNull($runner->run($process, new \SplObjectStorage(), true)); |
} |
|
public function testRunSuccessFullProcessWithHandlers() |
{ |
$logger = $this->createLoggerMock(); |
$runner = $this->getProcessRunner($logger); |
|
$capturedCallback = null; |
|
$process = $this->createProcessMock(1, true, '--helloworld--', "Kikoo Romain", null, true); |
$process->expects($this->once()) |
->method('run') |
->with($this->isInstanceOf('Closure')) |
->will($this->returnCallback(function ($callback) use (&$capturedCallback) { |
$capturedCallback = $callback; |
})); |
|
$logger |
->expects($this->never()) |
->method('error'); |
$logger |
->expects($this->exactly(2)) |
->method('info'); |
|
$listener = new TestListener(); |
$storage = new \SplObjectStorage(); |
$storage->attach($listener); |
|
$capturedType = $capturedData = null; |
|
$listener->on('received', function ($type, $data) use (&$capturedType, &$capturedData) { |
$capturedData = $data; |
$capturedType = $type; |
}); |
|
$this->assertEquals('Kikoo Romain', $runner->run($process, $storage, false)); |
|
$type = 'err'; |
$data = 'data'; |
|
$capturedCallback($type, $data); |
|
$this->assertEquals($data, $capturedData); |
$this->assertEquals($type, $capturedType); |
} |
} |
|
class TestListener extends EventEmitter implements ListenerInterface |
{ |
public function handle($type, $data) |
{ |
return $this->emit('received', array($type, $data)); |
} |
|
public function forwardedEvents() |
{ |
return array(); |
} |
} |