Testing exceptions in PHPunit always fails

Question

I have few custom exceptions in PHP:

class MainException extends Exception {};
class ExceptionOne extends MainException {};
class ExceptionTwo extends MainException {};

And I'm using them in my class in two simple methods:

public function firstFunction($param) {
    if ($some_condition) {
        // do whatever
    } else {
        throw new ExceptionOne();
    }
}

public function secondFunction($param) {
    if ($some_condition) {
        // do whatever
    } else {
        throw new ExceptionTwo();
    }
}

I also have a PHPUnit test for both of exceptions, similar to this:

public function testFirstException() {
    try {
        // anything
    } catch (Exception $e) {
        $this->assertType('ExceptionOne', $e);
        $this->assertType('MainException', $e);
    }
}
public function testSecondException() {
    try {
        // anything
    } catch (Exception $e) {
        $this->assertType('ExceptionTwo', $e);
        $this->assertType('MainException', $e);
    }
}

If I test my class in browser and intentionally make my functions fail (with same stuff as in PHPUnit test) I can see ExceptionOne and ExceptionTwo are raised whenever needed. However, when I test it with PHPUnit I always get a failure:

1) testSecondException(SomeTest)
Failed asserting that <PHPUnit_Framework_ExpectationFailedException> is an instance of class "ExceptionTwo".
C:\test.php:67

Line 67 is
$this->assertType('ExceptionTwo', $e);
and it fails here no matter what I try. I'm pretty sure that my condition in secondFunction works correct. The first test (testFirstException) works perfectly and I never get a failure like in the second one.
I'd like to add that I shouldn't change PHPUnit test here!

What am I doing wrong here??

Answer 1

From your comments to cbuckley's excellent answer, is appears that the test was written like this:

public function testFirstException() {
    try {
        // some code that is supposed to throw ExceptionOne
        $this->assertTrue(false, "Test failed");
    } catch (Exception $e) {
        $this->assertType('ExceptionOne', $e);
        $this->assertType('MainException', $e);
    }
}

The assertTrue is used to make sure the test fails if the exception isn't thrown during the test. However, this doesn't work because the failed assertion throws a different exception type which causes the error message to be confusing.

Failed asserting that <PHPUnit_Framework_ExpectationFailedException> 
is an instance of class "ExceptionOne".

You can fix this by using either @expectedException or setExpectedException. Not only will the test pass when ExceptionOne is thrown, but it will fail when it isn't thrown or some other exception type is thrown.

/**
 * @expectedException ExceptionOne
 */
public function testFirstException() {
    // some code that is supposed to throw ExceptionOne
}

When no exception is thrown the error message is

Failed asserting that exception of type "ExceptionOne" is thrown.

and when different type of exception is thrown you'll see

Failed asserting that exception of type "Exception" matches
expected exception "RuntimeException".

This method of testing exceptions is

• easier to write,
• easier to read,
• easier to debug when the test fails,
• and correct.

Answer 2

It looks like you're masking a different error inside your try/catch. If there is a test assertion within your try block, and that assertion fails, then it is thrown as an exception. Try using setExpectedException instead of a try/catch block:

public function testFirstException() {
    $this->setExpectedException('ExceptionOne');
    $fixture->firstFunction();
}

You should put the setExpectedException call immediately before the line which you expect to throw the exception.

Another alternative is to use the @expectedException docblock annotation.

/**
 * @expectedException ExceptionOne
 */
public function testFirstException() {
    $fixture->firstFunction();
}

If you want to keep the try/catch approach, the same applies: make sure that the only line in the try block is the line which should throw the exception.

Answer 3

With php unit you must generate the exception about any of the methods that are within the Try {} falsifying your response.

public function testFirstFunction() {
....
$this->methodOnGenerateExeption(Argumen::Any())->willReturn()->willThrow(\Exception::class);
$this->setExpectedException(\Exception::class);

  $this->classMockToTest->firstFunction($parameters)
}