PersistentObject/tests/relations/multi_relation_test.php - zetacomponents - Git at Google

 <?php
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
  * @version //autogentag//
  * @filesource
  * @package PersistentObject
  * @subpackage Tests
  */

 require_once dirname( __FILE__ ) . "/../data/multi_relation_test_person.php";

 /**
  * Tests ezcPersistentManyToManyRelation class.
  *
  * @package PersistentObject
  * @subpackage Tests
  */
 class ezcPersistentMultiRelationTest extends ezcTestCase
 {

     private $session;

     public static function suite()
     {
         return new PHPUnit_Framework_TestSuite( __CLASS__ );
     }

     public function setup()
     {
         try
         {
             $this->db = ezcDbInstance::get();
         }
         catch ( Exception $e )
         {
             $this->markTestSkipped( 'There was no database configured' );
         }
         MultiRelationTestPerson::setupTables();
         MultiRelationTestPerson::insertData();
         $this->session = new ezcPersistentSession(
             ezcDbInstance::get(),
             new ezcPersistentCodeManager( dirname( __FILE__ ) . "/../data/" )
         );
     }

     public function teardown()
     {
         MultiRelationTestPerson::cleanup();
     }

     public function testLoad()
     {
         $rootMother = $this->session->load( 'MultiRelationTestPerson', 1 );
         $this->assertEquals(
             'Root mother without parents.',
             $rootMother->name,
             'MultiRelationTestPerson with ID 1 not loaded correctly.'
         );

         $rootFather = $this->session->load( 'MultiRelationTestPerson', 2 );
         $this->assertEquals(
             'Root father without parents.',
             $rootFather->name,
             'MultiRelationTestPerson with ID 2 not loaded correctly.'
         );
     }

     public function testFind()
     {
         $q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
         $q->where(
             $q->expr->gt(
                 $this->session->database->quoteIdentifier( 'id' ),
                 $q->bindValue( 2 )
             ),
             $q->expr->lt(
                 $this->session->database->quoteIdentifier( 'id' ),
                 $q->bindValue( 5 )
             )
         );
         $persons = $this->session->find( $q, 'MultiRelationTestPerson' );

         $this->assertEquals(
             2,
             count( $persons ),
             'MultiRelationTestPerson object not found correctly.'
         );
         $this->assertTrue( isset( $persons[3] ) && isset( $persons[4] ) );

         $this->assertEquals(
             3,
             $persons[3]->id,
             'First MultiRelationTestPerson object not found correctly.'
         );

         $this->assertEquals(
             4,
             $persons[4]->id,
             'First MultiRelationTestPerson object not found correctly.'
         );
     }

     public function testSave()
     {
         $newChild = new MultiRelationTestPerson();
         $newChild->name = "New child";

         $this->session->save( $newChild );

         $this->assertEquals(
             6,
             $newChild->id,
             'New MultiRelationTestPerson saved with incorrect ID.'
         );
     }

     public function testGetRelatedObjectsFailureWithoutRelationName()
     {
         $mother = $this->session->load( 'MultiRelationTestPerson', 1 );
         try
         {
             $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson' );
             $this->fail( 'Exception not thrown on getRelatedObjects() without relation name.' );
         }
         catch ( ezcPersistentUndeterministicRelationException $e ) {}
     }

     public function testGetRelatedObjectFailureWithoutRelationName()
     {
         $mother = $this->session->load( 'MultiRelationTestPerson', 1 );
         try
         {
             $this->session->getRelatedObject( $mother, 'MultiRelationTestPerson' );
             $this->fail( 'Exception not thrown on getRelatedObjects() without relation name.' );
         }
         catch ( ezcPersistentUndeterministicRelationException $e ) {}
     }

     public function testGetRelatedObjectsSuccessMotherChild()
     {
         $mother   = $this->session->load( 'MultiRelationTestPerson', 1 );
         $children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

         $this->assertEquals(
             3,
             count( $children ),
             'Number of found children incorrect.'
         );
         $this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

         $this->assertEquals(
             3,
             $children[3]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             4,
             $children[4]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             5,
             $children[5]->id,
             'First child fetched incorrect.'
         );
     }

     public function testFindRelatedObjectsSuccessMotherChild()
     {
         $mother   = $this->session->load( 'MultiRelationTestPerson', 1 );
         $q = $this->session->createRelationFindQuery( $mother, 'MultiRelationTestPerson', 'mothers_children' );
         $children = $this->session->find( $q );

         $this->assertEquals(
             3,
             count( $children ),
             'Number of found children incorrect.'
         );
         $this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

         $this->assertEquals(
             3,
             $children[3]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             4,
             $children[4]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             5,
             $children[5]->id,
             'First child fetched incorrect.'
         );
     }

     public function testGetRelatedObjectSuccessFatherChild()
     {
         $father   = $this->session->load( 'MultiRelationTestPerson', 2 );
         $children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

         $this->assertEquals(
             3,
             count( $children ),
             'Number of found children incorrect.'
         );
         $this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

         $this->assertEquals(
             3,
             $children[3]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             4,
             $children[4]->id,
             'First child fetched incorrect.'
         );

         $this->assertEquals(
             5,
             $children[5]->id,
             'First child fetched incorrect.'
         );
     }

     public function testGetRelatedObjectSuccessChildMother()
     {
         $child   = $this->session->load( 'MultiRelationTestPerson', 3 );
         $mother = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'mother' );

         $this->assertEquals(
             1,
             $mother->id,
             'Mother fetched incorrectly for child 3'
         );
     }

     public function testGetRelatedObjectSuccessChildFather()
     {
         $child  = $this->session->load( 'MultiRelationTestPerson', 4 );
         $father = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'father' );

         $this->assertEquals(
             2,
             $father->id,
             'Father fetched incorrectly for MultiRelationTestPerson 4'
         );
     }

     public function testGetRelatedObjectsSuccessSiblings()
     {
         $child    = $this->session->load( 'MultiRelationTestPerson', 3 );
         $siblings = $this->session->getRelatedObjects( $child, 'MultiRelationTestPerson', 'siblings' );

         $this->assertEquals(
             2,
             count( $siblings ),
             'Siblings not correctly found for MultiRelationTestPerson 3'
         );
     }

     public function testAddObjectsFailureWithoutRelationName()
     {
         $newChild = new MultiRelationTestPerson();
         $newChild->name = "New child";

         $this->session->save( $newChild );

         $mother = $this->session->load( 'MultiRelationTestPerson', 1 );

         try
         {
             $this->session->addRelatedObject( $mother, $newChild );
             $this->fail( 'Exception not thrown on addRelatedObject() without relation name.' );
         }
         catch ( ezcPersistentUndeterministicRelationException $e ) {}
     }

     public function testAddRelatedObjectOneToManySuccess()
     {
         $newChild = new MultiRelationTestPerson();
         $newChild->name = "New child";

         $this->session->save( $newChild );

         $mother = $this->session->load( 'MultiRelationTestPerson', 1 );

         $this->session->addRelatedObject( $mother, $newChild, 'mothers_children' );

         $this->assertEquals(
             $mother->id,
             $newChild->mother,
             'New MultiRelationTestPerson child not added correctly'
         );
     }

     public function testAddRelatedObjectManyToManySuccess()
     {
         $newSibling = new MultiRelationTestPerson();
         $newSibling->name = "New child";

         $this->session->save( $newSibling );

         $sibling = $this->session->load( 'MultiRelationTestPerson', 3 );

         $this->session->addRelatedObject( $sibling, $newSibling, 'siblings' );

         $q = $this->session->database->createSelectQuery();
         $q->select( '*' )
           ->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
           ->where(
             $q->expr->eq(
                 $this->session->database->quoteIdentifier( 'sibling' ),
                 $q->bindValue( $newSibling->id )
             )
           );

         $stmt = $q->prepare();
         $stmt->execute();
         $rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

         $this->assertEquals(
             1,
             count( $rows ),
             'Incorrect number of relation records.'
         );

         $this->assertEquals(
             $sibling->id,
             $rows[0]['person'],
             'Incorrect perso ID in relation record.'
         );
     }

     public function testRemoveObjectsFailureWithoutRelationName()
     {
         $mother   = $this->session->load( 'MultiRelationTestPerson', 1 );
         $children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

         try
         {
             $this->session->removeRelatedObject( $mother, $children[3] );
             $this->fail( 'Exception not thrown on removeRelatedObject() without relation name.' );
         }
         catch ( ezcPersistentUndeterministicRelationException $e ) {}
     }

     public function testRemoveRelatedObjectSuccessMotherChildren()
     {
         $mother   = $this->session->load( 'MultiRelationTestPerson', 1 );
         $children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

         foreach( $children as $child )
         {
             $this->session->removeRelatedObject( $mother, $child, 'mothers_children' );

             $this->assertNull(
                 $child->mother,
                 "MultiRelationTestPerson child {$child->id} not correctly removed from mother."
             );
             $this->assertNotNull(
                 $child->father,
                 "MultiRelationTestPerson child {$child->id} also removed from father instead from mother only."
             );
         }
     }

     public function testRemoveRelatedObjectSuccessFatherChildren()
     {
         $father   = $this->session->load( 'MultiRelationTestPerson', 2 );
         $children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

         foreach( $children as $child )
         {
             $this->session->removeRelatedObject( $father, $child, 'fathers_children' );

             $this->assertNull(
                 $child->father,
                 "MultiRelationTestPerson child {$child->id} not correctly removed from father."
             );
             $this->assertNotNull(
                 $child->mother,
                 "MultiRelationTestPerson child {$child->id} also removed from mother instead from father only."
             );
         }
     }

     public function testRemoveRelatedObjectFailureChildMother()
     {
         $child   = $this->session->load( 'MultiRelationTestPerson', 3 );
         $mother = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'mother' );

         try
         {
             $this->session->removeRelatedObject( $child, $mother, 'mother' );
             $this->fail( "MultiRelationTestPerson correctly removed from mother although relation is marked reverse." );
         }
         catch ( ezcPersistentRelationOperationNotSupportedException $e ) {}
     }

     public function testRemoveRelatedObjectFailureChildFather()
     {
         $child  = $this->session->load( 'MultiRelationTestPerson', 4 );
         $father = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'father' );

         try
         {
             $this->session->removeRelatedObject( $child, $father, 'father' );
             $this->fail( "MultiRelationTestPerson correctly removed from father although relation is marked reverse." );
         }
         catch ( ezcPersistentRelationOperationNotSupportedException $e ) {}
     }

     public function testRemoveRelatedObjectSuccessSiblings()
     {
         $child    = $this->session->load( 'MultiRelationTestPerson', 3 );
         $siblings = $this->session->getRelatedObjects( $child, 'MultiRelationTestPerson', 'siblings' );

         foreach ( $siblings as $sibling )
         {
             $this->session->removeRelatedObject( $child, $sibling, 'siblings' );
         }

         $q = $this->session->database->createSelectQuery();
         $q->select( '*' )
           ->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
           ->where(
             $q->expr->eq(
                 $this->session->database->quoteIdentifier( 'person' ),
                 $q->bindValue( $child->id )
             )
           );

         $stmt = $q->prepare();
         $stmt->execute();
         $rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

         $this->assertEquals(
             0,
             count( $rows ),
             'Incorrect number of relation records after removing all siblings.'
         );
     }

     public function testDeleteCascade()
     {
         $mother   = $this->session->load( 'MultiRelationTestPerson', 1 );

         $this->session->delete( $mother );

         $q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
         $q->where(
             $q->expr->eq(
                 'mother',
                 $q->bindValue( 1 )
             )
           );

         $stmt = $q->prepare();
         $stmt->execute();
         $rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

         $this->assertEquals(
             0,
             count( $rows ),
             "Cascading while deleting MultiRelationTestPerson mother did not work."
         );
     }

     public function testDeleteNoCascade()
     {
         $father   = $this->session->load( 'MultiRelationTestPerson', 2 );

         $this->session->delete( $father );

         $q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
         $q->where(
             $q->expr->eq(
                 'father',
                 $q->bindValue( 2 )
             )
           );

         $stmt = $q->prepare();
         $stmt->execute();
         $rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

         $this->assertNotEquals(
             0,
             count( $rows ),
             "Cascaded while deleting MultiRelationTestPerson father while cascade was not desired."
         );
     }

     public function testRemoveRelatioRecordsOnDeleteSiblings()
     {
         $child    = $this->session->load( 'MultiRelationTestPerson', 3 );

         $this->session->delete( $child );

         $q = $this->session->database->createSelectQuery();
         $q->select( '*' )
           ->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
           ->where(
             $q->expr->eq(
                 $this->session->database->quoteIdentifier( 'person' ),
                 $q->bindValue( $child->id )
             )
           );

         $stmt = $q->prepare();
         $stmt->execute();
         $rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

         $this->assertEquals(
             0,
             count( $rows ),
             'Incorrect number of relation records after removing all siblings.'
         );
     }

     public function testIsRelatedSuccess()
     {
         $father   = $this->session->load( 'MultiRelationTestPerson', 2 );
         $children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

         foreach ( $children as $child )
         {
             $this->assertTrue( $this->session->isRelated( $father, $child, "fathers_children" ) );
         }
     }

     public function testIsRelatedReverseSuccess()
     {
         $father   = $this->session->load( 'MultiRelationTestPerson', 2 );
         $children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

         foreach ( $children as $child )
         {
             $this->assertTrue( $this->session->isRelated( $child, $father, "father" ) );
         }
     }

     public function testIsRelatedFailure()
     {
         $person = $this->session->load( "MultiRelationTestPerson", 2 );

         $otherPerson = new MultiRelationTestPerson();
         $otherPerson->id = 23;
         $otherPerson->mother = 42;
         $otherPerson->father = 43;

         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "fathers_children" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "father" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mothers_children" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mother" ) );

         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "father" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "fathers_children" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mother" ) );
         $this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mothers_children" ) );
     }

     public function testIsRelatedErrorMissingRelationName()
     {
         $person = $this->session->load( "MultiRelationTestPerson", 2 );

         $otherPerson = new MultiRelationTestPerson();
         $otherPerson->id = 23;
         $otherPerson->mother = 42;
         $otherPerson->father = 43;

         try
         {
             $this->session->isRelated( $person, $otherPerson );
             $this->fail( 'Exception not thrown on missing relation name.' );
         }
         catch ( ezcPersistentUndeterministicRelationException $e ) {}
     }
 }

 ?>
	<?php
	/**
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
	* @version //autogentag//
	* @filesource
	* @package PersistentObject
	* @subpackage Tests
	*/

	require_once dirname( __FILE__ ) . "/../data/multi_relation_test_person.php";

	/**
	* Tests ezcPersistentManyToManyRelation class.
	*
	* @package PersistentObject
	* @subpackage Tests
	*/
	class ezcPersistentMultiRelationTest extends ezcTestCase
	{

	private $session;

	public static function suite()
	{
	return new PHPUnit_Framework_TestSuite( __CLASS__ );
	}

	public function setup()
	{
	try
	{
	$this->db = ezcDbInstance::get();
	}
	catch ( Exception $e )
	{
	$this->markTestSkipped( 'There was no database configured' );
	}
	MultiRelationTestPerson::setupTables();
	MultiRelationTestPerson::insertData();
	$this->session = new ezcPersistentSession(
	ezcDbInstance::get(),
	new ezcPersistentCodeManager( dirname( __FILE__ ) . "/../data/" )
	);
	}

	public function teardown()
	{
	MultiRelationTestPerson::cleanup();
	}

	public function testLoad()
	{
	$rootMother = $this->session->load( 'MultiRelationTestPerson', 1 );
	$this->assertEquals(
	'Root mother without parents.',
	$rootMother->name,
	'MultiRelationTestPerson with ID 1 not loaded correctly.'
	);

	$rootFather = $this->session->load( 'MultiRelationTestPerson', 2 );
	$this->assertEquals(
	'Root father without parents.',
	$rootFather->name,
	'MultiRelationTestPerson with ID 2 not loaded correctly.'
	);
	}

	public function testFind()
	{
	$q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
	$q->where(
	$q->expr->gt(
	$this->session->database->quoteIdentifier( 'id' ),
	$q->bindValue( 2 )
	),
	$q->expr->lt(
	$this->session->database->quoteIdentifier( 'id' ),
	$q->bindValue( 5 )
	)
	);
	$persons = $this->session->find( $q, 'MultiRelationTestPerson' );

	$this->assertEquals(
	2,
	count( $persons ),
	'MultiRelationTestPerson object not found correctly.'
	);
	$this->assertTrue( isset( $persons[3] ) && isset( $persons[4] ) );

	$this->assertEquals(
	3,
	$persons[3]->id,
	'First MultiRelationTestPerson object not found correctly.'
	);

	$this->assertEquals(
	4,
	$persons[4]->id,
	'First MultiRelationTestPerson object not found correctly.'
	);
	}

	public function testSave()
	{
	$newChild = new MultiRelationTestPerson();
	$newChild->name = "New child";

	$this->session->save( $newChild );

	$this->assertEquals(
	6,
	$newChild->id,
	'New MultiRelationTestPerson saved with incorrect ID.'
	);
	}

	public function testGetRelatedObjectsFailureWithoutRelationName()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	try
	{
	$this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson' );
	$this->fail( 'Exception not thrown on getRelatedObjects() without relation name.' );
	}
	catch ( ezcPersistentUndeterministicRelationException $e ) {}
	}

	public function testGetRelatedObjectFailureWithoutRelationName()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	try
	{
	$this->session->getRelatedObject( $mother, 'MultiRelationTestPerson' );
	$this->fail( 'Exception not thrown on getRelatedObjects() without relation name.' );
	}
	catch ( ezcPersistentUndeterministicRelationException $e ) {}
	}

	public function testGetRelatedObjectsSuccessMotherChild()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	$children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

	$this->assertEquals(
	3,
	count( $children ),
	'Number of found children incorrect.'
	);
	$this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

	$this->assertEquals(
	3,
	$children[3]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	4,
	$children[4]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	5,
	$children[5]->id,
	'First child fetched incorrect.'
	);
	}

	public function testFindRelatedObjectsSuccessMotherChild()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	$q = $this->session->createRelationFindQuery( $mother, 'MultiRelationTestPerson', 'mothers_children' );
	$children = $this->session->find( $q );

	$this->assertEquals(
	3,
	count( $children ),
	'Number of found children incorrect.'
	);
	$this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

	$this->assertEquals(
	3,
	$children[3]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	4,
	$children[4]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	5,
	$children[5]->id,
	'First child fetched incorrect.'
	);
	}

	public function testGetRelatedObjectSuccessFatherChild()
	{
	$father = $this->session->load( 'MultiRelationTestPerson', 2 );
	$children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

	$this->assertEquals(
	3,
	count( $children ),
	'Number of found children incorrect.'
	);
	$this->assertTrue( isset( $children[3] ) && isset( $children[4] ) && isset( $children[5] ) );

	$this->assertEquals(
	3,
	$children[3]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	4,
	$children[4]->id,
	'First child fetched incorrect.'
	);

	$this->assertEquals(
	5,
	$children[5]->id,
	'First child fetched incorrect.'
	);
	}

	public function testGetRelatedObjectSuccessChildMother()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 3 );
	$mother = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'mother' );

	$this->assertEquals(
	1,
	$mother->id,
	'Mother fetched incorrectly for child 3'
	);
	}

	public function testGetRelatedObjectSuccessChildFather()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 4 );
	$father = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'father' );

	$this->assertEquals(
	2,
	$father->id,
	'Father fetched incorrectly for MultiRelationTestPerson 4'
	);
	}

	public function testGetRelatedObjectsSuccessSiblings()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 3 );
	$siblings = $this->session->getRelatedObjects( $child, 'MultiRelationTestPerson', 'siblings' );

	$this->assertEquals(
	2,
	count( $siblings ),
	'Siblings not correctly found for MultiRelationTestPerson 3'
	);
	}

	public function testAddObjectsFailureWithoutRelationName()
	{
	$newChild = new MultiRelationTestPerson();
	$newChild->name = "New child";

	$this->session->save( $newChild );

	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );

	try
	{
	$this->session->addRelatedObject( $mother, $newChild );
	$this->fail( 'Exception not thrown on addRelatedObject() without relation name.' );
	}
	catch ( ezcPersistentUndeterministicRelationException $e ) {}
	}

	public function testAddRelatedObjectOneToManySuccess()
	{
	$newChild = new MultiRelationTestPerson();
	$newChild->name = "New child";

	$this->session->save( $newChild );

	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );

	$this->session->addRelatedObject( $mother, $newChild, 'mothers_children' );

	$this->assertEquals(
	$mother->id,
	$newChild->mother,
	'New MultiRelationTestPerson child not added correctly'
	);
	}

	public function testAddRelatedObjectManyToManySuccess()
	{
	$newSibling = new MultiRelationTestPerson();
	$newSibling->name = "New child";

	$this->session->save( $newSibling );

	$sibling = $this->session->load( 'MultiRelationTestPerson', 3 );

	$this->session->addRelatedObject( $sibling, $newSibling, 'siblings' );

	$q = $this->session->database->createSelectQuery();
	$q->select( '*' )
	->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
	->where(
	$q->expr->eq(
	$this->session->database->quoteIdentifier( 'sibling' ),
	$q->bindValue( $newSibling->id )
	)
	);

	$stmt = $q->prepare();
	$stmt->execute();
	$rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

	$this->assertEquals(
	1,
	count( $rows ),
	'Incorrect number of relation records.'
	);

	$this->assertEquals(
	$sibling->id,
	$rows[0]['person'],
	'Incorrect perso ID in relation record.'
	);
	}

	public function testRemoveObjectsFailureWithoutRelationName()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	$children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

	try
	{
	$this->session->removeRelatedObject( $mother, $children[3] );
	$this->fail( 'Exception not thrown on removeRelatedObject() without relation name.' );
	}
	catch ( ezcPersistentUndeterministicRelationException $e ) {}
	}

	public function testRemoveRelatedObjectSuccessMotherChildren()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );
	$children = $this->session->getRelatedObjects( $mother, 'MultiRelationTestPerson', 'mothers_children' );

	foreach( $children as $child )
	{
	$this->session->removeRelatedObject( $mother, $child, 'mothers_children' );

	$this->assertNull(
	$child->mother,
	"MultiRelationTestPerson child {$child->id} not correctly removed from mother."
	);
	$this->assertNotNull(
	$child->father,
	"MultiRelationTestPerson child {$child->id} also removed from father instead from mother only."
	);
	}
	}

	public function testRemoveRelatedObjectSuccessFatherChildren()
	{
	$father = $this->session->load( 'MultiRelationTestPerson', 2 );
	$children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

	foreach( $children as $child )
	{
	$this->session->removeRelatedObject( $father, $child, 'fathers_children' );

	$this->assertNull(
	$child->father,
	"MultiRelationTestPerson child {$child->id} not correctly removed from father."
	);
	$this->assertNotNull(
	$child->mother,
	"MultiRelationTestPerson child {$child->id} also removed from mother instead from father only."
	);
	}
	}

	public function testRemoveRelatedObjectFailureChildMother()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 3 );
	$mother = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'mother' );

	try
	{
	$this->session->removeRelatedObject( $child, $mother, 'mother' );
	$this->fail( "MultiRelationTestPerson correctly removed from mother although relation is marked reverse." );
	}
	catch ( ezcPersistentRelationOperationNotSupportedException $e ) {}
	}

	public function testRemoveRelatedObjectFailureChildFather()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 4 );
	$father = $this->session->getRelatedObject( $child, 'MultiRelationTestPerson', 'father' );

	try
	{
	$this->session->removeRelatedObject( $child, $father, 'father' );
	$this->fail( "MultiRelationTestPerson correctly removed from father although relation is marked reverse." );
	}
	catch ( ezcPersistentRelationOperationNotSupportedException $e ) {}
	}

	public function testRemoveRelatedObjectSuccessSiblings()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 3 );
	$siblings = $this->session->getRelatedObjects( $child, 'MultiRelationTestPerson', 'siblings' );

	foreach ( $siblings as $sibling )
	{
	$this->session->removeRelatedObject( $child, $sibling, 'siblings' );
	}

	$q = $this->session->database->createSelectQuery();
	$q->select( '*' )
	->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
	->where(
	$q->expr->eq(
	$this->session->database->quoteIdentifier( 'person' ),
	$q->bindValue( $child->id )
	)
	);

	$stmt = $q->prepare();
	$stmt->execute();
	$rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

	$this->assertEquals(
	0,
	count( $rows ),
	'Incorrect number of relation records after removing all siblings.'
	);
	}

	public function testDeleteCascade()
	{
	$mother = $this->session->load( 'MultiRelationTestPerson', 1 );

	$this->session->delete( $mother );

	$q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
	$q->where(
	$q->expr->eq(
	'mother',
	$q->bindValue( 1 )
	)
	);

	$stmt = $q->prepare();
	$stmt->execute();
	$rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

	$this->assertEquals(
	0,
	count( $rows ),
	"Cascading while deleting MultiRelationTestPerson mother did not work."
	);
	}

	public function testDeleteNoCascade()
	{
	$father = $this->session->load( 'MultiRelationTestPerson', 2 );

	$this->session->delete( $father );

	$q = $this->session->createFindQuery( 'MultiRelationTestPerson' );
	$q->where(
	$q->expr->eq(
	'father',
	$q->bindValue( 2 )
	)
	);

	$stmt = $q->prepare();
	$stmt->execute();
	$rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

	$this->assertNotEquals(
	0,
	count( $rows ),
	"Cascaded while deleting MultiRelationTestPerson father while cascade was not desired."
	);
	}

	public function testRemoveRelatioRecordsOnDeleteSiblings()
	{
	$child = $this->session->load( 'MultiRelationTestPerson', 3 );

	$this->session->delete( $child );

	$q = $this->session->database->createSelectQuery();
	$q->select( '*' )
	->from( $this->session->database->quoteIdentifier( 'PO_sibling' ) )
	->where(
	$q->expr->eq(
	$this->session->database->quoteIdentifier( 'person' ),
	$q->bindValue( $child->id )
	)
	);

	$stmt = $q->prepare();
	$stmt->execute();
	$rows = $stmt->fetchAll( PDO::FETCH_ASSOC );

	$this->assertEquals(
	0,
	count( $rows ),
	'Incorrect number of relation records after removing all siblings.'
	);
	}

	public function testIsRelatedSuccess()
	{
	$father = $this->session->load( 'MultiRelationTestPerson', 2 );
	$children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

	foreach ( $children as $child )
	{
	$this->assertTrue( $this->session->isRelated( $father, $child, "fathers_children" ) );
	}
	}

	public function testIsRelatedReverseSuccess()
	{
	$father = $this->session->load( 'MultiRelationTestPerson', 2 );
	$children = $this->session->getRelatedObjects( $father, 'MultiRelationTestPerson', 'fathers_children' );

	foreach ( $children as $child )
	{
	$this->assertTrue( $this->session->isRelated( $child, $father, "father" ) );
	}
	}

	public function testIsRelatedFailure()
	{
	$person = $this->session->load( "MultiRelationTestPerson", 2 );

	$otherPerson = new MultiRelationTestPerson();
	$otherPerson->id = 23;
	$otherPerson->mother = 42;
	$otherPerson->father = 43;

	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "fathers_children" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "father" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mothers_children" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mother" ) );

	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "father" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "fathers_children" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mother" ) );
	$this->assertFalse( $this->session->isRelated( $person, $otherPerson, "mothers_children" ) );
	}

	public function testIsRelatedErrorMissingRelationName()
	{
	$person = $this->session->load( "MultiRelationTestPerson", 2 );

	$otherPerson = new MultiRelationTestPerson();
	$otherPerson->id = 23;
	$otherPerson->mother = 42;
	$otherPerson->father = 43;

	try
	{
	$this->session->isRelated( $person, $otherPerson );
	$this->fail( 'Exception not thrown on missing relation name.' );
	}
	catch ( ezcPersistentUndeterministicRelationException $e ) {}
	}
	}

	?>