public function testTokens() { $table = new TableNode(); $table->addRow(array('username', 'password')); $table->addRow(array('<username>', '<password>')); $tableCompare = new TableNode(<<<TABLE | username | password | | everzet | qwerty | TABLE ); $exampleTable = $table->createExampleRowStepArgument(array('username' => 'everzet', 'password' => 'qwerty')); $this->assertNotSame($table, $exampleTable); $this->assertSame($tableCompare->getRows(), $exampleTable->getRows()); }
public function testTableFromArrayCreation() { $table1 = new TableNode(); $table1->addRow(array('username', 'password')); $table1->addRow(array('everzet', 'qwerty')); $table1->addRow(array('antono', 'pa$sword')); $table2 = new TableNode(<<<TABLE | username | password | | everzet | qwerty | | antono | pa\$sword| TABLE ); $this->assertEquals($table2->getRows(), $table1->getRows()); $this->assertEquals(array(array('username' => 'everzet', 'password' => 'qwerty'), array('username' => 'antono', 'password' => 'pa$sword')), $table1->getHash()); $this->assertEquals(array('username' => 'password', 'everzet' => 'qwerty', 'antono' => 'pa$sword'), $table2->getRowsHash()); }
/** * The assert_entities step should verify that entities have expected values * * @param \Ingenerator\BeEntity\Factory $factory the entity factory mock * @param \Ingenerator\BeEntity\FactoryManager $manager the factory manager mock * @param \Doctrine\ORM\EntityManager $entity_manager the entity manager * * @return void * @see \Ingenerator\BeEntity\Context\BeEntityContext::assert_entities */ public function it_can_verify_that_expected_entities_have_expected_values($factory, $manager, $entity_manager) { $manager->create_factory('Dummy')->willReturn($factory); $this->set_factory_manager($manager); // The entity exists but has invalid values $factory->matches('not existing dummy', array('active' => 'y', 'foo' => 'bar'))->willReturn(array('foo' => array('exp' => 'bar', 'got' => 'foo'))); // Stub some entity data that would be specified in the table $data_1 = array('title' => 'not existing dummy', 'active' => 'y', 'foo' => 'bar'); $table = new TableNode(); $table->addRow(array_keys($data_1)); $table->addRow($data_1); // The entity manager should be cleared to ensure values are reloaded from DB $entity_manager->clear()->shouldBeCalled(); $this->shouldThrow('\\Ingenerator\\BeEntity\\Exception\\ExpectationException')->during('assert_entities', array('Dummy', $table)); }
public function translationTestDataProvider() { $data = array(); $translator = $this->getTranslator(); $parser = $this->getParser(); $finder = new Finder(); $i18ns = $finder->files()->name('*.xliff')->in(__DIR__ . '/../Fixtures/i18n'); foreach ($i18ns as $i18n) { $language = basename($i18n, '.xliff'); $translator->addResource('xliff', $i18n, $language, 'gherkin'); $etalon = array(); $features = array(); foreach ($this->getTranslatedKeywords('Feature', $language) as $featureNum => $featureKeyword) { $gherkin = "# language: {$language}"; $lineNum = 1; $feature = new Node\FeatureNode(null, null, null, ++$lineNum); $feature->setLanguage($language); $feature->setKeyword($featureKeyword); $feature->setTitle($title = "title of the feature N{$featureNum}"); $feature->setDescription($description = "some\nfeature\ndescription"); $gherkin .= "\n{$featureKeyword}: {$title}"; $gherkin .= "\n{$description}"; $lineNum += 3; $stepKeywords = $this->getTranslatedKeywords('Given|When|Then|And|But', $language); $backgroundKeywords = $this->getTranslatedKeywords('Background', $language); $examplesKeywords = $this->getTranslatedKeywords('Examples', $language); // Background $backgroundKeyword = $backgroundKeywords[0]; $background = new Node\BackgroundNode(null, ++$lineNum); $background->setKeyword($backgroundKeyword); $feature->setBackground($background); $gherkin .= "\n{$backgroundKeyword}:"; foreach ($stepKeywords as $stepNum => $stepKeyword) { $step = new Node\StepNode($stepKeyword, $text = "text of the step N{$stepNum}", ++$lineNum); $background->addStep($step); $gherkin .= "\n{$stepKeyword} {$text}"; } // Scenarios foreach ($this->getTranslatedKeywords('Scenario', $language) as $scenarioNum => $scenarioKeyword) { $scenario = new Node\ScenarioNode($title = "title of the scenario N{$scenarioNum}", ++$lineNum); $scenario->setKeyword($scenarioKeyword); $feature->addScenario($scenario); $gherkin .= "\n{$scenarioKeyword}: {$title}"; foreach ($stepKeywords as $stepNum => $stepKeyword) { $step = new Node\StepNode($stepKeyword, $text = "text of the step N{$stepNum}", ++$lineNum); $scenario->addStep($step); $gherkin .= "\n{$stepKeyword} {$text}"; } } // Scenario Outlines foreach ($this->getTranslatedKeywords('Scenario Outline', $language) as $outlineNum => $outlineKeyword) { $outline = new Node\OutlineNode($title = "title of the outline N{$outlineNum}", ++$lineNum); $outline->setKeyword($outlineKeyword); $feature->addScenario($outline); $gherkin .= "\n{$outlineKeyword}: {$title}"; $stepKeyword = $stepKeywords[0]; $step = new Node\StepNode($stepKeyword, $text = "text of the step <num>", ++$lineNum); $outline->addStep($step); $gherkin .= "\n{$stepKeyword} {$text}"; $examplesKeyword = $examplesKeywords[0]; $examples = new Node\TableNode(); $examples->setKeyword($examplesKeyword); $examples->addRow(array('num')); $examples->addRow(array(2)); $outline->setExamples($examples); $gherkin .= "\n{$examplesKeyword}:"; $gherkin .= "\n | num |"; $gherkin .= "\n | 2 |"; $lineNum += 3; } $etalon[] = $feature; $features[] = $this->getParser()->parse($gherkin); } $data[] = array($language, $etalon, $features); } return $data; }
/** * Helper function to modify #count#, #refcount# and #repeatcount# in table. * * @param TableNode $data Data to be passed to the resource. * @throws */ protected function fix_data_counter(TableNode $data) { $datanodes = array(); $rows = $data->getRows(); // Get table keys and remove instances and reference $firstrow = array_shift($rows); if (($instancekey = array_search('instances', $firstrow)) !== false) { unset($firstrow[$instancekey]); } if (($refkey = array_search('referencecount', $firstrow)) !== false) { unset($firstrow[$refkey]); } if (($repeatkey = array_search('repeat', $firstrow)) !== false) { unset($firstrow[$repeatkey]); } // Create all instances. foreach ($rows as $row) { // Get count and unset instances key. $instances = $row[$instancekey]; unset($row[$instancekey]); // Check if there is an refrence which needs to be met. // Reference is like how many categories to use to create given instances of sub-category. $reference = 0; if ($refkey) { $reference = $row[$refkey]; unset($row[$refkey]); // We want sequential filling of data so keep track of counter. $referencecounter = 1; $maxperreference = ceil($instances / $reference); } // Check if repeat is given to repeat process. $repeat = 1; if ($repeatkey) { $repeat = $row[$repeatkey]; unset($row[$repeatkey]); } for ($repeatcounter = 1; $repeatcounter <= $repeat; $repeatcounter++) { for ($i = 1; $i <= $instances; $i++) { $rowtoadd = $row; $datanode = new TableNode(); $datanode->addRow($firstrow); foreach ($rowtoadd as $key => $value) { if ($reference) { $rowtoadd[$key] = str_replace("#count#", $referencecounter, $value); } else { $rowtoadd[$key] = str_replace("#count#", $i, $value); } $rowtoadd[$key] = str_replace("#refcount#", $i, $rowtoadd[$key]); $rowtoadd[$key] = str_replace("#repeatcount#", $repeatcounter, $rowtoadd[$key]); } $datanode->addRow($rowtoadd); // Call generator function. //$contexttouse->$function($elementname, $datanode); $datanodes[] = $datanode; // We want sequential filling of data so increment reference counter. if ($reference && $i % $maxperreference == 0) { $referencecounter++; } } } } return $datanodes; }
/** * Loads table from provided hash. * * @param array $hash Table hash * * @return TableNode */ protected function loadTableHash(array $hash) { $table = new Node\TableNode(); foreach ($hash as $line => $row) { $table->addRow($row, $line); } return $table; }
public function translationTestDataProvider() { $keywords = $this->getKeywords(); $lexer = new Lexer($keywords); $parser = new Parser($lexer); $dumper = new KeywordsDumper($keywords); $data = array(); foreach ($this->getKeywordsArray() as $lang => $i18nKeywords) { $features = array(); foreach (explode('|', $i18nKeywords['feature']) as $transNum => $featureKeyword) { $line = 1; if ('en' !== $lang) { $line = 2; } $feature = new Node\FeatureNode('Internal operations', <<<DESC In order to stay secret As a secret organization We need to be able to erase past agents' memory DESC , $lang . '_' . ($transNum + 1) . '.feature', $line); $feature->setLanguage($lang); $feature->setKeyword($featureKeyword); $line += 5; $background = new Node\BackgroundNode(null, $line); $keywords = explode('|', $i18nKeywords['background']); $background->setKeyword($keywords[0]); $line += 1; $line = $this->addSteps($background, $i18nKeywords['given'], 'there is agent A', $line); $line = $this->addSteps($background, $i18nKeywords['and'], 'there is agent B', $line); $feature->setBackground($background); $line += 1; foreach (explode('|', $i18nKeywords['scenario']) as $scenarioKeyword) { $scenario = new Node\ScenarioNode('Erasing agent memory', $line); $scenario->setKeyword($scenarioKeyword); $line += 1; $line = $this->addSteps($scenario, $i18nKeywords['given'], 'there is agent J', $line); $line = $this->addSteps($scenario, $i18nKeywords['and'], 'there is agent K', $line); $line = $this->addSteps($scenario, $i18nKeywords['when'], 'I erase agent K\'s memory', $line); $line = $this->addSteps($scenario, $i18nKeywords['then'], 'there should be agent J', $line); $line = $this->addSteps($scenario, $i18nKeywords['but'], 'there should not be agent K', $line); $feature->addScenario($scenario); $line += 1; } foreach (explode('|', $i18nKeywords['scenario_outline']) as $outlineKeyword) { $outline = new Node\OutlineNode('Erasing other agents\' memory', $line); $outline->setKeyword($outlineKeyword); $line += 1; $line = $this->addSteps($outline, $i18nKeywords['given'], 'there is agent <agent1>', $line); $line = $this->addSteps($outline, $i18nKeywords['and'], 'there is agent <agent2>', $line); $line = $this->addSteps($outline, $i18nKeywords['when'], 'I erase agent <agent2>\'s memory', $line); $line = $this->addSteps($outline, $i18nKeywords['then'], 'there should be agent <agent1>', $line); $line = $this->addSteps($outline, $i18nKeywords['but'], 'there should not be agent <agent2>', $line); $line += 1; $examples = new Node\TableNode(); $examples->addRow(' | agent1 | agent2 |', ++$line); $examples->addRow(' | D | M |', ++$line); $outline->setExamples($examples); $keywords = explode('|', $i18nKeywords['examples']); $examples->setKeyword($keywords[0]); $line += 1; $feature->addScenario($outline); $line += 1; } $features[] = $feature; } $dumped = $dumper->dump($lang, false); $parsed = array(); try { foreach ($dumped as $num => $dumpedFeature) { $parsed[] = $parser->parse($dumpedFeature, $lang . '_' . ($num + 1) . '.feature'); } } catch (\Exception $e) { throw new \Exception($e->getMessage() . ":\n" . $dumped, 0, $e); } $data[] = array($lang, $features, $parsed); } return $data; }
/** * Parses table token & returns it's node. * * @return Behat\Gherkin\Node\TableNode */ protected function parseTable() { $token = $this->expectTokenType('TableRow'); $node = new Node\TableNode(); $node->addRow($token->columns); $this->skipExtraChars(); while ('TableRow' === $this->predictTokenType()) { $token = $this->expectTokenType('TableRow'); $node->addRow($token->columns); $this->skipExtraChars(); } return $node; }
public function providerTableNode() { // complete table $node1 = new TableNode(); $node1->addRow(array('lib1', 'lib2', 'lib3')); $node1->addRow(array(1, 2, 3)); $node1->addRow(array(4, 5, 6)); $expected1 = ' | lib1 | lib2 | lib3 | | 1 | 2 | 3 | | 4 | 5 | 6 |'; // empty table $node2 = new TableNode(); $expected2 = ''; return array(array($node1, $expected1), array($node2, $expected2)); }