CODEWITHSUNDEEP
phpobjectmockingphpunit
cweiske
cweiske

Reputation: 31147

PHPUnit: Mock methods of existing object

PHPUnit's getMock($classname, $mockmethods) creates a new object based on the given class name and lets me change/test the behavior of the methods I specified.

I long for something different; it's changing the behavior of methods of an existing object - without constructing a new object.

Is that possible? If yes, how?

When thinking about the problem I came to the conclusion that it would be possible by serializing the object, changing the serialized string to let the object be instance of a new class that extends the old class plus the mocked methods. I'd like some code for that - or maybe there is such code already somewhere.

While it would certainly be possible to create the to-be-mocked object again, it's just too complicated to do it in my test. Thus I don't want to do that if I don't really really really have to. It's a TYPO3 TSFE instance, and setting that up once in the bootstrapping process is hard enough already.

Upvotes: 25

Views: 33324

Answers (3)

Bailey Parker
Bailey Parker

Reputation: 15903

I know this answer is rather late, but I feel for future viewers of this question there now exists a simpler solution (which has some drawbacks, but depending on your needs can be much easier to implement). Mockery has support for mocking pre-existing objects with what they call a "proxied partial mock." They say that this is for classes with final methods, but it can be used in this case (although the docs do caution that it should be a "last resort").

$existingObjectMock = \Mockery::mock($existingObject);
$existingObjectMock->shouldReceive('someAction')->andReturn('foobar');

It acts by creating a proxy object which hands all method calls and attribute gets/sets to the existing object unless they are mocked.

It should be noted, though, that the proxy suffers from the obvious issue of failing any typechecks or typehints. But this can be usually avoided, because the $existingObject can still be passed around. You should only use the $existingObjectMock when you need the mock capabilities.

Upvotes: 15

edorian
edorian

Reputation: 38981

Let me start of by saying: Welcome to the dark side of unit testing.

Meaning: You usually don't want to do this but as you explained you have what seems to be a valid use case.

runkit

What you can do quite easily, well not trivial but easier than changing your application architecture, is to change class behavior on the fly by using runkit

runkit_method_rename(
    get_class($object), 'methodToMock', 'methodToMock_old'
);
runkit_method_add(
    get_class($object), 'methodToMock', '$param1, $param2', 'return 7;'
);

runkit::method_add

and after the test to a method_remove and the rename again. I don't know of any framework / component that helps you with that but it's not that much to implement on your own in a UglyTestsBaseTest extends PHPUnit_Framework_TestCase.

Well...

If all you have access to is a reference to that object (as in: The $x in $x = new Foo();) i don't know of any way to say: $x, you are now of type SomethingElse and all other variables pointing to that object should change too.

I'm going to assume you already know things like testing your privates but it doesn't help you because you don't have control over the objects life cycle.

The php test helpers extension

Note: the Test-Helper extension is superseded by https://github.com/krakjoe/uopz

What also might help you out here is: Stubbing Hard-Coded Dependencies using the php-test-helpers extension that allows you do to things like Intercepting Object Creation.

That means while your application calls $x = new Something(); you can hack PHP to make it so that $x then contains an instance of YourSpecialCraftedSomething.

You might create that classing using the PHPUnit Mocking API or write it yourself.

As far as i know those are your options. If it's worth going there (or just writing integration / selenium tests for that project) is something you have to figure out on your own as it heavily depends on your circumstances.

Upvotes: 11

PaulC
PaulC

Reputation: 555

Not all pre-existing code can be tested. Code really needs to be designed to be testable. So, while not exactly what you're asking for, you can refactor the code so that the instantiation of the object is in a separate method, then mock that method to return what you want.

class foo {
  function new_bar($arg) { return new bar($arg); }
  function blah() {
    ...
    $obj = $this->new_bar($arg);
    return $obj->twiddle();
  }
}

and then you can test it with

class foo_Test extends PHPUnit_Framework_TestCase {
  function test_blah() {
    $sut = $this->getMock('foo', array('new_bar', 'twiddle'));
    $sut->expects($this->once())->method('new_bar')->will($this->returnSelf());
    $sut->expects($this->once())->method('twiddle')->will($this->returnValue('yes'));
    $this->assertEquals('yes', $sut->blah());
  }
}

Upvotes: 13

Related Questions