Question

I’m building a session management class and associated unit test. In order to separate the class from the global state of $_SESSION I’m using an extremely simple class to manage the binding between the class and the session data.

The entire source of the Binding class is as follows:

class Binding implements iface\Binding
{
    public function &getNamespace ($namespace)
    {
        return $_SESSION [$namespace];
    }
}

In the consuming Session class I have the following:

protected function initStorage ()
{
    // Check that storage hasn't already been bound to the session
    if ($this -> storage === NULL)
    {
        // Attempt to start the session if it hasn't already been started
        if (($this -> sessionId () !== '')
        || ((!$this -> headersSent ())
        && ($this -> startSession ())))
        {
            // Bind the storage to the session
            $this -> storage    =& $this -> binding -> getNamespace ($this -> namespace);
            // Make sure the session is in a usable state
            if (!$this -> hasData ())
            {
                $this -> reset ();
            }
        }
        else
        {
            // We couldn't start the session
            throw new \RuntimeException (__METHOD__ . ': Unable to initiate session storage at this time');
        }
    }

    return $this;
}

sessionId, headersSent and startSession are simple one-line functions that serve as “test seams”, which I can easily replace with mocks in PHPUnit.

I realised whilst writing the test that I could do more with a mock binding class than just detach the session from the class, I could also use it as a way of observing a non-public property of the class without having to actually expose any internal state and thus making the class fragile. As the class operates on a reference to an array rather than directly on an array I can observe the array being referenced.

I was hoping to do this with PHPUnit’s mocking API, but I can’t figure out how to do it.

I know I can create a mock that returns an array like this:

$mock = $this -> getMock ('iface\Binding');

$mock -> expects ($this -> any ())
      -> method ('getNamespace')
      -> will ($this -> returnValue (array ()));

It’s not useful for observing the state changes though, as it returns a different array every time. What I need is a mock that returns a reference to the same array every time.

In the end I wrote a class to take the place of the real Binding class and use that instead:

class BindingMock implements iface\Binding
{
    protected $storage = array ();

    public function &getNamespace ($namespace)
    {
        return $this -> storage [$namespace];
    }
}

Using this class lets me examine the contents of $storage before and after calling something in the Session API because I can look at what’s in the storage array without having to expose non-public state in the Session class. Here’s an example test that uses the technique:

public function testCreateItem ()
{
    $storage    =& $this -> binding -> getNamespace ('unittest');
    $this -> assertEmpty ($storage);
    $this -> object ->  createItem ('This is a test', 'test');
    $this -> assertNotEmpty ($storage);
    $this -> assertEquals ('This is a test', $storage ['test']);
}

I’d rather be able to generate the substitute class using PHPUnit, though, having the additional class just for the unit test seems like the wrong way to do it unless there’s no way of achieving the same thing in PHPUnit.

Answer 1

I think you could return an ArrayObject that exposes the internal array to your tests, but I’d prefer in this case to avoid exposing the array from the Binding at all. Instead, the Binding interface should provide methods to get, set and clear values along with other higher-level operations. Then you could pass in a mock object that expects those calls rather than one that returns a raw array.