如何测试作为参数传递给函数的 PHP 闭包是否已被准确调用次数

Question

我正在尝试找到一种方法来检查传递给我的单元测试中的方法的闭包函数是否被准确地调用了一次。但是 PHP 中的 Closure 类被声明为 final，当我运行它时我收到以下错误消息：“Class "Closure" is declared "final" and cannot be mocked."

这是一个代码示例。我正在尝试检查 valueProducer() 是否被调用了一次。

class PoorCache{
    protected $storage;

    /**
     * Returns value from cache and if the value lacks puts it into the cache storage
     * @param string $key
     * @param Closure $valueProducer produces a value for storage, i.e. makes a request to DB
     * @return mixed
     */
    public function remember($key, Closure $valueProducer)
    {
            if (array_key_exists($key, $this->storage))
            {
                    return $this->storage[$key];
            }

            $this->storage[$key] = $valueProducer();
            return $this->storage[$key];
    }
}

class PoorCacheTest extends TestCase {
    public function testRemeber(){
        $mockedValueProducer = $this->getMock(\Closure::class);
        $mockedValueProducer->expects($this->once())->method('call');

        $cache = new PoorCache();
        $cache->remember('myKey', $mockedValueProducer);
        $cache->remember('myKey', $mockedValueProducer);
    }
}

Answer 1

您可以创建一个不存在的类 double 来实现 __invoke 方法。但 double 不会是 \Closure 的实例，因此您必须删除 remember 方法的 \Closure 类型提示。

// Create double
$double = $this->getMockBuilder('NonExistentClass')
    ->setMethods(['__invoke'])
    ->getMock();

// Set expectations
$double->expects($this->once())->method('__invoke');

// Test
$double();

Answer 2

不是存储给定闭包的结果，而是存储闭包，然后调用一次。

像这样：

class PoorCache {

    protected $storage;
    private $called = [];

    /**
     * Returns value from cache and if the value lacks puts it into the cache storage
     * @param string $key
     * @param Closure $valueProducer produces a value for storage, i.e. makes a request to DB
     * @return null
     */
    public function remember($key, Closure $valueProducer)
    {
            // store $valueProducder Closure
            $this->storage[$key] = $valueProducer;

            if(isset($this->called[$key])) {
                unset($this->called[$key]); 
            }
            return null;
    }

    // call producer closure by key 
    public function callProducer($key)
    {
        if(isset($this->storage[$key]))  {

           // check if $key has been called 
           // if true returns false
           if(isset($this->called[$key])) {
                return false;
           }

           // add $key to called array 
           $this->called[] = $key;
           // call closure
           return ($this->storage[$key])();
        }
    }
}

class PoorCacheTest extends TestCase {

    public function testRemeber(){
        $mockedValueProducer = $this->getMock(\Closure::class);
        $mockedValueProducer->expects($this->once())->method('call');

        $cache = new PoorCache();

        // store closure once 
        $cache->remember('myKey', $mockedValueProducer);

        // store closure twice 
        // this is going to override the own before it 
        // since they both have the same key 
        $cache->remember('myKey', $mockedValueProducer);

        // call producer once 
        $cache->callProducer('myKey');

        // call producer twice
        // NOTE: this going to return false since 'myKey' 
        // has already been called 
        $cache->callProducer('myKey');
    }
}