<?php
/**
* Whoops - php errors for cool kids
* @author Filipe Dobreira <http://github.com/filp>
*/
namespace Whoops;
use ArrayObject;
use Exception;
use InvalidArgumentException;
use Mockery as m;
use RuntimeException;
use Whoops\Handler\Handler;
use Whoops\Exception\Frame;
class RunTest extends TestCase
{
public function testImplementsRunInterface()
{
$this->assertNotFalse(class_implements('Whoops\\Run', 'Whoops\\RunInterface'));
}
public function testConstantsAreAccessibleFromTheClass()
{
$this->assertEquals(RunInterface::ERROR_HANDLER, Run::ERROR_HANDLER);
$this->assertEquals(RunInterface::EXCEPTION_HANDLER, Run::EXCEPTION_HANDLER);
$this->assertEquals(RunInterface::SHUTDOWN_HANDLER, Run::SHUTDOWN_HANDLER);
}
/**
* @param string $message
* @return Exception
*/
protected function getException($message = "")
{
// HHVM does not support mocking exceptions
// Since we do not use any additional features of Mockery for exceptions,
// we can just use native Exceptions instead.
return new \Exception($message);
}
/**
* @return Handler
*/
protected function getHandler()
{
return m::mock('Whoops\\Handler\\Handler')
->shouldReceive('setRun')
->andReturn(null)
->mock()
->shouldReceive('setInspector')
->andReturn(null)
->mock()
->shouldReceive('setException')
->andReturn(null)
->mock();
}
/**
* @covers Whoops\Run::clearHandlers
*/
public function testClearHandlers()
{
$run = $this->getRunInstance();
$run->clearHandlers();
$handlers = $run->getHandlers();
$this->assertEmpty($handlers);
}
/**
* @covers Whoops\Run::pushHandler
*/
public function testPushHandler()
{
$run = $this->getRunInstance();
$run->clearHandlers();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$run->pushHandler($handlerOne);
$run->pushHandler($handlerTwo);
$handlers = $run->getHandlers();
$this->assertCount(2, $handlers);
$this->assertContains($handlerOne, $handlers);
$this->assertContains($handlerTwo, $handlers);
}
/**
* @covers Whoops\Run::pushHandler
*/
public function testPushInvalidHandler()
{
$run = $this->getRunInstance();
$this->expectExceptionOfType('InvalidArgumentException');
$run->pushHandler('actually turnip');
}
/**
* @covers Whoops\Run::pushHandler
*/
public function testPushClosureBecomesHandler()
{
$run = $this->getRunInstance();
$run->pushHandler(function () {});
$this->assertInstanceOf('Whoops\\Handler\\CallbackHandler', $run->popHandler());
}
/**
* @covers Whoops\Run::popHandler
* @covers Whoops\Run::getHandlers
*/
public function testPopHandler()
{
$run = $this->getRunInstance();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$handlerThree = $this->getHandler();
$run->pushHandler($handlerOne);
$run->pushHandler($handlerTwo);
$run->pushHandler($handlerThree);
$this->assertSame($handlerThree, $run->popHandler());
$this->assertSame($handlerTwo, $run->popHandler());
$this->assertSame($handlerOne, $run->popHandler());
// Should return null if there's nothing else in
// the stack
$this->assertNull($run->popHandler());
// Should be empty since we popped everything off
// the stack:
$this->assertEmpty($run->getHandlers());
}
/**
* @covers Whoops\Run::removeFirstHandler
* @covers Whoops\Run::removeLastHandler
* @covers Whoops\Run::getHandlers
*/
public function testRemoveHandler()
{
$run = $this->getRunInstance();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$handlerThree = $this->getHandler();
$run->pushHandler($handlerOne);
$run->pushHandler($handlerTwo);
$run->pushHandler($handlerThree);
$run->removeLastHandler();
$this->assertSame($handlerTwo, $run->getHandlers()[0]);
$run->removeFirstHandler();
$this->assertSame($handlerTwo, $run->getHandlers()[0]);
$this->assertCount(1, $run->getHandlers());
}
/**
* @covers Whoops\Run::register
*/
public function testRegisterHandler()
{
// It is impossible to test the Run::register method using phpunit,
// as given how every test is always inside a giant try/catch block,
// any thrown exception will never hit a global exception handler.
// On the other hand, there is not much need in testing
// a call to a native PHP function.
$this->assertTrue(true);
}
/**
* @covers Whoops\Run::unregister
*/
public function testUnregisterHandler()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
$run->unregister();
$this->expectExceptionOfType('Exception');
throw $this->getException("I'm not supposed to be caught!");
}
/**
* @covers Whoops\Run::pushHandler
* @covers Whoops\Run::getHandlers
*/
public function testHandlerHoldsOrder()
{
$run = $this->getRunInstance();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$handlerThree = $this->getHandler();
$handlerFour = $this->getHandler();
$run->pushHandler($handlerOne);
$run->prependHandler($handlerTwo);
$run->appendHandler($handlerThree);
$run->appendHandler($handlerFour);
$handlers = $run->getHandlers();
$this->assertSame($handlers[0], $handlerFour);
$this->assertSame($handlers[1], $handlerThree);
$this->assertSame($handlers[2], $handlerOne);
$this->assertSame($handlers[3], $handlerTwo);
}
/**
* @todo possibly split this up a bit and move
* some of this test to Handler unit tests?
* @covers Whoops\Run::handleException
*/
public function testHandlersGonnaHandle()
{
$run = $this->getRunInstance();
$exception = $this->getException();
$order = new ArrayObject();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$handlerThree = $this->getHandler();
$handlerOne->shouldReceive('handle')
->andReturnUsing(function () use ($order) { $order[] = 1; });
$handlerTwo->shouldReceive('handle')
->andReturnUsing(function () use ($order) { $order[] = 2; });
$handlerThree->shouldReceive('handle')
->andReturnUsing(function () use ($order) { $order[] = 3; });
$run->pushHandler($handlerOne);
$run->pushHandler($handlerTwo);
$run->pushHandler($handlerThree);
// Get an exception to be handled, and verify that the handlers
// are given the handler, and in the inverse order they were
// registered.
$run->handleException($exception);
$this->assertEquals((array) $order, [3, 2, 1]);
}
/**
* @covers Whoops\Run::handleException
*/
public function testLastHandler()
{
$run = $this->getRunInstance();
$handlerOne = $this->getHandler();
$handlerTwo = $this->getHandler();
$handlerThree = $this->getHandler();
$handlerFour = $this->getHandler();
$run->pushHandler($handlerOne);
$run->prependHandler($handlerTwo);
$run->appendHandler($handlerThree);
$run->appendHandler($handlerFour);
$test = $this;
$handlerFour
->shouldReceive('handle')
->andReturnUsing(function () use ($test) {
$test->fail('$handlerFour should not be called');
});
$handlerThree
->shouldReceive('handle')
->andReturn(Handler::LAST_HANDLER);
$twoRan = false;
$handlerOne
->shouldReceive('handle')
->andReturnUsing(function () use ($test, &$twoRan) {
$test->assertTrue($twoRan);
});
$handlerTwo
->shouldReceive('handle')
->andReturnUsing(function () use (&$twoRan) {
$twoRan = true;
});
$run->handleException($this->getException());
// Reached the end without errors
$this->assertTrue(true);
}
/**
* Test error suppression using @ operator.
*/
public function testErrorSuppression()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
$test = $this;
$handler
->shouldReceive('handle')
->andReturnUsing(function () use ($test) {
$test->fail('$handler should not be called, error not suppressed');
});
@trigger_error("Test error suppression");
// Reached the end without errors
$this->assertTrue(true);
}
public function testErrorCatching()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
$test = $this;
$handler
->shouldReceive('handle')
->andReturnUsing(function () use ($test) {
$test->fail('$handler should not be called error should be caught');
});
try {
trigger_error('foo', E_USER_NOTICE);
$this->fail('Should not continue after error thrown');
} catch (\ErrorException $e) {
// Do nothing
$this->assertTrue(true);
return;
}
$this->fail('Should not continue here, should have been caught.');
}
/**
* Test to make sure that error_reporting is respected.
*/
public function testErrorReporting()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
$test = $this;
$handler
->shouldReceive('handle')
->andReturnUsing(function () use ($test) {
$test->fail('$handler should not be called, error_reporting not respected');
});
$oldLevel = error_reporting(E_ALL ^ E_USER_NOTICE);
trigger_error("Test error reporting", E_USER_NOTICE);
error_reporting($oldLevel);
// Reached the end without errors
$this->assertTrue(true);
}
/**
* @covers Whoops\Run::silenceErrorsInPaths
*/
public function testSilenceErrorsInPaths()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
$test = $this;
$handler
->shouldReceive('handle')
->andReturnUsing(function () use ($test) {
$test->fail('$handler should not be called, silenceErrorsInPaths not respected');
});
$run->silenceErrorsInPaths('@^'.preg_quote(__FILE__, '@').'$@', E_USER_NOTICE);
trigger_error('Test', E_USER_NOTICE);
$this->assertTrue(true);
}
/**
* @covers Whoops\Run::handleError
* @requires PHP < 8
*/
public function testGetSilencedError()
{
$run = $this->getRunInstance();
$run->register();
$handler = $this->getHandler();
$run->pushHandler($handler);
@strpos();
$error = error_get_last();
$this->assertTrue($error && strpos($error['message'], 'strpos()') !== false);
}
/**
* @covers Whoops\Run::handleError
* @see https://github.com/filp/whoops/issues/267
*/
public function testErrorWrappedInException()
{
try {
$run = $this->getRunInstance();
$run->handleError(E_WARNING, 'my message', 'my file', 99);
$this->fail("missing expected exception");
} catch (\ErrorException $e) {
$this->assertSame(E_WARNING, $e->getSeverity());
$this->assertSame(E_WARNING, $e->getCode(), "For BC reasons getCode() should match getSeverity()");
$this->assertSame('my message', $e->getMessage());
$this->assertSame('my file', $e->getFile());
$this->assertSame(99, $e->getLine());
}
}
/**
* @covers Whoops\Run::handleException
* @covers Whoops\Run::writeToOutput
*/
public function testOutputIsSent()
{
$run = $this->getRunInstance();
$run->pushHandler(function () {
echo "hello there";
});
ob_start();
$run->handleException(new RuntimeException());
$this->assertEquals("hello there", ob_get_clean());
}
/**
* @covers Whoops\Run::handleException
* @covers Whoops\Run::writeToOutput
*/
public function testOutputIsNotSent()
{
$run = $this->getRunInstance();
$run->writeToOutput(false);
$run->pushHandler(function () {
echo "hello there";
});
ob_start();
$this->assertEquals("hello there", $run->handleException(new RuntimeException()));
$this->assertEquals("", ob_get_clean());
}
/**
* @covers Whoops\Run::sendHttpCode
*/
public function testSendHttpCode()
{
$run = $this->getRunInstance();
$run->sendHttpCode(true);
$this->assertEquals(500, $run->sendHttpCode());
}
/**
* @covers Whoops\Run::sendHttpCode
*/
public function testSendHttpCodeNullCode()
{
$run = $this->getRunInstance();
$this->assertEquals(false, $run->sendHttpCode(null));
}
/**
* @covers Whoops\Run::sendHttpCode
*/
public function testSendHttpCodeWrongCode()
{
$this->expectExceptionOfType('InvalidArgumentException');
$this->getRunInstance()->sendHttpCode(1337);
}
/**
* @covers Whoops\Run::sendHttpCode
*/
public function testSendExitCode()
{
$run = $this->getRunInstance();
$run->sendExitCode(42);
$this->assertEquals(42, $run->sendExitCode());
}
/**
* @covers Whoops\Run::sendExitCode
*/
public function testSendExitCodeDefaultCode()
{
$run = $this->getRunInstance();
$this->assertEquals(1, $run->sendExitCode());
}
/**
* @covers Whoops\Run::sendExitCode
*/
public function testSendExitCodeWrongCode()
{
$this->expectExceptionOfType('InvalidArgumentException');
$this->getRunInstance()->sendExitCode(255);
}
/**
* @covers Whoops\Run::addFrameFilter
* @covers Whoops\Run::getFrameFilters
*/
public function testAddFrameFilter()
{
$run = $this->getRunInstance();
$filterCallbackOne = function(Frame $frame) {};
$filterCallbackTwo = function(Frame $frame) {};
$run
->addFrameFilter($filterCallbackOne)
->addFrameFilter($filterCallbackTwo);
$frameFilters = $run->getFrameFilters();
$this->assertCount(2, $frameFilters);
$this->assertContains($filterCallbackOne, $frameFilters);
$this->assertContains($filterCallbackTwo, $frameFilters);
$this->assertInstanceOf("Whoops\\RunInterface", $run);
}
/**
* @covers Whoops\Run::clearFrameFilters
* @covers Whoops\Run::getFrameFilters
*/
public function testClearFrameFilters()
{
$run = $this->getRunInstance();
$run->addFrameFilter(function(Frame $frame) {});
$run = $run->clearFrameFilters();
$this->assertEmpty($run->getFrameFilters());
$this->assertInstanceOf("Whoops\\RunInterface", $run);
}
}