/**
  * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
  * @param \Doctrine\Common\Persistence\ManagerRegistry $doctrine
  * @param \Doctrine\Common\Persistence\ObjectManager $manager
  * @param \Behat\Behat\Hook\Scope\ScenarioScope $event
  * @param \Behat\Gherkin\Node\FeatureNode $feature
  * @param \Behat\Gherkin\Node\ScenarioNode $scenario
  * @param \Knp\FriendlyContexts\Alice\Loader\Yaml $loader
  * @param \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory $metadataFactory
  * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $userMetadata
  * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $placeMetadata
  * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $productMetadata
  */
 function let($container, $doctrine, $manager, $event, $loader, $feature, $scenario, $metadataFactory, $userMetadata, $placeMetadata, $productMetadata)
 {
     $doctrine->getManager()->willReturn($manager);
     $feature->getTags()->willReturn(['alice(Place)', 'admin']);
     $scenario->getTags()->willReturn(['alice(User)']);
     $event->getFeature()->willReturn($feature);
     $event->getScenario()->willReturn($scenario);
     $loader->load('user.yml')->willReturn([]);
     $loader->load('product.yml')->willReturn([]);
     $loader->load('place.yml')->willReturn([]);
     $loader->getCache()->willReturn([]);
     $loader->clearCache()->willReturn(null);
     $fixtures = ['User' => 'user.yml', 'Product' => 'product.yml', 'Place' => 'place.yml'];
     $config = ['alice' => ['fixtures' => $fixtures, 'dependencies' => []]];
     $container->has(Argument::any())->willReturn(true);
     $container->hasParameter(Argument::any())->willReturn(true);
     $container->get('friendly.alice.loader.yaml')->willReturn($loader);
     $container->get('doctrine')->willReturn($doctrine);
     $container->getParameter('friendly.alice.fixtures')->willReturn($fixtures);
     $container->getParameter('friendly.alice.dependencies')->willReturn([]);
     $manager->getMetadataFactory()->willReturn($metadataFactory);
     $metadataFactory->getAllMetadata()->willReturn([$userMetadata, $placeMetadata, $productMetadata]);
     $userMetadata->getName()->willReturn('User');
     $placeMetadata->getName()->willReturn('Place');
     $productMetadata->getName()->willReturn('Product');
     $this->initialize($config, $container);
 }
 /**
  * @param FeatureNode $feature
  *
  * @return array
  */
 public function extract(FeatureNode $feature)
 {
     $allScenarios = [];
     foreach ($feature->getScenarios() as $scenario) {
         $scenarios = [];
         switch (true) {
             case $scenario instanceof OutlineNode && $this->isParallelExamples($scenario):
                 foreach ($scenario->getExamples() as $exampleNode) {
                     $scenarios[] = new ScenarioInfo($feature->getFile(), $exampleNode->getLine());
                 }
                 break;
             case $scenario instanceof OutlineNode:
             case $scenario instanceof ScenarioInterface:
                 $scenarios[] = new ScenarioInfo($feature->getFile(), $scenario->getLine());
         }
         if ($this->isParallelWait($scenario) || !$this->isParallel($scenario)) {
             $allScenarios[] = [];
         }
         $lastIndex = empty($allScenarios) ? 0 : count($allScenarios) - 1;
         if (!array_key_exists($lastIndex, $allScenarios)) {
             $allScenarios[$lastIndex] = [];
         }
         $allScenarios[$lastIndex] = array_merge($allScenarios[$lastIndex], $scenarios);
         if (!$this->isParallel($scenario)) {
             $allScenarios[] = [];
         }
     }
     return array_values(array_filter($allScenarios));
 }
Example #3
0
 /**
  * Loads feature from provided feature hash.
  *
  * @param   array   $hash   feature hash
  * @param   integer $line   feature definition line
  *
  * @return  Behat\Gherkin\Node\FeatureNode
  */
 protected function loadFeatureHash(array $hash, $line = 0)
 {
     $feature = new Node\FeatureNode(null, null, null, isset($hash['line']) ? $hash['line'] : $line);
     $feature->setKeyword(isset($hash['keyword']) ? $hash['keyword'] : 'Feature');
     if (isset($hash['title'])) {
         $feature->setTitle($hash['title']);
     }
     if (isset($hash['description'])) {
         $feature->setDescription($hash['description']);
     }
     if (isset($hash['tags'])) {
         $feature->setTags($hash['tags']);
     }
     if (isset($hash['language'])) {
         $feature->setLanguage($hash['language']);
     }
     if (isset($hash['background'])) {
         $feature->setBackground($this->loadBackgroundHash($hash['background']));
     }
     if (isset($hash['scenarios'])) {
         foreach ($hash['scenarios'] as $scenarioIterator => $scenarioHash) {
             if (isset($scenarioHash['type']) && 'outline' === $scenarioHash['type']) {
                 $feature->addScenario($this->loadOutlineHash($scenarioHash, $scenarioIterator));
             } else {
                 $feature->addScenario($this->loadScenarioHash($scenarioHash, $scenarioIterator));
             }
         }
     }
     return $feature;
 }
Example #4
0
 /**
  * {@inheritdoc}
  */
 public function isFeatureMatch(FeatureNode $feature)
 {
     if ('/' === $this->filterString[0]) {
         return (bool) preg_match($this->filterString, $feature->getTitle());
     }
     return false !== mb_strpos($feature->getTitle(), $this->filterString);
 }
 /**
  * @param  FeatureNode  $featureNode
  * @param  ScenarioInterface $scenarioNode
  *
  * @return string
  */
 public function generateFileName(FeatureNode $featureNode, ScenarioInterface $scenarioNode)
 {
     $feature = $this->relativizePaths($featureNode->getFile());
     $line = $scenarioNode->getLine();
     $fileName = join('_', [$feature, $line]);
     return preg_replace('/[^A-Za-z0-9\\-]/', '_', mb_strtolower($fileName)) . '.png';
 }
 public function testCacheAndRead()
 {
     $feature = new FeatureNode('Some feature', 'some description');
     $feature->addScenario(new ScenarioNode('Some scenario'));
     $this->cache->write('some_feature', $feature);
     $featureRead = $this->cache->read('some_feature');
     $this->assertEquals($feature, $featureRead);
 }
 function it_generates_filename_from_step_name(ScreenshotTaker $screenshotTaker, StepFilenameGenerator $filenameGenerator, Environment $env, FeatureNode $feature, StepNode $step, StepResult $result, Teardown $tearDown)
 {
     $event = new AfterStepTested($env->getWrappedObject(), $feature->getWrappedObject(), $step->getWrappedObject(), $result->getWrappedObject(), $tearDown->getWrappedObject());
     $result->getResultCode()->willReturn(TestResult::FAILED);
     $filenameGenerator->convertStepToFileName($step)->willReturn('test.jpg')->shouldBeCalled();
     $screenshotTaker->takeScreenshot('test.jpg')->shouldBeCalled();
     $this->checkAfterStep($event);
 }
 /**
  * {@inheritdoc}
  */
 public function test(Environment $env, FeatureNode $feature, $skip)
 {
     $background = $feature->getBackground();
     if (null === $background) {
         throw new FeatureHasNoBackgroundException(sprintf('Feature `%s` has no background that could be tested.', $feature->getFile()), $feature);
     }
     $results = $this->containerTester->test($env, $feature, $background, $skip);
     return new TestResults($results);
 }
 /**
  * update feature results based on step tests results
  * @param  FeatureNode $feature    object
  * @param  TestResult  $testResult object
  * @return null
  */
 public function updateFeatureStatus(FeatureNode $feature, TestResult $testResult)
 {
     $featurePath = $feature->getFile();
     $resultCode = $testResult->getResultCode();
     if ($resultCode > $this->testResults[$featurePath]["testResultCode"]) {
         $this->testResults[$featurePath]["testResultCode"] = $resultCode;
         $this->testResults[$featurePath]["testResult"] = self::RESULT_CODES_MAPPING[$resultCode];
     }
 }
Example #10
0
 /**
  * Checks if Feature matches specified filter.
  *
  * @param FeatureNode $feature Feature instance
  *
  * @return Boolean
  */
 public function isFeatureMatch(FeatureNode $feature)
 {
     foreach ($this->filterPaths as $path) {
         if (0 === strpos($feature->getFile(), $path)) {
             return true;
         }
     }
     return false;
 }
 /**
  * {@inheritdoc}
  */
 public function tearDown(Environment $env, FeatureNode $feature, $skip, TestResult $result)
 {
     $event = new BeforeBackgroundTeardown($env, $feature, $feature->getBackground(), $result);
     $this->eventDispatcher->dispatch(BackgroundTested::BEFORE_TEARDOWN, $event);
     $teardown = $this->baseTester->tearDown($env, $feature, $skip, $result);
     $event = new AfterBackgroundTested($env, $feature, $feature->getBackground(), $result, $teardown);
     $this->eventDispatcher->dispatch(BackgroundTested::AFTER, $event);
     return $teardown;
 }
 /**
  * Filters feature according to the filter.
  *
  * @param FeatureNode $feature
  */
 public function filterFeature(FeatureNode $feature)
 {
     $scenarios = $feature->getScenarios();
     foreach ($scenarios as $i => $scenario) {
         if (!$this->isScenarioMatch($scenario)) {
             unset($scenarios[$i]);
         }
     }
     $feature->setScenarios($scenarios);
 }
 /**
  * {@inheritdoc}
  */
 public function test(Environment $env, FeatureNode $feature, Scenario $scenario, $skip = false)
 {
     $results = array();
     if ($feature->hasBackground()) {
         $backgroundResult = $this->testBackground($env, $feature, $skip);
         $skip = !$backgroundResult->isPassed() || $skip;
         $results[] = $backgroundResult;
     }
     $results = array_merge($results, $this->containerTester->test($env, $feature, $scenario, $skip));
     return new TestResults($results);
 }
 /**
  * @param FeatureNode $feature
  *
  * @return string
  */
 public function format(FeatureNode $feature)
 {
     $shortDesc = $feature->getKeyword() . ': ' . $feature->getTitle() . "\n";
     if (!$feature->hasDescription()) {
         return rtrim($shortDesc);
     }
     $longDesc = implode(array_map(function ($descriptionLine) {
         return $this->indent() . trim($descriptionLine) . "\n";
     }, explode("\n", $feature->getDescription())));
     return $shortDesc . rtrim($longDesc);
 }
Example #15
0
 /**
  * Filters feature according to the filter.
  *
  * @param FeatureNode $feature
  *
  * @return FeatureNode
  */
 public function filterFeature(FeatureNode $feature)
 {
     $scenarios = array();
     foreach ($feature->getScenarios() as $scenario) {
         if (!$this->isScenarioMatch($feature, $scenario)) {
             continue;
         }
         $scenarios[] = $scenario;
     }
     return new FeatureNode($feature->getTitle(), $feature->getDescription(), $feature->getTags(), $feature->getBackground(), $scenarios, $feature->getKeyword(), $feature->getLanguage(), $feature->getFile(), $feature->getLine());
 }
 public function createFilename(FeatureNode $feature, ScenarioInterface $scenario, OutlineNode $outline = null)
 {
     $filename = Transliterator::transliterate($feature->getTitle(), $this->separator) . DIRECTORY_SEPARATOR;
     if ($outline) {
         $filename .= Transliterator::transliterate($outline->getTitle(), $this->separator) . DIRECTORY_SEPARATOR . $this->separator;
     }
     $filename .= Transliterator::transliterate($scenario->getTitle(), $this->separator);
     if ($outline) {
         $filename .= $this->separator;
     }
     return $filename;
 }
 function its_printHeader_when_basePath_is_specified_should_output_file_and_line_with_relative_path(Formatter $formatter, FeatureNode $featureNode, Scenario $scenario, OutputPrinter $printer)
 {
     $folderName = 'foldername';
     $filename = 'file';
     $lineNumber = 2;
     $this->beConstructedWith($folderName);
     $formatter->getOutputPrinter()->shouldBeCalled()->willReturn($printer);
     $featureNode->getFile()->shouldBeCalled()->willReturn($folderName . '/' . $filename);
     $scenario->getLine()->shouldBeCalled()->willReturn($lineNumber);
     $printer->write("{$filename}:{$lineNumber}")->shouldBeCalled();
     $this->printHeader($formatter, $featureNode, $scenario);
 }
Example #18
0
 /**
  * Prints scenario path comment.
  *
  * @param Formatter   $formatter
  * @param FeatureNode $feature
  * @param Scenario    $scenario
  * @param integer     $indentation
  */
 public function printScenarioPath(Formatter $formatter, FeatureNode $feature, Scenario $scenario, $indentation)
 {
     $printer = $formatter->getOutputPrinter();
     if (!$formatter->getParameter('paths')) {
         $printer->writeln();
         return;
     }
     $fileAndLine = sprintf('%s:%s', $this->relativizePaths($feature->getFile()), $scenario->getLine());
     $headerWidth = $this->widthCalculator->calculateScenarioHeaderWidth($scenario, $indentation);
     $scenarioWidth = $this->widthCalculator->calculateScenarioWidth($scenario, $indentation, 2);
     $spacing = str_repeat(' ', max(0, $scenarioWidth - $headerWidth));
     $printer->writeln(sprintf('%s {+comment}# %s{-comment}', $spacing, $fileAndLine));
 }
Example #19
0
 /**
  * {@inheritDoc}
  */
 public function printHeader(Formatter $formatter, FeatureNode $feature)
 {
     $stats = $this->statistics->getScenarioStatCounts();
     if (0 === count($stats)) {
         $totalCount = 0;
     } else {
         $totalCount = array_sum($stats);
     }
     /** @var JUnitOutputPrinter $outputPrinter */
     $outputPrinter = $formatter->getOutputPrinter();
     $outputPrinter->addTestsuite(array('name' => $feature->getTitle(), 'tests' => $totalCount, 'skipped' => $stats[TestResult::SKIPPED], 'failures' => $stats[TestResult::FAILED], 'errors' => $stats[TestResult::PENDING] + $stats[StepResult::UNDEFINED]));
     $this->statistics->reset();
 }
Example #20
0
 private function findStepNodes()
 {
     $scenarios = $this->featureNode->getScenarios();
     if (count($scenarios) === 0) {
         throw new \InvalidArgumentException('Unable to find any scenarios in dummy feature');
     }
     $scenario = $scenarios[0];
     $steps = $scenario->getSteps();
     if (count($steps) === 0) {
         throw new \InvalidArgumentException('Unable to find any steps in dummy feature');
     }
     $this->stepNodes = $steps;
 }
Example #21
0
 public function test()
 {
     $this->makeContexts();
     $description = explode("\n", $this->featureNode->getDescription());
     foreach ($description as $line) {
         $this->getScenario()->runStep(new Comment($line));
     }
     if ($background = $this->featureNode->getBackground()) {
         foreach ($background->getSteps() as $step) {
             $this->runStep($step);
         }
     }
     foreach ($this->scenarioNode->getSteps() as $step) {
         $this->runStep($step);
     }
 }
 public function testTokens()
 {
     $step = new StepNode('When', 'Some "<text>" in <string>');
     $scenario = new ScenarioNode();
     $scenario->addStep($step);
     $feature = new FeatureNode();
     $feature->addScenario($scenario);
     $feature->freeze();
     $step1 = $step->createExampleRowStep(array('text' => 'change'));
     $this->assertNotSame($step, $step1);
     $this->assertEquals('Some "change" in <string>', $step1->getText());
     $this->assertEquals('Some "<text>" in <string>', $step1->getCleanText());
     $step2 = $step->createExampleRowStep(array('text' => 'change', 'string' => 'browser'));
     $this->assertNotSame($step, $step2);
     $this->assertEquals('Some "change" in browser', $step2->getText());
     $this->assertEquals('Some "<text>" in <string>', $step2->getCleanText());
 }
Example #23
0
 public function testLoader()
 {
     $gherkin = new Gherkin();
     $gherkin->addLoader($loader = $this->getLoaderMock());
     $gherkin->addFilter($nameFilter = $this->getNameFilterMock());
     $gherkin->addFilter($tagFilter = $this->getTagFilterMock());
     $feature = new FeatureNode();
     $feature->addScenario($scenario = new ScenarioNode());
     $loader->expects($this->once())->method('supports')->with($resource = 'some/feature/resource')->will($this->returnValue(true));
     $loader->expects($this->once())->method('load')->with($resource)->will($this->returnValue(array($feature)));
     $nameFilter->expects($this->once())->method('isScenarioMatch')->with($scenario)->will($this->returnValue(true));
     $tagFilter->expects($this->once())->method('isScenarioMatch')->with($scenario)->will($this->returnValue(true));
     $features = $gherkin->load($resource);
     $this->assertEquals(1, count($features));
     $scenarios = $features[0]->getScenarios();
     $this->assertEquals(1, count($scenarios));
     $this->assertSame($scenario, $scenarios[0]);
 }
Example #24
0
 /**
  * {@inheritdoc}
  */
 protected function printFeatureDescription(FeatureNode $feature)
 {
     $lines = explode("\n", $feature->getDescription());
     $this->writeln('<p>');
     foreach ($lines as $line) {
         $this->writeln(htmlspecialchars($line) . "<br />");
     }
     $this->writeln('</p>');
 }
Example #25
0
 /**
  * Prints feature header.
  *
  * @param FeatureNode $feature Current feature node
  * @return [void]
  *
  * @uses printFeatureOrScenarioTags()
  * @uses printFeatureName()
  * @uses printFeatureDescription()
  */
 protected function printFeatureHeader(FeatureNode $feature)
 {
     $this->writeln('<table style="' . $this->_getTableStyles() . '">');
     $this->writeln('<colgroup>
     <col width="287">
     <col width="121">
     <col width="157">
     <col width="77">
     <col width="288">
     </colgroup>');
     $this->writeln('<tr>
     <th colspan=5 rowspan=1 style="' . $this->_getTitleStyles() . '">
     Pantheon: ' . $feature->getTitle() . '<br>' . date('Y-m-d') . '</th>
     </tr>');
     $this->writeln('<tr>');
     $headers = array('Core Experience', 'Status', 'Errors', 'Workflow ID', 'Comments');
     foreach ($headers as $header) {
         $this->writeln('<th style="' . $this->_getHeaderStyles() . '">' . $header . '</th>');
     }
 }
 /**
  * {@inheritdoc}
  *
  * @throws AmbiguousMatchException
  */
 public function searchDefinition(Environment $environment, FeatureNode $feature, StepNode $step)
 {
     $suite = $environment->getSuite();
     $language = $feature->getLanguage();
     $stepText = $step->getText();
     $multi = $step->getArguments();
     $definitions = array();
     $result = null;
     foreach ($this->repository->getEnvironmentDefinitions($environment) as $definition) {
         $definition = $this->translator->translateDefinition($suite, $definition, $language);
         if (!($newResult = $this->match($definition, $stepText, $multi))) {
             continue;
         }
         $result = $newResult;
         $definitions[] = $newResult->getMatchedDefinition();
     }
     if (count($definitions) > 1) {
         throw new AmbiguousMatchException($result->getMatchedText(), $definitions);
     }
     return $result;
 }
 /**
  * Dumps feature.
  *
  * @param FeatureNode $feature Feature instance
  *
  * @return string
  */
 public function dumpFeature(FeatureNode $feature)
 {
     $language = $feature->getLanguage();
     $this->keywords->setLanguage($language);
     $content = '' . $this->dumpLanguage($language) . ($feature->getTags() ? PHP_EOL . $this->dumpTags($feature->getTags(), 0) : '') . PHP_EOL . $this->dumpKeyword($this->keywords->getFeatureKeywords(), $feature->getTitle(), 0) . PHP_EOL . $this->dumpText($feature->getDescription(), 1);
     if ($feature->getBackground()) {
         $content .= $this->dumpBackground($feature->getBackground());
     }
     $scenarios = $feature->getScenarios();
     foreach ($scenarios as $scenario) {
         $content .= PHP_EOL . $this->dumpScenario($scenario);
     }
     return $content;
 }
Example #28
0
 /**
  * Filters feature according to the filter.
  *
  * @param FeatureNode $feature
  */
 public function filterFeature(FeatureNode $feature)
 {
     $scenarios = $feature->getScenarios();
     foreach ($scenarios as $i => $scenario) {
         if (!$this->isScenarioMatch($scenario)) {
             unset($scenarios[$i]);
             continue;
         }
         if ($scenario instanceof OutlineNode && $scenario->hasExamples()) {
             $lines = $scenario->getExamples()->getRowLines();
             $rows = $scenario->getExamples()->getNumeratedRows();
             if (current($lines) <= $this->filterLine && end($lines) >= $this->filterLine) {
                 $scenario->getExamples()->setRows(array());
                 $scenario->getExamples()->addRow($rows[$lines[0]], $lines[0]);
                 if ($lines[0] !== $this->filterLine) {
                     $scenario->getExamples()->addRow($rows[$this->filterLine], $this->filterLine);
                 }
             }
         }
     }
     $feature->setScenarios($scenarios);
 }
Example #29
0
 /**
  * Filters feature according to the filter and returns new one.
  *
  * @param FeatureNode $feature
  *
  * @return FeatureNode
  */
 public function filterFeature(FeatureNode $feature)
 {
     $scenarios = array();
     foreach ($feature->getScenarios() as $scenario) {
         if (!$this->isScenarioMatch($scenario)) {
             continue;
         }
         if ($scenario instanceof OutlineNode && $scenario->hasExamples()) {
             $table = $scenario->getExampleTable()->getTable();
             $lines = array_keys($table);
             if (in_array($this->filterLine, $lines)) {
                 $filteredTable = array($lines[0] => $table[$lines[0]]);
                 if ($lines[0] !== $this->filterLine) {
                     $filteredTable[$this->filterLine] = $table[$this->filterLine];
                 }
                 $scenario = new OutlineNode($scenario->getTitle(), $scenario->getTags(), $scenario->getSteps(), new ExampleTableNode($filteredTable, $scenario->getExampleTable()->getKeyword()), $scenario->getKeyword(), $scenario->getLine());
             }
         }
         $scenarios[] = $scenario;
     }
     return new FeatureNode($feature->getTitle(), $feature->getDescription(), $feature->getTags(), $feature->getBackground(), $scenarios, $feature->getKeyword(), $feature->getLanguage(), $feature->getFile(), $feature->getLine());
 }
 public function testLoader()
 {
     $customFilter1 = $this->getCustomFilterMock();
     $customFilter2 = $this->getCustomFilterMock();
     $gherkin = new Gherkin();
     $gherkin->addLoader($loader = $this->getLoaderMock());
     $gherkin->addFilter($nameFilter = $this->getNameFilterMock());
     $gherkin->addFilter($tagFilter = $this->getTagFilterMock());
     $feature = new FeatureNode();
     $feature->addScenario($scenario = new ScenarioNode());
     $loader->expects($this->once())->method('supports')->with($resource = 'some/feature/resource')->will($this->returnValue(true));
     $loader->expects($this->once())->method('load')->with($resource)->will($this->returnValue(array($feature)));
     $nameFilter->expects($this->once())->method('filterFeature')->with($this->identicalTo($feature));
     $tagFilter->expects($this->once())->method('filterFeature')->with($this->identicalTo($feature));
     $customFilter1->expects($this->once())->method('filterFeature')->with($this->identicalTo($feature));
     $customFilter2->expects($this->once())->method('filterFeature')->with($this->identicalTo($feature));
     $features = $gherkin->load($resource, array($customFilter1, $customFilter2));
     $this->assertEquals(1, count($features));
     $this->assertTrue($feature->isFrozen());
     $scenarios = $features[0]->getScenarios();
     $this->assertEquals(1, count($scenarios));
     $this->assertSame($scenario, $scenarios[0]);
 }