PHPUnit call to undefined method `Mock_x_::method()`

The getMockBuilder function accepts only the className as parameter. The correct way to initialize your mock object methods would be to use setMethods function (see phpunit docs)

   $mailer = $this->getMockBuilder('IMailer')
       ->setMethods(array('send', 'sent'))
       ->getMock();

Additionally you probably want to have some expects definition also when you use your mock object:

   $mailer->expects($this->any())
        ->method('send')
        ->willReturn(0);

EDIT

The above holds true for newer phpunit versions. For phpunit 3.7.28 the mock object usage is a bit different (i.e. the expects seems to be mandatory and willReturn is not yet available). For 3.7.28 version you should modify the second part to:

   $mailer->expects($this->any())
        ->method('send')
        ->will($this->returnValue(0));

I would recommend updating to later phpunit version as it seems to be somewhat difficult to find documentation to this much older releases.

An alternative solution, for anybody that is still using old versions of PHPUnit, but still wants to be able to call method() directly, is to override the default mock object class template.

Copy MockObject/Generator/mocked_class.tpl.dist, and name the copy mocked_class.tpl. Then, just add the code for the method() method to the template:

public function method()
{
    $any = new PHPUnit_Framework_MockObject_Matcher_AnyInvokedCount;
    $expects = $this->expects($any);
    $args = func_get_args();
    return call_user_func_array(array($expects, 'method'), $args);
}

This will allow you to call $mock->method() directly. However, you need to still use ->will($this->returnValue(0)) instead of ->willReturn(0). To do that, you need to introduce a custom invocation builder and invocation mocker:

class My_MockObject_Builder_InvocationMocker
    extends PHPUnit_Framework_MockObject_Builder_InvocationMocker {

    public function willReturn( $value ) {
        return $this->will( new PHPUnit_Framework_MockObject_Stub_Return( $value ) );
    }
}

class My_MockObject_InvocationMocker
    extends PHPUnit_Framework_MockObject_InvocationMocker {

    public function expects( PHPUnit_Framework_MockObject_Matcher_Invocation $matcher ) {
        return new My_MockObject_Builder_InvocationMocker($this, $matcher);
    }
}

And update your template again, to use My_MockObject_InvocationMocker instead of PHPUnit_Framework_MockObject_InvocationMocker.

The full template would then look like this:

{prologue}{class_declaration}
{
    protected static $staticInvocationMocker;
    protected $invocationMocker;

{clone}{mocked_methods}
    public function expects(PHPUnit_Framework_MockObject_Matcher_Invocation $matcher)
    {
        return $this->__phpunit_getInvocationMocker()->expects($matcher);
    }

    public function method()
    {
        $any = new PHPUnit_Framework_MockObject_Matcher_AnyInvokedCount;
        $expects = $this->expects($any);
        $args = func_get_args();
        return call_user_func_array(array($expects, 'method'), $args );
    }

    public static function staticExpects(PHPUnit_Framework_MockObject_Matcher_Invocation $matcher)
    {
        return self::__phpunit_getStaticInvocationMocker()->expects($matcher);
    }

    public function __phpunit_getInvocationMocker()
    {
        if ($this->invocationMocker === NULL) {
            $this->invocationMocker = new My_MockObject_InvocationMocker;
        }

        return $this->invocationMocker;
    }

    public static function __phpunit_getStaticInvocationMocker()
    {
        if (self::$staticInvocationMocker === NULL) {
            self::$staticInvocationMocker = new My_MockObject_InvocationMocker;
        }

        return self::$staticInvocationMocker;
    }

    public function __phpunit_hasMatchers()
    {
        return self::__phpunit_getStaticInvocationMocker()->hasMatchers() ||
               $this->__phpunit_getInvocationMocker()->hasMatchers();
    }

    public function __phpunit_verify()
    {
        self::__phpunit_getStaticInvocationMocker()->verify();
        $this->__phpunit_getInvocationMocker()->verify();
    }

    public function __phpunit_cleanup()
    {
        self::$staticInvocationMocker = NULL;
        $this->invocationMocker       = NULL;
    }
}{epilogue}