TestCase::getJobs() - Code Metrics - Inspection of "deprecated Environment" - konecnyjakub/mytester - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3cc3ad...47373b )

by Jakub

created 2020-10-01 17:05 UTC

TestCase::getJobs() B

↳ Parent: TestCase

Complexity

Conditions	6
Paths	2

Size

Total Lines	34
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	0	Features	0

Metric	Value
cc	6
eloc	26
nc	2
nop	0
dl	0
loc	34
rs	8.8817
c	7
b	0
f	0

<?php
declare(strict_types=1);

namespace MyTester;

use MyTester\Annotations\NetteReflectionEngine;
use MyTester\Annotations\PhpAttributesEngine;
use MyTester\Annotations\Reader;
use ReflectionClass;
use ReflectionMethod;

/**
 * One test suit
 *
 * @author Jakub Konečný
 * @property-read Job[] $jobs @internal
 */
abstract class TestCase {
  use \Nette\SmartObject;
  use TAssertions;

  public const RESULT_PASSED = ".";
  public const RESULT_SKIPPED = "s";
  public const RESULT_FAILED = "F";
  
  public const METHOD_PATTERN = '#^test[A-Z0-9_]#';

  /** @internal */
  public const ANNOTATION_TEST = "test";
  /** @internal */
  public const ANNOTATION_TEST_SUIT = "testSuit";

  protected SkipChecker $skipChecker;
  protected ShouldFailChecker $shouldFailChecker;
  protected DataProvider $dataProvider;
  protected Reader $annotationsReader;

  public function __construct() {
    $this->annotationsReader = new Reader();
    $this->annotationsReader->registerEngine(new PhpAttributesEngine());
    $this->annotationsReader->registerEngine(new NetteReflectionEngine());
    $this->skipChecker = new SkipChecker($this->annotationsReader);
    $this->shouldFailChecker = new ShouldFailChecker($this->annotationsReader);
    $this->dataProvider = new DataProvider($this->annotationsReader);
  }
  
  /**
   * Get list of jobs with parameters for current test suit
   * 
   * @return Job[]
   */
  protected function getJobs(): array {
    static $jobs = [];
    if(count($jobs) === 0) {
      $r = new ReflectionClass(static::class);
      $methods = array_values(preg_grep(static::METHOD_PATTERN, array_map(function(ReflectionMethod $rm) {
        return $rm->getName();
      }, $r->getMethods())));
      foreach($methods as $method) {
        $reflection = new ReflectionMethod(static::class, $method);
        if(!$reflection->isPublic()) {
          continue;
        }
        /** @var callable $callback */
        $callback = [$this, $method];
        $job = [
          "name" => $this->getJobName(static::class, $method),
          "callback" => $callback,
          "params" => [],
          "skip" => $this->skipChecker->shouldSkip(static::class, $method),
          "shouldFail" => $this->shouldFailChecker->shouldFail(static::class, $method),
        ];
        $data = $this->dataProvider->getData(static::class, $method);
        if(count($data) > 0) {
          foreach($data as $value) {
            $job["params"][0] = $value;
            $jobs[] = new Job($job["name"], $job["callback"], $job["params"], $job["skip"], $job["shouldFail"]);
            $job["params"] = [];
          }
        } else {
          $jobs[] = new Job($job["name"], $job["callback"], $job["params"], $job["skip"], $job["shouldFail"]);
        }
      }
    }
    return $jobs;
  }
  
  /**
   * Get name of current test suit
   */
  protected function getSuitName(): string {
    $annotation = $this->annotationsReader->getAnnotation(static::ANNOTATION_TEST_SUIT, static::class);
    if($annotation !== null) {
      return $annotation;
    }
    return static::class;
  }
  
  /**
   * Get name for a job
   * @param string|object $class
   */
  protected function getJobName($class, string $method): string {
    $annotation = $this->annotationsReader->getAnnotation(static::ANNOTATION_TEST, $class, $method);
    if($annotation !== null) {
      return $annotation;
    }
    return $this->getSuitName() . "::" . $method;
  }
  
  /**
   * Called at start of the suit
   */
  public function startUp(): void {
  }
  
  /**
   * Called at end of the suit
   */
  public function shutDown(): void {
  }
  
  /**
   * Called before each job
   */
  public function setUp(): void {
  }
  
  /**
   * Called after each job
   */
  public function tearDown(): void {
  }
  
  protected function runJob(Job $job): string {
    Environment::$currentJob = $job->name;
    $this->resetCounter();
    if(!$job->skip) {
      $this->setUp();
    }
    $this->shouldFail = $job->shouldFail;
    $job->execute();
    if(!$job->skip) {
      $this->tearDown();
    }
    $this->shouldFail = false;
    Environment::$currentJob = "";
    $this->resetCounter();
    switch($job->result) {
      case Job::RESULT_PASSED:
        return static::RESULT_PASSED;
      case Job::RESULT_SKIPPED:
        return static::RESULT_SKIPPED;
      case Job::RESULT_FAILED:
        return static::RESULT_FAILED;
    }
    return "";
  }
  
  /**
   * Runs the test suit
   */
  public function run(): bool {
    $this->startUp();
    $jobs = $this->getJobs();
    $passed = true;
    foreach($jobs as $job) {
      $result = $this->runJob($job);
      Environment::addResult($result);
      /** @scrutinizer ignore-deprecated */ Environment::addResult($result);
      if($job->result === Job::RESULT_FAILED) {
        $passed = false;
      }
    }
    $this->shutDown();
    return $passed;
  }
}
?>

konecnyjakub / mytester

Push — master ( 3cc3ad...47373b )

TestCase::getJobs() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like