public function parseScenarioOptions($code)
{
$annotations = ['group', 'env', 'skip', 'incomplete', 'ignore'];
$comments = $this->matchComments($code);
foreach ($annotations as $annotation) {
$values = Annotation::fetchAllFromComment($annotation, $comments);
foreach ($values as $value) {
call_user_func([$this->scenario, $annotation], $value);
}
}
// deprecated - parsing $scenario->xxx calls
$metaData = ['group', 'env'];
$phpCode = $this->stripComments($code);
$scenario = $this->scenario;
$feature = $scenario->getFeature();
foreach ($metaData as $call) {
$res = preg_match_all("~\\\$scenario->{$call}.*?;~", $phpCode, $matches);
if (!$res) {
continue;
}
foreach ($matches[0] as $line) {
// run $scenario->group or $scenario->env
\Codeception\Lib\Deprecation::add("\$scenario->{$call}() is deprecated in favor of annotation: // @{$call}", $this->scenario->getFeature());
eval($line);
}
}
}
public function preload()
{
$this->scenario->setFeature($this->getSpecFromMethod());
$code = $this->getSourceCode();
$this->parser->parseFeature($code);
$this->parser->attachMetadata(Annotation::forMethod($this->testClassInstance, $this->testMethod)->raw());
$this->getMetadata()->getService('di')->injectDependencies($this->testClassInstance);
}
public function attachMetadata($comments)
{
$this->metadata->setGroups(Annotation::fetchAllFromComment('group', $comments));
$this->metadata->setEnv(Annotation::fetchAllFromComment('env', $comments));
$this->metadata->setDependencies(Annotation::fetchAllFromComment('depends', $comments));
$this->metadata->setSkip($this->firstOrNull(Annotation::fetchAllFromComment('skip', $comments)));
$this->metadata->setIncomplete($this->firstOrNull(Annotation::fetchAllFromComment('incomplete', $comments)));
}
protected function executeAfter($testMethod, $I)
{
$after = Annotation::forClass($this->testClassInstance)->method($testMethod)->fetch('after');
if (!$after) {
return;
}
$this->executeContextMethod($after, $I);
}
public function attachMetadata($comments)
{
$annotations = ['group', 'env', 'skip', 'incomplete', 'ignore'];
foreach ($annotations as $annotation) {
$values = Annotation::fetchAllFromComment($annotation, $comments);
foreach ($values as $value) {
call_user_func([$this->scenario, $annotation], $value);
}
}
}
protected function enhancePhpunitTest(\PHPUnit_Framework_TestCase $test)
{
$className = get_class($test);
$methodName = $test->getName(false);
$dependencies = \PHPUnit_Util_Test::getDependencies($className, $methodName);
$test->setDependencies($dependencies);
if ($test instanceof TestCaseFormat) {
$test->getMetadata()->setDependencies($dependencies);
$test->getMetadata()->setEnv(Annotation::forMethod($test, $methodName)->fetchAll('env'));
}
}
public function preload()
{
$this->scenario->setFeature($this->getSpecFromMethod());
$code = $this->getSourceCode();
$this->parser->parseFeature($code);
$this->parser->attachMetadata(Annotation::forMethod($this->testClassInstance, $this->testMethod)->raw());
$this->getMetadata()->getService('di')->injectDependencies($this->testClassInstance);
// add example params to feature
if ($this->getMetadata()->getCurrent('example')) {
$params = implode(', ', array_values($this->getMetadata()->getCurrent('example')));
$this->getScenario()->setFeature($this->getScenario()->getFeature() . ' | ' . $params);
}
}
public function preload()
{
$this->scenario->setFeature($this->getSpecFromMethod());
$code = $this->getSourceCode();
$this->parser->parseFeature($code);
$this->parser->attachMetadata(Annotation::forMethod($this->testClassInstance, $this->testMethod)->raw());
$this->getMetadata()->getService('di')->injectDependencies($this->testClassInstance);
// add example params to feature
if ($this->getMetadata()->getCurrent('example')) {
$step = new Comment('', $this->getMetadata()->getCurrent('example'));
$this->getScenario()->setFeature($this->getScenario()->getFeature() . ' | ' . $step->getArgumentsAsString(100));
}
}
protected function enhancePhpunitTest(\PHPUnit_Framework_TestCase $test)
{
$className = get_class($test);
$methodName = $test->getName(false);
$dependencies = \PHPUnit_Util_Test::getDependencies($className, $methodName);
$test->setDependencies($dependencies);
if ($test instanceof UnitFormat) {
$feature = $test->getName();
$feature = preg_replace('/([A-Z]+)([A-Z][a-z])/', '\\1 \\2', $feature);
$feature = preg_replace('/([a-z\\d])([A-Z])/', '\\1 \\2', $feature);
$test->getMetadata()->setFeature(strtolower($feature));
$test->getMetadata()->setDependencies($dependencies);
$test->getMetadata()->setEnv(Annotation::forMethod($test, $methodName)->fetchAll('env'));
}
}
public function before(\Codeception\Event\SuiteEvent $se)
{
$suite = $se->getSuite();
$tests = $suite->tests();
foreach ($tests as $id => $test) {
if (is_a($test, 'Codeception\\Test\\Cest')) {
$testClass = $test->getTestClass();
$testClassName = get_class($testClass);
$testMethod = $test->getTestMethod();
$testFile = $test->getMetadata()->getFilename();
$testActor = $test->getMetadata()->getCurrent('actor');
$dataMethod = Annotation::forMethod($testClass, $testMethod)->fetch('dataprovider');
try {
if (empty($dataMethod)) {
continue;
}
if (false === is_callable([$testClass, $dataMethod])) {
throw new \Exception();
}
$dataProvider = new \PHPUnit_Framework_TestSuite_DataProvider();
$examples = $testClassName::$dataMethod();
foreach ($examples as $example) {
if ($example === null) {
throw new TestParseException($testFile, "Invalid values format returned by DataProvider {$dataMethod} for {$testClassName}->{$testMethod}.");
}
$dataTest = new CestFormat($testClass, $testMethod, $testFile);
$dataTest->getMetadata()->setServices(['di' => $test->getMetadata()->getService('di'), 'dispatcher' => $test->getMetadata()->getService('dispatcher'), 'modules' => $test->getMetadata()->getService('modules')]);
$dataTest->getMetadata()->setCurrent(['actor' => $testActor, 'example' => $example]);
$step = new Comment('', $dataTest->getMetadata()->getCurrent('example'));
$dataTest->getScenario()->setFeature($dataTest->getSpecFromMethod() . ' | ' . $step->getArgumentsAsString(100));
$groups = Annotation::forMethod($testClass, $testMethod)->fetchAll('group');
$dataProvider->addTest($dataTest, $groups);
}
$tests[$id] = $dataProvider;
} catch (\Exception $e) {
throw new TestParseException($testFile, "DataProvider {$dataMethod} for {$testClassName}->{$testMethod} is invalid or not callable." . PHP_EOL . "Make sure this is a public static function.");
}
}
}
$suite->setTests($tests);
}
protected function addSteps(array $contexts, $group = 'default')
{
$this->steps[$group] = [];
foreach ($contexts as $context) {
$methods = get_class_methods($context);
if (!$methods) {
continue;
}
foreach ($methods as $method) {
$annotation = Annotation::forMethod($context, $method);
foreach (['Given', 'When', 'Then'] as $type) {
$pattern = $annotation->fetch($type);
if (!$pattern) {
continue;
}
$pattern = $this->makePlaceholderPattern($pattern);
$this->steps[$group][$pattern] = [$context, $method];
}
}
}
}
public function loadTests($file)
{
Parser::load($file);
$testClasses = Parser::getClassesFromFile($file);
foreach ($testClasses as $testClass) {
if (substr($testClass, -strlen('Cest')) !== 'Cest') {
continue;
}
if (!(new \ReflectionClass($testClass))->isInstantiable()) {
continue;
}
$unit = new $testClass();
$methods = get_class_methods($testClass);
foreach ($methods as $method) {
if (strpos($method, '_') === 0) {
continue;
}
$rawExamples = Annotation::forMethod($unit, $method)->fetchAll('example');
if (count($rawExamples)) {
$examples = array_map(function ($v) {
return Annotation::arrayValue($v);
}, $rawExamples);
$dataProvider = new \PHPUnit_Framework_TestSuite_DataProvider();
foreach ($examples as $k => $example) {
if ($example === null) {
throw new TestParseException($file, "Example for {$testClass}->{$method} contains invalid data:\n" . $rawExamples[$k] . "\n" . "Make sure this is a valid JSON (Hint: \"-char for strings) or a single-line annotation in Doctrine-style");
}
$test = new CestFormat($unit, $method, $file);
$test->getMetadata()->setCurrent(['example' => $example]);
$groups = Annotation::forMethod($unit, $method)->fetchAll('group');
$dataProvider->addTest($test, $groups);
}
$this->tests[] = $dataProvider;
continue;
}
$this->tests[] = new CestFormat($unit, $method, $file);
}
}
}
public function testValueToSupportAnnotationStyle()
{
$values = Annotation::arrayValue('( code="200", user="******", email = "*****@*****.**")');
$this->assertEquals(['code' => '200', 'user' => 'davert', 'email' => '*****@*****.**'], $values);
}
protected function moduleActionBelongsToPart($module, $action, $part)
{
if (!is_array($part)) {
$part = [strtolower($part)];
}
$part = array_map('strtolower', $part);
$parts = Annotation::forMethod($module, $action)->fetchAll('part');
$usedParts = array_intersect($parts, $part);
return !empty($usedParts);
}
protected function createTestFromCestMethod($cestInstance, $methodName, $file, $guy)
{
$testClass = get_class($cestInstance);
if (strpos($methodName, '_') === 0) {
return;
}
$overriddenGuy = Annotation::forMethod($testClass, $methodName)->fetch('guy');
if (!$overriddenGuy) {
$overriddenGuy = Annotation::forClass($testClass)->fetch('guy');
}
if ($overriddenGuy) {
$guy = $overriddenGuy;
}
$cest = new TestCase\Cest($this->dispatcher, array('name' => $methodName, 'instance' => $cestInstance, 'method' => $methodName, 'file' => $file, 'bootstrap' => $this->settings['bootstrap'], 'guy' => $guy));
$cest->getScenario()->env(Annotation::forMethod($testClass, $methodName)->fetchAll('env'));
$cest->getScenario()->groups(\PHPUnit_Util_Test::getGroups($testClass, $methodName));
$cest->setDependencies(\PHPUnit_Util_Test::getDependencies($testClass, $methodName));
$cest->preload();
return $cest;
}
protected function createTestFromCestMethod($cestInstance, $methodName, $file)
{
if (strpos($methodName, '_') === 0 or $methodName == '__construct') {
return null;
}
$testClass = get_class($cestInstance);
$cest = new Cest();
$cest->configName($methodName)->configFile($file)->config('testClassInstance', $cestInstance)->config('testMethod', $methodName)->initConfig();
$cest->getScenario()->env(Annotation::forMethod($testClass, $methodName)->fetchAll('env'));
$cest->setDependencies(\PHPUnit_Util_Test::getDependencies($testClass, $methodName));
return $cest;
}
/**
* Should a method be included as an action?
*
* @param \Codeception\Module $module
* @param \ReflectionMethod $method
* @param array|null $configuredParts
* @return bool
*/
private function includeMethodAsAction($module, $method, $configuredParts = null)
{
// Filter out excluded actions
if (in_array($method->name, $module::$excludeActions)) {
return false;
}
// Keep only the $onlyActions if they are specified
if ($module::$onlyActions && !in_array($method->name, $module::$onlyActions)) {
return false;
}
// Do not include inherited actions if the static $includeInheritedActions property is set to false.
// However, if an inherited action is also specified in the static $onlyActions property
// it should be included as an action.
if (!$module::$includeInheritedActions) {
if (!in_array($method->name, $module::$onlyActions)) {
return false;
}
if ($method->getDeclaringClass()->getName() == get_class($module)) {
return false;
}
}
// Do not include hidden methods, methods with a name starting with an underscore
if (strpos($method->name, '_') === 0) {
return false;
}
// If a part is configured for the module, only include actions from that part
if ($configuredParts) {
$moduleParts = Annotation::forMethod($module, $method->name)->fetchAll('part');
if (!array_uintersect($moduleParts, $configuredParts, 'strcasecmp')) {
return false;
}
}
return true;
}
public function getEnvironment()
{
return Annotation::forMethod($this, $this->getName(false))->fetchAll('env');
}
public function configActor($actor)
{
foreach (['actor', 'guy'] as $annotation) {
$definedActor = Annotation::forMethod($this->testClassInstance, $this->testMethod)->fetch($annotation);
if (!$definedActor) {
$definedActor = Annotation::forClass($this->testClassInstance)->fetch($annotation);
}
if ($definedActor) {
$this->actor = $definedActor;
return $this;
}
}
$this->actor = $actor;
return $this;
}
public function getEnvironment()
{
return Annotation::forMethod($this->testClassInstance, $this->testMethod)->fetchAll('env');
}
public function testMultipleMethodAnnotations()
{
$this->assertEquals(array('$var1', '$var2'), Annotation::forClass(__CLASS__)->method('testMethodAnnotation')->fetchAll('param'));
}