function testFetch()
{
$entity = new DataSpace();
$entity->set('_node_id', $id = 10);
$result = new PagedArrayDataset(array());
$decorated_dao = new MockSQLBasedDAO($this);
$decorated_dao->expectOnce('addCriteria');
$decorated_dao->expectOnce('fetch');
$data = array(array('whatever1'),
array('whatever2'));
$rs = new PagedArrayDataset($data);
$decorated_dao->setReturnReference('fetch', $rs);
$criteria = new MockTreeNodeSiblingsCriteria($this);
$criteria->expectOnce('setParentNodeId', array($id));
$node_dao = new MockRequestResolverResultDAO($this);
$node_dao->expectOnce('fetchRecord');
$node_dao->setReturnReference('fetchRecord', $entity);
$dao = new NodeSiblingsDAOTestVersion($this);
$dao->NodeSiblingsDAO($decorated_dao, $node_dao);
$dao->setReturnReference('getTreeNodeSiblingsCriteria', $criteria);
$this->assertNotNull($dao->fetch());
$decorated_dao->tally();
$node_dao->tally();
$criteria->tally();
}
function testProcessUseNodeId()
{
$record = new DataSpace();
$record->import(array('_node_id' => $node_id = 100));
$this->translator->expectOnce('getPathToNode', array($node_id));
$this->translator->setReturnValue('getPathToNode', $path = '/whatever/');
$processor = new PathRecordProcessor();
$processor->process($record);
$this->assertEqual($record->get('_node_path'), $path);
}
function testLoginFailedPasswordNotMatched()
{
$users_dao = new MockAbstractUsersDAO($this);
$this->authenticator->setUsersDAO($users_dao);
$users_dao->expectOnce('findByLogin', array($login = '******'));
$user_data = new DataSpace();
$user_data->import(array('password' => md5('wrong_password')));
$users_dao->setReturnReference('findByLogin', $user_data);
$this->authenticator->login($login, $password = '******');
$toolkit =& Limb::toolkit();
$user =& $toolkit->getUser();
$this->assertFalse($user->isLoggedIn());
$users_dao->tally();
}
/**
* Gets a property value by navagating a dot separated path
* that dereferences elements within the dataspace.
* If an element cannot be dereferenced or is not set, the
* value NULL is returned.
* @param string name of property
* @return mixed value of property or NULL if not found
* @access public
*/
function getPath($path)
{
if (($pos = strpos($path, '.')) === FALSE) {
return $this->get($path);
} else {
$value = $this->get(substr($path, 0, $pos));
$dataspace =& DataSpace::makeDataSpace($value);
if (is_null($dataspace)) {
return NULL;
}
return $dataspace->getPath(substr($path, $pos + 1));
}
}
function testLoad()
{
$mapper1 = new MockMapper($this);
$mapper1->setReturnValue('getIdentityKeyName', 'id');
$mapper2 = new MockMapper($this);//will be used by default
$mapper2->setReturnValue('getIdentityKeyName', 'id');
$mapper = new EntityDataMapper();
$mapper->registerPartMapper('Part1', $mapper1);
$part1 = new EntityPartStub1();
$part1->set('id', 10);
$part2 = new EntityPartStub2();
$part2->set('id', 12);
$entity = new Entity();
$entity->registerPart('Part1', $part1);
$entity->registerPart('Part2', $part2);
$object_mapper = new MockMapper($this);
$this->toolkit->setReturnReference('createDataMapper', $object_mapper, array('ObjectMapper'));
$this->toolkit->setReturnReference('createDataMapper', $mapper1, array('EntityPartStub1Mapper'));
$this->toolkit->setReturnReference('createDataMapper', $mapper2, array('EntityPartStub2Mapper'));
$record = new DataSpace();
$record->set('oid', $oid = 1000);
$object_mapper->expectOnce('load', array($record, $entity));
$mapper1->expectOnce('load', array($record, $part1));
$mapper2->expectOnce('load', array($record, $part2));
$mapper->load($record, $entity);
$this->assertEqual($part1->get('oid'), $oid);
$this->assertEqual($part2->get('oid'), $oid);
$object_mapper->tally();
$mapper1->tally();
$mapper2->tally();
$uow =& $this->toolkit->getUOW();
$this->assertTrue($uow->isExisting($part1));
$this->assertTrue($uow->isExisting($part2));
}
function testFetchById()
{
$id = "10";
$criteria1 = new MockCriteria($this);
$criteria2 = new MockCriteria($this);
$this->dao->addCriteria($criteria1);
$this->dao->addCriteria($criteria2);
$criteria1->expectOnce('process', array(new IsAExpectation('MockComplexSelectSQL')));
$criteria2->expectOnce('process', array(new IsAExpectation('MockComplexSelectSQL')));
$this->sql->expectOnce('addCondition', array('oid=10'));
$this->sql->expectOnce('toString');
$this->sql->setReturnValue('toString', $str = 'SELECT *...');
$this->conn->expectOnce('newStatement', array($str));
$this->conn->setReturnReference('newStatement', $this->stmt, array($str));
$record = new DataSpace();
$record->import($row = array('whatever'));
$this->stmt->expectOnce('getRecordSet');
$this->stmt->setReturnValue('getRecordSet', $rs = new ArrayDataSet(array($row)));
$this->assertEqual($this->dao->fetchById($id), $record);
$criteria1->tally();
$criteria2->tally();
}
function testAdd()
{
$dao = new MockDAO($this);
$mapper = new ProxyTestMapper($this);
$proxy = new ProxyObjectCollection($dao, $mapper, new LimbHandle('Object'));
$raw_array = array(array('id' => 1));
$dao->expectOnce('fetch');
$dao->setReturnValue('fetch', $dataset = new ArrayDataSet($raw_array));
$ds1 = new DataSpace();
$ds1->import($raw_array[0]);
$mapper->expectOnce('load', array($ds1, new Object()));
$added_object = new Object();
$added_object->set('id', 2);
$proxy->add($added_object);
$proxy->rewind();
$fetched_object = new Object();
$fetched_object->set('id', 1);
$this->assertEqual($proxy->current(), $fetched_object);
$proxy->next();
$this->assertEqual($proxy->current(), $added_object);
$proxy->next();
$this->assertFalse($proxy->valid());
$dao->tally();
$mapper->tally();
}
function testLoad()
{
$record = new DataSpace();
$record->import($row = array('whatever'));
$object = new UOWTestObject();
$object->set('id', $id = 100);//we do the mapper's job
$this->toolkit->setReturnReference('createObject', $object, array('UOWTestObject'));
$this->dao->expectOnce('fetchById', array($id));
$this->dao->setReturnValue('fetchById', $record, array($id));
$this->mapper->expectOnce('load', array($record, $object));
$loaded_object =& $this->uow->load('UOWTestObject', $id);
$this->assertTrue($this->uow->isExisting($loaded_object));
$this->assertFalse($this->uow->isNew($loaded_object));
$this->assertEqual($object, $loaded_object);
//cache hit test
$object =& $this->uow->load('UOWTestObject', $id);
$this->assertEqual($object, $loaded_object);
}
function _coachMockUsingArray($array)
{
$mock =& new MockPagedArrayDataSet($this);
$mock->expectCallCount('rewind', 1);
$mock->expectCallCount('next', sizeof($array));
$mock->expectCallCount('valid', sizeof($array) + 1);
for($i=0; $i<sizeof($array); $i++)
{
$mock->setReturnValueAt($i, 'valid', true);
$dataspace = new DataSpace();
$dataspace->import($array[$i]);
$mock->setReturnValueAt($i, 'current', $dataspace);
}
$mock->setReturnValueAt($i, 'valid', false);
return $mock;
}
function &_createUserDataSpaceFromArray($user_data)
{
$result = new DataSpace();
$result->import(array('login' => $user_data[0], 'password' => $user_data[1], 'name' => $user_data[2], 'email' => $user_data[3], 'groups' => explode(',', $user_data[4])));
return $result;
}
