/libs/orm/tests/SchemaTest.php

<?php





require_once ('PHPUnit/Autoload.php');



class ORMTest extends PHPUnit_Framework_TestCase{

	

	/**

	 * @Datasource

	 */

	private $ds = null;

	

	/**

	 * 

	 * 

	 * @var PDO

	 */

	private $conn = null;

	

	const SCHEMA_SOURCE_FILE = "./resources/test-source-file.xml";

	const SCHEMA_TARGET_FILE = "./resources/test-target-file.xml";

	const CONFIG_SOURCE_FILE = "./resources/test-configuration.xml";

	

	public function __construct(){

		$this->backupGlobals = false;

		$this->backupStaticAttributes = false;

		

		$reader = new ConfigReader();

		$result = $reader->readConfigFromFile(self::CONFIG_SOURCE_FILE);

		$this->ds = $result[0]->datasources[0];

		$this->ds->connect();

		

		$this->conn = $this->ds->getConnection();

		$this->clearDatasource();

	}

	

	public function __destruct(){

		//$this->clearDatasource();

	}

	

	/**

	 * 

	 * Enter description here ...

	 * @return Schema

	 */

	private function getSchema(){

		$reader = new SchemaReader();

		return $reader->readSchemaFromFile(self::SCHEMA_SOURCE_FILE);

	}

	



	

	

	private function clearDatasource(){

		$statement = $this->conn->query("show tables");

		$result = $statement->fetchAll( PDO::FETCH_NUM );

		foreach($result as $row){

			$result = $this->conn->exec("DROP TABLE `{$row[0]}`");

		}

	}

	

	private function createTestDataStructure(){

		$this->conn->exec("CREATE TABLE  `orm`.`test_table` (

		`test1` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,

		`test2` VARCHAR( 255 ) NULL,

		`test3` integer NOT NULL,

		INDEX `test_index` (  `test2` )

		) ENGINE=InnoDB");

		

		$table1 = new Table();

		$table1->setClasspath( "orm.auto_path.AutoClassTest_table");

		$table1->setBaseClasspath( "auto.Persistent" );

		$table1->setTableName("test_table");

		

		

		

		$field_test1 = new Field(); 

		$field_test1->setName("test1");

		$field_test1->setAutoincrement(true);

		$field_test1->setPKey(true);

		$field_test1->setType("integer");

		$field_test1->setSize(11);

		

		$field_test2 = new Field();

		$field_test2->setName("test2");

		$field_test2->setType("varchar");

		$field_test2->setSize(255);

		

		$field_test3 = new Field();

		$field_test3->setName("test3");

		$field_test3->setType("integer");

		$field_test3->setRequired(true);

		$field_test3->setSize(11);

		

		$table1->addField($field_test1);

		$table1->addField($field_test2);

		$table1->addField($field_test3);

		

		

		

		$fKey = new ForeignKey();

		$fKey->setName("test_table_ibfk_1");

		$fKey->setForeignTableName("test_table2");

		$fKeyReferece = new ForeignKeyReference();

		$fKeyReferece->setLocalFieldName("test2");

		$fKeyReferece->setForeignFieldName("test2");

		$fKey->addReference($fKeyReferece);

		$fKey->setOnDelete(ForeignKey::MODE_CASCADE);

		$fKey->setOnUpdate(ForeignKey::MODE_CASCADE);

		$table1->addForeignKey($fKey);

		

		

		//$this->conn->exec("ALTER TABLE  `test_table` ADD INDEX `test_index2` (  `test2` )");

		$index = new Index();

		$index->addFieldName("test2");

		$index->setName("test_index");

		$index->setType("BTREE");

		

		//test_index

		

		

		$table1->addIndex($index);

		

		

		$this->conn->exec("CREATE TABLE  `orm`.`test_table2` (

		`test1` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,

		`test2` VARCHAR( 255 ) NOT NULL,

		`test3` integer NOT NULL,

		INDEX  (  `test2` )

		) ENGINE=InnoDB");

		

		$this->conn->exec("

		ALTER TABLE  `test_table` ADD FOREIGN KEY  (  `test2` ) REFERENCES  `orm`.`test_table2` (

		`test2`

		) ON DELETE CASCADE ON UPDATE CASCADE");

		

		$table2 = new Table();

		$table2->setClasspath( "orm.auto_path.AutoClassTest_table2");

		$table2->setBaseClasspath( "auto.Persistent" );

		$table2->setTableName("test_table2");

		

		$field_test1 = new Field(); 

		$field_test1->setName("test1");

		$field_test1->setAutoincrement(true);

		$field_test1->setPKey(true);

		$field_test1->setType("integer");

		$field_test1->setSize(11);

		

		$field_test2 = new Field();

		$field_test2->setName("test2");

		$field_test2->setType("varchar");

		$field_test2->setSize(255);

		$field_test2->setRequired(true);

		

		$field_test3 = new Field();

		$field_test3->setName("test3");

		$field_test3->setType("integer");

		$field_test3->setRequired(true);

		$field_test3->setSize(11);

		

		$table2->addField($field_test1);

		$table2->addField($field_test2);

		$table2->addField($field_test3);

		$index = new Index();

		$index->setName("test2");

		$index->addFieldName("test2");

		

		$index->setType("BTREE");

		

		$table2->addIndex($index);

		$schema = new Schema();

		

		$schema->addTable($table1);

		$schema->addTable($table2);



		return $schema;

	}

	

	

	

	public function testSchemaReader(){

		$schemaReader = new SchemaReader();

		$schema = $schemaReader->readSchemaFromFile(self::SCHEMA_SOURCE_FILE); 

		

		$tables = $schema->getTables();

		

		$this->assertEquals(2, count($tables), "Expected tables count not match");

		$this->assertEquals(13, count($tables[0]->getFields()), "Expected fields count not match");

	}

	

	public function testCaching(){

		$generator = new BaseDomainClassGenerator();

		$dir = "./cache/";

		$generator->targetDir = $dir;

		$schemaReader = new SchemaReader();

		$schema = $schemaReader->readSchemaFromFile(self::SCHEMA_SOURCE_FILE); 

		$generator->generate($schema);

		

		foreach($schema->getTables() as $table){

			$this->assertTrue(file_exists($dir."ORM_{$table->getClass()}.php"), "Domain clas file not generated");

		}

	}

	

	public function testConfigRead(){

		$reader = new ConfigReader();

		$result = $reader->readConfigFromFile(self::CONFIG_SOURCE_FILE);

		

		$this->assertEquals(1, count($result), "Expected group count not match");

		$this->assertEquals(1, count($result[0]->datasources), "Expected datasources count not match");

		

		$this->assertFalse($result[0]->datasources[0]->connectionString == "", "ConnectionString empty");

		$this->assertFalse($result[0]->datasources[0]->charset == "", "Charset string empty");

		$this->assertFalse($result[0]->datasources[0]->transactions , "Transaction is not set to true");

		

	}

	

	public function testSynchronizeTableToDs(){

		$this->clearDatasource();

		$schema = $this->getSchema();

		$synchronizer = new MysqlSynchronizer();

		$synchronizer->synchronize($schema, $this->ds );

		

		$statement = $this->conn->query("show tables");

		$result = $statement->fetchAll( PDO::FETCH_NUM );

		

		$this->assertEquals(2, count($result), "Expected number of tables not match");

		

	}

	

	public function testSynchronizeToSchema(){

		$this->clearDatasource();

		$testSchema = $this->createTestDataStructure();

		

		$schema = new Schema();

		$synchronizer = new MysqlSynchronizer();

		$synchronizer->synchronize($schema, $this->ds, AbstractSynchronizer::MODE_DS_TO_SCHEMA);

		

		$this->assertEquals($testSchema, $schema, "No to jazda");

	}

	

	public function testSynchronizeFieldsToDs(){

		$this->clearDatasource();

		$schema = $this->getSchema();

		$synchronizer = new MysqlSynchronizer();

		$synchronizer->synchronize( $schema, $this->ds, AbstractSynchronizer::MODE_SCHEMA_TO_DS);

		

		foreach($schema->getTables() as $table){

			$statement = $this->conn->query("SHOW COLUMNS FROM {$table->getTableName()}");

			$fields = $table->getFields();

			

			$i = 0;

			while( $row = $statement->fetch( PDO::FETCH_ASSOC ) ) {

				

				$this->assertEquals($fields[$i]->getName(), $row["Field"], "Field name not matched");

				if( $fields[$i]->isPKey() )

					$this->assertEquals("PRI", $row["Key"], "Primary key fail for field `{$row["Field"]}`");

				if( $fields[$i]->isAutoincrement() )

					$this->assertEquals("auto_increment", $row["Extra"], "Autoincrement fail for field `{$row["Field"]}`");

				if( $fields[$i]->getDefault() )

					$this->assertEquals( $table->fields[$i]->getDefault(), $row["Default"], "Default value  fail for field `{$row["Field"]}`");

				if( $fields[$i]->isRequired() )

					$this->assertTrue( $row["Null"]=="NO", "Required fail for field `{$row["Field"]}`" );

				

				

				$tmp = explode("(",$row["Type"]);

				$type = $tmp[0];

				

				//print  $table->fields[$i]->type."(".$table->fields[$i]->size.") => ".  $row["Type"]."\n";

				

				$size = false;

				//longvarchar is changed for text and it not posses size

				if( $fields[$i]->getSize() && $fields[$i]->getType() != "LONGVARCHAR"){

					$size = str_replace(")", "", $tmp[1]);

					$this->assertEquals($fields[$i]->getSize(), $size, "Size fail for field `{$row["Field"]}`");

				}

				

				$types = array( "INTEGER" => "INT", "LONGVARCHAR" => "TEXT" );

				$testType = strtolower( str_replace(array_keys($types), $types, $fields[$i]->getType()));

				if($testType == "text" && $size < 65535 )

					$testType = "text";

				if($testType == "text" && $size < 16777215 )

					$testType = "mediumtext";

				if($testType == "text" && $size > 16777215 )

					$testType = "longtext";

					

				$this->assertEquals($testType, $type, "Type fail for field `{$row["Field"]}`");

				

				$i++;

			}	

		}

		

		

	}

	



	

	public function testSynchronizeIndexToDs(){

		$this->clearDatasource();

		$schema = $this->getSchema();

		$synchronizer = new MysqlSynchronizer();

		$synchronizer->synchronize($schema, $this->ds );

		

		//$statement = $this->conn->query("show tables");

		//$result = $statement->fetchAll( PDO::FETCH_NUM );

		

		//$this->assertEquals(2, count($result), "Expected number of tables not match");

		

	}

	

	public function testSynchronizeForeignKeyToDs(){

		$this->clearDatasource();

		$schema = $this->getSchema();

		$synchronizer = new MysqlSynchronizer();

		$synchronizer->synchronize($schema, $this->ds );

	}

	

	



	

	public function _testSchemaWriter(){

		$reader = new ConfigReader();

		$result = $reader->readConfigFromFile(self::CONFIG_SOURCE_FILE);

		$ds = $result[0]->datasources[0];

		$ds->connect();

		$conn = $ds->getConnection();

		

		$synchro = new MysqlSynchronizer();

		$schema = new Schema();

		

		$synchro->datasourceToSchema( $ds, $schema );

		

		require_once '../schema/SchemaWriter.php';

		

		$writer = new SchemaWriter();

		$writer->writeSchemaToFile($schema, self::SCHEMA_TARGET_FILE);

		

	}	

	

	

	

}

require_once '../schema/SchemaLoader.php';

SchemaLoader::getInstance();



$suite = new PHPUnit_Framework_TestSuite('ORMTest');

print "<pre>";

PHPUnit_TextUI_TestRunner::run($suite);

print "</pre>";



?>