1: <?php
  2: 
  3: /**
  4:  * 
  5:  * @package Tests
  6:  */
  7: if(!class_exists('Person')){
  8:     require_once __INCLUDES__ .'/model/Person.class.php';
  9: }
 10: if(!class_exists('Project')){
 11:     require_once __INCLUDES__ .'/model/Project.class.php';
 12: }
 13: if(!class_exists('Login')){
 14:     require_once __INCLUDES__ .'/model/Login.class.php';
 15: }
 16: if(!class_exists('Milestone')){
 17:     require_once __INCLUDES__ .'/model/Milestone.class.php';
 18: }
 19: if(!class_exists('Address')){
 20:     require_once __INCLUDES__ .'/model/Address.class.php';
 21: }
 22: 
 23: if(!class_exists('QAbstractCacheProvider')){
 24:     include_once __QCUBED_CORE__ . '/framework/QCacheProviderLocalMemory.class.php';
 25: }
 26: 
 27: /**
 28:  * Cache provider like QCacheProviderLocalMemory, but with public access to the underlying array.
 29:  */
 30: class QCacheProviderLocalMemoryTest extends QCacheProviderLocalMemory {
 31:     /**
 32:      * @var array
 33:      * @access public We need it to be public to enumerate cached values.
 34:      */
 35:     public $arrLocalCache;
 36: 
 37: }
 38: 
 39: // test cases:
 40: // 1. roll back after save should leave cache empty
 41: // 2. roll back after save should leave object in a cache unchanged (object already were in a cache)
 42: // 3. commit after save should place modified object into the cache
 43: // 3a. commit after save should place modified object into the cache (object already were in a cache)
 44: // 4. commit after the object delete should leave the cache empty
 45: // 4a. commit after the object delete should leave the cache empty (cache was populated with object to be deleted before transaction begins)
 46: // 5. roll back after the object delete should leave the cache empty
 47: // 5a. roll back after the object delete should leave object in a cache unchanged (cache was populated with object to be deleted before transaction begins)
 48: //
 49: class QDatabaseTests extends QUnitTestCaseBase {
 50:     // 1. roll back after save should leave cache empty
 51:     public function testTransactionWithCacheSaveRollBack() {
 52:         Person::GetDatabase()->Caching = true;
 53:         // establish a cache object we can work with
 54:         $objCacheProvider = QApplication::$objCacheProvider;
 55:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
 56:         // cache is empty now
 57:         
 58:         $strPerson1_FirstName = null;
 59:         try {
 60:             Person::GetDatabase()->TransactionBegin();
 61:             // cache is substituted
 62:             $objPerson1 = Person::Load(1);
 63:             // person object is placed in the temporary cache
 64:             $strPerson1_FirstName = $objPerson1->FirstName;
 65:             $objPerson1->FirstName = "New value 1";
 66:             $objPerson1->Save();
 67:             // person object is removed from the temporary cache
 68:             
 69:             // imitate the load made by other client.
 70:             // It populates the cache with old value.
 71:             $objPerson1a = Person::Load(1);
 72:             // old person value is placed in the temporary cache
 73: 
 74:             throw new Exception("DATABASE ERROR!"); // imitate the database error in the next Save call
 75:             
 76:             Person::GetDatabase()->TransactionCommit();
 77:         } catch(Exception $ex) {
 78:             Person::GetDatabase()->TransactionRollBack();
 79:             // temporary cache is throwed out. the empty application cache is restored.
 80:         }
 81:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not placed in a cache because of the transaction roll back.");
 82: 
 83:         // restore the actual cache object
 84:         QApplication::$objCacheProvider = $objCacheProvider;
 85:     }
 86:     
 87:     // 2. roll back after save should leave object in a cache unchanged (object already were in a cache)
 88:     public function testTransactionWithCacheSaveRollBack2() {
 89:         Person::GetDatabase()->Caching = true;
 90:         // establish a cache object we can work with
 91:         $objCacheProvider = QApplication::$objCacheProvider;
 92:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
 93:         // cache is empty now
 94:         
 95:         $objPerson1z = Person::Load(1);
 96:         // original person value is placed in a cache
 97:         $strPerson1_FirstName = $objPerson1z->FirstName;
 98:         try {
 99:             Person::GetDatabase()->TransactionBegin();
100:             // cache is substituted
101:             $objPerson1 = Person::Load(1);
102:             // person object is placed in the temporary cache
103:             $objPerson1->FirstName = "New value 1";
104:             $objPerson1->Save();
105:             // person object is removed from the temporary cache
106:             
107:             // imitate the load made by other client.
108:             // It populates the cache with old value.
109:             $objPerson1a = Person::Load(1);
110:             // old person value is placed in the temporary cache
111: 
112:             throw new Exception("DATABASE ERROR!"); // imitate the database error in the next Save call
113: 
114:             Person::GetDatabase()->TransactionCommit();
115:         } catch(Exception $ex) {
116:             Person::GetDatabase()->TransactionRollBack();
117:             // temporary cache is throwed out. the empty application cache is restored.
118:         }
119:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not dropped from a cache because of the transaction roll back.");
120:         foreach (QApplication::$objCacheProvider->arrLocalCache as $objPerson) {
121:             $this->assertEquals($strPerson1_FirstName, $objPerson->FirstName, "Object is not modified in a cache because of the transaction roll back.");
122:         }
123: 
124:         // restore the actual cache object
125:         QApplication::$objCacheProvider = $objCacheProvider;
126:     }
127:     
128:     // 3. commit after save should place modified object into the cache
129:     public function testTransactionWithCacheSaveCommit() {
130:         Person::GetDatabase()->Caching = true;
131:         // establish a cache object we can work with
132:         $objCacheProvider = QApplication::$objCacheProvider;
133:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
134:         // cache is empty now
135:         
136:         try {
137:             Person::GetDatabase()->TransactionBegin();
138:             // cache is substituted
139:             $objPerson1 = Person::Load(1);
140:             // person object is placed in the temporary cache
141:             $objPerson1->FirstName = "New value 1";
142:             $objPerson1->Save();
143:             // person object is removed from the temporary cache
144:             
145:             Person::GetDatabase()->TransactionCommit();
146:             // new person value is placed in the database
147:         } catch(Exception $ex) {
148:             Person::GetDatabase()->TransactionRollBack();
149:         }
150:         
151:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not placed in a cache after save because of the transaction commit.");
152:         
153:         // imitate the load made by other client.
154:         // It populates the cache with new value.
155:         $objPerson1a = Person::Load(1);
156:         // new person value is placed in the application cache
157:         
158:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is added to a cache because of the transaction commit.");
159:         foreach (QApplication::$objCacheProvider->arrLocalCache as $objPerson) {
160:             $this->assertEquals("New value 1", $objPerson->FirstName, "Object is modified in a cache because of the transaction commit.");
161:         }
162:         
163:         // Restore the original value to not break other tests
164:         $objPerson1a->FirstName = "John";
165:         $objPerson1a->Save();
166: 
167:         // restore the actual cache object
168:         QApplication::$objCacheProvider = $objCacheProvider;
169:     }
170:     
171:     // 3a. commit after save should place modified object into the cache (object already were in a cache)
172:     public function testTransactionWithCacheSaveCommit2() {
173:         Person::GetDatabase()->Caching = true;
174:         // establish a cache object we can work with
175:         $objCacheProvider = QApplication::$objCacheProvider;
176:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
177:         // cache is empty now
178:         
179:         $objPerson1z = Person::Load(1);
180:         // original person value is placed in a cache
181:         $strPerson1_FirstName = $objPerson1z->FirstName;
182:         try {
183:             Person::GetDatabase()->TransactionBegin();
184:             // cache is substituted
185:             $objPerson1 = Person::Load(1);
186:             // person object is placed in the temporary cache
187:             $objPerson1->FirstName = "New value 1";
188:             $objPerson1->Save();
189:             // person object is removed from the temporary cache
190:             
191:             Person::GetDatabase()->TransactionCommit();
192:             // new person value is placed in the database
193:         } catch(Exception $ex) {
194:             Person::GetDatabase()->TransactionRollBack();
195:         }
196:         
197:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is dropped from a cache because of the transaction commit.");
198:         
199:         // imitate the load made by other client.
200:         // It populates the cache with new value.
201:         $objPerson1a = Person::Load(1);
202:         // new person value is placed in the application cache
203:         
204:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not dropped from a cache because of the transaction commit.");
205:         foreach (QApplication::$objCacheProvider->arrLocalCache as $objPerson) {
206:             $this->assertEquals("New value 1", $objPerson->FirstName, "Object is modified in a cache because of the transaction commit.");
207:         }
208:         
209:         // Restore the original value to not break other tests
210:         $objPerson1a->FirstName = "John";
211:         $objPerson1a->Save();
212: 
213:         // restore the actual cache object
214:         QApplication::$objCacheProvider = $objCacheProvider;
215:     }
216:     
217:     // 4. commit after the object delete should leave the cache empty
218:     public function testTransactionWithCacheDeleteCommit() {
219:         // create an object in the database
220:         $objPerson1z = new Person;
221:         $objPerson1z->FirstName = "test";
222:         $objPerson1z->LastName = "test";
223:         $objPerson1z->Save();
224:         
225:         Person::GetDatabase()->Caching = true;
226:         // establish a cache object we can work with
227:         $objCacheProvider = QApplication::$objCacheProvider;
228:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
229:         // cache is empty now
230:         
231:         try {
232:             Person::GetDatabase()->TransactionBegin();
233:             // cache is substituted
234:             $objPerson1 = Person::Load($objPerson1z->Id);
235:             // person object is placed in the temporary cache
236:             $objPerson1->Delete();
237:             // person object is removed from the temporary cache
238:             
239:             Person::GetDatabase()->TransactionCommit();
240:             // person value is removed from the database
241:         } catch(Exception $ex) {
242:             Person::GetDatabase()->TransactionRollBack();
243:         }
244:         
245:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not placed in a cache after delete because of the transaction commit.");
246:         
247:         // restore the actual cache object
248:         QApplication::$objCacheProvider = $objCacheProvider;
249:     }
250:     
251:     // 4a. commit after the object delete should leave the cache empty (cache was populated with object to be deleted before transaction begins)
252:     public function testTransactionWithCacheDeleteCommit2() {
253:         Person::GetDatabase()->Caching = true;
254:         // establish a cache object we can work with
255:         $objCacheProvider = QApplication::$objCacheProvider;
256:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
257:         // cache is empty now
258:         
259:         // create an object in the database
260:         $objPerson1z = new Person;
261:         $objPerson1z->FirstName = "test";
262:         $objPerson1z->LastName = "test";
263:         $objPerson1z->Save();
264:         
265:         Person::Load($objPerson1z->Id);
266:         // the person object is placed in a cache
267:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is placed in a cache.");
268:         
269:         try {
270:             Person::GetDatabase()->TransactionBegin();
271:             // cache is substituted
272:             $objPerson1 = Person::Load($objPerson1z->Id);
273:             // person object is placed in the temporary cache
274:             $objPerson1->Delete();
275:             // person object is removed from the temporary cache
276:             
277:             Person::GetDatabase()->TransactionCommit();
278:             // person value is removed from the database
279:         } catch(Exception $ex) {
280:             Person::GetDatabase()->TransactionRollBack();
281:         }
282:         
283:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is removed from a cache after delete because of the transaction commit.");
284:         
285:         // restore the actual cache object
286:         QApplication::$objCacheProvider = $objCacheProvider;
287:     }
288:     
289:     // 5. roll back after the object delete should leave the cache empty
290:     public function testTransactionWithCacheDeleteRollBack() {
291:         // create an object in the database
292:         $objPerson1z = new Person;
293:         $objPerson1z->FirstName = "test";
294:         $objPerson1z->LastName = "test";
295:         $objPerson1z->Save();
296:         
297:         Person::GetDatabase()->Caching = true;
298:         // establish a cache object we can work with
299:         $objCacheProvider = QApplication::$objCacheProvider;
300:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
301:         // cache is empty now
302:         
303:         try {
304:             Person::GetDatabase()->TransactionBegin();
305:             // cache is substituted
306:             $objPerson1 = Person::Load($objPerson1z->Id);
307:             // person object is placed in the temporary cache
308:             $objPerson1->Delete();
309:             // person object is removed from the temporary cache
310:             
311:             throw new Exception("DATABASE ERROR!"); // imitate the database error in the next Save call
312:             
313:             Person::GetDatabase()->TransactionCommit();
314:         } catch(Exception $ex) {
315:             Person::GetDatabase()->TransactionRollBack();
316:             // actual cache leaved unchanged
317:         }
318:         
319:         $this->assertEquals(0, count(QApplication::$objCacheProvider->arrLocalCache), "Object is not placed in a cache after delete because of the transaction roll back.");
320:         
321:         // restore the actual cache object
322:         QApplication::$objCacheProvider = $objCacheProvider;
323:         
324:         // clean up
325:         $objPerson1 = Person::Load($objPerson1z->Id);
326:         // person object is placed in the temporary cache
327:         $objPerson1->Delete();
328:     }
329: 
330:     // 5a. roll back after the object delete should leave object in a cache unchanged (cache was populated with object to be deleted before transaction begins)
331:     public function testTransactionWithCacheDeleteRollBack2() {
332:         Person::GetDatabase()->Caching = true;
333:         // establish a cache object we can work with
334:         $objCacheProvider = QApplication::$objCacheProvider;
335:         QApplication::$objCacheProvider = new QCacheProviderLocalMemoryTest(array());
336:         // cache is empty now
337:         
338:         // create an object in the database
339:         $objPerson1z = new Person;
340:         $objPerson1z->FirstName = "test";
341:         $objPerson1z->LastName = "test";
342:         $objPerson1z->Save();
343:         
344:         Person::Load($objPerson1z->Id);
345:         // the person object is placed in a cache
346:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is placed in a cache.");
347:         
348:         try {
349:             Person::GetDatabase()->TransactionBegin();
350:             // cache is substituted
351:             $objPerson1 = Person::Load($objPerson1z->Id);
352:             // person object is placed in the temporary cache
353:             $objPerson1->Delete();
354:             // person object is removed from the temporary cache
355:             
356:             throw new Exception("DATABASE ERROR!"); // imitate the database error in the next Save call
357:             
358:             Person::GetDatabase()->TransactionCommit();
359:         } catch(Exception $ex) {
360:             Person::GetDatabase()->TransactionRollBack();
361:             // actual cache leaved unchanged
362:         }
363:         
364:         $this->assertEquals(1, count(QApplication::$objCacheProvider->arrLocalCache), "Object is NOT removed from a cache after delete because of the transaction roll back.");
365:         
366:         // restore the actual cache object
367:         QApplication::$objCacheProvider = $objCacheProvider;
368:         
369:         // clean up
370:         $objPerson1 = Person::Load($objPerson1z->Id);
371:         // person object is placed in the temporary cache
372:         $objPerson1->Delete();
373:     }
374: }