CODEWITHSUNDEEP
phpphpunitautomated-testsmockery
x-yuri
x-yuri

Reputation: 18953

How do I mock an object I can't pass to a method to trigger an exception?

Consider the following method:

function m1()
{
    $ent = new Entity;
    ...
    try {
        $ent->save();
    } catch (QueryException $e) {
        ...
    }

I've got to trigger an exception. Preferably with mockery. How do I do that?

P.S. I can't pass $ent into the method.

UPD Let me describe my particular case to confirm if I do need to trigger an exception. Here I'm trying to test controller's action that is triggered by payment system to notify that user has made a payment. In it I, among other things, store in database all the data coming from payment system in PaymentSystemCallback model, and link it to Order model, which is created before redirecting user to the payment system. So, it goes like this:

function callback(Request $request)
{
    $c = new PaymentSystemCallback;
    $c->remote_addr = $request->ip();
    $c->post_data = ...;
    $c->headers = ...;
    ...
    $c->save();

    $c->order_id = $request->request->get('order_id');
    $c->save();
}

But if incorrect order_id comes in, foreign constraint fails, so I change it this way:

try {
    $c->save();
} catch (QueryException $e) {
    return response('', 400);
}

But it doesn't look good to handle any database exception this way, so I'm seeking for a way to rethrow the exception unless $e->errorInfo[1] == 1452.

Upvotes: 1

Views: 934

Answers (3)

bishop
bishop

Reputation: 39434

Your method is not designed for test. Fix that. If you can't, then you have to monkey patch, which PHP does not support natively.

My recommended approach would be to have your test suite install its own priority autoloader. Have your test case register a mock class into that autoloader, associated with class name Entity. Your mock class will do its magic to throw an exception. If you're using PHP 7, you have access to anonymous classes, which makes fixtures easier: new class Entity {}.

Per the accepted answer, Mockery supports this autoloading trick using the overload: quantifier on mocked classes. This saves a lot of work on your part!

Upvotes: 0

John Joseph
John Joseph

Reputation: 951

The easiest way around this is to call a factory method that creates a mock instance of your Entity. Something like:

function testSomething()
{
    $ent = $this->getEntity();
    ...
    try {
        $ent->save();
    } catch (QueryException $e) {
        ...
    }
}

function getEntity()
{
    $mock = $this->createMock(Entity::class);
    $mock
        ->method('save')
        ->will($this->throwException(new QueryException));

    return $mock;
}

Upvotes: 0

x-yuri
x-yuri

Reputation: 18953

And here's what I came up with:

/**
 * @runInSeparateProcess
 * @preserveGlobalState disabled
 */
function testExceptionOnSave()
{
    $this->setUpState();

    Mockery::mock('overload:App\PaymentSystemCallback')
        ->shouldReceive('save')
        ->andReturnUsing(function() {}, function() {
            throw new QueryException('', [], new Exception);
        });

    $this->doRequest();

    $this->assertBalanceDidntChange();
    $this->assertNotProcessed();
    $this->seeStatusCode(500);
}

I use @runInSeparateProcess because preceding tests trigger the same action, and therefore the class is loaded before mockery has a chance to mock it.

As for @preserveGlobalState disabled it doesn't work without it. As phpunit's documentation put it:

Note: By default, PHPUnit will attempt to preserve the global state from the parent process by serializing all globals in the parent process and unserializing them in the child process. This can cause problems if the parent process contains globals that are not serializable. See the section called “@preserveGlobalState” for information on how to fix this.

I deviate a little from what mockery's documentation says when I'm marking only one test to run in a separate process, since I need it only for one test. Not the whole class.

Constrictive criticism is welcome.

Upvotes: 1

Related Questions