python/php/sdk/google/appengine/runtime/MemcacheTest.php

   1 <?php
   2 /**
   3  * Copyright 2007 Google Inc.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 /**
  18  * Unit tests for the emulated "memcache" PHP extension.
  19  *
  20  */
  21
  22 require_once 'google/appengine/api/memcache/memcache_service_pb.php';
  23 require_once 'google/appengine/runtime/Memcache.php';
  24 require_once 'google/appengine/testing/ApiProxyTestBase.php';
  25
  26 use google\appengine\MemcacheDeleteRequest;
  27 use google\appengine\MemcacheDeleteResponse;
  28 use google\appengine\MemcacheDeleteResponse\DeleteStatusCode;
  29 use google\appengine\MemcacheFlushRequest;
  30 use google\appengine\MemcacheFlushResponse;
  31 use google\appengine\MemcacheGetRequest;
  32 use google\appengine\MemcacheGetResponse;
  33 use google\appengine\MemcacheIncrementRequest;
  34 use google\appengine\MemcacheIncrementResponse;
  35 use google\appengine\MemcacheSetRequest;
  36 use google\appengine\MemcacheSetRequest\SetPolicy;
  37 use google\appengine\MemcacheSetResponse;
  38 use google\appengine\MemcacheSetResponse\SetStatusCode;
  39 use google\appengine\testing\ApiProxyTestBase;
  40
  41
  42 class MemcacheTest extends ApiProxyTestBase {
  43
  44   public function setUp() {
  45     parent::setUp();
  46     $this->_SERVER = $_SERVER;
  47   }
  48
  49   public function tearDown() {
  50     $_SERVER = $this->_SERVER;
  51     parent::tearDown();
  52   }
  53
  54   public function testAddSuccess() {
  55     $memcache = new Memcache();
  56
  57     $request = new MemcacheSetRequest();
  58     $item = $request->addItem();
  59     $item->setKey("float");
  60     $item->setValue("2");
  61     $item->setFlags(6);  // float
  62     $item->setSetPolicy(SetPolicy::ADD);
  63     $item->setExpirationTime(30);
  64
  65     $response = new MemcacheSetResponse();
  66     $response->addSetStatus(SetStatusCode::STORED);
  67
  68     $this->apiProxyMock->expectCall('memcache',
  69                                     'Set',
  70                                     $request,
  71                                     $response);
  72     $this->assertTrue(memcache_add($memcache, "float", 2.0, null, 30));
  73     $this->apiProxyMock->verify();
  74   }
  75
  76   public function testAddAlreadyThere() {
  77     $memcache = new Memcache();
  78
  79     $request = new MemcacheSetRequest();
  80     $item = $request->addItem();
  81     $item->setKey("float");
  82     $item->setValue("2");
  83     $item->setFlags(6);   // float
  84     $item->setSetPolicy(SetPolicy::ADD);
  85     $item->setExpirationTime(30);
  86
  87     $response = new MemcacheSetResponse();
  88     $response->addSetStatus(SetStatusCode::NOT_STORED);
  89
  90     $this->apiProxyMock->expectCall('memcache',
  91                                     'Set',
  92                                     $request,
  93                                     $response);
  94     $this->assertFalse(memcache_add($memcache, "float", 2.0, null, 30));
  95     $this->apiProxyMock->verify();
  96   }
  97
  98   public function testDeleteSuccess() {
  99     $memcache = new Memcache();
 100
 101     $request = new MemcacheDeleteRequest();
 102     $item = $request->addItem();
 103     $item->setKey("delete_key");
 104
 105     $response = new MemcacheDeleteResponse();
 106     $response->addDeleteStatus(DeleteStatusCode::DELETED);
 107
 108     $this->apiProxyMock->expectCall('memcache',
 109                                     'Delete',
 110                                     $request,
 111                                     $response);
 112     $this->assertTrue(memcache_delete($memcache, "delete_key"));
 113     $this->apiProxyMock->verify();
 114   }
 115
 116   public function testDeleteNotThere() {
 117     $memcache = new Memcache();
 118
 119     $request = new MemcacheDeleteRequest();
 120     $item = $request->addItem();
 121     $item->setKey("delete_key");
 122
 123     $response = new MemcacheDeleteResponse();
 124     $response->addDeleteStatus(DeleteStatusCode::NOT_FOUND);
 125
 126     $this->apiProxyMock->expectCall('memcache',
 127                                     'Delete',
 128                                     $request,
 129                                     $response);
 130     $this->assertFalse(memcache_delete($memcache, "delete_key"));
 131     $this->apiProxyMock->verify();
 132   }
 133
 134   public function testFlush() {
 135     $req = new MemcacheFlushRequest();
 136     $resp = new MemcacheFlushResponse();
 137     $memcache = new Memcache();
 138
 139     $this->apiProxyMock->expectCall('memcache',
 140                                     'FlushAll',
 141                                     $req,
 142                                     $resp);
 143     memcache_flush($memcache);
 144     $this->apiProxyMock->verify();
 145   }
 146
 147   public function testGetStringSuccess() {
 148     $memcache = new Memcache();
 149
 150     $request = new MemcacheGetRequest();
 151     $request->addKey("key");
 152
 153     $response = new MemcacheGetResponse();
 154     $item = $response->addItem();
 155     $item->setKey("key");
 156     $item->setValue("value");
 157     $item->setFlags(0);  // String.
 158
 159     $this->apiProxyMock->expectCall('memcache',
 160                                     'Get',
 161                                     $request,
 162                                     $response);
 163     $this->assertEquals("value", memcache_get($memcache, "key"));
 164     $this->apiProxyMock->verify();
 165   }
 166
 167   public function testGetUnicodeSuccess() {
 168     $memcache = new Memcache();
 169
 170     $request = new MemcacheGetRequest();
 171     $request->addKey("key");
 172
 173     $response = new MemcacheGetResponse();
 174     $item = $response->addItem();
 175     $item->setKey("key");
 176     $item->setValue("value");
 177     $item->setFlags(1);  // Unicode.
 178
 179     $this->apiProxyMock->expectCall('memcache',
 180                                     'Get',
 181                                     $request,
 182                                     $response);
 183     $this->assertEquals("value", memcache_get($memcache, "key"));
 184     $this->apiProxyMock->verify();
 185   }
 186
 187   public function testGetMissing() {
 188     $memcache = new Memcache();
 189
 190     $request = new MemcacheGetRequest();
 191     $request->addKey("key");
 192
 193     $response = new MemcacheGetResponse();
 194
 195     $this->apiProxyMock->expectCall('memcache',
 196                                     'Get',
 197                                     $request,
 198                                     $response);
 199     $this->assertFalse(memcache_get($memcache, "key"));
 200     $this->apiProxyMock->verify();
 201   }
 202
 203   public function testGetMany() {
 204     $memcache = new Memcache();
 205
 206     $request = new MemcacheGetRequest();
 207     $request->addKey("key1");
 208     $request->addKey("key2");
 209     $request->addKey("key3");
 210
 211     $response = new MemcacheGetResponse();
 212     $item3 = $response->addItem();
 213     $item3->setKey("key3");
 214     $item3->setValue("value3");
 215     $item3->setFlags(0);  // string.
 216     $item1 = $response->addItem();
 217     $item1->setKey("key1");
 218     $item1->setValue("value1");
 219     $item1->setFlags(0);  // string.
 220
 221     $this->apiProxyMock->expectCall('memcache',
 222                                     'Get',
 223                                     $request,
 224                                     $response);
 225     $this->assertEquals(array("key1" => "value1", "key3" => "value3"),
 226                         memcache_get($memcache, array("key1", "key2", "key3")));
 227     $this->apiProxyMock->verify();
 228   }
 229
 230   public function testGetManyAllMissing() {
 231     $memcache = new Memcache();
 232
 233     $request = new MemcacheGetRequest();
 234     $request->addKey("key1");
 235     $request->addKey("key2");
 236     $request->addKey("key3");
 237
 238     $response = new MemcacheGetResponse();
 239
 240     $this->apiProxyMock->expectCall('memcache',
 241                                     'Get',
 242                                     $request,
 243                                     $response);
 244     $this->assertFalse(memcache_get($memcache, array("key1", "key2", "key3")));
 245     $this->apiProxyMock->verify();
 246   }
 247
 248   public function testIncrementSuccess() {
 249     $memcache = new Memcache();
 250
 251     $request = new MemcacheIncrementRequest();
 252     $request->setKey("key");
 253     $request->setDelta(5);
 254
 255     $response = new MemcacheIncrementResponse();
 256     $response->setNewValue(7);
 257
 258     $this->apiProxyMock->expectCall('memcache',
 259                                     'Increment',
 260                                     $request,
 261                                     $response);
 262     $this->assertEquals(7, memcache_increment($memcache, "key", 5));
 263     $this->apiProxyMock->verify();
 264   }
 265
 266   public function testIncrementNonExistingValue() {
 267     $memcache = new Memcache();
 268
 269     $request = new MemcacheIncrementRequest();
 270     $request->setKey("key");
 271     $request->setDelta(5);
 272
 273     $response = new MemcacheIncrementResponse();
 274
 275     $this->apiProxyMock->expectCall('memcache',
 276                                     'Increment',
 277                                     $request,
 278                                     $response);
 279     $this->assertFalse(memcache_increment($memcache, "key", 5));
 280     $this->apiProxyMock->verify();
 281   }
 282
 283   public function testReplaceSuccess() {
 284     $memcache = new Memcache();
 285
 286     $request = new MemcacheSetRequest();
 287     $item = $request->addItem();
 288     $item->setKey("float");
 289     $item->setValue("2");
 290     $item->setFlags(6);  // float
 291     $item->setSetPolicy(SetPolicy::REPLACE);
 292     $item->setExpirationTime(30);
 293
 294     $response = new MemcacheSetResponse();
 295     $response->addSetStatus(SetStatusCode::STORED);
 296
 297     $this->apiProxyMock->expectCall('memcache',
 298                                     'Set',
 299                                     $request,
 300                                     $response);
 301     $this->assertTrue(memcache_replace($memcache, "float", 2.0, null, 30));
 302     $this->apiProxyMock->verify();
 303   }
 304
 305   public function testReplaceNotThere() {
 306     $memcache = new Memcache();
 307
 308     $request = new MemcacheSetRequest();
 309     $item = $request->addItem();
 310     $item->setKey("float");
 311     $item->setValue("2");
 312     $item->setFlags(6);  // float
 313     $item->setSetPolicy(SetPolicy::REPLACE);
 314     $item->setExpirationTime(30);
 315
 316     $response = new MemcacheSetResponse();
 317     $response->addSetStatus(SetStatusCode::NOT_STORED);
 318
 319     $this->apiProxyMock->expectCall('memcache',
 320                                     'Set',
 321                                     $request,
 322                                     $response);
 323     $this->assertFalse(memcache_replace($memcache, "float", 2.0, null, 30));
 324     $this->apiProxyMock->verify();
 325   }
 326
 327   public function testSetSuccess() {
 328     $memcache = new Memcache();
 329
 330     $request = new MemcacheSetRequest();
 331     $item = $request->addItem();
 332     $item->setKey("float");
 333     $item->setValue("2");
 334     $item->setFlags(6);  // float
 335     $item->setSetPolicy(SetPolicy::SET);
 336     $item->setExpirationTime(30);
 337
 338     $response = new MemcacheSetResponse();
 339     $response->addSetStatus(SetStatusCode::STORED);
 340
 341     $this->apiProxyMock->expectCall('memcache',
 342                                     'Set',
 343                                     $request,
 344                                     $response);
 345     $this->assertTrue(memcache_set($memcache, "float", 2.0, null, 30));
 346     $this->apiProxyMock->verify();
 347   }
 348
 349   public function testSetSuccessCompressed() {
 350     $memcache = new Memcache();
 351
 352     $request = new MemcacheSetRequest();
 353     $item = $request->addItem();
 354     $item->setKey("float");
 355     $item->setValue("3");
 356     $item->setFlags(6);  // float
 357     $item->setSetPolicy(SetPolicy::SET);
 358     $item->setExpirationTime(30);
 359
 360     $response = new MemcacheSetResponse();
 361     $response->addSetStatus(SetStatusCode::STORED);
 362
 363     $this->apiProxyMock->expectCall('memcache',
 364                                     'Set',
 365                                     $request,
 366                                     $response);
 367     $this->assertTrue(memcache_set($memcache, "float", 3.0, MEMCACHE_COMPRESSED,
 368                                    30));
 369     $this->apiProxyMock->verify();
 370   }
 371 }