RepositoryTestHelper.php

<?php

namespace Webfactory\Bundle\PagesBundle\Tests;

use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\SchemaTool;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\ObjectRepository;

/**
 * Hilfsklasse, die für Tests einen Doctrine ORM ObjectManager erzeugen kann,
 * der im Hintergrund eine in-memory sqlite-Datenbank hat.
 *
 * Das Datenbankschema für die benötigten Entitäten wird in dieser Datenbank
 * automatisch erzeugt.
 *
 * Eine praktische Verwendung ist beispielsweise der Test von eigenen Repositories,
 * weil dann deren Methoden echt gegen eine Datenbank ausgeführt werden können.
 */
class RepositoryTestHelper
{

    protected $dbParams = array(
        'driver'   => 'pdo_sqlite',
        'user'     => 'root',
        'password' => '',
        'dbname'   => 'foo',
    );

    protected $paths;

    protected $entityClasses;

    /**
     * @param array $paths Liste von Pfaden, in denen die Entitätsklassen gesucht werden
     * @param array $entityClasses Die vollqualifizierten Namen der Entitäten, die unterstützt werden sollen. Default null = alle Klassen.
     */
    public function __construct(array $paths, array $entityClasses = null)
    {
        $this->paths = $paths;
        $this->entityClasses = $entityClasses;
    }

    /**
     * Gibt das Repository für eine Entitätsklasse zurück.
     *
     * @param $forClassName Name der Entitäts-Klasse, für die das Repository gesucht wird
     * @return ObjectRepository
     */
    public function getRepository($forClassName)
    {
        $em = $this->getObjectManager();
        return $em->getRepository($forClassName);
    }

    /**
     * Gibt den Doctrine ORM ObjectManager (Interface des EntityManager) zurück.
     * @return ObjectManager
     */
    public function getObjectManager()
    {
        $isDevMode = true;

        // the connection configuration
        $config = Setup::createAnnotationMetadataConfiguration($this->paths, $isDevMode, null, null, false);
        $objectManager = EntityManager::create($this->dbParams, $config);

        $this->createSchemaForSupportedEntities($objectManager);

        return $objectManager;
    }

    protected function createSchemaForSupportedEntities(EntityManager $em)
    {
        $metadatas = $this->getMetadatasForSupportedEntities($em->getMetadataFactory());

        $schemaTool = new SchemaTool($em);
        $schemaTool->createSchema($metadatas);
    }

    protected function getMetadatasForSupportedEntities(ClassMetadataFactory $metadataFactory)
    {
        if ($this->entityClasses) {
            $metadatas = array();

            foreach ($this->entityClasses as $class) {
                $metadatas[] = $metadataFactory->getMetadataFor($class);
            }
        } else {
            $metadatas = $metadataFactory->getAllMetadata();
        }

        return $metadatas;
    }
}

Gefällt mir gut.
Die Angabe der Pfade könnte man sich sparen und stattdessen per Reflection ermitteln, wo die Entities liegen.