Test::restoreErrorHandlers() - Code Metrics - Inspection of "Tests now fail when an error occurs." - peridot-php/peridot - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#177)

by Erin

created 2016-03-09 07:25 UTC

Test::restoreErrorHandlers() A

↳ Parent: Test

Complexity

Conditions	4
Paths	4

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	16
rs	9.2
cc	4
eloc	8
nc	4
nop	1

<?php

namespace Peridot\Core;

use ErrorException;
use Exception;
use Throwable;

/**
 * The main test fixture for Peridot.
 *
 * @package Peridot\Core
 */
class Test extends AbstractTest
{
    /**
     * @param string $description
     * @param callable $definition
     */
    public function __construct($description, callable $definition = null)
    {
        if ($definition === null) {
            $this->pending = true;
            $definition = function () {
                //noop
            };
        }
        parent::__construct($description, $definition);
    }

    /**
     * Execute the test along with any setup and tear down functions.
     *
     * @param  TestResult $result
     * @return void
     */
    public function run(TestResult $result)
    {
        $result->startTest($this);

        if ($this->getPending()) {
            $result->pendTest($this);
            return;
        }
        $this->executeTest($result);
        $result->endTest($this);
    }

    /**
     * Attempt to execute setup functions and run the test definition
     *
     * @param TestResult $result
     */
    protected function executeTest(TestResult $result)
    {
        $action = ['passTest', $this];
        $handlers = $this->handleErrors($result, $action);
        try {
            $this->runSetup();
            call_user_func_array($this->getDefinition(), $this->getDefinitionArguments());
        } catch (Throwable $e) {

            if ('passTest' === $action[0]) {
                $action = ['failTest', $this, $e];
            }
        } catch (Exception $e) {
            if ('passTest' === $action[0]) {
                $action = ['failTest', $this, $e];
            }
        }
        $this->runTearDown($result, $action);
        $this->restoreErrorHandlers($handlers);
    }

    /**
     * Excecute the test's setup functions
     */
    protected function runSetup()
    {
        $this->forEachNodeTopDown(function (TestInterface $node) {
            $setups = $node->getSetupFunctions();
            foreach ($setups as $setup) {
                $setup();
            }
        });
    }

    /**
     * Run the tests tear down methods and have the result
     * perform the method indicated by $action
     *
     * @param TestResult $result
     * @param array $action
     */
    protected function runTearDown(TestResult $result, $action)
    {
        $this->forEachNodeBottomUp(function (TestInterface $test) use ($result, &$action) {
            $tearDowns = $test->getTearDownFunctions();
            foreach ($tearDowns as $tearDown) {
                try {
                    $tearDown();
                } catch (Throwable $e) {

                    if ('passTest' === $action[0]) {
                        $action = ['failTest', $this, $e];
                    }
                } catch (Exception $e) {
                    if ('passTest' === $action[0]) {
                        $action = ['failTest', $this, $e];
                    }
                }
            }
        });
        call_user_func_array([$result, $action[0]], array_slice($action, 1));
    }

    /**
     * Set an error handler to handle errors within the test
     *
     * @param TestResult $result
     * @param array      &$action
     *
     * @return array
     */
    protected function handleErrors(TestResult $result, &$action)
    {
        // first, unwind the current handler stack for later restoration
        $handlers = [];

        do {
            if ($handler = set_error_handler(function () {})) {
                $handlers[] = $handler;
                restore_error_handler();
            }

            restore_error_handler();
        } while ($handler);

        // determine the most recently added handler
        if ($handlers) {

            $handler = $handlers[0];
        } else {
            $handler = null;
        }

        set_error_handler(function ($severity, $message, $path, $line) use ($result, &$action, &$handler) {
            // if there is an existing error handler, call it and record the result
            $isHandled = $handler && false !== $handler($severity, $message, $path, $line);

            if (!$isHandled) {
                $result->getEventEmitter()->emit('error', [$severity, $message, $path, $line]);

                // honor the error reporting configuration - this also takes care of the error control operator (@)
                $errorReporting = error_reporting();
                $shouldHandle = $severity === ($severity & $errorReporting);

                if ($shouldHandle && 'passTest' === $action[0]) {
                    $action = ['failTest', $this, new ErrorException($message, 0, $severity, $path, $line)];
                }
            }
        });

        return $handlers;
    }

    /**
     * Restore the error handler stack to a previous state
     *
     * @param array $handlers
     */
    protected function restoreErrorHandlers($handlers)
    {
        // discard existing handlers
        do {
            if ($handler = set_error_handler(function () {})) {
                restore_error_handler();
            }

            restore_error_handler();
        } while ($handler);

        // restore handlers in reverse order
        for ($i = count($handlers) - 1; $i >= 0; --$i) {
            set_error_handler($handlers[$i]);
        }
    }
}


1			<?php
2
3			namespace Peridot\Core;
4
5			use ErrorException;
6			use Exception;
7			use Throwable;
8
9			/**
10			* The main test fixture for Peridot.
11			*
12			* @package Peridot\Core
13			*/
14			class Test extends AbstractTest
15			{
16			/**
17			* @param string $description
18			* @param callable $definition
19			*/
20			public function __construct($description, callable $definition = null)
21			{
22			if ($definition === null) {
23			$this->pending = true;
24			$definition = function () {
25			//noop
26			};
27			}
28			parent::__construct($description, $definition);
29			}
30
31			/**
32			* Execute the test along with any setup and tear down functions.
33			*
34			* @param TestResult $result
35			* @return void
36			*/
37			public function run(TestResult $result)
38			{
39			$result->startTest($this);
40
41			if ($this->getPending()) {
42			$result->pendTest($this);
43			return;
44			}
45			$this->executeTest($result);
46			$result->endTest($this);
47			}
48
49			/**
50			* Attempt to execute setup functions and run the test definition
51			*
52			* @param TestResult $result
53			*/
54			protected function executeTest(TestResult $result)
55			{
56			$action = ['passTest', $this];
57			$handlers = $this->handleErrors($result, $action);
58			try {
59			$this->runSetup();
60			call_user_func_array($this->getDefinition(), $this->getDefinitionArguments());
61			} catch (Throwable $e) {
			0 ignored issues – show Bug introduced 2016-03-09 05:53 UTC by Report Bug Copy Issue Report The class `Throwable` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
62			if ('passTest' === $action[0]) {
63			$action = ['failTest', $this, $e];
64			}
65			} catch (Exception $e) {
66			if ('passTest' === $action[0]) {
67			$action = ['failTest', $this, $e];
68			}
69			}
70			$this->runTearDown($result, $action);
71			$this->restoreErrorHandlers($handlers);
72			}
73
74			/**
75			* Excecute the test's setup functions
76			*/
77			protected function runSetup()
78			{
79			$this->forEachNodeTopDown(function (TestInterface $node) {
80			$setups = $node->getSetupFunctions();
81			foreach ($setups as $setup) {
82			$setup();
83			}
84			});
85			}
86
87			/**
88			* Run the tests tear down methods and have the result
89			* perform the method indicated by $action
90			*
91			* @param TestResult $result
92			* @param array $action
93			*/
94			protected function runTearDown(TestResult $result, $action)
95			{
96			$this->forEachNodeBottomUp(function (TestInterface $test) use ($result, &$action) {
97			$tearDowns = $test->getTearDownFunctions();
98			foreach ($tearDowns as $tearDown) {
99			try {
100			$tearDown();
101			} catch (Throwable $e) {
			0 ignored issues – show Bug introduced 2016-03-09 05:53 UTC by Report Bug Copy Issue Report The class `Throwable` does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json? Loading history...
102			if ('passTest' === $action[0]) {
103			$action = ['failTest', $this, $e];
104			}
105			} catch (Exception $e) {
106			if ('passTest' === $action[0]) {
107			$action = ['failTest', $this, $e];
108			}
109			}
110			}
111			});
112			call_user_func_array([$result, $action[0]], array_slice($action, 1));
113			}
114
115			/**
116			* Set an error handler to handle errors within the test
117			*
118			* @param TestResult $result
119			* @param array &$action
120			*
121			* @return array
122			*/
123			protected function handleErrors(TestResult $result, &$action)
124			{
125			// first, unwind the current handler stack for later restoration
126			$handlers = [];
127
128			do {
129			if ($handler = set_error_handler(function () {})) {
130			$handlers[] = $handler;
131			restore_error_handler();
132			}
133
134			restore_error_handler();
135			} while ($handler);
136
137			// determine the most recently added handler
138			if ($handlers) {
			0 ignored issues – show Bug Best Practice introduced 2016-03-09 05:53 UTC by Report Bug Copy Issue Report The expression `$handlers` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
139			$handler = $handlers[0];
140			} else {
141			$handler = null;
142			}
143
144			set_error_handler(function ($severity, $message, $path, $line) use ($result, &$action, &$handler) {
145			// if there is an existing error handler, call it and record the result
146			$isHandled = $handler && false !== $handler($severity, $message, $path, $line);
147
148			if (!$isHandled) {
149			$result->getEventEmitter()->emit('error', [$severity, $message, $path, $line]);
150
151			// honor the error reporting configuration - this also takes care of the error control operator (@)
152			$errorReporting = error_reporting();
153			$shouldHandle = $severity === ($severity & $errorReporting);
154
155			if ($shouldHandle && 'passTest' === $action[0]) {
156			$action = ['failTest', $this, new ErrorException($message, 0, $severity, $path, $line)];
157			}
158			}
159			});
160
161			return $handlers;
162			}
163
164			/**
165			* Restore the error handler stack to a previous state
166			*
167			* @param array $handlers
168			*/
169			protected function restoreErrorHandlers($handlers)
170			{
171			// discard existing handlers
172			do {
173			if ($handler = set_error_handler(function () {})) {
174			restore_error_handler();
175			}
176
177			restore_error_handler();
178			} while ($handler);
179
180			// restore handlers in reverse order
181			for ($i = count($handlers) - 1; $i >= 0; --$i) {
182			set_error_handler($handlers[$i]);
183			}
184			}
185			}
186

peridot-php / peridot

Pull Request — master (#177)

Test::restoreErrorHandlers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like