Question

For objects which compose another object as part of their implementation, what’s the best way to write the unit test so only the principle object gets tested? Trivial example:

class myObj {      public function doSomethingWhichIsLogged()     {         // ...         $logger = new logger('/tmp/log.txt');         $logger->info('some message');         // ...     } } 

I know that the object could be designed so that the logger object dependency could be injected and hence mocked in a unit test, but that’s not always the case – in more complicated scenarios, you do need to compose other objects or make calls to static methods.

As we don’t want to test the logger object, only the myObj, how do we proceed? Do we create a stubbed ‘double’ with the test script? Something like:

class logger {     public function __construct($filepath) {}     public function info($message) {} }  class TestMyObj extends PHPUnit_Framework_TestCase  {     // ... } 

This seems feasible for small objects but would be a pain for more complicated APIs where the SUT depended on the return values. Also, what if you want to test the calls to the dependency object in the same was you can with mock objects? Is there a way of mocking objects which are instantiated by the SUT rather than being passed in?

I’ve read the man page on mocks but it doesn’t seem to cover this situation where the dependency is composed rather than aggregated. How do you do it?

Answer 1

As you seem to be aware already, Concrete Class Dependencies makes testing hard (or outright impossible). You need to decouple that dependency. A simple change, that doesn’t break the existing API, is to default to the current behaviour, but provide a hook to override it. There are a number of ways that this could be implemented.

Some languages have tools that can inject mock classes into code, but I don’t know of anything like this for PHP. In most cases, you would probably be better off refactoring your code anyway.