function it_should_run_all_after_running_features_passed(ContainerInterface $container, Runner $runner, Process $process, BehatPlugin $plugin, Filesystem $filesystem)
{
$filesystem->putFileContents($this->rerunFile, Argument::any())->willReturn();
$options = $this->options;
$options['all_after_pass'] = true;
$plugin->getOptions()->willReturn($options);
$this->setContainer($container);
$runner->run(Argument::any())->shouldBeCalled()->willReturn($process);
$process->getExitCode()->willReturn(0);
$paths = array('some.feature');
$results = $this->run($paths);
$results->shouldContainMessage('some.feature');
$results->shouldContainMessage(Inspector::RUN_ALL_SUCCESS_MESSAGE);
}
public function testPrintReport()
{
if (file_exists($file = CodeCoverageSession::getCacheFile())) {
unlink($file);
}
$options = array('enabled' => true, 'output.text' => true, 'output.html' => getcwd(), 'output.clover' => getcwd() . '/clover.xml');
static::$container->setParameter('session.results', array('some'));
$runner = new CodeCoverageSession();
$runner->setOptions($options);
$runner->setContainer(static::$container);
$event = new ProcessEvent(static::$container->get('plugins.test'));
$genericEvent = new GenericEvent(static::$container);
$genericEvent->addProcessEvent($event);
// not display coverage when results file not exists
$runner->process($genericEvent);
$this->assertNotDisplayContains('html output');
$this->assertNotDisplayContains('text output');
$this->assertNotDisplayContains('clover output');
// display coverage when cache file exists
Filesystem::create()->serialize($file, $runner);
$runner->process($genericEvent);
$this->assertDisplayContains('html output');
$this->assertDisplayContains('text output');
$this->assertDisplayContains('clover output');
}
public function testShouldRunAllAfterPass()
{
Filesystem::create()->cleanDir(static::$tmpDir);
Filesystem::create()->mkdir(static::$tmpDir);
static::buildFixtures();
static::createApplication();
$this->createTestClass('FooTest', 'tests/FooTest.php', '$this->assertTrue(true);');
$this->createTestClass('SucceedTest', 'tests/SucceedTest.php', '$this->assertTrue(true);');
$this->createTestClass('FailedTest', 'tests/FailedTest.php', '$this->assertTrue(false);');
$this->getTester()->run('-vvv');
$this->getTester()->run('all phpunit -vvv');
$this->assertDisplayContains('Tests: 3');
$this->assertDisplayContains('Assertions: 3');
$this->assertDisplayContains('Failures: 1');
$this->getTester()->run('all phpunit -vvv');
$this->getTester()->run('all phpunit -vvv');
$this->assertDisplayContains('Tests: 1');
$this->assertDisplayContains('Assertions: 1');
$this->assertDisplayContains('Failures: 1');
$this->assertDisplayContains('Test\\FailedTest');
$this->createTestClass('FailedTest', 'tests/FailedTest.php', '$this->assertTrue(true);');
$this->evaluate();
$this->assertDisplayContains('1 test, 1 assertion');
$this->getTester()->run('all phpunit -vvv');
$this->assertDisplayContains('3 tests');
}
function let(ContainerInterface $container, PhpGuard $guard, PluginInterface $plugin)
{
Filesystem::create()->cleanDir(self::$tmpDir);
Filesystem::create()->mkdir(self::$tmpDir);
$container->get('phpguard')->willReturn($guard);
$this->setContainer($container);
}
public function afterSuite()
{
Filesystem::create()->serialize(Inspector::getCacheFileName(), $this->results);
if ($this->coverage) {
$this->coverage->saveState();
}
}
public function testShouldMonitorBasedOnTags()
{
Filesystem::create()->cleanDir($dirTag1 = self::$tmpDir . '/tag1');
Filesystem::create()->cleanDir($dirTag2 = self::$tmpDir . '/tag2');
Filesystem::create()->mkdir($dirTag1);
Filesystem::create()->mkdir($dirTag2);
$ftag1 = $dirTag1 . '/test1.php';
$ftag2 = $dirTag2 . '/test1.php';
$this->getTester()->run('--tags=tag1');
file_put_contents($ftag1, 'Hello World');
file_put_contents($ftag2, 'Hello WOrld');
$this->evaluate();
$this->assertContains($ftag1, $this->getDisplay());
$this->assertNotContains($ftag2, $this->getDisplay());
$this->getTester()->run('--tags=tag2');
touch($ftag1 = $dirTag1 . '/test2.php');
touch($ftag2 = $dirTag2 . '/test2.php');
$this->evaluate();
$this->assertContains($ftag2, $this->getDisplay());
$this->assertNotContains($ftag1, $this->getDisplay());
$this->getTester()->run('--tags=tag1,tag2');
touch($ftag1 = $dirTag1 . '/test3.php');
touch($ftag2 = $dirTag2 . '/test3.php');
$this->evaluate();
$this->assertContains($ftag2, $this->getDisplay());
$this->assertContains($ftag1, $this->getDisplay());
}
public function testSerialization()
{
$file = getcwd() . '/test.dat';
$data = array('foo' => 'bar', 'hello' => 'world');
Filesystem::create()->serialize($file, $data);
$unserialized = Filesystem::create()->unserialize($file);
$this->assertEquals($data, $unserialized);
}
function its_runAll_create_success_event_if_results_only_contain_success_events(Runner $runner)
{
$results = array('succeed1' => ResultEvent::createSucceed('Succeed1'), 'succeed2' => ResultEvent::createSucceed('Succeed2'), 'succeed3' => ResultEvent::createSucceed('Succeed3'));
Filesystem::create()->serialize($this->cacheFile, $results);
$runner->run(Argument::any())->shouldBeCalled();
$results = $this->runAll()->getResults();
$results->shouldHaveCount(1);
$result = $results[0];
$result->shouldBeSucceed();
}
public static function create()
{
$dir = PhpGuard::getPluginCache('behat');
$file = $dir . DIRECTORY_SEPARATOR . static::FILENAME;
clearstatcache($file);
if (file_exists($file)) {
return Filesystem::create()->unserialize($file);
} else {
return new self();
}
}
protected static function buildFixtures()
{
$finder = Finder::create();
Filesystem::create()->copyDir(__DIR__ . '/fixtures', static::$tmpDir, $finder);
chdir(static::$tmpDir);
$exFinder = new ExecutableFinder();
if (!is_executable($executable = $exFinder->find('composer.phar'))) {
$executable = $exFinder->find('composer');
}
$process = new Process($executable . ' dumpautoload');
$process->run();
//static::$composerOutput = $process->getOutput();
}
public function __construct(CodeCoverageSession $coverageSession = null, Session $session = null, Filesystem $filesystem = null)
{
if (is_null($filesystem)) {
$filesystem = Filesystem::create();
}
if (is_null($session)) {
$session = new Session();
}
$this->coverageSession = $coverageSession;
$this->filesystem = $filesystem;
$this->session = $session;
$this->cwd = getcwd();
}
/**
* @BeforeScenario
*/
public function createBootstrapFile()
{
$contextClass = uniqid("FeatureContext");
$content = <<<EOC
<?php
use Behat\\Behat\\Context\\BehatContext;
use Behat\\Behat\\Exception\\PendingException;
class {$contextClass} extends BehatContext
{
public function __construct(array \$parameters)
{
}
/**
* @Given /^I have passed step\$/
*/
public function iHavePassStep()
{
return true;
}
/**
* @Then /^I have failed step\$/
*/
public function iHaveFailedStep()
{
throw new \\Exception("failed");
}
}
EOC;
$fs = Filesystem::create();
$file = 'features/bootstrap/' . $contextClass . '.php';
$dir = dirname($file);
if (!is_dir($dir)) {
mkdir($dir, 0777, true);
}
$fs->putFileContents($file, $content);
$behatContents = <<<EOC
default:
context:
class: {$contextClass}
EOC;
$fs->putFileContents('behat.yml', $behatContents);
}
function let(ContainerInterface $container, PluginInterface $plugin, AdapterInterface $adapter, Listener $listener, ConsoleHandler $handler, Logger $logger, GenericEvent $event, InputInterface $input)
{
if (is_null(static::$cwd)) {
static::$cwd = getcwd();
}
Filesystem::create()->mkdir(static::$tmpDir);
$container->getByPrefix('plugins')->willReturn(array($plugin));
$container->getParameter(Argument::any(), Argument::any())->willReturn(null);
$container->setParameter(Argument::any(), Argument::any())->willReturn(null);
$container->get('listen.listener')->willReturn($listener);
$container->get('listen.adapter')->willReturn($adapter);
$container->get('logger.handler')->willReturn($handler);
$container->get('logger')->willReturn($logger);
$event->getContainer()->willReturn($container);
$container->get('ui.input')->willReturn($input);
$this->setContainer($container);
}
public static function buildFixtures($suffix = 'common')
{
$finder = Finder::create();
Filesystem::create()->copyDir(static::$cwd . '/tests/fixtures/' . $suffix, static::$tmpDir, $finder);
}
function letgo()
{
Filesystem::create()->cleanDir(self::$tmpDir);
}
/**
* @Given /^(?:|the )(?:spec |class |feature )file "(?P<file>[^"]+)" contains:$/
*/
public function theFileContains($file, PyStringNode $string)
{
$fs = Filesystem::create();
$dirname = dirname($file);
if (!file_exists($dirname)) {
$fs->mkdir($dirname);
}
$fs->putFileContents($file, $string->getRaw());
clearstatcache($file);
}
/**
* @codeCoverageIgnore
*/
public function handleShutdown()
{
$fatalErrors = array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR);
$lastError = error_get_last();
if ($lastError && in_array($lastError['type'], $fatalErrors)) {
$message = 'Fatal Error ' . $lastError['message'];
$error = $lastError;
$trace = file($this->errorFile);
$traces = array();
for ($i = 0, $count = count($trace); $i < $count; $i++) {
$text = trim($trace[$i]);
if (false !== ($pos = strpos($text, 'PHP '))) {
$text = substr($text, $pos + 4);
}
$traces[] = $text;
}
$event = ResultEvent::createError($message, $error, null, $traces);
Filesystem::create()->serialize(Inspector::getResultFileName(), array($event));
if ($this->coverageRunner) {
$this->coverageRunner->saveState();
}
}
}
/**
* @throws \RuntimeException
*
* @return array
*/
private function renderResult()
{
/* @var ResultEvent $resultEvent */
$results = array();
$file = static::getCacheFileName();
if (!file_exists($file)) {
throw new \RuntimeException(sprintf('Unknown PhpSpec results'));
}
$data = Filesystem::create()->unserialize($file);
// processing succeed first
foreach ($data as $resultEvent) {
$file = $resultEvent->getArgument('file');
$failedKey = md5($file);
if ($resultEvent->isSucceed()) {
if (isset($this->failed[$failedKey])) {
unset($this->failed[$failedKey]);
}
}
}
foreach ($data as $resultEvent) {
$file = $resultEvent->getArgument('file');
$failedKey = md5($file);
if (!$resultEvent->isSucceed()) {
$this->failed[$failedKey] = $resultEvent;
$results[] = $resultEvent;
}
}
return $results;
}
public function saveState()
{
$target = $this->path . '/coverage_session.dat';
if (is_writable($this->path)) {
Filesystem::create()->serialize($target, $this);
}
}
function letgo()
{
chdir(self::$cwd);
Filesystem::create()->cleanDir(self::$tmpDir . '/test-config');
}
function letgo()
{
Filesystem::create()->cleanDir(static::$tmpDir);
chdir(static::$cwd);
}
private function checkResult($showSuccess = true)
{
/* @var ResultEvent $event */
$file = static::getResultFileName();
if (!is_file($file)) {
throw new \RuntimeException('Unknown phpunit results.');
}
$data = Filesystem::create()->unserialize($file);
$results = array();
foreach ($data as $event) {
$file = $event->getArgument('file');
$failedKey = md5(realpath($file));
if ($event->isSucceed()) {
unset($this->failed[$failedKey]);
if ($showSuccess) {
$results[] = $event;
}
} else {
$this->failed[$failedKey] = $file;
$results[] = $event;
}
}
return $results;
}
function its_runAll_should_set_application_exit_code_if_results_has_failed_or_broken(ContainerInterface $container)
{
$failed = ResultEvent::createFailed('Failed', array('file' => 'some_file'));
$success = ResultEvent::createSucceed('Success');
Filesystem::create()->serialize($this->cacheFile, array('failed' => $failed, 'success' => $success));
$container->setParameter('application.exit_code', ResultEvent::FAILED)->shouldBeCalled();
$this->runAll();
}
protected function buildSpec($target, $class, $content)
{
$time = new \DateTime();
$time = $time->format('H:i:s');
$content = $this->getSpecContent($class, $content);
$content = str_replace('%relative_path%', $target, $content);
$target = static::$tmpDir . '/' . $target;
$dir = dirname($target);
Filesystem::create()->mkdir($dir);
file_put_contents($target, $content);
return $target;
}
