tests/phpunit/includes/libs/MemoizedCallableTest.php

   1 <?php
   2 /**
   3  * A MemoizedCallable subclass that stores function return values
   4  * in an instance property rather than APC.
   5  */
   6 class ArrayBackedMemoizedCallable extends MemoizedCallable {
   7         public $cache = array();
   8
   9         protected function fetchResult( $key, &$success ) {
  10                 if ( array_key_exists( $key, $this->cache ) ) {
  11                         $success = true;
  12                         return $this->cache[$key];
  13                 }
  14                 $success = false;
  15                 return false;
  16         }
  17
  18         protected function storeResult( $key, $result ) {
  19                 $this->cache[$key] = $result;
  20         }
  21 }
  22
  23 /**
  24  * PHP Unit tests for MemoizedCallable class.
  25  * @covers MemoizedCallable
  26  */
  27 class MemoizedCallableTest extends PHPUnit_Framework_TestCase {
  28
  29         /**
  30          * The memoized callable should relate inputs to outputs in the same
  31          * way as the original underlying callable.
  32          */
  33         public function testReturnValuePassedThrough() {
  34                 $mock = $this->getMock( 'stdClass', array( 'reverse' ) );
  35                 $mock->expects( $this->any() )
  36                         ->method( 'reverse' )
  37                         ->will( $this->returnCallback( 'strrev' ) );
  38
  39                 $memoized = new MemoizedCallable( array( $mock, 'reverse' ) );
  40                 $this->assertEquals( 'flow', $memoized->invoke( 'wolf' ) );
  41         }
  42
  43         /**
  44          * Consecutive calls to the memoized callable with the same arguments
  45          * should result in just one invocation of the underlying callable.
  46          *
  47          * @requires function apc_store
  48          */
  49         public function testCallableMemoized() {
  50                 $observer = $this->getMock( 'stdClass', array( 'computeSomething' ) );
  51                 $observer->expects( $this->once() )
  52                         ->method( 'computeSomething' )
  53                         ->will( $this->returnValue( 'ok' ) );
  54
  55                 $memoized = new ArrayBackedMemoizedCallable( array( $observer, 'computeSomething' ) );
  56
  57                 // First invocation -- delegates to $observer->computeSomething()
  58                 $this->assertEquals( 'ok', $memoized->invoke() );
  59
  60                 // Second invocation -- returns memoized result
  61                 $this->assertEquals( 'ok', $memoized->invoke() );
  62         }
  63
  64         /**
  65          * @covers MemoizedCallable::invoke
  66          */
  67         public function testInvokeVariadic() {
  68                 $memoized = new MemoizedCallable( 'sprintf' );
  69                 $this->assertEquals(
  70                         $memoized->invokeArgs( array( 'this is %s', 'correct' ) ),
  71                         $memoized->invoke( 'this is %s', 'correct' )
  72                 );
  73         }
  74
  75         /**
  76          * @covers MemoizedCallable::call
  77          */
  78         public function testShortcutMethod() {
  79                 $this->assertEquals(
  80                         'this is correct',
  81                         MemoizedCallable::call( 'sprintf', array( 'this is %s', 'correct' ) )
  82                 );
  83         }
  84
  85         /**
  86          * Outlier TTL values should be coerced to range 1 - 86400.
  87          */
  88         public function testTTLMaxMin() {
  89                 $memoized = new MemoizedCallable( 'abs', 100000 );
  90                 $this->assertEquals( 86400, $this->readAttribute( $memoized, 'ttl' ) );
  91
  92                 $memoized = new MemoizedCallable( 'abs', -10 );
  93                 $this->assertEquals( 1, $this->readAttribute( $memoized, 'ttl' ) );
  94         }
  95
  96         /**
  97          * Closure names should be distinct.
  98          */
  99         public function testMemoizedClosure() {
 100                 $a = new MemoizedCallable( function () {
 101                         return 'a';
 102                 } );
 103
 104                 $b = new MemoizedCallable( function () {
 105                         return 'b';
 106                 } );
 107
 108                 $this->assertEquals( $a->invokeArgs(), 'a' );
 109                 $this->assertEquals( $b->invokeArgs(), 'b' );
 110
 111                 $this->assertNotEquals(
 112                         $this->readAttribute( $a, 'callableName' ),
 113                         $this->readAttribute( $b, 'callableName' )
 114                 );
 115         }
 116
 117         /**
 118          * @expectedExceptionMessage non-scalar argument
 119          * @expectedException        InvalidArgumentException
 120          */
 121         public function testNonScalarArguments() {
 122                 $memoized = new MemoizedCallable( 'gettype' );
 123                 $memoized->invoke( new stdClass() );
 124         }
 125
 126         /**
 127          * @expectedExceptionMessage must be an instance of callable
 128          * @expectedException        InvalidArgumentException
 129          */
 130         public function testNotCallable() {
 131                 $memoized = new MemoizedCallable( 14 );
 132         }
 133 }