RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-02-06 15:29:26 +03:00
Code Issues Projects Releases Wiki Activity

lots of refactorings

Browse Source
This commit is contained in:
zYne 2007-01-21 18:31:51 +00:00
parent b4bf33fc8c
commit 1eb8b54d81
21 changed files with 439 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/Doctrine/Collection.php
View File

@ -660,8 +660,8 @@ class Doctrine_Collection extends Doctrine_Access implements Countable, Iterator
} }
} elseif ($rel instanceof Doctrine_Relation_ForeignKey) { } elseif ($rel instanceof Doctrine_Relation_ForeignKey) {
foreach ($this->data as $key => $record) { foreach ($this->data as $key => $record) {
if ($record->getState() == Doctrine_Record::STATE_TCLEAN if ($record->state() == Doctrine_Record::STATE_TCLEAN
|| $record->getState() == Doctrine_Record::STATE_TDIRTY || $record->state() == Doctrine_Record::STATE_TDIRTY
) { ) {
continue; continue;
} }
@ -682,8 +682,8 @@ class Doctrine_Collection extends Doctrine_Access implements Countable, Iterator
$name = $table->getComponentName(); $name = $table->getComponentName();
foreach ($this->data as $key => $record) { foreach ($this->data as $key => $record) {
if ($record->getState() == Doctrine_Record::STATE_TCLEAN if ($record->state() == Doctrine_Record::STATE_TCLEAN
|| $record->getState() == Doctrine_Record::STATE_TDIRTY || $record->state() == Doctrine_Record::STATE_TDIRTY
) { ) {
continue; continue;
} }

2
lib/Doctrine/Connection.php
View File

@ -886,7 +886,7 @@ abstract class Doctrine_Connection extends Doctrine_Configurable implements Coun
{ {
$record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onPreSave($record); $record->getTable()->getAttribute(Doctrine::ATTR_LISTENER)->onPreSave($record);
switch ($record->getState()) { switch ($record->state()) {
case Doctrine_Record::STATE_TDIRTY: case Doctrine_Record::STATE_TDIRTY:
$this->unitOfWork->insert($record); $this->unitOfWork->insert($record);
break; break;

4
lib/Doctrine/Connection/UnitOfWork.php
View File

@ -157,7 +157,7 @@ class Doctrine_Connection_UnitOfWork extends Doctrine_Connection_Module implemen
// ONE-TO-ONE relationship // ONE-TO-ONE relationship
$obj = $record->get($fk->getAlias()); $obj = $record->get($fk->getAlias());
if ($obj->getState() != Doctrine_Record::STATE_TCLEAN) { if ($obj->state() != Doctrine_Record::STATE_TCLEAN) {
$obj->save(); $obj->save();
} }
} }
@ -261,7 +261,7 @@ class Doctrine_Connection_UnitOfWork extends Doctrine_Connection_Module implemen
$set[] = $name." = ?"; $set[] = $name." = ?";
if ($value instanceof Doctrine_Record) { if ($value instanceof Doctrine_Record) {
switch ($value->getState()) { switch ($value->state()) {
case Doctrine_Record::STATE_TCLEAN: case Doctrine_Record::STATE_TCLEAN:
case Doctrine_Record::STATE_TDIRTY: case Doctrine_Record::STATE_TDIRTY:
$record->save(); $record->save();

2
lib/Doctrine/Export/Sqlite.php
View File

@ -157,7 +157,7 @@ class Doctrine_Export_Sqlite extends Doctrine_Export
$sequenceName = $this->conn->quoteIdentifier($this->conn->getSequenceName($seqName), true); $sequenceName = $this->conn->quoteIdentifier($this->conn->getSequenceName($seqName), true);
$seqcolName = $this->conn->quoteIdentifier($this->conn->getAttribute(Doctrine::ATTR_SEQCOL_NAME), true); $seqcolName = $this->conn->quoteIdentifier($this->conn->getAttribute(Doctrine::ATTR_SEQCOL_NAME), true);
$query = 'CREATE TABLE ' . $sequenceName . ' (' . $seqcolName . ' INTEGER PRIMARY KEY DEFAULT 0 NOT NULL)'; $query = 'CREATE TABLE ' . $sequenceName . ' (' . $seqcolName . ' INTEGER PRIMARY KEY DEFAULT 0 NOT NULL)';
$this->conn->exec($query); $this->conn->exec($query);
if ($start == 1) { if ($start == 1) {

45
lib/Doctrine/Record.php
View File

@ -186,7 +186,7 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
} }
// set the default values for this record // set the default values for this record
$this->setDefaultValues(); $this->assignDefaultValues();
// listen the onCreate event // listen the onCreate event
$this->_table->getAttribute(Doctrine::ATTR_LISTENER)->onCreate($this); $this->_table->getAttribute(Doctrine::ATTR_LISTENER)->onCreate($this);
@ -309,6 +309,24 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
{ {
return $this->_errorStack; return $this->_errorStack;
} }
/**
* errorStack
* assigns / returns record errorStack
*
* @param Doctrine_Validator_ErrorStack errorStack to be assigned for this record
* @return void|Doctrine_Validator_ErrorStack returns the errorStack associated with this record
*/
public function errorStack($stack = null)
{
if($stack !== null) {
if( ! ($stack instanceof Doctrine_Validator_ErrorStack)) {
throw new Doctrine_Record_Exception('Argument should be an instance of Doctrine_Validator_ErrorStack.');
}
$this->_errorStack = $stack;
} else {
return $this->_errorStack;
}
}
/** /**
* setDefaultValues * setDefaultValues
* sets the default values for records internal data * sets the default values for records internal data
@ -316,7 +334,7 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
* @param boolean $overwrite whether or not to overwrite the already set values * @param boolean $overwrite whether or not to overwrite the already set values
* @return boolean * @return boolean
*/ */
public function setDefaultValues($overwrite = false) public function assignDefaultValues($overwrite = false)
{ {
if ( ! $this->_table->hasDefaultValues()) { if ( ! $this->_table->hasDefaultValues()) {
return false; return false;
@ -1462,6 +1480,29 @@ abstract class Doctrine_Record extends Doctrine_Access implements Countable, Ite
{ {
$this->_table->setEnumValues($column, $values); $this->_table->setEnumValues($column, $values);
} }
/**
* attribute
* sets or retrieves an option
*
* @see Doctrine::ATTR_* constants availible attributes
* @param mixed $attr
* @param mixed $value
* @return mixed
*/
public function attribute($attr, $value)
{
if ($value == null) {
if (is_array($attr)) {
foreach ($attr as $k => $v) {
$this->_table->setAttribute($k, $v);
}
} else {
return $this->_table->getAttribute($attr);
}
} else {
$this->_table->setAttribute($attr, $value);
}
}
/** /**
* option * option
* sets or retrieves an option * sets or retrieves an option

123
lib/Doctrine/Table.php
View File

@ -260,7 +260,16 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
} }
} }
}; };
/**
if ( ! isset($definition['values'])) {
throw new Doctrine_Table_Exception('No values set for enum column ' . $name);
}
if ( ! is_array($definition['values'])) {
throw new Doctrine_Table_Exception('Enum column values should be specified as an array.');
}
*/
if ($this->getAttribute(Doctrine::ATTR_CREATE_TABLES)) { if ($this->getAttribute(Doctrine::ATTR_CREATE_TABLES)) {
$this->export(); $this->export();
} }
@ -276,7 +285,7 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
array_pop($names); array_pop($names);
$this->parents = $names; $this->parents = $names;
$this->query = "SELECT ".implode(", ",array_keys($this->columns))." FROM ".$this->getTableName(); $this->query = 'SELECT ' . implode(', ', array_keys($this->columns)) . ' FROM ' . $this->getTableName();
// check if an instance of this table is already initialized // check if an instance of this table is already initialized
if ( ! $this->conn->addTable($this)) { if ( ! $this->conn->addTable($this)) {
@ -294,35 +303,44 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
* false if table already existed in the database * false if table already existed in the database
*/ */
public function export() { public function export() {
if (Doctrine::isValidClassname($this->options['declaringClass']->getName())) { if ( ! Doctrine::isValidClassname($this->options['declaringClass']->getName())) {
try { throw new Doctrine_Table_Exception('Class name not valid.');
$columns = array(); }
$primary = array();
foreach ($this->columns as $name => $column) {
$definition = $column[2];
$definition['type'] = $column[0];
$definition['length'] = $column[1];
if ($definition['type'] == 'enum' && isset($definition['default'])) { try {
$definition['default'] = $this->enumIndex($name, $definition['default']); $columns = array();
} $primary = array();
if ($definition['type'] == 'boolean' && isset($definition['default'])) {
$definition['default'] = (int) $definition['default'];
}
$columns[$name] = $definition;
if(isset($definition['primary']) && $definition['primary']) {
$primary[] = $name;
}
}
$options['primary'] = $primary;
$this->conn->export->createTable($this->options['tableName'], $columns, array_merge($this->options, $options)); foreach ($this->columns as $name => $column) {
} catch(Doctrine_Connection_Exception $e) { $definition = $column[2];
// we only want to silence table already exists errors $definition['type'] = $column[0];
if($e->getPortableCode() !== Doctrine::ERR_ALREADY_EXISTS) { $definition['length'] = $column[1];
throw $e;
switch ($definition['type']) {
case 'enum':
if (isset($definition['default'])) {
$definition['default'] = $this->enumIndex($name, $definition['default']);
}
break;
case 'boolean':
if (isset($definition['default'])) {
$definition['default'] = (int) $definition['default'];
}
break;
} }
$columns[$name] = $definition;
if(isset($definition['primary']) && $definition['primary']) {
$primary[] = $name;
}
}
$options['primary'] = $primary;
$this->conn->export->createTable($this->options['tableName'], $columns, array_merge($this->options, $options));
} catch(Doctrine_Connection_Exception $e) {
// we only want to silence table already exists errors
if($e->getPortableCode() !== Doctrine::ERR_ALREADY_EXISTS) {
throw $e;
} }
} }
} }
@ -902,12 +920,12 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
$id = array_values($id); $id = array_values($id);
} }
$query = $this->query." WHERE ".implode(" = ? AND ",$this->primaryKeys)." = ?"; $query = $this->query . ' WHERE ' . implode(' = ? AND ', $this->primaryKeys) . ' = ?';
$query = $this->applyInheritance($query); $query = $this->applyInheritance($query);
$params = array_merge($id, array_values($this->options['inheritanceMap'])); $params = array_merge($id, array_values($this->options['inheritanceMap']));
$stmt = $this->conn->execute($query,$params); $stmt = $this->conn->execute($query, $params);
$this->data = $stmt->fetch(PDO::FETCH_ASSOC); $this->data = $stmt->fetch(PDO::FETCH_ASSOC);
@ -928,10 +946,10 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
if ( ! empty($this->options['inheritanceMap'])) { if ( ! empty($this->options['inheritanceMap'])) {
$a = array(); $a = array();
foreach ($this->options['inheritanceMap'] as $field => $value) { foreach ($this->options['inheritanceMap'] as $field => $value) {
$a[] = $field." = ?"; $a[] = $field . ' = ?';
} }
$i = implode(" AND ",$a); $i = implode(' AND ', $a);
$where .= " AND $i"; $where .= ' AND ' . $i;
} }
return $where; return $where;
} }
@ -1017,7 +1035,9 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
final public function getProxy($id = null) final public function getProxy($id = null)
{ {
if ($id !== null) { if ($id !== null) {
$query = "SELECT ".implode(", ",$this->primaryKeys)." FROM ".$this->getTableName()." WHERE ".implode(" = ? && ",$this->primaryKeys)." = ?"; $query = 'SELECT ' . implode(', ',$this->primaryKeys)
. ' FROM ' . $this->getTableName()
. ' WHERE ' . implode(' = ? && ',$this->primaryKeys).' = ?';
$query = $this->applyInheritance($query); $query = $this->applyInheritance($query);
$params = array_merge(array($id), array_values($this->options['inheritanceMap'])); $params = array_merge(array($id), array_values($this->options['inheritanceMap']));
@ -1104,12 +1124,29 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
* @param integer $index * @param integer $index
* @return mixed * @return mixed
*/ */
final public function enumValue($field, $index) public function enumValue($field, $index)
{ {
if ($index instanceof Doctrine_Null) if ($index instanceof Doctrine_Null)
return $index; return $index;
return isset($this->options['enumMap'][$field][$index]) ? $this->options['enumMap'][$field][$index] : $index; return isset($this->columns[$field][2]['values'][$index]) ? $this->columns[$field][2]['values'][$index] : $index;
}
/**
* enumIndex
*
* @param string $field
* @param mixed $value
* @return mixed
*/
public function enumIndex($field, $value)
{
if ( ! isset($this->columns[$field][2]['values'])) {
$values = array();
} else {
$values = $this->columns[$field][2]['values'];
}
return array_search($value, $values);
} }
/** /**
* invokeSet * invokeSet
@ -1155,23 +1192,7 @@ class Doctrine_Table extends Doctrine_Configurable implements Countable
return $value; return $value;
} }
/**
* enumIndex
*
* @param string $field
* @param mixed $value
* @return mixed
*/
final public function enumIndex($field, $value)
{
if ( ! isset($this->options['enumMap'][$field])) {
$values = array();
} else {
$values = $this->options['enumMap'][$field];
}
return array_search($value, $values);
}
/** /**
* getDefinitionOf * getDefinitionOf
* *

8
lib/Doctrine/Tree/NestedSet.php
View File

@ -53,7 +53,7 @@ class Doctrine_Tree_NestedSet extends Doctrine_Tree implements Doctrine_Tree_Int
*/ */
public function setTableDefinition() public function setTableDefinition()
{ {
if ($root = $this->getAttribute('root_column_name')) { if ($root = $this->getAttribute('rootColumnName')) {
$this->table->setColumn($root, 'integer', 11); $this->table->setColumn($root, 'integer', 11);
} }
@ -207,7 +207,7 @@ class Doctrine_Tree_NestedSet extends Doctrine_Tree implements Doctrine_Tree_Int
public function getMaxRootId() public function getMaxRootId()
{ {
$component = $this->table->getComponentName(); $component = $this->table->getComponentName();
$column = $this->getAttribute('root_column_name'); $column = $this->getAttribute('rootColumnName');
// cannot get this dql to work, cannot retrieve result using $coll[0]->max // cannot get this dql to work, cannot retrieve result using $coll[0]->max
//$dql = "SELECT MAX(c.$column) FROM $component c"; //$dql = "SELECT MAX(c.$column) FROM $component c";
@ -229,10 +229,10 @@ class Doctrine_Tree_NestedSet extends Doctrine_Tree implements Doctrine_Tree_Int
* @param object $query Doctrine_Query * @param object $query Doctrine_Query
* @param integer $root_id id of destination root * @param integer $root_id id of destination root
* @return object Doctrine_Query * @return object Doctrine_Query
*/ */
public function returnQueryWithRootId($query, $rootId = 1) public function returnQueryWithRootId($query, $rootId = 1)
{ {
if ($root = $this->getAttribute('root_column_name')) { if ($root = $this->getAttribute('rootColumnName')) {
$query->addWhere($root . ' = ?', $rootId); $query->addWhere($root . ' = ?', $rootId);
} }

6
tests/BooleanTestCase.php
View File

@ -42,7 +42,7 @@ class Doctrine_Boolean_TestCase extends Doctrine_UnitTestCase {
$test->is_working = false; $test->is_working = false;
$this->assertEqual($test->is_working, false); $this->assertEqual($test->is_working, false);
$this->assertEqual($test->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($test->state(), Doctrine_Record::STATE_TDIRTY);
$test->save(); $test->save();
$test->refresh(); $test->refresh();
@ -98,7 +98,7 @@ class Doctrine_Boolean_TestCase extends Doctrine_UnitTestCase {
$this->is_working = null; $this->is_working = null;
$this->assertEqual($this->is_working, null); $this->assertEqual($this->is_working, null);
$this->assertEqual($test->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($test->state(), Doctrine_Record::STATE_TDIRTY);
$test->save(); $test->save();
$test->refresh(); $test->refresh();
@ -108,7 +108,7 @@ class Doctrine_Boolean_TestCase extends Doctrine_UnitTestCase {
$this->is_working_notnull = null; $this->is_working_notnull = null;
$this->assertEqual($this->is_working_notnull, false); $this->assertEqual($this->is_working_notnull, false);
$this->assertEqual($test->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($test->state(), Doctrine_Record::STATE_TDIRTY);
$test->save(); $test->save();
$test->refresh(); $test->refresh();

30
tests/CollectionTestCase.php
View File

@ -240,7 +240,7 @@ class Doctrine_Collection_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual(count($coll), 3); $this->assertEqual(count($coll), 3);
$this->assertEqual($coll[2]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($coll[2]->state(), Doctrine_Record::STATE_PROXY);
@ -268,33 +268,33 @@ class Doctrine_Collection_TestCase extends Doctrine_UnitTestCase {
} }
public function testFetchCollectionWithIdAsIndex() { public function testFetchCollectionWithIdAsIndex() {
$user = new User(); $user = new User();
$user->setAttribute(Doctrine::ATTR_COLL_KEY, 'id'); $user->attribute(Doctrine::ATTR_COLL_KEY, 'id');
$users = $user->getTable()->findAll(); $users = $user->getTable()->findAll();
$this->assertFalse($users->contains(0)); $this->assertFalse($users->contains(0));
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertEqual($users[0]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($users[0]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($users[4]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($users[4]->state(), Doctrine_Record::STATE_CLEAN);
} }
public function testFetchCollectionWithNameAsIndex() { public function testFetchCollectionWithNameAsIndex() {
$user = new User(); $user = new User();
$user->setAttribute(Doctrine::ATTR_COLL_KEY, 'name'); $user->attribute(Doctrine::ATTR_COLL_KEY, 'name');
$users = $user->getTable()->findAll(); $users = $user->getTable()->findAll();
$this->assertFalse($users->contains(0)); $this->assertFalse($users->contains(0));
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertEqual($users[0]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($users[0]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($users['zYne']->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($users['zYne']->state(), Doctrine_Record::STATE_CLEAN);
} }
public function testFetchMultipleCollections() { public function testFetchMultipleCollections() {
$this->connection->clear(); $this->connection->clear();
$user = new User(); $user = new User();
$user->setAttribute(Doctrine::ATTR_COLL_KEY, 'id'); $user->attribute(Doctrine::ATTR_COLL_KEY, 'id');
$phonenumber = new Phonenumber(); $phonenumber = new Phonenumber();
$phonenumber->setAttribute(Doctrine::ATTR_COLL_KEY, 'id'); $phonenumber->attribute(Doctrine::ATTR_COLL_KEY, 'id');
$q = new Doctrine_Query(); $q = new Doctrine_Query();
@ -302,16 +302,16 @@ class Doctrine_Collection_TestCase extends Doctrine_UnitTestCase {
$this->assertFalse($users->contains(0)); $this->assertFalse($users->contains(0));
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertEqual($users[0]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($users[0]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($users[2]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($users[2]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($users[3]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($users[3]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($users[4]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($users[4]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($users[4]->name, 'zYne'); $this->assertEqual($users[4]->name, 'zYne');
$this->assertEqual($users[4]->Phonenumber[0]->exists(), false); $this->assertEqual($users[4]->Phonenumber[0]->exists(), false);
$this->assertEqual($users[4]->Phonenumber[0]->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($users[4]->Phonenumber[0]->state(), Doctrine_Record::STATE_TDIRTY);
$this->assertEqual($users[4]->Phonenumber[1]->exists(), false); $this->assertEqual($users[4]->Phonenumber[1]->exists(), false);
$this->assertEqual($users[4]->Phonenumber[2]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($users[4]->Phonenumber[2]->state(), Doctrine_Record::STATE_CLEAN);
} }
} }

2
tests/ConnectionTestCase.php
View File

@ -135,7 +135,7 @@ class Doctrine_Connection_TestCase extends Doctrine_UnitTestCase {
public function testDelete() { public function testDelete() {
$user = $this->connection->create('User'); $user = $this->connection->create('User');
$this->connection->delete($user); $this->connection->delete($user);
$this->assertEqual($user->getState(),Doctrine_Record::STATE_TCLEAN); $this->assertEqual($user->state(),Doctrine_Record::STATE_TCLEAN);
} }
public function testGetTable() { public function testGetTable() {
$table = $this->connection->getTable('Group'); $table = $this->connection->getTable('Group');

24
tests/Db/ProfilerTestCase.php
View File

@ -17,7 +17,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'CREATE TABLE test (id INT)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'CREATE TABLE test (id INT)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::QUERY); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::QUERY);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$this->assertEqual($this->dbh->count(), 1); $this->assertEqual($this->dbh->count(), 1);
@ -29,14 +29,14 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($event->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($event->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::PREPARE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::PREPARE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$stmt->execute(array(1)); $stmt->execute(array(1));
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::EXECUTE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::EXECUTE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$this->assertEqual($this->dbh->count(), 2); $this->assertEqual($this->dbh->count(), 2);
@ -46,13 +46,13 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$stmt = $this->dbh->prepare('INSERT INTO test (id) VALUES (?)'); $stmt = $this->dbh->prepare('INSERT INTO test (id) VALUES (?)');
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::PREPARE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::PREPARE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$stmt2 = $this->dbh->prepare('INSERT INTO test (id) VALUES (?)'); $stmt2 = $this->dbh->prepare('INSERT INTO test (id) VALUES (?)');
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::PREPARE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::PREPARE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$stmt->execute(array(1)); $stmt->execute(array(1));
@ -60,7 +60,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::EXECUTE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::EXECUTE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$this->assertEqual($this->dbh->count(), 4); $this->assertEqual($this->dbh->count(), 4);
@ -77,12 +77,12 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
} }
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::EXECUTE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::EXECUTE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
$this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)'); $this->assertEqual($this->profiler->lastEvent()->getQuery(), 'INSERT INTO test (id) VALUES (?)');
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::EXECUTE); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::EXECUTE);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
} }
public function testTransactionRollback() { public function testTransactionRollback() {
@ -94,7 +94,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
} }
$this->assertEqual($this->profiler->lastEvent()->getQuery(), null); $this->assertEqual($this->profiler->lastEvent()->getQuery(), null);
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::BEGIN); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::BEGIN);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
try { try {
@ -106,7 +106,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($this->profiler->lastEvent()->getQuery(), null); $this->assertEqual($this->profiler->lastEvent()->getQuery(), null);
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::ROLLBACK); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::ROLLBACK);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
} }
public function testTransactionCommit() { public function testTransactionCommit() {
@ -118,7 +118,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
} }
$this->assertEqual($this->profiler->lastEvent()->getQuery(), null); $this->assertEqual($this->profiler->lastEvent()->getQuery(), null);
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::BEGIN); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::BEGIN);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
try { try {
@ -131,7 +131,7 @@ class Doctrine_Db_Profiler_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($this->profiler->lastEvent()->getQuery(), null); $this->assertEqual($this->profiler->lastEvent()->getQuery(), null);
$this->assertTrue($this->profiler->lastEvent()->hasEnded()); $this->assertTrue($this->profiler->lastEvent()->hasEnded());
$this->assertEqual($this->profiler->lastEvent()->getType(), Doctrine_Db_Event::COMMIT); $this->assertEqual($this->profiler->lastEvent()->getCode(), Doctrine_Db_Event::COMMIT);
$this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs())); $this->assertTrue(is_numeric($this->profiler->lastEvent()->getElapsedSecs()));
} }
} }

4
tests/EventListener/ChainTestCase.php
View File

@ -29,7 +29,7 @@
* @link www.phpdoctrine.com * @link www.phpdoctrine.com
* @since 1.0 * @since 1.0
* @version $Revision$ * @version $Revision$
*/ */
class Doctrine_EventListener_Chain_TestCase extends Doctrine_UnitTestCase { class Doctrine_EventListener_Chain_TestCase extends Doctrine_UnitTestCase {
public function testAccessorInvokerChain() { public function testAccessorInvokerChain() {
@ -79,7 +79,7 @@ class EventListenerChainTest extends Doctrine_Record {
$chain = new Doctrine_EventListener_Chain(); $chain = new Doctrine_EventListener_Chain();
$chain->add(new Doctrine_EventListener_TestA()); $chain->add(new Doctrine_EventListener_TestA());
$chain->add(new Doctrine_EventListener_TestB()); $chain->add(new Doctrine_EventListener_TestB());
$this->setAttribute(Doctrine::ATTR_LISTENER, $chain); $this->attribute(Doctrine::ATTR_LISTENER, $chain);
} }
} }

2
tests/EventListenerChainTestCase.php
View File

@ -38,7 +38,7 @@ class EventListenerChainTest extends Doctrine_Record {
$chain = new Doctrine_EventListener_Chain(); $chain = new Doctrine_EventListener_Chain();
$chain->add(new Doctrine_EventListener_TestA()); $chain->add(new Doctrine_EventListener_TestA());
$chain->add(new Doctrine_EventListener_TestB()); $chain->add(new Doctrine_EventListener_TestB());
$this->setAttribute(Doctrine::ATTR_LISTENER, $chain); $this->attribute(Doctrine::ATTR_LISTENER, $chain);
} }
} }

2
tests/EventListenerTestCase.php
View File

@ -36,7 +36,7 @@ class EventListenerTest extends Doctrine_Record {
$this->hasColumn("password", "string", 8); $this->hasColumn("password", "string", 8);
} }
public function setUp() { public function setUp() {
$this->setAttribute(Doctrine::ATTR_LISTENER, new Doctrine_EventListener_AccessorInvoker()); $this->attribute(Doctrine::ATTR_LISTENER, new Doctrine_EventListener_AccessorInvoker());
} }
public function getName($name) { public function getName($name) {
return strtoupper($name); return strtoupper($name);

42
tests/QueryTestCase.php
View File

@ -524,14 +524,14 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$query->from("Task-l:ResourceAlias-l"); $query->from("Task-l:ResourceAlias-l");
$tasks = $query->execute(); $tasks = $query->execute();
$this->assertEqual($tasks->count(), 3); $this->assertEqual($tasks->count(), 3);
$this->assertTrue($tasks instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks instanceof Doctrine_Collection);
$this->assertEqual($tasks[0]->ResourceAlias->count(), 2); $this->assertEqual($tasks[0]->ResourceAlias->count(), 2);
$this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[1]->ResourceAlias->count(), 4); $this->assertEqual($tasks[1]->ResourceAlias->count(), 4);
$this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection);
// sanity checking // sanity checking
$this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_PROXY);
$this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_PROXY);
@ -548,7 +548,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual(count($this->dbh), ($count + 4)); $this->assertEqual(count($this->dbh), ($count + 4));
$this->assertEqual($tasks[2]->ResourceAlias->count(), 1); $this->assertEqual($tasks[2]->ResourceAlias->count(), 1);
$this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection);
} }
public function testManyToManyFetchingWithDotOperator() { public function testManyToManyFetchingWithDotOperator() {
@ -560,16 +560,16 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$tasks = $query->query("FROM Task-l.ResourceAlias-l"); $tasks = $query->query("FROM Task-l.ResourceAlias-l");
$this->assertEqual($tasks->count(), 4); $this->assertEqual($tasks->count(), 4);
$this->assertTrue($tasks instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks instanceof Doctrine_Collection);
$this->assertEqual($tasks[0]->ResourceAlias->count(), 2); $this->assertEqual($tasks[0]->ResourceAlias->count(), 2);
$this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[1]->ResourceAlias->count(), 4); $this->assertEqual($tasks[1]->ResourceAlias->count(), 4);
$this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[1]->ResourceAlias->count(), 4); $this->assertEqual($tasks[1]->ResourceAlias->count(), 4);
$this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection);
// sanity checking // sanity checking
$this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_PROXY);
$this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_PROXY);
@ -586,7 +586,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual(count($this->dbh), ($count + 4)); $this->assertEqual(count($this->dbh), ($count + 4));
$this->assertEqual($tasks[2]->ResourceAlias->count(), 1); $this->assertEqual($tasks[2]->ResourceAlias->count(), 1);
$this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[3]->ResourceAlias->count(), 0); $this->assertEqual($tasks[3]->ResourceAlias->count(), 0);
$this->assertTrue($tasks[3]->ResourceAlias instanceof Doctrine_Collection); $this->assertTrue($tasks[3]->ResourceAlias instanceof Doctrine_Collection);
@ -597,16 +597,16 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$tasks = $query->query("FROM Task-l.ResourceAlias-l"); $tasks = $query->query("FROM Task-l.ResourceAlias-l");
$this->assertEqual($tasks->count(), 4); $this->assertEqual($tasks->count(), 4);
$this->assertTrue($tasks instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks instanceof Doctrine_Collection);
$this->assertEqual($tasks[0]->ResourceAlias->count(), 2); $this->assertEqual($tasks[0]->ResourceAlias->count(), 2);
$this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[0]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[1]->ResourceAlias->count(), 4); $this->assertEqual($tasks[1]->ResourceAlias->count(), 4);
$this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[1]->ResourceAlias->count(), 4); $this->assertEqual($tasks[1]->ResourceAlias->count(), 4);
$this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[1]->ResourceAlias instanceof Doctrine_Collection);
// sanity checking // sanity checking
$this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($tasks[1]->ResourceAlias[0]->getState(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($tasks[1]->ResourceAlias[1]->getState(), Doctrine_Record::STATE_CLEAN);
@ -623,7 +623,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual(count($this->dbh), $count); $this->assertEqual(count($this->dbh), $count);
$this->assertEqual($tasks[2]->ResourceAlias->count(), 1); $this->assertEqual($tasks[2]->ResourceAlias->count(), 1);
$this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection_Lazy); $this->assertTrue($tasks[2]->ResourceAlias instanceof Doctrine_Collection);
$this->assertEqual($tasks[3]->ResourceAlias->count(), 0); $this->assertEqual($tasks[3]->ResourceAlias->count(), 0);
$this->assertTrue($tasks[3]->ResourceAlias instanceof Doctrine_Collection); $this->assertTrue($tasks[3]->ResourceAlias instanceof Doctrine_Collection);
@ -755,7 +755,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$q->from("User-l(name, email_id)"); $q->from("User-l(name, email_id)");
$users = $q->execute(); $users = $q->execute();
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertTrue($users instanceof Doctrine_Collection_Lazy); $this->assertTrue($users instanceof Doctrine_Collection);
$count = count($this->dbh); $count = count($this->dbh);
$this->assertTrue(is_string($users[0]->name)); $this->assertTrue(is_string($users[0]->name));
$this->assertEqual($count, count($this->dbh)); $this->assertEqual($count, count($this->dbh));
@ -768,7 +768,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$q->from("User-b(name, email_id)"); $q->from("User-b(name, email_id)");
$users = $q->execute(); $users = $q->execute();
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertTrue($users instanceof Doctrine_Collection_Batch); $this->assertTrue($users instanceof Doctrine_Collection);
$count = count($this->dbh); $count = count($this->dbh);
$this->assertTrue(is_string($users[0]->name)); $this->assertTrue(is_string($users[0]->name));
$this->assertEqual($count, count($this->dbh)); $this->assertEqual($count, count($this->dbh));
@ -830,7 +830,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$count = $this->dbh->count(); $count = $this->dbh->count();
$users = $this->query->from("User-l:Email-i")->execute(); $users = $this->query->from("User-l:Email-i")->execute();
$this->assertEqual(($count + 1), $this->dbh->count()); $this->assertEqual(($count + 1), $this->dbh->count());
$this->assertTrue($users instanceof Doctrine_Collection_Lazy); $this->assertTrue($users instanceof Doctrine_Collection);
$count = $this->dbh->count(); $count = $this->dbh->count();
foreach($users as $user) { foreach($users as $user) {
@ -858,7 +858,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$count = $this->dbh->count(); $count = $this->dbh->count();
$users = $this->query->from("User-l:Account-i")->execute(); $users = $this->query->from("User-l:Account-i")->execute();
$this->assertEqual(($count + 1), $this->dbh->count()); $this->assertEqual(($count + 1), $this->dbh->count());
$this->assertTrue($users instanceof Doctrine_Collection_Lazy); $this->assertTrue($users instanceof Doctrine_Collection);
$this->assertEqual($users->count(), 1); $this->assertEqual($users->count(), 1);
$this->assertEqual($users[0]->Account->amount,3000); $this->assertEqual($users[0]->Account->amount,3000);
@ -1003,7 +1003,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
$this->assertFalse(strpos($query->getQuery(),"LIMIT")); $this->assertFalse(strpos($query->getQuery(),"LIMIT"));
$coll = $query->execute(); $coll = $query->execute();
$this->assertTrue($coll instanceof Doctrine_Collection_Lazy); $this->assertTrue($coll instanceof Doctrine_Collection);
$this->assertEqual($coll->count(), 1); $this->assertEqual($coll->count(), 1);
@ -1054,7 +1054,7 @@ class Doctrine_Query_TestCase extends Doctrine_UnitTestCase {
"SELECT e.id AS e__id FROM entity e WHERE (e.type = 0)"); "SELECT e.id AS e__id FROM entity e WHERE (e.type = 0)");
$this->assertEqual($users[0]->name, "zYne"); $this->assertEqual($users[0]->name, "zYne");
$this->assertTrue($users instanceof Doctrine_Collection_Lazy); $this->assertTrue($users instanceof Doctrine_Collection);
} }

8
tests/RawSqlTestCase.php
View File

@ -49,8 +49,8 @@ class Doctrine_RawSql_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($coll->count(), 11); $this->assertEqual($coll->count(), 11);
$this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($coll[0]->state(), Doctrine_Record::STATE_PROXY);
$this->assertEqual($coll[3]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($coll[3]->state(), Doctrine_Record::STATE_PROXY);
} }
public function testSmartMapping() { public function testSmartMapping() {
@ -66,8 +66,8 @@ class Doctrine_RawSql_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($coll->count(), 11); $this->assertEqual($coll->count(), 11);
$this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($coll[0]->state(), Doctrine_Record::STATE_PROXY);
$this->assertEqual($coll[3]->getState(), Doctrine_Record::STATE_PROXY); $this->assertEqual($coll[3]->state(), Doctrine_Record::STATE_PROXY);
} }
public function testMultipleComponents() { public function testMultipleComponents() {

72
tests/RecordTestCase.php
View File

@ -80,8 +80,8 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue($e->Entity[0] instanceof Entity); $this->assertTrue($e->Entity[0] instanceof Entity);
$this->assertTrue($e->Entity[1] instanceof Entity); $this->assertTrue($e->Entity[1] instanceof Entity);
$this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($e->Entity[0]->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($e->Entity[1]->state(), Doctrine_Record::STATE_TCLEAN);
$e->Entity[0]->name = "Friend 1"; $e->Entity[0]->name = "Friend 1";
$e->Entity[1]->name = "Friend 2"; $e->Entity[1]->name = "Friend 2";
@ -102,15 +102,15 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2"); $this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2");
$this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($e->Entity[0]->state(), Doctrine_Record::STATE_TDIRTY);
$this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($e->Entity[1]->state(), Doctrine_Record::STATE_TDIRTY);
$count = count($this->dbh); $count = count($this->dbh);
$e->save(); $e->save();
$this->assertEqual(($count + 13), $this->dbh->count()); $this->assertEqual(($count + 13), $this->dbh->count());
$this->assertEqual($e->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($e->state(), Doctrine_Record::STATE_CLEAN);
$this->assertTrue($e->Entity[0] instanceof Entity); $this->assertTrue($e->Entity[0] instanceof Entity);
$this->assertTrue($e->Entity[1] instanceof Entity); $this->assertTrue($e->Entity[1] instanceof Entity);
@ -124,8 +124,8 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($e->Entity[1]->Entity[0]->name, "Friend 2 1"); $this->assertEqual($e->Entity[1]->Entity[0]->name, "Friend 2 1");
$this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2"); $this->assertEqual($e->Entity[1]->Entity[1]->name, "Friend 2 2");
$this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($e->Entity[0]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($e->Entity[1]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertTrue(is_numeric($e->id)); $this->assertTrue(is_numeric($e->id));
@ -168,12 +168,12 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual(count($this->dbh), ($count + 3)); $this->assertEqual(count($this->dbh), ($count + 3));
$this->assertEqual($e->Entity[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($e->Entity[0]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($e->Entity[1]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($e->Entity[1]->state(), Doctrine_Record::STATE_CLEAN);
$coll = $this->connection->query("FROM Entity WHERE Entity.name = 'Friend 1'"); $coll = $this->connection->query("FROM Entity WHERE Entity.name = 'Friend 1'");
$this->assertEqual($coll->count(), 1); $this->assertEqual($coll->count(), 1);
$this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($coll[0]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($coll[0]->name, "Friend 1"); $this->assertEqual($coll[0]->name, "Friend 1");
@ -302,23 +302,23 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($record->getTable()->getIdentifier(), array("entity1","entity2")); $this->assertEqual($record->getTable()->getIdentifier(), array("entity1","entity2"));
$this->assertEqual($record->getTable()->getIdentifierType(), Doctrine_Identifier::COMPOSITE); $this->assertEqual($record->getTable()->getIdentifierType(), Doctrine_Identifier::COMPOSITE);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => null, "entity2" => null)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => null, "entity2" => null));
$this->assertEqual($record->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_TCLEAN);
$record->entity1 = 3; $record->entity1 = 3;
$record->entity2 = 4; $record->entity2 = 4;
$this->assertEqual($record->entity2, 4); $this->assertEqual($record->entity2, 4);
$this->assertEqual($record->entity1, 3); $this->assertEqual($record->entity1, 3);
$this->assertEqual($record->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($record->state(), Doctrine_Record::STATE_TDIRTY);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => null, "entity2" => null)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => null, "entity2" => null));
$record->save(); $record->save();
$this->assertEqual($record->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($record->entity2, 4); $this->assertEqual($record->entity2, 4);
$this->assertEqual($record->entity1, 3); $this->assertEqual($record->entity1, 3);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => 3, "entity2" => 4)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => 3, "entity2" => 4));
$record = $record->getTable()->find($record->obtainIdentifier()); $record = $record->getTable()->find($record->obtainIdentifier());
$this->assertEqual($record->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($record->entity2, 4); $this->assertEqual($record->entity2, 4);
$this->assertEqual($record->entity1, 3); $this->assertEqual($record->entity1, 3);
@ -326,25 +326,25 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$record->entity2 = 5; $record->entity2 = 5;
$record->entity1 = 2; $record->entity1 = 2;
$this->assertEqual($record->getState(), Doctrine_Record::STATE_DIRTY); $this->assertEqual($record->state(), Doctrine_Record::STATE_DIRTY);
$this->assertEqual($record->entity2, 5); $this->assertEqual($record->entity2, 5);
$this->assertEqual($record->entity1, 2); $this->assertEqual($record->entity1, 2);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => 3, "entity2" => 4)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => 3, "entity2" => 4));
$record->save(); $record->save();
$this->assertEqual($record->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($record->entity2, 5); $this->assertEqual($record->entity2, 5);
$this->assertEqual($record->entity1, 2); $this->assertEqual($record->entity1, 2);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5));
$record = $record->getTable()->find($record->obtainIdentifier()); $record = $record->getTable()->find($record->obtainIdentifier());
$this->assertEqual($record->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($record->entity2, 5); $this->assertEqual($record->entity2, 5);
$this->assertEqual($record->entity1, 2); $this->assertEqual($record->entity1, 2);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5));
$record->refresh(); $record->refresh();
$this->assertEqual($record->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($record->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($record->entity2, 5); $this->assertEqual($record->entity2, 5);
$this->assertEqual($record->entity1, 2); $this->assertEqual($record->entity1, 2);
$this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5)); $this->assertEqual($record->obtainIdentifier(), array("entity1" => 2, "entity2" => 5));
@ -356,9 +356,9 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$coll = $this->connection->query("FROM EntityReference-b"); $coll = $this->connection->query("FROM EntityReference-b");
$this->assertTrue($coll[0] instanceof EntityReference); $this->assertTrue($coll[0] instanceof EntityReference);
$this->assertEqual($coll[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($coll[0]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertTrue($coll[1] instanceof EntityReference); $this->assertTrue($coll[1] instanceof EntityReference);
$this->assertEqual($coll[1]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($coll[1]->state(), Doctrine_Record::STATE_CLEAN);
$coll = $this->connection->query("FROM EntityReference-b WHERE EntityReference.entity2 = 5"); $coll = $this->connection->query("FROM EntityReference-b WHERE EntityReference.entity2 = 5");
$this->assertEqual($coll->count(), 1); $this->assertEqual($coll->count(), 1);
@ -380,12 +380,12 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$task = new Task(); $task = new Task();
$this->assertTrue($task instanceof Task); $this->assertTrue($task instanceof Task);
$this->assertEqual($task->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($task->state(), Doctrine_Record::STATE_TCLEAN);
$this->assertTrue($task->Subtask[0] instanceof Task); $this->assertTrue($task->Subtask[0] instanceof Task);
//$this->assertEqual($task->Subtask[0]->getState(), Doctrine_Record::STATE_TDIRTY); //$this->assertEqual($task->Subtask[0]->state(), Doctrine_Record::STATE_TDIRTY);
$this->assertTrue($task->ResourceAlias[0] instanceof Resource); $this->assertTrue($task->ResourceAlias[0] instanceof Resource);
$this->assertEqual($task->ResourceAlias[0]->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($task->ResourceAlias[0]->state(), Doctrine_Record::STATE_TCLEAN);
$task->name = "Task 1"; $task->name = "Task 1";
$task->ResourceAlias[0]->name = "Resource 1"; $task->ResourceAlias[0]->name = "Resource 1";
@ -414,7 +414,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$account = $user->Account; $account = $user->Account;
$account->amount = 1000; $account->amount = 1000;
$this->assertTrue($account instanceof Account); $this->assertTrue($account instanceof Account);
$this->assertEqual($account->getState(), Doctrine_Record::STATE_TDIRTY); $this->assertEqual($account->state(), Doctrine_Record::STATE_TDIRTY);
$this->assertEqual($account->entity_id, $user); $this->assertEqual($account->entity_id, $user);
$this->assertEqual($account->amount, 1000); $this->assertEqual($account->amount, 1000);
$this->assertEqual($user->name, "Richard Linklater"); $this->assertEqual($user->name, "Richard Linklater");
@ -424,7 +424,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$user->refresh(); $user->refresh();
$account = $user->Account; $account = $user->Account;
$this->assertTrue($account instanceof Account); $this->assertTrue($account instanceof Account);
$this->assertEqual($account->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($account->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($account->entity_id, $user->id); $this->assertEqual($account->entity_id, $user->id);
$this->assertEqual($account->amount, 1000); $this->assertEqual($account->amount, 1000);
$this->assertEqual($user->name, "Richard Linklater"); $this->assertEqual($user->name, "Richard Linklater");
@ -437,7 +437,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount")); $this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount"));
$this->connection->flush(); $this->connection->flush();
$this->assertEqual($user->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($user->state(), Doctrine_Record::STATE_CLEAN);
$this->assertTrue($account instanceof Account); $this->assertTrue($account instanceof Account);
$this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount")); $this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount"));
@ -446,13 +446,13 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$user = $user->getTable()->find($user->id); $user = $user->getTable()->find($user->id);
$this->assertEqual($user->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($user->state(), Doctrine_Record::STATE_CLEAN);
$account = $user->Account; $account = $user->Account;
$this->assertTrue($account instanceof Account); $this->assertTrue($account instanceof Account);
$this->assertEqual($account->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($account->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount")); $this->assertEqual($account->getTable()->getColumnNames(), array("id","entity_id","amount"));
$this->assertEqual($account->entity_id, $user->id); $this->assertEqual($account->entity_id, $user->id);
@ -482,13 +482,13 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($this->connection->getTable("User")->getData(), array()); $this->assertEqual($this->connection->getTable("User")->getData(), array());
$user = new User(); $user = new User();
$this->assertEqual(Doctrine_Lib::getRecordStateAsString($user->getState()), Doctrine_Lib::getRecordStateAsString(Doctrine_Record::STATE_TCLEAN)); $this->assertEqual(Doctrine_Lib::getRecordStateAsString($user->state()), Doctrine_Lib::getRecordStateAsString(Doctrine_Record::STATE_TCLEAN));
$user->name = "John Locke"; $user->name = "John Locke";
$this->assertTrue($user->name,"John Locke"); $this->assertTrue($user->name,"John Locke");
$this->assertTrue($user->getState() == Doctrine_Record::STATE_TDIRTY); $this->assertTrue($user->state() == Doctrine_Record::STATE_TDIRTY);
$user->save(); $user->save();
$this->assertTrue($user->getState() == Doctrine_Record::STATE_CLEAN); $this->assertTrue($user->state() == Doctrine_Record::STATE_CLEAN);
$this->assertTrue($user->name,"John Locke"); $this->assertTrue($user->name,"John Locke");
} }
@ -627,10 +627,10 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue(is_numeric($user->id) && $user->id > 0); $this->assertTrue(is_numeric($user->id) && $user->id > 0);
$this->assertTrue($user->getModified() == array()); $this->assertTrue($user->getModified() == array());
$this->assertTrue($user->getState() == Doctrine_Record::STATE_CLEAN); $this->assertTrue($user->state() == Doctrine_Record::STATE_CLEAN);
$user->delete(); $user->delete();
$this->assertEqual($user->getState(), Doctrine_Record::STATE_TCLEAN); $this->assertEqual($user->state(), Doctrine_Record::STATE_TCLEAN);
} }
public function testUpdate() { public function testUpdate() {
@ -650,7 +650,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$new = $user->copy(); $new = $user->copy();
$this->assertTrue($new instanceof Doctrine_Record); $this->assertTrue($new instanceof Doctrine_Record);
$this->assertTrue($new->getState() == Doctrine_Record::STATE_TDIRTY); $this->assertTrue($new->state() == Doctrine_Record::STATE_TDIRTY);
$new = $user->copy(); $new = $user->copy();
$new->save(); $new->save();
@ -666,7 +666,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$new = $user->copy(); $new = $user->copy();
$this->assertTrue($new instanceof Doctrine_Record); $this->assertTrue($new instanceof Doctrine_Record);
$this->assertTrue($new->getState() == Doctrine_Record::STATE_TDIRTY); $this->assertTrue($new->state() == Doctrine_Record::STATE_TDIRTY);
$new->loginname = 'jackd'; $new->loginname = 'jackd';
@ -782,7 +782,7 @@ class Doctrine_Record_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue($user->Email instanceof Email); $this->assertTrue($user->Email instanceof Email);
$this->assertEqual($user->Email->id, $user->email_id); $this->assertEqual($user->Email->id, $user->email_id);
$this->assertEqual($user->Email->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($user->Email->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($user->Email->address, "drinker@drinkmore.info"); $this->assertEqual($user->Email->address, "drinker@drinkmore.info");
$id = $user->Email->id; $id = $user->Email->id;

2
tests/TableTestCase.php
View File

@ -135,7 +135,7 @@ class Doctrine_Table_TestCase extends Doctrine_UnitTestCase {
public function testCreate() { public function testCreate() {
$record = $this->objTable->create(); $record = $this->objTable->create();
$this->assertTrue($record instanceof Doctrine_Record); $this->assertTrue($record instanceof Doctrine_Record);
$this->assertTrue($record->getState() == Doctrine_Record::STATE_TCLEAN); $this->assertTrue($record->state() == Doctrine_Record::STATE_TCLEAN);
} }
public function testFind() { public function testFind() {
$record = $this->objTable->find(4); $record = $this->objTable->find(4);

36
tests/ValidatorTestCase.php
View File

@ -119,7 +119,7 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$validator = new Doctrine_Validator(); $validator = new Doctrine_Validator();
$validator->validateRecord($test); $validator->validateRecord($test);
$stack = $test->getErrorStack(); $stack = $test->errorStack();
$this->assertTrue($stack instanceof Doctrine_Validator_ErrorStack); $this->assertTrue($stack instanceof Doctrine_Validator_ErrorStack);
@ -137,15 +137,15 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
* Tests Doctrine_Validator::validateRecord() * Tests Doctrine_Validator::validateRecord()
*/ */
public function testValidate() { public function testValidate() {
$user = $this->connection->getTable("User")->find(4); $user = $this->connection->getTable('User')->find(4);
$set = array("password" => "this is an example of too long password", $set = array('password' => 'this is an example of too long password',
"loginname" => "this is an example of too long loginname", 'loginname' => 'this is an example of too long loginname',
"name" => "valid name", 'name' => 'valid name',
"created" => "invalid"); 'created' => 'invalid');
$user->setArray($set); $user->setArray($set);
$email = $user->Email; $email = $user->Email;
$email->address = "zYne@invalid"; $email->address = 'zYne@invalid';
$this->assertTrue($user->getModified() == $set); $this->assertTrue($user->getModified() == $set);
@ -153,7 +153,7 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$validator->validateRecord($user); $validator->validateRecord($user);
$stack = $user->getErrorStack(); $stack = $user->errorStack();
$this->assertTrue($stack instanceof Doctrine_Validator_ErrorStack); $this->assertTrue($stack instanceof Doctrine_Validator_ErrorStack);
$this->assertTrue(in_array('length', $stack['loginname'])); $this->assertTrue(in_array('length', $stack['loginname']));
@ -161,12 +161,12 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue(in_array('type', $stack['created'])); $this->assertTrue(in_array('type', $stack['created']));
$validator->validateRecord($email); $validator->validateRecord($email);
$stack = $email->getErrorStack(); $stack = $email->errorStack();
$this->assertTrue(in_array('email', $stack['address'])); $this->assertTrue(in_array('email', $stack['address']));
$email->address = "arnold@example.com"; $email->address = 'arnold@example.com';
$validator->validateRecord($email); $validator->validateRecord($email);
$stack = $email->getErrorStack(); $stack = $email->errorStack();
$this->assertTrue(in_array('unique', $stack['address'])); $this->assertTrue(in_array('unique', $stack['address']));
} }
@ -205,7 +205,7 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($e->count(), 1); $this->assertEqual($e->count(), 1);
$invalidRecords = $e->getInvalidRecords(); $invalidRecords = $e->getInvalidRecords();
$this->assertEqual(count($invalidRecords), 1); $this->assertEqual(count($invalidRecords), 1);
$stack = $invalidRecords[0]->getErrorStack(); $stack = $invalidRecords[0]->errorStack();
$this->assertTrue(in_array('length', $stack['name'])); $this->assertTrue(in_array('length', $stack['name']));
} }
@ -222,8 +222,8 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue(is_array($a)); $this->assertTrue(is_array($a));
$emailStack = $a[array_search($user->Email, $a)]->getErrorStack(); $emailStack = $a[array_search($user->Email, $a)]->errorStack();
$userStack = $a[array_search($user, $a)]->getErrorStack(); $userStack = $a[array_search($user, $a)]->errorStack();
$this->assertTrue(in_array('email', $emailStack['address'])); $this->assertTrue(in_array('email', $emailStack['address']));
$this->assertTrue(in_array('length', $userStack['name'])); $this->assertTrue(in_array('length', $userStack['name']));
@ -247,8 +247,8 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$this->assertEqual($e->count(), 1); $this->assertEqual($e->count(), 1);
$invalidRecords = $e->getInvalidRecords(); $invalidRecords = $e->getInvalidRecords();
$this->assertEqual(count($invalidRecords), 1); $this->assertEqual(count($invalidRecords), 1);
$stack = $invalidRecords[0]->getErrorStack(); $stack = $invalidRecords[0]->errorStack();
$this->assertEqual($stack->count(), 2); $this->assertEqual($stack->count(), 2);
$this->assertTrue(in_array('notTheSaint', $stack['name'])); // validate() hook constraint $this->assertTrue(in_array('notTheSaint', $stack['name'])); // validate() hook constraint
@ -267,7 +267,7 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$invalidRecords = $e->getInvalidRecords(); $invalidRecords = $e->getInvalidRecords();
$this->assertEqual(count($invalidRecords), 1); $this->assertEqual(count($invalidRecords), 1);
$stack = $invalidRecords[0]->getErrorStack(); $stack = $invalidRecords[0]->errorStack();
$this->assertEqual($stack->count(), 1); $this->assertEqual($stack->count(), 1);
$this->assertTrue(in_array('notNobody', $stack['loginname'])); // validateOnUpdate() hook constraint $this->assertTrue(in_array('notNobody', $stack['loginname'])); // validateOnUpdate() hook constraint
@ -290,7 +290,7 @@ class Doctrine_Validator_TestCase extends Doctrine_UnitTestCase {
$user->save(); $user->save();
$this->fail(); $this->fail();
} catch (Doctrine_Validator_Exception $ex) { } catch (Doctrine_Validator_Exception $ex) {
$errors = $user->getErrorStack(); $errors = $user->errorStack();
$this->assertTrue(in_array('pwNotTopSecret', $errors['password'])); $this->assertTrue(in_array('pwNotTopSecret', $errors['password']));
} }

2
tests/ViewTestCase.php
View File

@ -56,7 +56,7 @@ class Doctrine_View_TestCase extends Doctrine_UnitTestCase {
$this->assertTrue($users instanceof Doctrine_Collection); $this->assertTrue($users instanceof Doctrine_Collection);
$this->assertEqual($users->count(), 8); $this->assertEqual($users->count(), 8);
$this->assertEqual($users[0]->name, 'zYne'); $this->assertEqual($users[0]->name, 'zYne');
$this->assertEqual($users[0]->getState(), Doctrine_Record::STATE_CLEAN); $this->assertEqual($users[0]->state(), Doctrine_Record::STATE_CLEAN);
$this->assertEqual($count, $this->dbh->count()); $this->assertEqual($count, $this->dbh->count());
$success = true; $success = true;

396
tests/classes.php
View File

@ -1,473 +1,469 @@
<?php <?php
class Entity extends Doctrine_Record { class Entity extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->ownsOne("Email","Entity.email_id"); $this->ownsOne('Email', 'Entity.email_id');
$this->ownsMany("Phonenumber","Phonenumber.entity_id"); $this->ownsMany('Phonenumber', 'Phonenumber.entity_id');
$this->ownsOne("Account","Account.entity_id"); $this->ownsOne('Account', 'Account.entity_id');
$this->hasMany("Entity","EntityReference.entity1-entity2"); $this->hasMany('Entity', 'EntityReference.entity1-entity2');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("id","integer",20,"autoincrement|primary"); $this->hasColumn('id', 'integer',20, 'autoincrement|primary');
$this->hasColumn("name","string",50); $this->hasColumn('name', 'string',50);
$this->hasColumn("loginname","string",20, array("unique")); $this->hasColumn('loginname', 'string',20, array('unique'));
$this->hasColumn("password","string",16); $this->hasColumn('password', 'string',16);
$this->hasColumn("type","integer",1); $this->hasColumn('type', 'integer',1);
$this->hasColumn("created","integer",11); $this->hasColumn('created', 'integer',11);
$this->hasColumn("updated","integer",11); $this->hasColumn('updated', 'integer',11);
$this->hasColumn("email_id","integer"); $this->hasColumn('email_id', 'integer');
} }
} }
class FieldNameTest extends Doctrine_Record { class FieldNameTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("someColumn", "string", 200, array('default' => 'some string')); $this->hasColumn('someColumn', 'string', 200, array('default' => 'some string'));
$this->hasColumn("someEnum", "enum", 4, array('default' => 'php')); $this->hasColumn('someEnum', 'enum', 4, array('default' => 'php', 'values' => array('php', 'java', 'python')));
$this->hasColumn("someArray", "array", 100, array('default' => array())); $this->hasColumn('someArray', 'array', 100, array('default' => array()));
$this->hasColumn("someObject", "object", 200, array('default' => new stdClass)); $this->hasColumn('someObject', 'object', 200, array('default' => new stdClass));
$this->hasColumn("someInt", "integer", 20, array('default' => 11)); $this->hasColumn('someInt', 'integer', 20, array('default' => 11));
$this->setEnumValues("someEnum", array('php', 'java', 'python'));
} }
} }
class EntityReference extends Doctrine_Record { class EntityReference extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("entity1","integer"); $this->hasColumn('entity1', 'integer', null, 'primary');
$this->hasColumn("entity2","integer"); $this->hasColumn('entity2', 'integer', null, 'primary');
$this->setPrimaryKey(array("entity1","entity2")); //$this->setPrimaryKey(array('entity1', 'entity2'));
} }
} }
class Account extends Doctrine_Record { class Account extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("entity_id","integer"); $this->hasColumn('entity_id', 'integer');
$this->hasColumn("amount","integer"); $this->hasColumn('amount', 'integer');
} }
} }
class EntityAddress extends Doctrine_Record { class EntityAddress extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("entity_id","integer"); $this->hasColumn('entity_id', 'integer');
$this->hasColumn("address_id","integer"); $this->hasColumn('address_id', 'integer');
} }
} }
class Address extends Doctrine_Record { class Address extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("User","Entityaddress.entity_id"); $this->hasMany('User', 'Entityaddress.entity_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("address","string",200); $this->hasColumn('address', 'string',200);
} }
} }
// grouptable doesn't extend Doctrine_Table -> Doctrine_Connection // grouptable doesn't extend Doctrine_Table -> Doctrine_Connection
// won't initialize grouptable when Doctrine_Connection->getTable("Group") is called // won't initialize grouptable when Doctrine_Connection->getTable('Group') is called
class GroupTable { } class GroupTable { }
class Group extends Entity { class Group extends Entity {
public function setUp() { public function setUp() {
parent::setUp(); parent::setUp();
$this->hasMany("User","Groupuser.user_id"); $this->hasMany('User', 'Groupuser.user_id');
$this->setInheritanceMap(array("type"=>1)); $this->option('inheritanceMap', array('type' => 1));
} }
} }
class Error extends Doctrine_Record { class Error extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->ownsMany("Description","Description.file_md5","file_md5"); $this->ownsMany('Description', 'Description.file_md5', 'file_md5');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("message","string",200); $this->hasColumn('message', 'string',200);
$this->hasColumn("code","integer",11); $this->hasColumn('code', 'integer',11);
$this->hasColumn("file_md5","string",32,"primary"); $this->hasColumn('file_md5', 'string',32, 'primary');
} }
} }
class Description extends Doctrine_Record { class Description extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("description","string",3000); $this->hasColumn('description', 'string',3000);
$this->hasColumn("file_md5","string",32); $this->hasColumn('file_md5', 'string',32);
} }
} }
class UserTable extends Doctrine_Table { } class UserTable extends Doctrine_Table { }
class User extends Entity { class User extends Entity {
public function setUp() { public function setUp() {
parent::setUp(); parent::setUp();
$this->hasMany("Address","Entityaddress.address_id"); $this->hasMany('Address', 'Entityaddress.address_id');
$this->ownsMany("Album","Album.user_id"); $this->ownsMany('Album', 'Album.user_id');
$this->ownsMany("Book", "Book.user_id"); $this->ownsMany('Book', 'Book.user_id');
$this->hasMany("Group","Groupuser.group_id"); $this->hasMany('Group', 'Groupuser.group_id');
$this->setInheritanceMap(array("type"=>0)); $this->option('inheritanceMap', array('type' => 0));
} }
/** Custom validation */ /** Custom validation */
public function validate() { public function validate() {
// Allow only one name! // Allow only one name!
if ($this->name !== 'The Saint') { if ($this->name !== 'The Saint') {
$this->getErrorStack()->add('name', 'notTheSaint'); $this->errorStack()->add('name', 'notTheSaint');
} }
} }
public function validateOnInsert() { public function validateOnInsert() {
if ($this->password !== 'Top Secret') { if ($this->password !== 'Top Secret') {
$this->getErrorStack()->add('password', 'pwNotTopSecret'); $this->errorStack()->add('password', 'pwNotTopSecret');
} }
} }
public function validateOnUpdate() { public function validateOnUpdate() {
if ($this->loginname !== 'Nobody') { if ($this->loginname !== 'Nobody') {
$this->getErrorStack()->add('loginname', 'notNobody'); $this->errorStack()->add('loginname', 'notNobody');
} }
} }
} }
class Groupuser extends Doctrine_Record { class Groupuser extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("added","integer"); $this->hasColumn('added', 'integer');
$this->hasColumn("group_id","integer"); $this->hasColumn('group_id', 'integer');
$this->hasColumn("user_id","integer"); $this->hasColumn('user_id', 'integer');
} }
} }
class Phonenumber extends Doctrine_Record { class Phonenumber extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("phonenumber","string",20); $this->hasColumn('phonenumber', 'string',20);
$this->hasColumn("entity_id","integer"); $this->hasColumn('entity_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasOne("Entity", "Phonenumber.entity_id"); $this->hasOne('Entity', 'Phonenumber.entity_id');
} }
} }
class Element extends Doctrine_Record { class Element extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 100); $this->hasColumn('name', 'string', 100);
$this->hasColumn("parent_id", "integer"); $this->hasColumn('parent_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasMany("Element as Child","Child.parent_id"); $this->hasMany('Element as Child', 'Child.parent_id');
$this->hasOne("Element as Parent","Element.parent_id"); $this->hasOne('Element as Parent', 'Element.parent_id');
} }
} }
class Email extends Doctrine_Record { class Email extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("address","string",150,"email|unique"); $this->hasColumn('address', 'string',150, 'email|unique');
} }
} }
class Book extends Doctrine_Record { class Book extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->ownsMany("Author","Author.book_id"); $this->ownsMany('Author', 'Author.book_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("user_id","integer"); $this->hasColumn('user_id', 'integer');
$this->hasColumn("name","string",20); $this->hasColumn('name', 'string',20);
} }
} }
class Author extends Doctrine_Record { class Author extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("book_id","integer"); $this->hasColumn('book_id', 'integer');
$this->hasColumn("name","string",20); $this->hasColumn('name', 'string',20);
} }
} }
class Album extends Doctrine_Record { class Album extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->ownsMany("Song","Song.album_id"); $this->ownsMany('Song', 'Song.album_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("user_id","integer"); $this->hasColumn('user_id', 'integer');
$this->hasColumn("name","string",20); $this->hasColumn('name', 'string',20);
} }
} }
class Song extends Doctrine_Record { class Song extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("album_id","integer"); $this->hasColumn('album_id', 'integer');
$this->hasColumn("genre","string",20); $this->hasColumn('genre', 'string',20);
$this->hasColumn("title","string",30); $this->hasColumn('title', 'string',30);
} }
} }
class Task extends Doctrine_Record { class Task extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("Resource as ResourceAlias","Assignment.resource_id"); $this->hasMany('Resource as ResourceAlias', 'Assignment.resource_id');
$this->hasMany("Task as Subtask","Subtask.parent_id"); $this->hasMany('Task as Subtask', 'Subtask.parent_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name","string",100); $this->hasColumn('name', 'string',100);
$this->hasColumn("parent_id","integer"); $this->hasColumn('parent_id', 'integer');
} }
} }
class Resource extends Doctrine_Record { class Resource extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("Task as TaskAlias", "Assignment.task_id"); $this->hasMany('Task as TaskAlias', 'Assignment.task_id');
$this->hasMany("ResourceType as Type", "ResourceReference.type_id"); $this->hasMany('ResourceType as Type', 'ResourceReference.type_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name","string",100); $this->hasColumn('name', 'string',100);
} }
} }
class ResourceReference extends Doctrine_Record { class ResourceReference extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("type_id","integer"); $this->hasColumn('type_id', 'integer');
$this->hasColumn("resource_id","integer"); $this->hasColumn('resource_id', 'integer');
} }
} }
class ResourceType extends Doctrine_Record { class ResourceType extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("Resource as ResourceAlias", "ResourceReference.resource_id"); $this->hasMany('Resource as ResourceAlias', 'ResourceReference.resource_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("type","string",100); $this->hasColumn('type', 'string',100);
} }
} }
class Assignment extends Doctrine_Record { class Assignment extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("task_id","integer"); $this->hasColumn('task_id', 'integer');
$this->hasColumn("resource_id","integer"); $this->hasColumn('resource_id', 'integer');
} }
} }
class Forum_Category extends Doctrine_Record { class Forum_Category extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("root_category_id", "integer", 10); $this->hasColumn('root_category_id', 'integer', 10);
$this->hasColumn("parent_category_id", "integer", 10); $this->hasColumn('parent_category_id', 'integer', 10);
$this->hasColumn("name", "string", 50); $this->hasColumn('name', 'string', 50);
$this->hasColumn("description", "string", 99999); $this->hasColumn('description', 'string', 99999);
} }
public function setUp() { public function setUp() {
$this->hasMany("Forum_Category as Subcategory", "Subcategory.parent_category_id"); $this->hasMany('Forum_Category as Subcategory', 'Subcategory.parent_category_id');
$this->hasOne("Forum_Category as Parent", "Forum_Category.parent_category_id"); $this->hasOne('Forum_Category as Parent', 'Forum_Category.parent_category_id');
$this->hasOne("Forum_Category as Rootcategory", "Forum_Category.root_category_id"); $this->hasOne('Forum_Category as Rootcategory', 'Forum_Category.root_category_id');
} }
} }
class Forum_Board extends Doctrine_Record { class Forum_Board extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("category_id", "integer", 10); $this->hasColumn('category_id', 'integer', 10);
$this->hasColumn("name", "string", 100); $this->hasColumn('name', 'string', 100);
$this->hasColumn("description", "string", 5000); $this->hasColumn('description', 'string', 5000);
} }
public function setUp() { public function setUp() {
$this->hasOne("Forum_Category as Category", "Forum_Board.category_id"); $this->hasOne('Forum_Category as Category', 'Forum_Board.category_id');
$this->ownsMany("Forum_Thread as Threads", "Forum_Thread.board_id"); $this->ownsMany('Forum_Thread as Threads', 'Forum_Thread.board_id');
} }
} }
class Forum_Entry extends Doctrine_Record { class Forum_Entry extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("author", "string", 50); $this->hasColumn('author', 'string', 50);
$this->hasColumn("topic", "string", 100); $this->hasColumn('topic', 'string', 100);
$this->hasColumn("message", "string", 99999); $this->hasColumn('message', 'string', 99999);
$this->hasColumn("parent_entry_id", "integer", 10); $this->hasColumn('parent_entry_id', 'integer', 10);
$this->hasColumn("thread_id", "integer", 10); $this->hasColumn('thread_id', 'integer', 10);
$this->hasColumn("date", "integer", 10); $this->hasColumn('date', 'integer', 10);
} }
public function setUp() { public function setUp() {
$this->hasOne("Forum_Entry as Parent", "Forum_Entry.parent_entry_id"); $this->hasOne('Forum_Entry as Parent', 'Forum_Entry.parent_entry_id');
$this->hasOne("Forum_Thread as Thread", "Forum_Entry.thread_id"); $this->hasOne('Forum_Thread as Thread', 'Forum_Entry.thread_id');
} }
} }
class Forum_Thread extends Doctrine_Record { class Forum_Thread extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("board_id", "integer", 10); $this->hasColumn('board_id', 'integer', 10);
$this->hasColumn("updated", "integer", 10); $this->hasColumn('updated', 'integer', 10);
$this->hasColumn("closed", "integer", 1); $this->hasColumn('closed', 'integer', 1);
} }
public function setUp() { public function setUp() {
$this->hasOne("Forum_Board as Board", "Forum_Thread.board_id"); $this->hasOne('Forum_Board as Board', 'Forum_Thread.board_id');
$this->ownsMany("Forum_Entry as Entries", "Forum_Entry.thread_id"); $this->ownsMany('Forum_Entry as Entries', 'Forum_Entry.thread_id');
} }
} }
class App extends Doctrine_Record { class App extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 32); $this->hasColumn('name', 'string', 32);
$this->hasColumn("user_id", "integer", 11); $this->hasColumn('user_id', 'integer', 11);
$this->hasColumn("app_category_id", "integer", 11); $this->hasColumn('app_category_id', 'integer', 11);
} }
public function setUp() { public function setUp() {
$this->hasOne("User","User.id"); $this->hasOne('User', 'User.id');
$this->hasMany("App_Category as Category","App_Category.id"); $this->hasMany('App_Category as Category', 'App_Category.id');
} }
} }
class App_User extends Doctrine_Record { class App_User extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("first_name", "string", 32); $this->hasColumn('first_name', 'string', 32);
$this->hasColumn("last_name", "string", 32); $this->hasColumn('last_name', 'string', 32);
$this->hasColumn("email", "string", 128, "email"); $this->hasColumn('email', 'string', 128, 'email');
$this->hasColumn("username", "string", 16, "unique, nospace"); $this->hasColumn('username', 'string', 16, 'unique, nospace');
$this->hasColumn("password", "string", 128, "notblank"); $this->hasColumn('password', 'string', 128, 'notblank');
$this->hasColumn("country", "string", 2, "country"); $this->hasColumn('country', 'string', 2, 'country');
$this->hasColumn("zipcode", "string", 9, "nospace"); $this->hasColumn('zipcode', 'string', 9, 'nospace');
} }
public function setUp() { public function setUp() {
$this->hasMany("App","App.user_id"); $this->hasMany('App', 'App.user_id');
} }
} }
class App_Category extends Doctrine_Record { class App_Category extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 32); $this->hasColumn('name', 'string', 32);
$this->hasColumn("parent_id","integer"); $this->hasColumn('parent_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasMany("App","App.app_category_id"); $this->hasMany('App', 'App.app_category_id');
$this->hasMany("App_Category as Parent","App_Category.parent_id"); $this->hasMany('App_Category as Parent', 'App_Category.parent_id');
} }
} }
class ORM_TestEntry extends Doctrine_Record { class ORM_TestEntry extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->setTableName('test_entries'); $this->setTableName('test_entries');
$this->hasColumn("id", "integer", 11, "autoincrement|primary"); $this->hasColumn('id', 'integer', 11, 'autoincrement|primary');
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
$this->hasColumn("stamp", "timestamp"); $this->hasColumn('stamp', 'timestamp');
$this->hasColumn("amount", "float"); $this->hasColumn('amount', 'float');
$this->hasColumn("itemID", "integer"); $this->hasColumn('itemID', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasOne("ORM_TestItem", "ORM_TestEntry.itemID"); $this->hasOne('ORM_TestItem', 'ORM_TestEntry.itemID');
} }
} }
class ORM_TestItem extends Doctrine_Record { class ORM_TestItem extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->setTableName('test_items'); $this->setTableName('test_items');
$this->hasColumn("id", "integer", 11, "autoincrement|primary"); $this->hasColumn('id', 'integer', 11, 'autoincrement|primary');
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasOne("ORM_TestEntry", "ORM_TestEntry.itemID"); $this->hasOne('ORM_TestEntry', 'ORM_TestEntry.itemID');
} }
} }
class ORM_AccessControl extends Doctrine_Record { class ORM_AccessControl extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasMany("ORM_AccessGroup as accessGroups", "ORM_AccessControlsGroups.accessGroupID"); $this->hasMany('ORM_AccessGroup as accessGroups', 'ORM_AccessControlsGroups.accessGroupID');
} }
} }
class ORM_AccessGroup extends Doctrine_Record { class ORM_AccessGroup extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasMany("ORM_AccessControl as accessControls", "ORM_AccessControlsGroups.accessControlID"); $this->hasMany('ORM_AccessControl as accessControls', 'ORM_AccessControlsGroups.accessControlID');
} }
} }
class ORM_AccessControlsGroups extends Doctrine_Record { class ORM_AccessControlsGroups extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("accessControlID", "integer", 11); $this->hasColumn('accessControlID', 'integer', 11);
$this->hasColumn("accessGroupID", "integer", 11); $this->hasColumn('accessGroupID', 'integer', 11);
$this->setPrimaryKey(array("accessControlID", "accessGroupID")); $this->setPrimaryKey(array('accessControlID', 'accessGroupID'));
} }
} }
class EnumTest extends Doctrine_Record { class EnumTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("status","enum",11); $this->hasColumn('status', 'enum', 11, array('values' => array('open', 'verified', 'closed')));
$this->setEnumValues("status", array("open","verified","closed"));
} }
} }
class FilterTest extends Doctrine_Record { class FilterTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name","string",100); $this->hasColumn('name', 'string',100);
} }
public function setUp() { public function setUp() {
$this->ownsMany("FilterTest2 as filtered", "FilterTest2.test1_id"); $this->ownsMany('FilterTest2 as filtered', 'FilterTest2.test1_id');
} }
} }
class FilterTest2 extends Doctrine_Record { class FilterTest2 extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name","string",100); $this->hasColumn('name', 'string',100);
$this->hasColumn("test1_id","integer"); $this->hasColumn('test1_id', 'integer');
} }
} }
class CustomPK extends Doctrine_Record { class CustomPK extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("uid","integer",11,"autoincrement|primary"); $this->hasColumn('uid', 'integer',11, 'autoincrement|primary');
$this->hasColumn("name","string",255); $this->hasColumn('name', 'string',255);
} }
} }
class Log_Entry extends Doctrine_Record { class Log_Entry extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("stamp", "timestamp"); $this->hasColumn('stamp', 'timestamp');
$this->hasColumn("status_id", "integer"); $this->hasColumn('status_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasOne("Log_Status", "Log_Entry.status_id"); $this->hasOne('Log_Status', 'Log_Entry.status_id');
} }
} }
class CPK_Test extends Doctrine_Record { class CPK_Test extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasMany("CPK_Test2 as Test","CPK_Association.test2_id"); $this->hasMany('CPK_Test2 as Test', 'CPK_Association.test2_id');
} }
} }
class CPK_Test2 extends Doctrine_Record { class CPK_Test2 extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasMany("CPK_Test as Test","CPK_Association.test1_id"); $this->hasMany('CPK_Test as Test', 'CPK_Association.test1_id');
} }
} }
class CPK_Association extends Doctrine_Record { class CPK_Association extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("test1_id", "integer", 11, "primary"); $this->hasColumn('test1_id', 'integer', 11, 'primary');
$this->hasColumn("test2_id", "integer", 11, "primary"); $this->hasColumn('test2_id', 'integer', 11, 'primary');
} }
} }
class Log_Status extends Doctrine_Record { class Log_Status extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
} }
class ValidatorTest extends Doctrine_Record { class ValidatorTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("mymixed","string", 100); $this->hasColumn('mymixed', 'string', 100);
$this->hasColumn("mystring","string", 100, "notnull|unique"); $this->hasColumn('mystring', 'string', 100, 'notnull|unique');
$this->hasColumn("myarray", "array", 1000); $this->hasColumn('myarray', 'array', 1000);
$this->hasColumn("myobject", "object", 1000); $this->hasColumn('myobject', 'object', 1000);
$this->hasColumn("myinteger", "integer", 11); $this->hasColumn('myinteger', 'integer', 11);
$this->hasColumn("myrange", "integer", 11, array('range' => array(4,123))); $this->hasColumn('myrange', 'integer', 11, array('range' => array(4,123)));
$this->hasColumn("myregexp", "string", 5, array('regexp' => '/^[0-9]+$/')); $this->hasColumn('myregexp', 'string', 5, array('regexp' => '/^[0-9]+$/'));
$this->hasColumn("myemail", "string", 100, "email"); $this->hasColumn('myemail', 'string', 100, 'email');
$this->hasColumn("myemail2", "string", 100, "email|notblank"); $this->hasColumn('myemail2', 'string', 100, 'email|notblank');
} }
} }
class DateTest extends Doctrine_Record { class DateTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("date", "date", 20); $this->hasColumn('date', 'date', 20);
} }
} }
class GzipTest extends Doctrine_Record { class GzipTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("gzip", "gzip", 100000); $this->hasColumn('gzip', 'gzip', 100000);
} }
} }
class Tag extends Doctrine_Record { class Tag extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("Photo", "Phototag.photo_id"); $this->hasMany('Photo', 'Phototag.photo_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("tag", "string", 100); $this->hasColumn('tag', 'string', 100);
} }
} }
class Photo extends Doctrine_Record { class Photo extends Doctrine_Record {
public function setUp() { public function setUp() {
$this->hasMany("Tag", "Phototag.tag_id"); $this->hasMany('Tag', 'Phototag.tag_id');
} }
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 100); $this->hasColumn('name', 'string', 100);
} }
} }
class Phototag extends Doctrine_Record { class Phototag extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("photo_id", "integer"); $this->hasColumn('photo_id', 'integer');
$this->hasColumn("tag_id", "integer"); $this->hasColumn('tag_id', 'integer');
} }
} }
@ -479,82 +475,82 @@ class BooleanTest extends Doctrine_Record {
} }
class Data_File extends Doctrine_Record { class Data_File extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("filename", "string"); $this->hasColumn('filename', 'string');
$this->hasColumn("file_owner_id", "integer"); $this->hasColumn('file_owner_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasOne("File_Owner", "Data_File.file_owner_id"); $this->hasOne('File_Owner', 'Data_File.file_owner_id');
} }
} }
class NotNullTest extends Doctrine_Record { class NotNullTest extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 100, "notnull"); $this->hasColumn('name', 'string', 100, 'notnull');
$this->hasColumn("type", "integer", 11); $this->hasColumn('type', 'integer', 11);
} }
} }
class File_Owner extends Doctrine_Record { class File_Owner extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->hasOne("Data_File", "Data_File.file_owner_id"); $this->hasOne('Data_File', 'Data_File.file_owner_id');
} }
} }
class MyUser extends Doctrine_Record { class MyUser extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string"); $this->hasColumn('name', 'string');
} }
public function setUp() { public function setUp() {
$this->hasMany("MyOneThing", "MyOneThing.user_id"); $this->hasMany('MyOneThing', 'MyOneThing.user_id');
$this->hasMany("MyOtherThing", "MyOtherThing.user_id"); $this->hasMany('MyOtherThing', 'MyOtherThing.user_id');
} }
} }
class MyOneThing extends Doctrine_Record { class MyOneThing extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string"); $this->hasColumn('name', 'string');
$this->hasColumn("user_id", "integer"); $this->hasColumn('user_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasMany("MyUserOneThing", "MyUserOneThing.one_thing_id"); $this->hasMany('MyUserOneThing', 'MyUserOneThing.one_thing_id');
} }
} }
class MyOtherThing extends Doctrine_Record { class MyOtherThing extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("name", "string"); $this->hasColumn('name', 'string');
$this->hasColumn("user_id", "integer"); $this->hasColumn('user_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasMany("MyUserOtherThing", "MyUserOtherThing.other_thing_id"); $this->hasMany('MyUserOtherThing', 'MyUserOtherThing.other_thing_id');
} }
} }
class MyUserOneThing extends Doctrine_Record { class MyUserOneThing extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("user_id", "integer"); $this->hasColumn('user_id', 'integer');
$this->hasColumn("one_thing_id", "integer"); $this->hasColumn('one_thing_id', 'integer');
} }
} }
class MyUserOtherThing extends Doctrine_Record { class MyUserOtherThing extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("user_id", "integer"); $this->hasColumn('user_id', 'integer');
$this->hasColumn("other_thing_id", "integer"); $this->hasColumn('other_thing_id', 'integer');
} }
} }
class CategoryWithPosition extends Doctrine_Record { class CategoryWithPosition extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("position", "integer"); $this->hasColumn('position', 'integer');
$this->hasColumn("name", "string", 255); $this->hasColumn('name', 'string', 255);
} }
public function setUp() { public function setUp() {
$this->ownsMany("BoardWithPosition as Boards", "BoardWithPosition.category_id"); $this->ownsMany('BoardWithPosition as Boards', 'BoardWithPosition.category_id');
} }
} }
class BoardWithPosition extends Doctrine_Record { class BoardWithPosition extends Doctrine_Record {
public function setTableDefinition() { public function setTableDefinition() {
$this->hasColumn("position", "integer"); $this->hasColumn('position', 'integer');
$this->hasColumn("category_id", "integer"); $this->hasColumn('category_id', 'integer');
} }
public function setUp() { public function setUp() {
$this->hasOne("CategoryWithPosition as Category", "BoardWithPosition.category_id"); $this->hasOne('CategoryWithPosition as Category', 'BoardWithPosition.category_id');
} }
} }
class Package extends Doctrine_Record { class Package extends Doctrine_Record {