Login   Register  
PHP Classes
elePHPant
Icontem

File: test/modelTest.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Eustaquio Rangel de Oliveira Jr.  >  torm  >  test/modelTest.php  >  Download  
File: test/modelTest.php
Role: Unit test script
Content type: text/plain
Description: Unit test script
Class: torm
Store and retrieve objects using ActiveRecord
Author: By
Last change: Each model now can have different connections.
Date: 6 months ago
Size: 27,886 bytes
 

Contents

Class file image Download
<?php
   include_once "../torm.php";
   include_once "../models/user.php";
   include_once "../models/another_user.php";
   include_once "../models/ticket.php";
   include_once "../models/account.php";

   class ModelTest extends PHPUnit_Framework_TestCase {
      protected static $con  = null;
      protected static $user = null;

      public static function setUpBeforeClass() {
         $file = realpath(dirname(__FILE__)."/../database/test.sqlite3");
         self::$con  = new PDO("sqlite:$file");
         // self::$con  = new PDO('mysql:host=localhost;dbname=torm',"torm","torm");

         TORM\Connection::setConnection(self::$con, "test");
         TORM\Connection::setEncoding("UTF-8");
         TORM\Connection::setDriver("sqlite");
         // TORM\Connection::setDriver("mysql");
         TORM\Factory::setFactoriesPath("./factories");
         TORM\Log::enable(false);

         self::$user        = new User();
         self::$user->id    = 1;
         self::$user->name  = "John Doe Jr.";
         self::$user->email = "jr@doe.com";
         self::$user->code  = "12345";
         self::$user->level = 1;
      }

      public function setUp() {
         Account::all()->destroy();
      }

      public function testConnection() {
         $this->assertNotNull(self::$con);
         $this->assertEquals(self::$con,TORM\Connection::getConnection("test"));
      }      

      public function testFind() {
         $user = User::find(1);
         $this->assertEquals("Eustaquio Rangel",$user->name);
         $this->assertEquals("eustaquiorangel@gmail.com",$user->email);
      }

      public function testNotFound() {
         $user = User::find(10);
         $this->assertNull($user);
      }

      public function testSetAttribute() {
         $user = User::find(1);
         $user->name = "John Doe";
         $this->assertEquals("John Doe",$user->name);
      }

      public function testFirst() {
         $user = User::first();
         $this->assertEquals("Eustaquio Rangel",$user->name);
      }

      public function testFirstWithCondition() {
         $user = User::first(array("email"=>"eustaquiorangel@gmail.com"));
         $this->assertEquals("Eustaquio Rangel",$user->name);
      }

      public function testFirstNotFound() {
         $user = User::first(array("email"=>"yoda@gmail.com"));
         $this->assertNull($user);
      }

      public function testLast() {
         $user = User::last();
         $this->assertEquals("Rangel, Eustaquio",$user->name);
      }

      public function testLastWithCondition() {
         $user = User::last(array("email"=>"taq@bluefish.com.br"));
         $this->assertEquals("Rangel, Eustaquio",$user->name);
      }

      public function testLastNotFound() {
         $user = User::last(array("email"=>"yoda@gmail.com"));
         $this->assertNull($user);
      }

      public function testWhere() {
         $users = User::where(array("name"=>"Eustaquio Rangel"));
         $user  = $users->next();
         $this->assertEquals("Eustaquio Rangel",$user->name);
      }

      public function testWhereWithString() {
         $users = User::where("name='Eustaquio Rangel'");
         $user  = $users->next();
         $this->assertEquals("Eustaquio Rangel",$user->name);
      }

      public function testAll() {
         $users = User::all();
         $user  = $users->next();
         $this->assertEquals("Eustaquio Rangel",$user->name);

         $user  = $users->next();
         $this->assertEquals("Rangel, Eustaquio",$user->name);

         echo "checking all users ...\n";
         foreach(User::all() as $user) {
            echo "user: ".$user->name."\n";
         }
      }

      public function testInsert() {
         $user = new User();
         $user->name    = "John Doe";
         $user->email   = "john@doe.com";
         $user->level   = 1;
         $user->code    = "12345";
         $this->assertTrue($user->isValid());
         $this->assertNull($user->id);
         $this->assertTrue($user->save());
         $this->assertNotNull($user->id);
         $this->assertNotNull($user->created_at);

         $new_user = User::find($user->id);
         $this->assertNotNull($new_user);
         $this->assertEquals($user->name ,$new_user->name);
         $this->assertEquals($user->email,$new_user->email);
         $this->assertEquals($user->level,$new_user->level);
         $this->assertEquals($user->code ,$new_user->code);
      }

      public function testInsertNoCreatedAtColumn() {
         $ticket = new Ticket();
         $ticket->description = "A new ticket";
         $ticket->user_id = 1;
         $this->assertTrue($ticket->save());
         $this->assertTrue($ticket->destroy());
      }

      public function testUpdate() {
         $user = User::where("email='john@doe.com'")->next();
         $id   = $user->id;
         $user->name = "Doe, John";
         $user->save();

         $this->assertEquals("Doe, John",User::find($id)->name);
         $this->assertTrue($user->isValid());
         $user->save();
      }

      public function testUpdateNoUpdatedAtColumn() {
         $ticket = Ticket::first();
         $old_desc = $ticket->description;
         $ticket->description = "New description";
         $this->assertTrue($ticket->save());
         $ticket->description = $old_desc;
         $this->assertTrue($ticket->save());
      }

      public function testDestroy() {
         $user = User::where("email='john@doe.com'")->next();
         $this->assertTrue($user->destroy());
      }

      public function testCache() {
         $sql = "select * from Users where id=?";
         $this->assertNull(User::getCache($sql));
         User::putCache($sql);
         $this->assertNotNull(User::getCache($sql));
      }

      public function testInvalidPresence() {
         self::$user->name = null;
         $this->assertFalse(self::$user->isValid());
      }

      public function testValidPresence() {
         self::$user->name = "John Doe Jr.";
         $this->assertTrue(self::$user->isValid());
      }

      public function testInvalidFormat() {
         self::$user->email = "yadda@yadda";
         $this->assertFalse(self::$user->isValid());
      }

      public function testValidFormat() {
         self::$user->email = "jr@doe.com";
         $this->assertTrue(self::$user->isValid());
      }

      public function testEmptyFormat() {
         self::$user->code = "";
         $this->assertFalse(self::$user->isValid());
      }

      public function testNullFormat() {
         self::$user->code = null;
         $this->assertTrue(self::$user->isValid());
      }

      public function testUniqueness() {
         $old_user = User::find(1);
         $new_user = new User();
         $new_user->name  = $old_user->name;
         $new_user->email = $old_user->email;
         $this->assertFalse($new_user->isValid());
         $this->assertEquals(TORM\Validation::VALIDATION_UNIQUENESS,$new_user->errors["email"][0]);
      }

      public function testNotANumber() {
         self::$user->level = "one";
         $this->assertFalse(self::$user->isValid());
      }

      public function testNotANumberWithSpecialChars() {
         self::$user->level = "$%@";
         $this->assertFalse(self::$user->isValid());
      }

      public function testAPositiveNumber() {
         self::$user->level = 1;
         $this->assertTrue(self::$user->isValid());
      }

      public function testANegativeNumber() {
         self::$user->level = -1;
         $this->assertTrue(self::$user->isValid());
      }

      public function testAFloatingPointNumber() {
         self::$user->level = 1.23;
         $this->assertTrue(self::$user->isValid());
      }

      public function testCantSaveInvalidObject() {
         $user = new User();
         $this->assertFalse($user->save());
      }

      public function testLimit() {
         $users = User::where(array("name"=>"Eustaquio Rangel"))->limit(1);
         $this->assertNotNull($users->next());
         $this->assertNull($users->next());
      }

      public function testOrder() {
         $users = User::where("name like '%rangel%'")->order("email desc")->limit(1);
         $user  = $users->next();
         $this->assertNotNull($user);
         $this->assertEquals("taq@bluefish.com.br",$user->email);
      }

      public function testHasMany() {
         $user    = User::find(1);
         $tickets = $user->tickets;
         $this->assertNotNull($tickets);
         echo "\ntickets:\n";
         $ids = array();
         foreach($tickets as $ticket) {
            echo "ticket: ".$ticket->id." ".$ticket->description."\n";
            array_push($ids,$ticket->id);
         }
         $this->assertNotNull($user->ticket_ids);
         $this->assertEquals(sizeof($ids),sizeof($user->ticket_ids));
         foreach($ids as $id) {
            $this->assertTrue(in_array($id,$user->ticket_ids));
         }
      }

      public function testHasManyUpdateIds() {
         $user    = User::find(1);
         $ticket  = TORM\Factory::build("ticket");
         $ticket->user_id = $user->id;
         $this->assertTrue($ticket->save());

         $this->assertEquals(3,$user->tickets->count());
         $user->ticket_ids = [1,2];
         $this->assertEquals(2,$user->tickets->count());
         $this->assertNotNull(Ticket::find($ticket->id));
         $this->assertTrue($ticket->destroy());
      }

      public function testBelongs() {
         $ticket = Ticket::first();
         $this->assertNotNull($ticket);
         $user = $ticket->user;
         $this->assertNotNull($user);
         echo "user on belongs: ".$user->name."\n";
      }

      public function testCheckEmptySequence() {
         $this->assertEquals(null,User::resolveSequenceName());
      }

      public function testDefaultSequence() {
         $old = TORM\Driver::$primary_key_behaviour;
         TORM\Driver::$primary_key_behaviour = TORM\Driver::PRIMARY_KEY_SEQUENCE;
         $name = User::resolveSequenceName();
         $this->assertEquals("users_sequence",User::resolveSequenceName());
         TORM\Driver::$primary_key_behaviour = $old;
      }

      public function testNamedSequence() {
         $old = TORM\Driver::$primary_key_behaviour;
         TORM\Driver::$primary_key_behaviour = TORM\Driver::PRIMARY_KEY_SEQUENCE;
         $test = "yadda_sequence";
         User::setSequenceName($test);
         $name = User::resolveSequenceName();
         $this->assertEquals($test,User::resolveSequenceName());
         TORM\Driver::$primary_key_behaviour = $old;
      }

      public function testCantChangeExistingPK() {
         $user = User::find(1);
         $old  = $user->id;
         $user->id = 10;
         $this->assertEquals($old,$user->id);
      }

      public function testCanChangeNewPK() {
         $user = new User();
         $new  = 10;
         $user->id = $new;
         $this->assertEquals($new,$user->id);
      }

      public function testCount() {
         $this->assertEquals(2,User::all()->count());
      }

      public function testCountWithConditions() {
         $this->assertEquals(1,User::all(array("email"=>"eustaquiorangel@gmail.com"))->count());
      }

      public function testCountWithConditionsAndWhere() {
         $this->assertEquals(1,User::where(array("email"=>"eustaquiorangel@gmail.com"))->count());
      }

      public function testSum() {
         $this->assertEquals(3,User::all()->sum("level"));
      }

      public function testSumWithConditions() {
         $this->assertEquals(2,User::all(array("email"=>"taq@bluefish.com.br"))->sum("level"));
      }

      public function testSumWithConditionsAndWhere() {
         $this->assertEquals(1,User::where(array("email"=>"eustaquiorangel@gmail.com"))->sum("level"));
      }

      public function testAvg() {
         $this->assertEquals(1.5,User::all()->avg("level"));
      }

      public function testAvgWithConditions() {
         $this->assertEquals(2,User::all(array("email"=>"taq@bluefish.com.br"))->avg("level"));
      }

      public function testAvgWithConditionsAndWhere() {
         $this->assertEquals(1,User::where(array("email"=>"eustaquiorangel@gmail.com"))->avg("level"));
      }

      public function testMin() {
         $this->assertEquals(1,User::all()->min("level"));
      }

      public function testMinWithConditions() {
         $this->assertEquals(2,User::all(array("email"=>"taq@bluefish.com.br"))->min("level"));
      }

      public function testMinWithConditionsAndWhere() {
         $this->assertEquals(1,User::where(array("email"=>"eustaquiorangel@gmail.com"))->min("level"));
      }

      public function testMax() {
         $this->assertEquals(2,User::all()->max("level"));
      }

      public function testMaxWithConditions() {
         $this->assertEquals(2,User::all(array("email"=>"taq@bluefish.com.br"))->max("level"));
      }

      public function testMaxWithConditionsAndWhere() {
         $this->assertEquals(1,User::where(array("email"=>"eustaquiorangel@gmail.com"))->max("level"));
      }

      public function testDestroyCollection() {
         $users = User::all();
         $user1 = $users->next();
         $user2 = $users->next();
         User::all()->destroy();

         $this->assertEquals(0,User::all()->count());
         $this->assertTrue($user1->save());
         $this->assertTrue($user2->save());
         $this->assertEquals(2,User::all()->count());
      }

      public function testDestroyCollectionWithConditions() {
         $cond  = array("email"=>"eustaquiorangel@gmail.com");
         $users = User::all($cond);
         $user1 = $users->next();
         User::all($cond)->destroy();

         $this->assertEquals(1,User::all()->count());
         $this->assertTrue($user1->save());
         $this->assertEquals(2,User::all()->count());
      }

      public function testUpdateAttributes() {
         $new_level = 3;
         $new_email = "iwishigottaq@gmail.com";

         $user = User::find(1);
         $old_level = $user->level;
         $old_email = $user->email;
         $user->updateAttributes(array("email"=>$new_email,"level"=>$new_level));

         $user = User::find(1);
         $this->assertEquals($new_level,$user->level);
         $this->assertEquals($new_email,$user->email);
         $user->updateAttributes(array("email"=>$old_email,"level"=>$old_level));

         $user = User::find(1);
         $this->assertEquals($old_level,$user->level);
         $this->assertEquals($old_email,$user->email);
      }

      public function testCantUpdatePKAttributes() {
         $account = TORM\Factory::create("account");
         $this->assertTrue($account->save());

         $account = Account::first();
         $old_id  = $account->id;
         $new_id  = 999;
         $new_num = "54321";

         $this->assertTrue($account->updateAttributes(array("id"=>$new_id,"number"=>$new_num)));
         $account = Account::find($old_id);
         $this->assertNotNull($account);
         $this->assertEquals($new_num,$account->number);
         $this->assertNull(Account::find($new_id));
      }

      public function testUpdateAttributesOnCollection() {
         $users = User::all();
         $user1 = $users->next();
         $user2 = $users->next();

         User::all()->updateAttributes(array("email"=>"void@gmail.com","level"=>0));
         $users = User::all();
         while($user = $users->next()) {
            $this->assertEquals("void@gmail.com",$user->email);
            $this->assertEquals(0,$user->level);
         }

         $this->assertTrue($user1->save(true));
         $this->assertTrue($user2->save(true));
      }

      public function testUpdateAttributesOnCollectionWithConditions() {
         $cond  = array("email"=>"eustaquiorangel@gmail.com");
         $users = User::where($cond);
         $user1 = $users->next();
         $this->assertNotNull($user1);

         User::where($cond)->updateAttributes(array("email"=>"void@gmail.com","level"=>0));
         $users = User::where($cond);
         while($user = $users->next()) {
            $this->assertEquals("void@gmail.com",$user->email);
            $this->assertEquals(0,$user->level);
         }
         $this->assertTrue($user1->save(true));
      }

      public function testPKMethod() {
         $user   = User::first();
         $ticket = new Ticket();
         $ticket->user_id     = $user->id;
         $ticket->description = "pk value test";
         $this->assertTrue($ticket->save());

         $ticket = Ticket::last();
         $this->assertTrue($ticket->id>=time()-1000);
         $this->assertTrue($ticket->destroy());
      }

      public function testHasOneRelation() {
         $account = TORM\Factory::create("account");

         $user = User::first();
         $acct = $user->account;
         $this->assertNotNull($acct);
         $this->assertEquals("Account",get_class($acct));
         $this->assertEquals($account->number,$acct->number);
      }

      public function testGet() {
         $user = TORM\Factory::build("user");
         $this->assertNotNull($user->get("name"));
      }

      public function testNullGet() {
         $user = TORM\Factory::build("user");
         $this->assertNull($user->get("yadda"));
      }

      public function testHasCreateColumn() {
         $user = TORM\Factory::build("user");
         $this->assertNotNull($user->hasColumn("created_at"));
      }

      public function testHasNotCreateColumn() {
         $account = TORM\Factory::build("account");
         $this->assertNull($account->hasColumn("created_at"));
      }

      public function testHasUpdateColumn() {
         $user = TORM\Factory::build("user");
         $this->assertNotNull($user->hasColumn("updated_at"));
      }

      public function testHasNotUpdateColumn() {
         $account = TORM\Factory::build("account");
         $this->assertNull($account->hasColumn("updated_at"));
      }

      public function testHasHasManyRelation() {
         $account = TORM\Factory::build("account");
         $user    = TORM\Factory::build("user");

         $this->assertFalse($account->hasHasMany("users"));
         $this->assertTrue($user->hasHasMany("tickets"));
      }

      public function testHasManyClass() {
         $user = TORM\Factory::build("user");
         $this->assertEquals("Ticket",$user->hasManyClass("tickets"));
      }

      public function testHasManyForeignKey() {
         $user = TORM\Factory::build("user");
         $this->assertEquals("user_id",$user->hasManyForeignKey("tickets"));
      }

      public function testModelTableName() {
         $this->assertEquals("users",User::getTableName());
      }

      public function testModelTableNameByString() {
         $this->assertEquals("tickets",TORM\Model::getTableName("Ticket"));
      }

      public function testPushReceiverWithIdObjectWithId() {
         $user    = TORM\Factory::create("user");
         $ticket  = TORM\Factory::create("ticket");

         $this->assertEquals(0,$user->tickets->count());
         $user->push($ticket);
         $this->assertEquals($user->id,$ticket->user_id);
         $this->assertEquals(1,$user->tickets->count());

         $ticket = Ticket::find($ticket->id);
         $this->assertEquals($user->id,$ticket->user->id);
         $this->assertTrue($user->destroy());
         $this->assertTrue($ticket->destroy());
      }

      public function testPushReceiverWithoutIdObjectWithId() {
         $attrs       = TORM\Factory::attributes_for("user");
         $attrs["id"] = null;

         $user    = new User($attrs);
         $ticket  = TORM\Factory::create("ticket");

         $this->assertEquals(0,$user->tickets->count());
         $user->push($ticket);
         $this->assertTrue($user->save());
         $this->assertEquals(1,$user->tickets->count());

         $ticket = Ticket::find($ticket->id);
         $this->assertEquals($user->id,$ticket->user->id);
         $this->assertTrue($user->destroy());
         $this->assertTrue($ticket->destroy());
      }

      public function testPushReceiverWithIdObjectWithoutId() {
         $user    = TORM\Factory::create("user");
         $ticket  = TORM\Factory::build("ticket");

         $this->assertEquals(0,$user->tickets->count());
         $user->push($ticket);
         $this->assertEquals(1,$user->tickets->count());

         $ticket = Ticket::find($ticket->id);
         $this->assertEquals($user->id,$ticket->user->id);
         $this->assertTrue($user->destroy());
         $this->assertTrue($ticket->destroy());
      }

      public function testPushReceiverWithoutIdObjectWithoutId() {
         $user    = TORM\Factory::build("user");
         $ticket  = TORM\Factory::build("ticket");

         $user->push($ticket);
         $this->assertTrue($user->save());

         $ticket = Ticket::find($ticket->id);
         $this->assertEquals($user->id,$ticket->user->id);
         $this->assertTrue($user->destroy());
         $this->assertTrue($ticket->destroy());
      }

      public function testManyCollection() {
         $user = TORM\Factory::create("user");
         $t1   = TORM\Factory::create("ticket");
         $t2   = TORM\Factory::create("ticket");

         $this->assertEquals(0,$user->tickets->count());
         $user->tickets = array($t1,$t2);
         $this->assertEquals(2,$user->tickets->count());

         $this->assertTrue($user->destroy());
         $this->assertTrue($t1->destroy());
         $this->assertTrue($t2->destroy());
      }

      private function checkCallbackFile($file) {
         $user = TORM\Factory::build("user");
         if(file_exists($file))
            unlink($file);

         $this->assertFalse(file_exists($file));
         $this->assertTrue($user->save());
         $this->assertTrue($user->destroy());
         $this->assertTrue(file_exists($file));
      }

      public function testBeforeSave() {
         $this->checkCallbackFile("/tmp/torm-before-save.log");
      }

      public function testAfterSave() {
         $this->checkCallbackFile("/tmp/torm-after-save.log");
      }

      public function testBeforeDestroy() {
         $this->checkCallbackFile("/tmp/torm-before-destroy.log");
      }

      public function testAfterDestroy() {
         $this->checkCallbackFile("/tmp/torm-before-save.log");
      }

      public function testMustRespondToAScopeDefinitionMethod() {
         $this->assertTrue(method_exists("User","scope"));
      }

      public function testMustRespondToAScopeAsAMethod() {
         $this->assertEquals(1,User::first_level()->count());
      }

      public function testMustRespondToAScopeAsAMethodWithParameters() {
         $this->assertEquals(1,User::by_level(1)->count());
      }

      public function testMustRespondToAScopeAsAMethodWithMultipleParameters() {
         $this->assertEquals(1, User::by_level_and_date(1, date("Y-m-d", strtotime("+2 days")))->count());
      }

      public function testAccentedCharsOnValidation() {
         $user = TORM\Factory::build("user");
         $user->name = "Eustáquio Rangel";
         $this->assertTrue($user->isValid());
      }

      public function testCollectionToArray() {
         $user       = User::first();
         $tickets    = $user->tickets->toArray();
         $this->assertEquals(2,sizeof($tickets));
      }

      public function testCollectionToArrayWithLimit() {
         $user       = User::first();
         $tickets    = $user->tickets->toArray(1);
         $this->assertEquals(1,sizeof($tickets));
      }

      public function testFullErrorMessages() {
         Locale::setDefault("en-US");
         User::setYAMLFile("torm.yml");
         $user = User::first();
         $msgs = $user->fullMessages(array("name"  => array("presence"),
                                           "level" => array("numericality"),
                                           "email" => array("uniqueness","format")));

         $this->assertEquals("Name cannot be blank"      ,$msgs[0]);
         $this->assertEquals("Level must be a number"    ,$msgs[1]);
         $this->assertEquals("E-mail must be unique"     ,$msgs[2]);
         $this->assertEquals("E-mail has invalid format" ,$msgs[3]);
      }

      public function testPagination() {
         $user = User::first();
         $objs = array();
         for($i=0; $i<21; $i++) {
            $ticket = TORM\Factory::build("ticket");
            $ticket->user_id = $user->id;
            $this->assertTrue($ticket->save());
            array_push($objs,$ticket);
         }

         $pages = array(1=>5,2=>5,3=>5,4=>5,5=>3);
         foreach($pages as $page=>$qty) {
            $tickets = $user->tickets->paginate($page,5);
            $ar = $tickets->toArray();
            $this->assertEquals($page,$tickets->page);
            $this->assertEquals($qty,sizeof($ar));
         }

         foreach($objs as $obj) 
            $this->assertTrue($obj->destroy());
      }

      public function testOldAttr() {
         $user = TORM\Factory::build("user");
         $this->assertTrue($user->save());

         $old_name = $user->name;
         $new_name = "Dirty Objects";

         $user = User::find($user->id);
         $user->name = $new_name;
         $this->assertTrue($user->name_changed);
         $this->assertEquals($old_name,$user->name_was);
         $this->assertEquals(array($old_name,$new_name),$user->name_change);

         $this->assertEquals(0,sizeof(array_diff_assoc(array("name"),$user->changed())));

         $changes = $user->changes();
         $this->assertTrue(array_key_exists("name",$changes));
         $this->assertEquals(0,sizeof(array_diff_assoc(array($old_name,$new_name),$changes["name"])));
         $this->assertTrue($user->save());

         $newer_name = "Another dirty object test";
         $user->name = $newer_name;
         $this->assertTrue($user->name_changed);
         $this->assertEquals($new_name,$user->name_was);
         $this->assertEquals(array($new_name,$newer_name),$user->name_change);
         $this->assertTrue($user->destroy());
      }

      /**
       * @expectedException PDOException
       * @expectedExceptionMessage table users has no column named invalid_attr
       * @expectedExceptionCode HY000
       */
      public function testException() {
         $user = TORM\Factory::build("crazy_user");
         $this->assertFalse($user->save());
      }

      public function testExtractColumns() {
          $columns = User::extractColumns();
          $this->assertEquals('"users"."id","users"."name","users"."email","users"."level","users"."code","users"."created_at","users"."updated_at"',$columns);
      }

      /**
       * This is a test to check if the before callbacks are called before 
       * writing the record, where is checked if is a valid record.
       * There's a before callback that remove invalid chars from the email 
       * attr, so the record will be saved only if the callback is called 
       * before saving.
       */
      public function testBeforeInvalidChars() {
          $user = User::first();
          $user->email = $user->email."#";
          $this->assertTrue($user->save());
      }

      /**
       * Object has a afterInitialize method
       *
       * @return null
       */
      public function testAfterInitialize() {
         $user = TORM\Factory::build("unnamed_user");
         $this->assertTrue(method_exists($user, "afterInitialize"));
         $this->assertEquals("Unnamed User", $user->name);
      }

      /**
       * Other connection
       *
       * @return null
       */
      public function testOtherConnection()
      {
          $file = realpath(dirname(__FILE__)."/../database/another_test.sqlite3");
          $con  = new PDO("sqlite:$file");

          AnotherUser::setConnection($con, "test");
          $user = AnotherUser::first();
          $this->assertEquals("Walternate", $user->name);
      }
   }
?>