      1: <?php
      2:
      3: /**
      4:  *
      5:  * Test case for the AlphaDAO class
      6:  *
      7:  * @package alpha::tests
      8:  * @since 1.0
      9:  * @author John Collins <dev@alphaframework.org>
     10:  * @version $Id: AlphaDAO_Test.php 1759 2014-04-10 20:10:30Z alphadevx $
     11:  * @license http://www.opensource.org/licenses/bsd-license.php The BSD License
     12:  * @copyright Copyright (c) 2014, John Collins (founder of Alpha Framework).
     13:  * All rights reserved.
     14:  *
     15:  * <pre>
     16:  * Redistribution and use in source and binary forms, with or
     17:  * without modification, are permitted provided that the
     18:  * following conditions are met:
     19:  *
     20:  * * Redistributions of source code must retain the above
     21:  *   copyright notice, this list of conditions and the
     22:  *   following disclaimer.
     23:  * * Redistributions in binary form must reproduce the above
     24:  *   copyright notice, this list of conditions and the
     25:  *   following disclaimer in the documentation and/or other
     26:  *   materials provided with the distribution.
     27:  * * Neither the name of the Alpha Framework nor the names
     28:  *   of its contributors may be used to endorse or promote
     29:  *   products derived from this software without specific
     30:  *   prior written permission.
     31:  *
     32:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
     33:  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
     34:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     35:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     36:  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     37:  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     38:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     39:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     40:  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     41:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     42:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     43:  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     44:  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     45:  * </pre>
     46:  *
     47:  */
     48: class AlphaDAO_Test extends PHPUnit_Framework_TestCase {
     49:     /**
     50:      * A PersonObject for Testing (any business object will do)
     51:      *
     52:      * @var PersonObject
     53:      * @since 1.0
     54:      */
     55:     private $person;
     56:
     57:     /**
     58:      * Called before the test functions will be executed
     59:      * this function is defined in PHPUnit_TestCase and overwritten
     60:      * here
     61:      *
     62:      * @since 1.0
     63:      */
     64:     protected function setUp() {
     65:         AlphaDAO::begin();
     66:
     67:         $rights = new RightsObject();
     68:         $rights->rebuildTable();
     69:
     70:         $request = new BadRequestObject();
     71:         $request->rebuildTable();
     72:
     73:         $this->person = $this->createPersonObject('unitTestUser');
     74:         $this->person->rebuildTable();
     75:
     76:         // just making sure no previous test user is in the DB
     77:         $this->person->deleteAllByAttribute('URL', 'http://unitTestUser/');
     78:         $this->person->deleteAllByAttribute('displayName', 'unitTestUser');
     79:     }
     80:
     81:     /**
     82:      * Called after the test functions are executed
     83:      * this function is defined in PHPUnit_TestCase and overwritten
     84:      * here
     85:      *
     86:      * @since 1.0
     87:      */
     88:     protected function tearDown() {
     89:         AlphaDAO::rollback();
     90:         $this->person->dropTable();
     91:         unset($this->person);
     92:         $rights = new RightsObject();
     93:         $rights->dropTable();
     94:         $rights->dropTable('Person2Rights');
     95:         $request = new BadRequestObject();
     96:         $request->dropTable();
     97:     }
     98:
     99:     /**
    100:      * Creates a person object for Testing
    101:      *
    102:      * @return PersonObject
    103:      * @since 1.0
    104:      */
    105:     private function createPersonObject($name) {
    106:         $person = new PersonObject();
    107:         $person->setDisplayname($name);
    108:         $person->set('email', $name.'@test.com');
    109:         $person->set('password', 'passwordTest');
    110:         $person->set('URL', 'http://unitTestUser/');
    111:
    112:         return $person;
    113:     }
    114:
    115:     /**
    116:      * Test that the constructor sets the correct values of the "house keeping" attributes
    117:      *
    118:      * @since 1.0
    119:      */
    120:     public function testDefaultHouseKeepingValues() {
    121:         // make sure the person logged in is the same person to create/update the object
    122:         $this->assertEquals($_SESSION['currentUser']->getID(), $this->person->getCreatorId()->getValue(),
    123:             'test that the constructor sets the correct values of the "house keeping" attributes');
    124:         $this->assertEquals($_SESSION['currentUser']->getID(), $this->person->getUpdatorId()->getValue(),
    125:             'test that the constructor sets the correct values of the "house keeping" attributes');
    126:         // as it is a new object, make sure the version number is zero
    127:         $this->assertEquals(0, $this->person->getVersionNumber()->getValue(),
    128:             'test that the constructor sets the correct values of the "house keeping" attributes');
    129:
    130:         // check that the date created and updated equal to today
    131:         $today = date('Y-m-d');
    132:         $this->assertEquals($today, $this->person->getCreateTS()->getDate(),
    133:             'test that the constructor sets the correct values of the "house keeping" attributes');
    134:         $this->assertEquals($today, $this->person->getUpdateTS()->getDate(),
    135:             'test that the constructor sets the correct values of the "house keeping" attributes');
    136:
    137:         // make sure the object is transient
    138:         $this->assertTrue($this->person->isTransient(), 'test that the constructor sets the correct values of the "house keeping" attributes');
    139:     }
    140:
    141:     /**
    142:      * Testing the basic load/save functionality
    143:      *
    144:      * @since 1.0
    145:      */
    146:     public function testBasicLoadSave() {
    147:         $this->person->save();
    148:         $id = $this->person->getMAX();
    149:         $this->person->load($id);
    150:         $this->assertEquals('unitTestUser', $this->person->getDisplayname()->getValue(), 'Testing the basic load/save functionality');
    151:     }
    152:
    153:     /**
    154:      * Testing the checkRecordExists method
    155:      *
    156:      * @since 1.0
    157:      */
    158:     public function testCheckRecordExists() {
    159:         $this->person->save();
    160:         $person = new PersonObject();
    161:         $this->assertTrue($person->checkRecordExists($this->person->getOID()), 'Testing the checkRecordExists method');
    162:     }
    163:
    164:     /**
    165:      * Testing the loadByAttribute method
    166:      *
    167:      * @since 1.0
    168:      */
    169:     public function testLoadByAttribute() {
    170:         $this->person->save();
    171:         $this->person->loadByAttribute('displayName','unitTestUser');
    172:         $this->assertEquals('unitTestUser@test.com', $this->person->get('email'), 'Testing the loadByAttribute method');
    173:         $this->person->loadByAttribute('email','unitTestUser@test.com');
    174:         $this->assertEquals('unitTestUser', $this->person->getDisplayname()->getValue(), 'Testing the loadByAttribute method');
    175:     }
    176:
    177:     /**
    178:      * Testing loadAll method
    179:      *
    180:      * @since 1.0
    181:      */
    182:     public function testLoadAll() {
    183:         $this->person->save();
    184:         $peopleCount = $this->person->getCount();
    185:         $people = $this->person->loadAll();
    186:         $this->assertEquals($peopleCount, count($people), 'Testing loadAll method');
    187:         // only load 1
    188:         $people = $this->person->loadAll(0, 1);
    189:         $this->assertEquals(1, count($people), 'Testing loadAll method');
    190:     }
    191:
    192:     /**
    193:      * Testing the loadAllByAttribute method
    194:      *
    195:      * @since 1.0
    196:      */
    197:     public function testLoadAllByAttribute() {
    198:         $this->person->save();
    199:         $people = $this->person->loadAllByAttribute('email','unitTestUser@test.com');
    200:         $this->assertEquals(1, count($people), 'Testing the loadAllByAttribute method');
    201:         $this->assertEquals('unitTestUser', $people[0]->getDisplayname()->getValue(), 'Testing the loadAllByAttribute method');
    202:         $people[0]->delete();
    203:     }
    204:
    205:     /**
    206:      * Testing the loadAllByAttributes method
    207:      *
    208:      * @since 1.0
    209:      */
    210:     public function testLoadAllByAttributes() {
    211:         $this->person->save();
    212:         $people = $this->person->loadAllByAttributes(array('OID'),array($this->person->getOID()));
    213:         $this->assertEquals(1, count($people), 'Testing the loadAllByAttribute method');
    214:         $this->assertEquals('unitTestUser', $people[0]->getDisplayname()->getValue(), 'Testing the loadAllByAttributes method');
    215:         $people[0]->delete();
    216:     }
    217:
    218:     /**
    219:      * Testing the loadAllByDayUpdated method
    220:      *
    221:      * @since 1.0
    222:      */
    223:     public function testLoadAllByDayUpdated() {
    224:         $this->person->save();
    225:         $people = $this->person->loadAllByDayUpdated(date('Y-m-d'));
    226:         $this->assertGreaterThan(0, count($people), 'Testing the loadAllByDayUpdated method');
    227:         $people[0]->delete();
    228:     }
    229:
    230:     /**
    231:      * Testing the loadAllFieldValuesByAttribute method
    232:      *
    233:      * @since 1.0
    234:      */
    235:     public function testLoadAllFieldValuesByAttribute() {
    236:         $this->person->save();
    237:         $emails = $this->person->loadAllFieldValuesByAttribute('email', $this->person->get('email'), 'email');
    238:         $this->assertEquals($this->person->get('email'), $emails[0], 'Testing the loadAllFieldValuesByAttribute method');
    239:     }
    240:
    241:     /**
    242:      * Testing the save method on transient and non-transient objects
    243:      *
    244:      * @since 1.0
    245:      */
    246:     public function testSaveTransientOrPersistent() {
    247:         $this->assertTrue($this->person->isTransient(), 'Testing the save method on transient and non-transient objects');
    248:         $this->assertEquals(0, $this->person->getVersionNumber()->getValue(), 'Testing the save method on transient and non-transient objects');
    249:
    250:         $this->person->save();
    251:
    252:         $this->assertFalse($this->person->isTransient(), 'Testing the save method on transient and non-transient objects');
    253:         $this->assertEquals(1, $this->person->getVersionNumber()->getValue(), 'Testing the save method on transient and non-transient objects');
    254:     }
    255:
    256:     /**
    257:      * Testing to ensure that a transient object, once saved, will have an OID
    258:      *
    259:      * @since 1.0
    260:      */
    261:     public function testSaveTransientOID() {
    262:         $this->assertTrue($this->person->isTransient(), 'Testing to ensure that a transient object, once saved, will have an OID');
    263:         $this->person->save();
    264:         $this->assertGreaterThan(0, $this->person->getID(), 'Testing to ensure that a transient object, once saved, will have an OID');
    265:         $this->assertFalse($this->person->isTransient(), 'Testing to ensure that a transient object, once saved, will have an OID');
    266:     }
    267:
    268:     /**
    269:      * Testing optimistic locking mechanism#
    270:      *
    271:      * @since 1.0
    272:      */
    273:     public function testSaveObjectLocking() {
    274:         try {
    275:             $this->person->save();
    276:
    277:             $personInstance1 = new PersonObject();
    278:             $personInstance1->load($this->person->getID());
    279:             $personInstance2 = new PersonObject();
    280:             $personInstance2->load($this->person->getID());
    281:
    282:             $personInstance1->save();
    283:             $personInstance2->save();
    284:             $this->fail('Testing optimistic locking mechanism');
    285:         }catch (LockingException $e) {
    286:             $this->assertEquals('Could not save the object as it has been updated by another user.  Please try saving again.',
    287:                             $e->getMessage(),
    288:                             'Testing optimistic locking mechanism');
    289:         }
    290:     }
    291:
    292:     /**
    293:      * Testing the validation method
    294:      *
    295:      * @since 1.0
    296:      */
    297:     public function testValidation() {
    298:         try {
    299:             $person = new PersonObject();
    300:             $person->save();
    301:             $this->fail('Testing the validation method');
    302:         }catch (ValidationException $e) {
    303:             $this->assertEquals('Failed to save, validation error is:',
    304:                             mb_substr($e->getMessage(), 0, 36),
    305:                             'Testing the validation method');
    306:         }
    307:     }
    308:
    309:     /**
    310:      * Testing the delete method
    311:      *
    312:      * @since 1.0
    313:      */
    314:     public function testDelete() {
    315:         $this->person->save();
    316:         $this->assertFalse($this->person->isTransient(), 'Testing the delete method');
    317:         $id = $this->person->getID();
    318:         $this->person->delete();
    319:         // gone from memory (all attributes null)
    320:         $this->assertEquals(0, count(get_object_vars($this->person)), 'Testing the delete method');
    321:         // gone from the database
    322:         try {
    323:             $this->person = new PersonObject();
    324:             $this->person->load($id);
    325:             $this->fail('Testing the delete method');
    326:         }catch (BONotFoundException $e) {
    327:             $this->assertEquals('Failed to load object',
    328:                             mb_substr($e->getMessage(), 0, 21),
    329:                             'Testing the delete method');
    330:         }
    331:     }
    332:
    333:     /**
    334:      * Testing the deleteAllByAttribute method
    335:      *
    336:      * @since 1.0
    337:      */
    338:     public function testDeleteAllByAttribute() {
    339:         $person1 = new PersonObject();
    340:         $person1->setDisplayname('unitTestUser1');
    341:         $person1->set('email', 'unitTestUser1@test.com');
    342:         $person1->set('password', 'passwordTest');
    343:         $person1->set('URL', 'http://unitTestUser/');
    344:
    345:         $person2 = new PersonObject();
    346:         $person2->setDisplayname('unitTestUser2');
    347:         $person2->set('email', 'unitTestUser2@test.com');
    348:         $person2->set('password', 'passwordTest');
    349:         $person2->set('URL', 'http://unitTestUser/');
    350:
    351:         $person3 = new PersonObject();
    352:         $person3->setDisplayname('unitTestUser3');
    353:         $person3->set('email', 'unitTestUser3@test.com');
    354:         $person3->set('password', 'passwordTest');
    355:         $person3->set('URL', 'http://unitTestUser/');
    356:
    357:         $person1->save();
    358:         $person2->save();
    359:         $person3->save();
    360:         $this->assertEquals(3, $this->person->deleteAllByAttribute('URL', 'http://unitTestUser/'), 'Testing the deleteAllByAttribute method');
    361:     }
    362:
    363:     /**
    364:      * Testing the version numbers of business objects
    365:      *
    366:      * @since 1.0
    367:      */
    368:     public function testGetVersion() {
    369:         $this->assertEquals(0, $this->person->getVersion(), 'Testing the version numbers of business objects');
    370:         $this->assertEquals(0, $this->person->getVersionNumber()->getValue(), 'Testing the version numbers of business objects');
    371:         $this->person->save();
    372:         $this->assertEquals(1, $this->person->getVersion(), 'Testing the version numbers of business objects');
    373:         $this->assertEquals(1, $this->person->getVersionNumber()->getValue(), 'Testing the version numbers of business objects');
    374:         $this->person->save();
    375:         $this->assertEquals(2, $this->person->getVersion(), 'Testing the version numbers of business objects');
    376:         $this->assertEquals(2, $this->person->getVersionNumber()->getValue(), 'Testing the version numbers of business objects');
    377:     }
    378:
    379:     /**
    380:      * Testing the getMAX method
    381:      *
    382:      * @since 1.0
    383:      */
    384:     public function testGetMAX() {
    385:         $this->person->save();
    386:         $max = $this->person->getMAX();
    387:         $person2 = $this->createPersonObject('unitTestUser2');
    388:         $person2->save();
    389:         $this->assertEquals($max+1, $this->person->getMAX(), 'Testing the getMAX method');
    390:     }
    391:
    392:     /**
    393:      * Testing the getCount method
    394:      *
    395:      * @since 1.0
    396:      */
    397:     public function testGetCount() {
    398:         $count = $this->person->getCount();
    399:         $this->person->save();
    400:         $this->assertEquals($count+1, $this->person->getCount(), 'Testing the getCount method');
    401:     }
    402:
    403:     /**
    404:      * Testing the setEnumOptions method is loading enum options correctly
    405:      *
    406:      * @since 1.0
    407:      */
    408:     public function testSetEnumOptions() {
    409:         $this->person->save();
    410:         $id = $this->person->getMAX();
    411:         $this->person->load($id);
    412:         $this->assertTrue(in_array('Active', $this->person->getPropObject('state')->getOptions()),
    413:             'Testing the setEnumOptions method is loading enum options correctly');
    414:     }
    415:
    416:     /**
    417:      * Testing that checkTableExists returns true for the person BO
    418:      *
    419:      * @since 1.0
    420:      */
    421:     public function testCheckTableExists() {
    422:         $this->assertTrue($this->person->checkTableExists(), 'Testing that checkTableExists returns true for the person BO');
    423:     }
    424:
    425:     /**
    426:      * Testing that checkTableNeedsUpdate returns false for the person BO
    427:      *
    428:      * @since 1.0
    429:      */
    430:     public function testCheckTableNeedsUpdate() {
    431:         $this->assertFalse($this->person->checkTableNeedsUpdate(), 'Testing that checkTableNeedsUpdate returns false for the person BO');
    432:     }
    433:
    434:     /**
    435:      * Testing to ensure that the getTableName method can read the TABLE_NAME constant declared in the child class
    436:      *
    437:      * @since 1.0
    438:      */
    439:     public function testGetTableName() {
    440:         $this->assertEquals('Person', $this->person->getTableName(),
    441:             'Testing to ensure that the getTableName method can read the TABLE_NAME constant declared in the child class');
    442:     }
    443:
    444:     /**
    445:      * Testing the getDataLabel method
    446:      *
    447:      * @since 1.0
    448:      */
    449:     public function testGetDataLabel() {
    450:         $this->assertEquals('E-mail Address', $this->person->getDataLabel('email'), 'Testing the getDataLabel method');
    451:     }
    452:
    453:     /**
    454:      * Testing get on a String attribute with no child get method available
    455:      *
    456:      * @since 1.0
    457:      */
    458:     public function testGetNoChildMethod() {
    459:         $email = $this->person->get('email');
    460:
    461:         $this->assertEquals('unitTestUser@test.com', $email, 'Testing get on a String attribute with no child get method available');
    462:     }
    463:
    464:     /**
    465:      * Testing get on an Enum attribute with a child method available, with $noChildMethods disabled (default)
    466:      *
    467:      * @since 1.0
    468:      */
    469:     public function testGetNoChildMethodsDisabled() {
    470:         $state = $this->person->getPropObject('state');
    471:
    472:         $this->assertEquals('Enum', get_class($state),
    473:             'Testing get on an Enum attribute with a child method avaialble, with $noChildMethods disabled (default)');
    474:         $this->assertEquals('Active', $state->getValue(),
    475:             'Testing get on an Enum attribute with a child method avaialble, with $noChildMethods disabled (default)');
    476:     }
    477:
    478:     /**
    479:      * Testing get on an Enum attribute with a child method available, with $noChildMethods enabled
    480:      *
    481:      * @since 1.0
    482:      */
    483:     public function testGetNoChildMethodsEnabled() {
    484:         $state = $this->person->get('state', true);
    485:
    486:         $this->assertEquals('Active', $state, 'Testing get on an Enum attribute with a child method avaialble, with $noChildMethods enabled');
    487:     }
    488:
    489:     /**
    490:      * Testing get on a simple data type
    491:      *
    492:      * @since 1.0
    493:      */
    494:     public function testGetSimpleType() {
    495:         $labels = $this->person->get('dataLabels');
    496:
    497:         $this->assertTrue(is_array($labels), 'Testing get on a simple data type');
    498:     }
    499:
    500:     /**
    501:      * Testing set on a String attribute with no child get method available
    502:      *
    503:      * @since 1.0
    504:      */
    505:     public function testSetNoChildMethod() {
    506:         $this->person->set('email','test@test.com');
    507:
    508:         $this->assertEquals('test@test.com', $this->person->get('email'), 'Testing set on a String attribute with no child get method available');
    509:     }
    510:
    511:     /**
    512:      * Testing set on an Enum attribute with a child method available, with $noChildMethods disabled (default)
    513:      *
    514:      * @since 1.0
    515:      */
    516:     public function testSetNoChildMethodsDisabled() {
    517:         $this->person->set('state','Active');
    518:
    519:         $this->assertEquals('Active', $this->person->get('state'),
    520:             'Testing set on an Enum attribute with a child method avaialble, with $noChildMethods disabled (default)');
    521:     }
    522:
    523:     /**
    524:      * Testing set on an Enum attribute with a child method available, with $noChildMethods enabled
    525:      *
    526:      * @since 1.0
    527:      */
    528:     public function testSetNoChildMethodsEnabled() {
    529:         $this->person->set('state','Active', true);
    530:
    531:         $this->assertEquals('Active', $this->person->get('state'),
    532:             'Testing set on an Enum attribute with a child method avaialble, with $noChildMethods enabled');
    533:     }
    534:
    535:     /**
    536:      * Testing set on a simple data type
    537:      *
    538:      * @since 1.0
    539:      */
    540:     public function testSetSimpleType() {
    541:         $this->person->set('dataLabels', array('key'=>'value'));
    542:
    543:         $labels = $this->person->get('dataLabels');
    544:
    545:         $this->assertTrue(is_array($labels), 'Testing set on a simple data type');
    546:         $this->assertEquals('value', $labels['key'], 'Testing set on a simple data type');
    547:     }
    548:
    549:     /**
    550:      * Testing getPropObject on a complex type
    551:      *
    552:      * @since 1.0
    553:      */
    554:     public function testGetPropObjectComplexType() {
    555:         $state = $this->person->getPropObject('state');
    556:
    557:         $this->assertEquals('Enum', get_class($state), 'Testing getPropObject on a complex type');
    558:         $this->assertEquals('Active', $state->getValue(), 'Testing getPropObject on a complex type');
    559:     }
    560:
    561:     /**
    562:      * Testing getPropObject on a simple type
    563:      *
    564:      * @since 1.0
    565:      */
    566:     public function testGetPropObjectSimpleType() {
    567:         $labels = $this->person->getPropObject('dataLabels');
    568:
    569:         $this->assertTrue(is_array($labels), 'Testing getPropObject on a simple type');
    570:         $this->assertEquals('E-mail Address', $labels['email'], 'Testing getPropObject on a simple type');
    571:     }
    572:
    573:     /**
    574:      * Testing that markTransient and markPersistent methods
    575:      *
    576:      * @since 1.0
    577:      */
    578:     public function testMarkTransientPersistent() {
    579:         // initial save
    580:         $this->person->save();
    581:
    582:         // now mark the URL transient, and save again (old URL value should not be overwritten)
    583:         $this->person->markTransient('URL');
    584:         $this->assertTrue(in_array('URL', $this->person->getTransientAttributes()), 'Testing that markTransient and markPersistent methods');
    585:         $this->person->set('URL','http://www.alphaframework.org/');
    586:         $this->person->save();
    587:
    588:         // used to ensure that we attempt to reload it from the DB
    589:         $this->person->markPersistent('URL');
    590:         $this->assertFalse(in_array('URL', $this->person->getTransientAttributes()), 'Testing that markTransient and markPersistent methods');
    591:         // reload from DB
    592:         $this->person->reload();
    593:
    594:         $this->assertEquals('http://unitTestUser/', $this->person->get('URL'), 'Testing that markTransient and markPersistent methods');
    595:     }
    596:
    597:     /**
    598:      * Testing the getDataLabels method
    599:      *
    600:      * @since 1.0
    601:      */
    602:     public function testGetDataLabels() {
    603:         $this->assertTrue(is_array($this->person->getDataLabels()), 'Testing the getDataLabels method');
    604:         $labels = $this->person->getDataLabels();
    605:         $this->assertTrue(in_array('OID', array_keys($labels)), 'Testing the getDataLabels method');
    606:         $this->assertTrue(in_array('E-mail Address', $labels), 'Testing the getDataLabels method');
    607:     }
    608:
    609:     /**
    610:      * Testing the getTransientAttributes method in conjunction with markTransient/markPersistent
    611:      *
    612:      * @since 1.0
    613:      */
    614:     public function testGetTransientAttributes() {
    615:         $this->assertTrue(is_array($this->person->getTransientAttributes()),
    616:             'Testing the getTransientAttributes method in conjunction with markTransient/markPersistent');
    617:         $this->person->markTransient('URL');
    618:         $this->assertTrue(in_array('URL', $this->person->getTransientAttributes()),
    619:             'Testing the getTransientAttributes method in conjunction with markTransient/markPersistent');
    620:         $this->person->markPersistent('URL');
    621:         $this->assertFalse(in_array('URL', $this->person->getTransientAttributes()),
    622:             'Testing the getTransientAttributes method in conjunction with markTransient/markPersistent');
    623:     }
    624:
    625:     /**
    626:      * Testing isTransient before and after save
    627:      *
    628:      * @since 1.0
    629:      */
    630:     public function testIsTransient() {
    631:         $this->assertTrue($this->person->isTransient(), 'Testing isTransient before and after save');
    632:         $this->person->save();
    633:         $this->assertFalse($this->person->isTransient(), 'Testing isTransient before and after save');
    634:     }
    635:
    636:     /**
    637:      * Testing the getLastQuery method after various persistance calls
    638:      *
    639:      * @since 1.0
    640:      */
    641:     public function testGetLastQuery() {
    642:
    643:         global $config;
    644:
    645:         $this->person->save();
    646:
    647:         if($config->get('db.provider.name') == 'AlphaDAOProviderMySQL') {
    648:             $this->assertEquals('INSERT INTO Person', mb_substr($this->person->getLastQuery(), 0, 18),
    649:                 'Testing the getLastQuery method after various persistance calls');
    650:             $this->person->checkTableNeedsUpdate();
    651:             $this->assertEquals('SHOW INDEX FROM Person', mb_substr($this->person->getLastQuery(), 0, 22),
    652:                 'Testing the getLastQuery method after various persistance calls');
    653:             $this->person->getCount();
    654:             $this->assertEquals('SELECT COUNT(OID)', mb_substr($this->person->getLastQuery(), 0, 17),
    655:                 'Testing the getLastQuery method after various persistance calls');
    656:             $this->person->getMAX();
    657:             $this->assertEquals('SELECT MAX(OID)', mb_substr($this->person->getLastQuery(), 0, 15),
    658:                 'Testing the getLastQuery method after various persistance calls');
    659:             $this->person->load($this->person->getID());
    660:             $this->assertEquals('SHOW COLUMNS FROM Person', mb_substr($this->person->getLastQuery(), 0, 24),
    661:                 'Testing the getLastQuery method after various persistance calls');
    662:         }
    663:
    664:         if($config->get('db.provider.name') == 'AlphaDAOProviderSQLite') {
    665:             $this->assertEquals('PRAGMA table_info(Person)', mb_substr($this->person->getLastQuery(), 0, 25),
    666:                     'Testing the getLastQuery method after various persistance calls');
    667:             $this->person->checkTableNeedsUpdate();
    668:             $this->assertEquals('SELECT name FROM sqlite_master WHERE type=\'index\'', mb_substr($this->person->getLastQuery(), 0, 49),
    669:                     'Testing the getLastQuery method after various persistance calls');
    670:             $this->person->getCount();
    671:             $this->assertEquals('SELECT COUNT(OID)', mb_substr($this->person->getLastQuery(), 0, 17),
    672:                     'Testing the getLastQuery method after various persistance calls');
    673:             $this->person->getMAX();
    674:             $this->assertEquals('SELECT MAX(OID)', mb_substr($this->person->getLastQuery(), 0, 15),
    675:                     'Testing the getLastQuery method after various persistance calls');
    676:             $this->person->load($this->person->getID());
    677:             $this->assertEquals('SELECT displayName,email,password,state,URL,OID,version_num,created_ts,created_by,updated_ts,updated_by FROM Person WHERE OID = :OID LIMIT 1;',
    678:                     mb_substr($this->person->getLastQuery(), 0, 150),
    679:                     'Testing the getLastQuery method after various persistance calls');
    680:         }
    681:     }
    682:
    683:     /**
    684:      * Testing the clear method for unsetting the attributes of an object
    685:      *
    686:      * @since 1.0
    687:      */
    688:     public function testClear() {
    689:         $state = $this->person->get('state');
    690:         $this->assertTrue(!empty($state), 'Testing the clear method for unsetting the attributes of an object');
    691:
    692:         $reflection = new ReflectionClass(get_class($this->person));
    693:         $properties = $reflection->getProperties();
    694:
    695:         foreach($properties as $propObj) {
    696:             $propName = $propObj->name;
    697:             if(!in_array($propName, $this->person->getDefaultAttributes()) && !in_array($propName, $this->person->getTransientAttributes())) {
    698:                 $this->assertNotNull($this->person->get($propName), 'Testing the clear method for unsetting the attributes of an object');
    699:             }
    700:         }
    701:
    702:         // delete will invoke clear(), which is private
    703:         $this->person->delete();
    704:
    705:         try {
    706:             $state = $this->person->get('state');
    707:             $this->fail('Testing the clear method for unsetting the attributes of an object');
    708:         } catch (AlphaException $e) {
    709:             $reflection = new ReflectionClass(get_class($this->person));
    710:             $properties = $reflection->getProperties();
    711:
    712:             foreach($properties as $propObj) {
    713:                 $propName = $propObj->name;
    714:
    715:                 try {
    716:                     $this->person->get($propName);
    717:                 } catch (PHPException $e) {
    718:                     $this->assertEquals(preg_match("/Undefined property/", $e->getMessage()), 1,
    719:                         'Testing the clear method for unsetting the attributes of an object');
    720:                 } catch (AlphaException $e) {
    721:                     $this->assertEquals('Could not access the property ['.$propName.'] on the object of class [PersonObject]', $e->getMessage(),
    722:                         'Testing the clear method for unsetting the attributes of an object');
    723:                 }
    724:             }
    725:         }
    726:     }
    727:
    728:     /**
    729:      * Testing the saveAttribute method
    730:      *
    731:      * @since 1.0
    732:      */
    733:     public function testSaveAttribute() {
    734:         $this->person->save();
    735:         $this->person->saveAttribute('displayName', 'unitTestUserNew');
    736:
    737:         $this->assertEquals('unitTestUserNew', $this->person->getDisplayName()->getValue(),
    738:             'Testing that the value was set on the object in memory along with saving to the database');
    739:
    740:         $person = new PersonObject();
    741:
    742:         try {
    743:             $person->loadByAttribute('displayName', 'unitTestUserNew');
    744:             $this->assertEquals('unitTestUserNew', $person->getDisplayName()->getValue(), 'Testing that the value was saved to the database');
    745:         } catch (BONotFoundException $e) {
    746:             $this->fail('Failed to load the BO that was updated with the saveAttribute method');
    747:         }
    748:     }
    749:
    750:     /**
    751:      * Testing to ensure that a history table was created automatically
    752:      *
    753:      * @since 1.2.1
    754:      */
    755:     public function testHistoryTableCreated() {
    756:         $this->person->setMaintainHistory(true);
    757:         $this->person->rebuildTable(); // this should result in the _history table being created
    758:
    759:         $this->assertTrue($this->person->checkTableExists(true), 'Testing to ensure that a history table was created automatically');
    760:
    761:         $this->person->dropTable('Person_history');
    762:     }
    763:
    764:     /**
    765:      * Testing that the saveHistory() method is automatically invoked when it should be
    766:      *
    767:      * @since 1.2.1
    768:      */
    769:     public function testSaveHistory() {
    770:         $this->person->setMaintainHistory(true);
    771:         $this->person->rebuildTable(); // this should result in the _history table being created
    772:
    773:         $this->person->set('password', 'passwordhist1');
    774:         $this->person->save();
    775:
    776:         $this->assertEquals(1, $this->person->getHistoryCount(), 'Testing that a normal save is propegated to the history table for this class');
    777:         $this->person->setMaintainHistory(true);
    778:         $this->person->saveAttribute('password', 'passwordhist2');
    779:
    780:         $this->assertEquals(2, $this->person->getHistoryCount(), 'Testing that an attribute save is propegated to the history table for this class');
    781:
    782:         $this->person->dropTable('Person_history');
    783:     }
    784:
    785:     /**
    786:      * Testing the hasAttribute method
    787:      *
    788:      * @since 1.2.1
    789:      */
    790:     public function testHasAttribute() {
    791:         $this->assertTrue($this->person->hasAttribute('password'), 'testing the hasAttribute method for true');
    792:         $this->assertFalse($this->person->hasAttribute('doesnotexist'), 'testing the hasAttribute method for false');
    793:     }
    794:
    795:     /**
    796:      * Testing that you can add a DAO directly to the cache without saving
    797:      *
    798:      * @since 1.2.3
    799:      */
    800:     public function testAddToCache() {
    801:         global $config;
    802:
    803:         $oldSetting = $config->get('cache.provider.name');
    804:         $config->set('cache.provider.name', 'AlphaCacheProviderArray');
    805:
    806:         $this->person->setOID('123');
    807:         $this->person->addToCache();
    808:
    809:         $fromCache = new PersonObject();
    810:         $fromCache->setOID($this->person->getOID());
    811:
    812:         $this->assertTrue($fromCache->loadFromCache(), 'testing that the item loads from the cache');
    813:         $this->assertEquals('unitTestUser', $fromCache->get('displayName', true), 'testing that you can add a DAO directly to the cache without saving');
    814:
    815:         $config->set('cache.provider.name', $oldSetting);
    816:     }
    817:
    818:     /**
    819:      * Testing that a saved record is subsequently retrievable from the cache
    820:      *
    821:      * @since 1.2.1
    822:      */
    823:     public function testLoadFromCache() {
    824:
    825:         global $config;
    826:
    827:         $oldSetting = $config->get('cache.provider.name');
    828:         $config->set('cache.provider.name', 'AlphaCacheProviderArray');
    829:
    830:         $this->person->save();
    831:
    832:         $fromCache = new PersonObject();
    833:         $fromCache->setOID($this->person->getOID());
    834:
    835:         $this->assertTrue($fromCache->loadFromCache(), 'testing that the item loads from the cache');
    836:         $this->assertEquals('unitTestUser', $fromCache->get('displayName', true), 'testing that a saved record is subsequently retrievable from the cache');
    837:
    838:         $config->set('cache.provider.name', $oldSetting);
    839:     }
    840:
    841:     /**
    842:      * Testing the removeFromCache method
    843:      *
    844:      * @since 1.2.1
    845:      */
    846:     public function testRemoveFromCache() {
    847:
    848:         global $config;
    849:
    850:         $oldSetting = $config->get('cache.provider.name');
    851:         $config->set('cache.provider.name', 'AlphaCacheProviderArray');
    852:
    853:         $this->person->save();
    854:
    855:         $fromCache = new PersonObject();
    856:         $fromCache->setOID($this->person->getOID());
    857:
    858:         $this->assertTrue($fromCache->loadFromCache(), 'testing that the item loads from the cache');
    859:
    860:         $fromCache->removeFromCache();
    861:
    862:         $this->assertFalse($fromCache->loadFromCache(), 'testing that the item is gone from the cache');
    863:
    864:         $config->set('cache.provider.name', $oldSetting);
    865:     }
    866:
    867:     /**
    868:      * Testing the getFriendlyClassName() method
    869:      *
    870:      * @since 1.2.1
    871:      */
    872:     public function testGetFriendlyClassName() {
    873:         $person = new PersonObject();
    874:         $article = new ArticleObject();
    875:         $comment = new ArticleCommentObject();
    876:
    877:         $this->assertEquals('Person', $person->getFriendlyClassName(), 'testing the getFriendlyClassName() method');
    878:         $this->assertEquals('Article', $article->getFriendlyClassName(), 'testing the getFriendlyClassName() method');
    879:         $this->assertEquals('ArticleComment', $comment->getFriendlyClassName(), 'testing the getFriendlyClassName() method');
    880:     }
    881:
    882:     /**
    883:      * Testing the cast() method
    884:      *
    885:      * @since 1.2.1
    886:      */
    887:     public function testCast() {
    888:         $original = new BadRequestObject();
    889:         $original->set('IP', '127.0.0.1');
    890:         $copy = $original->cast('BlacklistedIPObject', $original);
    891:
    892:         $this->assertTrue($copy instanceof BlacklistedIPObject, 'testing the cast() method');
    893:         $this->assertTrue($copy->hasAttribute('IP'), 'testing the cast() method');
    894:         $this->assertEquals($original->get('IP'), $copy->get('IP'), 'testing the cast() method');
    895:     }
    896: }
    897:
    898: ?>