tests/CacheTest.php

   1 <?php
   2
   3 require "../lib/plugin/Cache/Cache.php";
   4
   5
   6 class CacheableModel extends ActiveMongo
   7 {
   8     public static $cacheable = TRUE;
   9 }
  10
  11 class CacheDriverMem extends CacheDriver
  12 {
  13     private $mem;
  14
  15     function flush()
  16     {
  17         $this->mem = array();
  18     }
  19
  20     function config($name, $value)
  21     {
  22         switch ($name) {
  23         case 'return':
  24             return $value;
  25         case 'true':
  26             return TRUE;
  27         case 'false':
  28             return FALSE;
  29         }
  30     }
  31
  32     function get($key, &$document)
  33     {
  34         if (isset($this->mem[$key])) {
  35             $document = $this->deserialize($this->mem[$key]);
  36             return TRUE;
  37         }
  38         return FALSE;
  39     }
  40
  41     function set($key, $document, $ttl)
  42     {
  43         $this->mem[$key] = $this->serialize($document);
  44     }
  45
  46     function delete(Array $keys)
  47     {
  48         foreach ($keys as $key) {
  49             unset($this->mem[$key]);
  50         }
  51     }
  52 }
  53
  54
  55 class CacheTest extends PHPUnit_Framework_TestCase
  56 {
  57     function testInit()
  58     {
  59         try {
  60             CacheableModel::drop();
  61         } Catch (ActiveMongo_Exception $e) {
  62         }
  63         ActiveMongo_Cache::setDriver(new CacheDriverMem);
  64     }
  65
  66     /**
  67      *  @depends testInit
  68      */
  69     function testCacheDriverConfig()
  70     {
  71         $this->assertTrue(ActiveMongo_Cache::config('true', NULL));
  72         $this->assertFalse(ActiveMongo_Cache::config('false', NULL));
  73         $this->assertEquals(ActiveMongo_Cache::config('return', 'foo'), 'foo');
  74     }
  75
  76     /**
  77      *  @depends testInit
  78      */
  79     function testCacheSimple()
  80     {
  81         $c = new CacheableModel;
  82         $c->prop = 'bar';
  83         $c->save();
  84         $id = $c->getID();
  85         $c->reset();
  86
  87         $c->where('_id', $id);
  88         $c->doQuery();
  89         $this->assertFalse($c->servedFromCache());
  90
  91         $d = new CacheableModel;
  92         $d->where('_id', $id);
  93         $d->doQuery();
  94
  95         $this->assertTrue($d->servedFromCache());
  96         $this->assertEquals($c->prop, $d->prop);
  97
  98         return $id;
  99     }
 100
 101     function testCacheMultiple()
 102     {
 103         $var = array('bar','foo','xxx','ccc');
 104         $c = new CacheableModel;
 105         foreach ($var as $v) {
 106             $c->reset();
 107             $c->var['var_name'] = $v;
 108             $c->$v = TRUE;
 109             $c->save();
 110         }
 111
 112         $query = new CacheableModel;
 113         $query->where('var.var_name IN', $var);
 114         $query->doQuery();
 115         $this->assertFalse($query->servedFromCache());
 116         $count1 = $query->count();
 117         foreach ($query as $result) {
 118             foreach ($result['var'] as $key => $value) {
 119                 $this->assertTrue(isset($result->$value));
 120             }
 121         }
 122
 123         $query->reset();
 124         $query->where('var.var_name IN', $var);
 125         $query->doQuery();
 126         $this->assertTrue($query->servedFromCache());
 127         $count2 = $query->count();
 128         $this->assertEquals($count1, $count2);
 129         $this->assertEquals($count1, count($var));
 130
 131         foreach ($query as $result) {
 132             foreach ($result['var'] as $key => $value) {
 133                 $this->assertTrue(isset($result->$value));
 134             }
 135         }
 136
 137         return $var;
 138     }
 139
 140     /**
 141      *  @depends testCacheSimple
 142      */
 143     function testUpdateCache($id)
 144     {
 145         $d = new CacheableModel;
 146         $d->where('_id', $id);
 147         $d->doQuery();
 148
 149         $this->assertEquals($d->prop, 'bar');
 150         $this->assertEquals(1, $d->count());
 151         $this->assertTrue($d->servedFromCache());
 152         $d->prop = 'new value';
 153         $d->save();
 154
 155         $c = new CacheableModel;
 156         $c->where('_id', $id);
 157         $c->doQuery();
 158
 159
 160         $this->assertTrue($d->servedFromCache());
 161         $this->assertEquals($c->prop, $d->prop);
 162
 163         return $id;
 164     }
 165
 166     /**
 167      *  @depends testCacheMultiple
 168      */
 169     function testUpdateQueryCache($vars)
 170     {
 171         /* assert the query is cached */
 172         $query = new CacheableModel;
 173         $query->where('var.var_name IN', $vars);
 174         $query->doQuery();
 175         $this->assertTrue($query->servedFromCache());
 176         $this->assertEquals(count($query), count($vars));
 177
 178         /* add a new element */
 179         $new = new CacheableModel;
 180         $new->var['var_name'] = 'xxx';
 181         $new->xxx = TRUE;
 182         $new->save();
 183
 184         /* query to mongodb, without cache */
 185         $query = new CacheableModel;
 186         $query->where('var.var_name IN', $vars);
 187         $query->doQuery(FALSE);
 188         $this->assertFalse($query->servedFromCache());
 189         $this->assertEquals(count($query), count($vars)+1);
 190
 191         /* check if the cache was overrided */
 192         $query = new CacheableModel;
 193         $query->where('var.var_name IN', $vars);
 194         $query->doQuery();
 195         $this->assertTrue($query->servedFromCache());
 196         $this->assertEquals(count($query), count($vars)+1);
 197     }
 198
 199     /**
 200      *  @depends testUpdateCache
 201      */
 202     function testFetchFromCache($id)
 203     {
 204         /* Test if one object is missing in the cache
 205          * is loaded properly by activemongo cache
 206          */
 207         ActiveMongo_Cache::deleteObject($id);
 208         $this->assertFalse(ActiveMongo_Cache::getObject($id));
 209         $d = new CacheableModel;
 210         $d->where('_id', $id);
 211         $d->doQuery();
 212         $this->assertTrue($d->servedFromCache());
 213         $this->assertEquals('new value', $d->prop);
 214         $this->assertTrue(is_array(ActiveMongo_Cache::getObject($id)));
 215     }
 216
 217     function testDrivers()
 218     {
 219         $drivers = glob("../lib/plugin/Cache/*.php");
 220         foreach ($drivers as $drive) {
 221             if (substr($drive,-9) == 'Cache.php') {
 222                 continue;
 223             }
 224             require $drive;
 225             if (!ActiveMongo_Cache::isDriverActived()) {
 226                 continue;
 227             }
 228             ActiveMongo_Cache::flushCache();
 229             CacheableModel::drop();
 230             $id   = $this->testCacheSimple();
 231             $vars = $this->testCacheMultiple();
 232             $this->testUpdateCache($id);
 233             $this->testFetchFromCache($id);
 234             $this->testUpdateQueryCache($vars);
 235         }
 236     }
 237 }