protected function expectRepositoryHydratesNot($identifier)
{
$this->repository->expects($this->once())->method('hydrate')->with($this->equalTo($identifier))->will($this->throwException(\Psc\Doctrine\EntityNotFoundException::criteria(array('identifier' => $identifier))));
}
/**
* Ruft den qbFunction-Hook auf dem QueryBuilder auf und gibt entsprechend ein Result oder den QueryBuilder zurück
*
* der Hook kann unterbrechen, dass das Query direkt ausgeführt wird (return) oder bestimmen in welcher Form das Result zurückgegeben werden soll
*
* die qbFunction kann folgende Strings zurückgeben umn das Verhalten von deliverQuery zu steuern:
* - return: gibt den QueryBuilder zurück
* - result erstellt das Query und gibt das Ergebnis von query::getResult() zurück
* - single erstellt das Query und gibt das Ergebnis von query::getSingleResult() zurück
* - scalar erstellt das Query und gibt das Ergebnis von query::getScalarResult() zurück
*
* die qbFunction erhält nur einen Parameter dies ist der QueryBuilder
* @param string $returnDefault ist qbFunction nicht gesetzt, wird dies als rückgabe Wert genommen (selbes format wie strings oben)
* @return mixed
*/
public function deliverQuery($queryBuilder, $qbFunction, $returnDefault)
{
$qbFunction = $this->compileQBFunction($qbFunction);
$return = $qbFunction($queryBuilder) ?: $returnDefault;
if ($queryBuilder instanceof \Doctrine\ORM\QueryBuilder) {
$query = $queryBuilder->getQuery();
} elseif ($queryBuilder instanceof \Doctrine\ORM\AbstractQuery) {
$query = $queryBuilder;
} else {
throw new \Psc\Exception('Parameter 1 kann nur QueryBuilder oder Query sein.');
}
try {
if ($return === 'return') {
return $queryBuilder;
} elseif ($return === 'result') {
return $query->getResult();
} elseif ($return === 'single') {
return $query->getSingleResult();
} elseif ($return === 'scalar') {
return $query->getScalarResult();
} elseif (mb_strtolower($return) === 'singleornull') {
try {
return $query->getSingleResult();
} catch (\Doctrine\ORM\NoResultException $e) {
return NULL;
}
} else {
return $query->getResult();
}
} catch (\Doctrine\ORM\Query\QueryException $e) {
throw new \Psc\Doctrine\QueryException(sprintf("%s \n\nDQL: '%s'", $e->getMessage(), $query->getDQL()));
} catch (\Doctrine\ORM\NoResultException $e) {
throw \Psc\Doctrine\EntityNotFoundException::fromQuery($query);
} catch (\Doctrine\ORM\NonUniqueResultException $e) {
throw \Psc\Doctrine\EntityNonUniqueResultException::fromQuery($query);
}
}
/**
* Returns the $revision of the entity with the $parentIdentifier
*
* notice that the returned Entity may not have the same identifier as $parentIdentifier
* @return Entity
*/
protected function hydrateEntityInRevision($parentIdentifier, $revision)
{
$parentIdentifier = $this->v->validateIdentifier($parentIdentifier, $this->getEntityMeta());
if ($revision === $this->defaultRevision) {
return $this->repository->hydrate($parentIdentifier);
} else {
throw EntityNotFoundException::criteria(compact('parentIdentifier', 'revision'));
}
}
/**
* Wird der Identifier angegeben schmeisst das Repository eine \Psc\Doctrine\EntityNotFoundException
*
* @return InvocationMockerBuilder
*/
public function expectDoesNotFind($identifier, $matcher = NULL)
{
return $this->buildExpectation('hydrate', $matcher)->with($this->equalTo($identifier))->will($this->throwException(\Psc\Doctrine\EntityNotFoundException::criteria(array('identifier' => $identifier))));
}
