Question

If I have a class A that interacts with class B then in my tests I want to mock class B so that I can test class A in isolation.

This is easy to do in PHPUnit with "getMock('classname')".

My problem currently is: If class A uses multiple instances of class B I can’t simulate this with "getMock('B')" because it appears that "getMock" will not return multiple instances if called multiple times but always the same mock of class B.

Following Example:

<?php

class A()
{
    private class_b_1;
    private class_b_2;


    public function setClassB1(B $class_b)
    {
        $this->class_b_1 = $class_b;
    }

    public function setClassB2(B $class_b)
    {
        $this->class_b_2 = $class_b;
    }   
}

And in my tests:

$mock_one_of_class_b = $this -> getMock('B');
$mock_two_of_class_b = $this -> getMock('B');

Then $mock_one_of_class_b is the same object as $mock_two_of_class_b.

How can I mock multiple instances of a class with PHPUnit?

Thanks in advance!

Answer 1

Actually the getMock method creates different instances of mocked class. Take a look on this example:

class Foo
{
    protected $value;

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

    public function getValue()
    {
        return $this->value;
    }
}

Now we create test for it:

class FooTest extends \PHPUnit_Framework_TestCase 
{
    public function testFoo()
    {
        $a = $this->getMock('Foo', array('someNonExistingMethod'));
        $b = $this->getMock('Foo', array('someNonExistingMethod'));

        $a->setValue(1);
        $b->setValue(234);

        $this->assertEquals(1, $a->getValue(), 'This test will fail if "a" and "b" objects are the same');
    }
}

Pay attention on the second argument in getMock method. In that argument you tell phpunit which methods will be mocked. If you don’t pass any argument at all – then phpunit assume you want mock all methods from the object. So, if you pass array('someNonExistingMethod') then there won’t be any mocked method (and “real” methods will be called on invocations).