Created
December 15, 2012 19:19
-
-
Save anonymous/4298336 to your computer and use it in GitHub Desktop.
Generic Exception Support for PHPUnit < v3.7 - A full test suite is included.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?php | |
/** | |
* Generic Exception Support for PHPUnit < v3.7 | |
* | |
* These classes help you test generic exceptions in PHPUnit versions less than | |
* v3.7, avoiding the 'You must not expect the generic exception class' error. | |
* | |
* We create a new exception to represent the generic exception, and provide | |
* multiple ways to incorporate the functionality into your tests: | |
* | |
* - Trait : You can use PHPUnit_GenericExceptionTrait | |
* | |
* - Base Class : Your TestCase can extend PHPUnit_GenericException_TestCase | |
* | |
* - Global Functions : If you can't use traits or the base class | |
* | |
* NOTE: Each technique is a full implementation, so you can remove any you | |
* don't want from your version of this file | |
* (i.e. you can delete the trait definition if your PHP version doesn't support it) | |
* | |
* Examples : See PHPUnit_GenericExceptionTest for examples | |
*/ | |
/** | |
* PHPUnit_GenericException Representation of generic exception | |
*/ | |
class PHPUnit_GenericException extends Exception | |
{ | |
/** | |
* Constructor | |
* | |
* We flesh this out as a duplicate of parent constructor to aid in | |
* IDE code-completion. | |
* | |
* @param message[optional] | |
* @param code[optional] | |
* @param previous[optional] | |
*/ | |
public function __construct ($message = null, $code = null, $previous = null) | |
{ | |
parent::__construct($message, $code, $previous); | |
} | |
} | |
/** | |
* PHPUnit_GenericExceptionSupport Interface definition for generic exception support | |
* | |
* This class serves largely to document the functions, as they are duplicated | |
* across several implementations. | |
*/ | |
interface PHPUnit_GenericExceptionSupport | |
{ | |
/** | |
* expectGenericException | |
* | |
* Use this function if your test cases are using setExpectedException() | |
* instead of using annotations. | |
* | |
* @param string $exceptionMessage[optional] | |
* @param int $exceptionCode[optional] | |
*/ | |
function expectGenericException($exceptionMessage = null, $exceptionCode = null); | |
/** | |
* replaceGenericException Replace Exception for PHPUnit_GenericException | |
* | |
* Returns an Exception suitable for throwing, swapping an instance of | |
* the generic exception with PHPUnit_GenericException | |
* | |
* @param Exception $e | |
* @return Exception|PHPUnit_GenericException | |
*/ | |
function replaceGenericException(Exception $e); | |
/** | |
* checkFunctionForGenericException | |
* | |
* Calls the specified function, replacing any generic exceptions thrown | |
* with PHPUnit_GenericException | |
* | |
* @param function $function | |
*/ | |
function checkFunctionForGenericException($function); | |
} | |
/** | |
* PHPUnit_GenericExceptionTrait | |
* | |
* For PHP versions that support traits, you can use this trait to exhibit | |
* generic exception support without cluttering your class hierarchy | |
* | |
* NOTE: If your PHP version supports abstract functions on traits, | |
* consider uncommenting the setExpectedException() declaration to help ensure | |
* you are using the trait on an appropriate class | |
*/ | |
trait PHPUnit_GenericExceptionTrait //implements PHPUnit_GenericExceptionSupport | |
{ | |
/* | |
* If your PHP version supports abstract functions on traits, | |
* consider uncommenting this, to help ensure you are using the trait | |
* on an appropriate class | |
*/ | |
// public abstract function setExpectedException($exceptionName, $exceptionMessage, $exceptionCode); | |
public function expectGenericException($exceptionMessage = null, $exceptionCode = null) | |
{ | |
$this->setExpectedException('PHPUnit_GenericException', $exceptionMessage, $exceptionCode); | |
} | |
public function replaceGenericException(Exception $e) | |
{ | |
if ('Exception' == get_class($e)) | |
{ | |
$e = new PHPUnit_GenericException($e->getMessage(), $e->getCode(), $e->getPrevious()); | |
} | |
return $e; | |
} | |
public function checkFunctionForGenericException($function) | |
{ | |
try | |
{ | |
$function(); | |
} | |
catch (Exception $e) | |
{ | |
throw replaceGenericException($e); | |
} | |
} | |
} | |
/** | |
* PHPUnit_GenericException_TestCase | |
* | |
* For PHP versions that don't support traits, you can extend this class to | |
* exhibit generic exception support. | |
*/ | |
abstract class PHPUnit_GenericException_TestCase extends PHPUnit_Framework_TestCase implements PHPUnit_GenericExceptionSupport | |
{ | |
public function expectGenericException($exceptionMessage = null, $exceptionCode = null) | |
{ | |
$this->setExpectedException('PHPUnit_GenericException', $exceptionMessage, $exceptionCode); | |
} | |
public function replaceGenericException(Exception $e) | |
{ | |
if ('Exception' == get_class($e)) | |
{ | |
$e = new PHPUnit_GenericException($e->getMessage(), $e->getCode(), $e->getPrevious()); | |
} | |
return $e; | |
} | |
public function checkFunctionForGenericException($function) | |
{ | |
try | |
{ | |
$function(); | |
} | |
catch (Exception $e) | |
{ | |
throw replaceGenericException($e); | |
} | |
} | |
} | |
/****************************************************************************** | |
* Global Functions | |
* | |
* If your PHP version does not support traits, and if you don't want to | |
* (or can't) extend the abstract class, you can use these global functions | |
******************************************************************************/ | |
function expectGenericException(PHPUnit_Framework_TestCase $test, $exceptionMessage = null, $exceptionCode = null) | |
{ | |
$test->setExpectedException('PHPUnit_GenericException', $exceptionMessage, $exceptionCode); | |
} | |
function replaceGenericException(Exception $e) | |
{ | |
if ('Exception' == get_class($e)) | |
{ | |
$e = new PHPUnit_GenericException($e->getMessage(), $e->getCode(), $e->getPrevious()); | |
} | |
return $e; | |
} | |
function checkFunctionForGenericException($function) | |
{ | |
try | |
{ | |
$function(); | |
} | |
catch (Exception $e) | |
{ | |
throw replaceGenericException($e); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?php | |
/** | |
* Test Classes for PHPUnit_GenericException support | |
*/ | |
require_once 'PHPUnit_GenericException.php'; | |
/** | |
* GenericExceptionTraitTest tests generic exception support via trait | |
* PHPUnit_GenericExceptionTrait | |
*/ | |
class GenericExceptionTraitTest extends PHPUnit_Framework_TestCase | |
{ | |
use PHPUnit_GenericExceptionTrait; | |
/** | |
* Simple example just showing what the annotation looks like. | |
* Your code would not throw PHPUnit_GenericException. | |
* | |
* @expectedException PHPUnit_GenericException | |
*/ | |
public function testAnnotation() | |
{ | |
throw new PHPUnit_GenericException(); | |
} | |
// Simple example showing how to declare exception without annotations. | |
public function testExpectedException() | |
{ | |
$this->expectGenericException(); | |
throw new PHPUnit_GenericException(); | |
} | |
// Example showing how to replace generic exception if you want | |
// your function to do the 'throw' | |
public function testReplaceException() | |
{ | |
$this->expectGenericException(); | |
try | |
{ | |
throw new Exception(); | |
} | |
catch (Exception $e) | |
{ | |
throw $this->replaceGenericException($e); | |
} | |
} | |
// Example of wrapping your test in a callback (or closure) and let | |
// us do the catch/replace/throw. | |
public function testCheckFunction() | |
{ | |
$this->expectGenericException(); | |
$function = function() | |
{ | |
throw new Exception(); | |
}; | |
$this->checkFunctionForGenericException($function); | |
} | |
} | |
/** | |
* GenericExceptionBaseTest Tests generic exception support via extending | |
* PHPUnit_GenericException_TestCase base class | |
*/ | |
class GenericExceptionBaseTest extends PHPUnit_GenericException_TestCase //PHPUnit_Framework_TestCase | |
{ | |
/** | |
* Simple example just showing what the annotation looks like. | |
* Your code would not throw PHPUnit_GenericException. | |
* | |
* @expectedException PHPUnit_GenericException | |
*/ | |
public function testAnnotation() | |
{ | |
throw new PHPUnit_GenericException(); | |
} | |
// Simple example showing how to declare exception without annotations. | |
public function testExpectedException() | |
{ | |
$this->expectGenericException(); | |
throw new PHPUnit_GenericException(); | |
} | |
// Example showing how to replace generic exception if you want | |
// your function to do the 'throw' | |
public function testReplaceException() | |
{ | |
$this->expectGenericException(); | |
try | |
{ | |
throw new Exception(); | |
} | |
catch (Exception $e) | |
{ | |
throw $this->replaceGenericException($e); | |
} | |
} | |
// Example of wrapping your test in a callback (or closure) and let | |
// us do the catch/replace/throw. | |
public function testCheckFunction() | |
{ | |
$this->expectGenericException(); | |
$function = function() | |
{ | |
throw new Exception(); | |
}; | |
$this->checkFunctionForGenericException($function); | |
} | |
} | |
/** | |
* GenericExceptionGlobalTest Tests generic exception support via global functions | |
*/ | |
class GenericExceptionGlobalTest extends PHPUnit_Framework_TestCase | |
{ | |
/** | |
* Simple example just showing what the annotation looks like. | |
* Your code would not throw PHPUnit_GenericException. | |
* | |
* @expectedException PHPUnit_GenericException | |
*/ | |
public function testAnnotation() | |
{ | |
throw new PHPUnit_GenericException(); | |
} | |
// Simple example showing how to declare exception without annotations. | |
public function testExpectedException() | |
{ | |
expectGenericException($this); | |
throw new PHPUnit_GenericException(); | |
} | |
// Example showing how to replace generic exception if you want | |
// your function to do the 'throw' | |
public function testReplaceException() | |
{ | |
expectGenericException($this); | |
try | |
{ | |
throw new Exception(); | |
} | |
catch (Exception $e) | |
{ | |
throw replaceGenericException($e); | |
} | |
} | |
// Example of wrapping your test in a callback (or closure) and let | |
// us do the catch/replace/throw. | |
public function testCheckFunction() | |
{ | |
expectGenericException($this); | |
$function = function() | |
{ | |
throw new Exception(); | |
}; | |
checkFunctionForGenericException($function); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
I hate how 'sign-in' works on GIST - Forget to sign-in and now you have an anonymous gist :(