Over a million developers have joined DZone.
Platinum Partner

Self-Initializing Fakes in PHP

· Integration Zone

The Integration Zone is brought to you in partnership with Red Hat. Use these flashcards along with the popular open source integration framework Apache Camel as an easy reference during the design and development of integration projects.

Testing becomes difficult when you consider objects at the boundary of a system: databases, web services, and other integration nightmares. What we usually do is adopting some specialization of the Hexagonal architecture, where the application defines a series of ports where adapters can be plugged into. The internals of the application only depends on the ports interfaces, and not on the actual adapter we use.

How does this architecture simplify testing? It divides your test code into two categories:

  • integration tests for the adapters, which are not run very often, and check that the integration with the external resource still works.
  • Unit or functional tests for components of the application, which use a Test Double (Stub, Mock, or Fake) in place of the real adapter.

In this article I have to assume you already know by heart the previous paragraph.

The problem

The issue with adapters is that sometimes the mechanism is so complex that you have to use a Fake instead of a simpler Test Double. For example, sqlite in-memory databases instead of the real database is a Fake, since you do not stub the calls to the adapter, but use an alternative, lightweight implementation.

Moreover, writing a Fake is usually very boring and involve saving giant responses. For example, here's a Fake representing an adapter for the Google Maps Directions web service:

...this goes on and on for some kilobytes

These responses may easily get out of sync with the real ones, but we cannot use the real service for each unit test as it will lower the speed of the tests of an order of magnitude (at least).

The solution



The purpose of the test developed here is just to test-drive the Self-Initializing Fake and make sure it works, but the tests where you would actually use it are the unit tests of the client code of the adapter. Note also that you'll have to share the same instance of the Fake between tests for the caching to work.

We start with a simple Fake, but we define a stricter tests that say a subsequent identical call should take less than 0.1 times the former one.

class SelfInitializingFakeTest extends PHPUnit_Framework_TestCase
    public function testReturnsAlwaysTheSameResultForEachQuery()
        $fake = new GoogleMapsDirectionsSelfInitializingFake();
        $httpStart = $this->currentTime();
        $fake->getDirections('Milan', 'Rome');
        $httpEnd = $this->currentTime();
        $cachedEnd = $this->currentTime();
        $httpTime = $httpEnd - $httpStart;
        $cachedTime = $cachedEnd - $httpEnd;
        $this->assertGreaterThan(10, $httpTime / $cachedTime);

    private function currentTime()
        return microtime(true);

class GoogleMapsDirectionsSelfInitializingFake
    public function getDirections($from, $to)
        $url = "http://maps.googleapis.com/maps/api/directions/xml?origin={$from}&destination={$to}&sensor=false";
        $response = file_get_contents($url);
        return new SimpleXMLElement($response);

Predicatably, the test fails:

[10:08:08][giorgio@Desmond:~]$ phpunit SelfInitializingFakeTest.php
PHPUnit 3.5.13 by Sebastian Bergmann.


Time: 1 second, Memory: 3.50Mb

There was 1 failure:

1) SelfInitializingFakeTest::testReturnsAlwaysTheSameResultForEachQuery
Failed asserting that <double:1.1485217269437> is greater than <integer:10>.


Tests: 1, Assertions: 1, Failures: 1.

By introducing a cache:

class GoogleMapsDirectionsSelfInitializingFake
    private $cache = array();

    public function getDirections($from, $to)
        if (isset($this->cache[$url])) {
            $response = $this->cache[$url];
        } else {
            $response = file_get_contents($url);
            $this->cache[$url] = $response;
        return new SimpleXMLElement($response);

...we make the test pass. Being this a potentially non-deterministic test, involving execution times, I tried it repetedly to catch possible false negatives:

[10:11:20][giorgio@Desmond:~/code/practical-php-testing-patterns]$ phpunit --repeat 100 SelfInitializingFakeTest.php
PHPUnit 3.5.13 by Sebastian Bergmann.


Time: 48 seconds, Memory: 3.50Mb

OK (100 tests, 100 assertions)


Now we have a Fake that can you save (asymptotically) the same execution time of an independently coded Fake. But it's implemented in 10 lines of code!

The Integration Zone is brought to you in partnership with Red Hat.  Discover how your integration architecture may be holding you back and 3 considerations for fixing it.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}