Esempio n. 1
0
 /**
  * Constructor
  *
  * @param string|object $actual   A fully-namespaced class name or an object instance.
  * @param string        $expected The expected method method name to be called.
  */
 public function __construct($actual, $expected)
 {
     $this->_backtrace = Debugger::backtrace();
     if (is_string($actual)) {
         $actual = ltrim($actual, '\\');
     }
     $this->_check($actual);
     if (!$expected) {
         throw new InvalidArgumentException("Method name can't be empty.");
     }
     $names = is_array($expected) ? $expected : [$expected];
     $reference = $actual;
     if (count($names) > 1) {
         if (!Stub::registered(Suite::hash($reference))) {
             throw new InvalidArgumentException("Kahlan can't Spy chained methods on real PHP code, you need to Stub the chain first.");
         }
     }
     $reference = $this->_reference($reference);
     foreach ($names as $index => $name) {
         if (preg_match('/^::.*/', $name)) {
             $reference = is_object($reference) ? get_class($reference) : $reference;
         }
         $this->_expected[] = $name;
         $this->_messages[$name] = $this->_watch(new Message(['parent' => $this, 'reference' => $reference, 'name' => $name]));
         $reference = null;
     }
 }
Esempio n. 2
0
 /**
  * Constructor
  *
  * @param string|object $actual   A fully-namespaced class name or an object instance.
  * @param string        $expected The expected method method name to be called.
  */
 public function __construct($actual)
 {
     $actual = ltrim($actual, '\\');
     $this->_actual = $actual;
     Suite::register(Suite::hash($actual));
     $this->_message = new Message(['name' => $actual]);
     $this->_backtrace = Debugger::backtrace();
 }
Esempio n. 3
0
 /**
  * Constructor
  *
  * @param string|object $actual   A fully-namespaced class name or an object instance.
  * @param string        $expected The expected method method name to be called.
  */
 public function __construct($actual, $expected)
 {
     if (preg_match('/^::.*/', $expected)) {
         $actual = is_object($actual) ? get_class($actual) : $actual;
     }
     $call = $this->_classes['call'];
     $this->_actual = $actual;
     $this->_expected = $expected;
     $this->_call = new $call($actual);
     $this->_message = $this->_call->method($expected);
     $this->_backtrace = Debugger::backtrace();
 }
Esempio n. 4
0
 /**
  * Overrides the default error handler
  *
  * @param boolean $enable  If `true` override the default error handler,
  *                         if `false` restore the default handler.
  * @param array   $options An options array. Available options are:
  *                         - 'handler': An error handler closure.
  *
  */
 protected function _errorHandler($enable, $options = [])
 {
     $defaults = ['handler' => null];
     $options += $defaults;
     if (!$enable) {
         return restore_error_handler();
     }
     $handler = function ($code, $message, $file, $line = 0, $args = []) {
         $trace = debug_backtrace();
         $trace = array_slice($trace, 1, count($trace));
         $message = "`" . Debugger::errorType($code) . "` {$message}";
         $code = 0;
         $exception = compact('code', 'message', 'file', 'line', 'trace');
         throw new PhpErrorException($exception);
     };
     $options['handler'] = $options['handler'] ?: $handler;
     set_error_handler($options['handler'], error_reporting());
 }
Esempio n. 5
0
    describe("::loader()", function () {
        it("gets/sets a loader", function () {
            $loader = Stub::create();
            expect(Debugger::loader($loader))->toBe($loader);
        });
    });
    describe("::errorType()", function () {
        it("returns some reader-friendly error type string", function () {
            expect(Debugger::errorType(E_ERROR))->toBe('E_ERROR');
            expect(Debugger::errorType(E_WARNING))->toBe('E_WARNING');
            expect(Debugger::errorType(E_PARSE))->toBe('E_PARSE');
            expect(Debugger::errorType(E_NOTICE))->toBe('E_NOTICE');
            expect(Debugger::errorType(E_CORE_ERROR))->toBe('E_CORE_ERROR');
            expect(Debugger::errorType(E_CORE_WARNING))->toBe('E_CORE_WARNING');
            expect(Debugger::errorType(E_CORE_ERROR))->toBe('E_CORE_ERROR');
            expect(Debugger::errorType(E_COMPILE_ERROR))->toBe('E_COMPILE_ERROR');
            expect(Debugger::errorType(E_CORE_WARNING))->toBe('E_CORE_WARNING');
            expect(Debugger::errorType(E_COMPILE_WARNING))->toBe('E_COMPILE_WARNING');
            expect(Debugger::errorType(E_USER_ERROR))->toBe('E_USER_ERROR');
            expect(Debugger::errorType(E_USER_WARNING))->toBe('E_USER_WARNING');
            expect(Debugger::errorType(E_USER_NOTICE))->toBe('E_USER_NOTICE');
            expect(Debugger::errorType(E_STRICT))->toBe('E_STRICT');
            expect(Debugger::errorType(E_RECOVERABLE_ERROR))->toBe('E_RECOVERABLE_ERROR');
            expect(Debugger::errorType(E_DEPRECATED))->toBe('E_DEPRECATED');
            expect(Debugger::errorType(E_USER_DEPRECATED))->toBe('E_USER_DEPRECATED');
        });
        it("returns <INVALID> for undefined error type", function () {
            expect(Debugger::errorType(123456))->toBe('<INVALID>');
        });
    });
});
Esempio n. 6
0
 /**
  * Applies focus up to the root.
  */
 protected function _emitFocus()
 {
     $this->_root->_focuses[] = Debugger::focus($this->backtraceFocus(), Debugger::backtrace());
     $instances = $this->_parents(true);
     foreach ($instances as $instance) {
         $instance->focus();
     }
 }
Esempio n. 7
0
 /**
  * Adds an expectation report and emits a report event.
  *
  * @param array $data The report data.
  */
 public function add($type, $data = [])
 {
     if ($this->type() === 'passed' && $type === 'failed') {
         $this->type('failed');
     }
     $data['type'] = $type;
     if (!isset($data['backtrace'])) {
         $data['backtrace'] = [];
     } else {
         $data['backtrace'] = Debugger::focus($this->scope()->backtraceFocus(), $data['backtrace'], 1);
     }
     $child = new static($data + ['scope' => $this->_scope]);
     $this->_children[] = $child;
     return $child;
 }
Esempio n. 8
0
 /**
  * Logs a result.
  *
  * @param  boolean $boolean Set `true` for success and `false` for failure.
  * @param  array   $data    Test details array.
  * @return boolean
  */
 protected function _log($boolean, $data = [])
 {
     $not = $this->_not;
     $pass = $not ? !$boolean : $boolean;
     if ($pass) {
         $data['type'] = 'pass';
     } else {
         $data['type'] = 'fail';
         $this->_passed = false;
     }
     $description = $data['description'];
     if (is_array($description)) {
         $data['params'] = $description['params'];
         $data['description'] = $description['description'];
     }
     $data['backtrace'] = Debugger::backtrace();
     $data['not'] = $not;
     $this->_logs[] = $data;
     $this->_not = false;
     return $boolean;
 }
Esempio n. 9
0
 /**
  * Helper which extracts the backtrace of a report.
  *
  * @param array $data The report data.
  */
 public function _backtrace($data)
 {
     if (isset($data['exception'])) {
         return Debugger::backtrace(['trace' => $data['exception']]);
     }
     $type = $data['type'];
     $depth = $type === 'pass' || $type === 'fail' | $type === 'skip' ? 1 : null;
     if (!isset($data['backtrace'])) {
         $data['backtrace'] = [];
     }
     return Debugger::focus($this->scope()->backtraceFocus(), $data['backtrace'], $depth);
 }
Esempio n. 10
0
 /**
  * Prints focused report to STDOUT
  *
  * @param array $report A report array.
  */
 protected function _reportFocused($report)
 {
     if (!($backtraces = $report['focuses'])) {
         return;
     }
     $this->write("Focus Mode Detected in the following files:\n", 'b;yellow;');
     foreach ($backtraces as $backtrace) {
         $this->write(Debugger::trace(['trace' => $backtrace, 'depth' => 1]), 'n;yellow');
         $this->write("\n");
     }
     $this->write("exit(-1)\n\n", 'red');
 }
Esempio n. 11
0
 /**
  * The Constructor.
  *
  * @param array $config The Suite config array. Options are:
  *                       -`'type'`    _string_ : supported type are `'normal'` & `'focus'`.
  *                       -`'message'` _string_ : the description message.
  *                       -`'parent'`  _object_ : the parent scope.
  *                       -`'root'`    _object_ : the root scope.
  *                       -`'log'`     _object_ : the log instance.
  *                       -`'timeout'` _integer_: the timeout.
  */
 public function __construct($config = [])
 {
     $defaults = ['type' => 'normal', 'message' => '', 'parent' => null, 'root' => null, 'log' => null, 'timeout' => 0, 'summary' => null];
     $config += $defaults;
     $this->_type = $config['type'];
     $this->_message = $config['message'];
     $this->_parent = $config['parent'];
     $this->_root = $this->_parent ? $this->_parent->_root : $this;
     $this->_timeout = $config['timeout'];
     $this->_backtrace = Debugger::focus($this->backtraceFocus(), Debugger::backtrace(), 1);
     $this->_log = $config['log'] ?: new Log(['scope' => $this, 'backtrace' => $this->_backtrace]);
     $this->_summary = $config['summary'];
     if ($this->_summary) {
         return;
     }
     if ($this->_root->summary()) {
         $this->_summary = $this->_root->summary();
     } else {
         $this->_summary = new Summary();
     }
 }