MyTester\Assert

Complexity

Total Complexity

57

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Importance

Changes	13
Bugs	3	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	count()	0	8	4
B	notContains()	0	17	9
A	notNull()	0	9	3
A	tryAssertion()	0	9	4
A	notSame()	0	9	3
B	type()	0	15	7
A	true()	0	9	3
A	same()	0	9	3
B	contains()	0	17	9
A	showStringOrArray()	0	2	2
A	notCount()	0	8	4
A	null()	0	9	3
A	false()	0	9	3

<?php
declare(strict_types=1);

namespace MyTester;

/**
 * Assertions
 *
 * @author Jakub Konečný
 * @copyright (c) 2015-2019, Jakub Konečný
 * @license https://spdx.org/licenses/BSD-3-Clause.html BSD-3-Clause
 */
final class Assert {
  use \Nette\StaticClass;

  /**
   * @param string|array $variable
   */
  private static function showStringOrArray($variable): string {
    return (is_string($variable) ? $variable : "(array)");
  }
  
  /**
   * Tries an assertion
   * 
   * @param mixed $code Assertion to try
   * @param string $successText Text to print on success
   * @param string $failureText Text to print on failure
   */
  public static function tryAssertion($code, string $successText = "", string $failureText = ""): void {

The method parameter $successText is never used

The parameter $successText is not used and could be removed.

    $success = ($code == true);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = ($failureText === "") ? "Assertion \"$code\" is not true." : $failureText;
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Are both values same?
   * 
   * @param mixed $expected
   * @param mixed $actual
   */
  public static function same($expected, $actual): void {
    $success = ($expected == $actual);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The value is not $expected but $actual.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Are not both values same?
   * 
   * @param mixed $expected
   * @param mixed $actual
   */
  public static function notSame($expected, $actual): void {
    $success = ($expected !== $actual);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The value is $expected.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the expression true?
   * 
   * @param mixed $actual
   */
  public static function true($actual): void {
    $success = ($actual == true);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The expression is not true.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the expression false?
   * 
   * @param mixed $actual
   */
  public static function false($actual): void {
    $success = ($actual == false);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The expression is not false.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is the value null?
   * 
   * @param mixed $actual
   */
  public static function null($actual): void {
    $success = ($actual == null);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The value is not null.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Is not the value null?
   * 
   * @param mixed $actual
   */
  public static function notNull($actual): void {
    $success = ($actual !== null);
    if(Environment::getShouldFail()) {
      $success = !$success;
    }
    if(!$success) {
      $message = "The value is null.";
    }
    Environment::testResult($message ?? "", $success);
  }
  
  /**
   * Does $actual contain $needle?
   * 
   * @param string|array $needle
   * @param string|array $actual
   */
  public static function contains($needle, $actual): void {
    if(!is_string($needle) AND !is_array($needle)) {

The condition is_array($needle) is always true.

      Environment::testResult("The variable is not string or array.", false);
    } elseif(is_string($actual) AND is_string($needle)) {
      if($needle !== "" AND strpos($actual, $needle) !== false) {
        Environment::testResult("");
      } else {
        Environment::testResult("$needle is not in the variable.", false);
      }
    } elseif(is_array($actual)) {
      if(in_array($needle, $actual)) {
        Environment::testResult(self::showStringOrArray($needle) . " is in the variable.");
      } else {
        Environment::testResult(self::showStringOrArray($needle) . " is not in the variable.", false);
      }
    } else {
      Environment::testResult(self::showStringOrArray($needle) . " is not in the variable.", false);
    }
  }
  
  /**
   * Does $actual not contain $needle?
   * 
   * @param string|array $needle
   * @param string|array $actual
   */
  public static function notContains($needle, $actual): void {
    if(!is_string($needle) AND !is_array($needle)) {

The condition is_array($needle) is always true.

      Environment::testResult("The variable is not string or array.", false);
    } elseif(is_string($actual) AND is_string($needle)) {
      if($needle === "" OR strpos($actual, $needle) === false) {
        Environment::testResult("");
      } else {
        Environment::testResult("$needle is in the variable.", false);
      }
    } elseif(is_array($actual)) {
      if(!in_array($needle, $actual)) {
        Environment::testResult("");
      } else {
        Environment::testResult(self::showStringOrArray($needle) . " is in the variable.", false);
      }
    } else {
      Environment::testResult(self::showStringOrArray($needle) . " is not in the variable.", false);
    }
  }
  
  /**
   * Does $value contain $count items?
   *
   * @param string|array|\Countable $value
   */
  public static function count(int $count, $value): void {
    if(!is_array($value) AND !$value instanceof \Countable) {
      Environment::testResult("The variable is not array or countable object.", false);
    } elseif(count($value) === $count) {
      Environment::testResult("");
    } else {
      $actual = count($value);
      Environment::testResult("Count of the variable is $actual.", false);
    }
  }
  
  /**
   * Does $value not contain $count items?
   *
   * @param string|array|\Countable $value
   */
  public static function notCount(int $count, $value): void {
    if(!is_array($value) AND !$value instanceof \Countable) {
      Environment::testResult("The variable is not array or countable object.", false);
    } elseif(count($value) === $count) {
      $actual = count($value);
      Environment::testResult("Count of the variable is $actual.", false);
    } else {
      Environment::testResult("");
    }
  }
  
  /**
   * Is $value of type $type?
   * 
   * @param string|object $type
   * @param mixed $value
   */
  public static function type($type, $value): void {
    if(!is_object($type) AND !is_string($type)) {

The condition is_string($type) is always true.

      Environment::testResult("Type must be string or object.", false);
    } elseif(in_array($type, ["array", "bool", "callable", "float",
      "int", "integer", "null", "object", "resource", "scalar", "string"], true)) {
      if(!call_user_func("is_$type", $value)) {
        Environment::testResult("The variable is " . gettype($value) . ".", false);
      } else {
        Environment::testResult("");
      }
    } elseif(!$value instanceof $type) {
      $actual = is_object($value) ? get_class($value) : gettype($value);
      Environment::testResult("The variable is instance of $actual.", false);
    } else {
      Environment::testResult("");
    }
  }
}
?>