PHPUnit - Cyclic Dependencies

Question

I have a class that looks something like this:

class Foo {
    protected $_arr = array();

    public function has($key) {
        return array_key_exists($key, $this->_arr);
    }

    public function add($key, $val) {
        $this->_arr[$key] = $val;
    }
}

For my PHPUnit tests for these methods, the only way I can think if to test add() is by asserting that has() returns TRUE for the same key after adding it. This makes my testAdd() test dependent on my testHas() test. Conversely, the only way I can think of to test has() is basically doing the exact same steps, but this would make this test dependent on an already dependent test, producing a chicken and egg type problem.

Am I going about this the wrong way? What's a better method for testing stuff like this?

Answer 1

Instead of writing one-test-per-method, design your tests around the functionality the class must provide. You'll have tests that exercise multiple methods, but that's fine because it indicates to the developer that those methods are related. This is where Test Driven Development--where you write the tests while designing the contract for the class before writing the code for the class--really shines.

class FooTest extends PHPUnit_Framework_TestCase
{
    function testStartsEmpty() {
        $foo = new Foo;
        self::assertFalse($foo->has('bar'));
    }

    function testAddStoresKeys() {
        $foo = new Foo;
        $foo->add('bar', 'baz');
        self::assertTrue($foo->has('bar'));
    }

    function testAddStoresKeysWithNullValues() {
        $foo = new Foo;
        $foo->add('bar', null);
        self::assertTrue($foo->has('bar'));
    }

    function testAddStoresValues() {
        $foo = new Foo;
        $foo->add('bar', 'baz');
        self::assertEquals('baz', $foo->get('bar'));  // fatal error
    }
}

Now that testAddStoresValues() fails, it's time to implement a method to get the value for a given key: Foo::get($key).

Answer 2

PHPUnit allows testing of non-public members.

However, using $sut->has() to find out whether $sut->add() worked is perfectly fine. Also, when you test $sut->add(), you dont need to write a separate test for $sut->has() as well, because it's covered in the $sut->add() test already. Just add a @covers annotation.

Answer 3

In reference to the long dicussions in the comments to @Gordon s answer:

The unit in unit testing is the object not the method! You don't want to test methods in isolation from the other methods of the objects. (If you wanted to do so just use functions ;) ) - It's really important to test how the object behaves and if it does the expected think when called and not how the methods interact internally.

I've recently written a blog post explaining why it is important to not test single methods in isolation:

http://edorian.posterous.com/the-unit-in-unit-testing

Quoting from my post:

Unit testing, in PHP, is about testing the observable behaviors of a class

Most importantly:

Observable from the outside! Nobody cares about the internal state of a class if it never changes the outcome of a method call.

---

Take this sample:

public function setValue($value) {
    $this->value = $value;
}

public function execute() {
    if (!$this->value) {
        throw new Exception("No Value, no good");
    }
    return $value * 10; // business logic
}

It sounds trivial but the distinction is important and more easy to overlook when looking at bigger classes.

What do we test there?

• IF we don’t setValue AND then call execute an exception is thrown!
• IF we DO setValue AND then call execute we get an computed result

So we are testing two behaviors of your class and not the methods in isolation!

Answer 4

IMO you can test behavior of the object. So you can test if has return false before and true after adding some stuff into collection.