/**
* Initialize doctrine
*
* @return void
*/
protected function initializeDoctrine()
{
$doctrineConfiguration = new \Doctrine\ORM\Configuration();
// Proxy configuration
$doctrineConfiguration->setProxyDir(ROOT . 'Data/Proxies/Doctrine/');
$doctrineConfiguration->setProxyNamespace('LEA\\Proxies');
$doctrineConfiguration->setAutoGenerateProxyClasses(APPLICATION_CONTEXT == 'development');
// Mapping Configuration
//$driverImpl = new Doctrine\ORM\Mapping\Driver\XmlDriver(__DIR__."/config/mappings/xml");
//$driverImpl = new Doctrine\ORM\Mapping\Driver\XmlDriver(__DIR__."/config/mappings/yml");
$driverImpl = $doctrineConfiguration->newDefaultAnnotationDriver(ROOT . 'Application/Domain/Model/');
$doctrineConfiguration->setMetadataDriverImpl($driverImpl);
// Caching Configuration
//if (APPLICATION_CONTEXT == 'development') {
$cache = new \Doctrine\Common\Cache\ArrayCache();
//} else {
// $cache = new \Doctrine\Common\Cache\ApcCache();
//}
$doctrineConfiguration->setMetadataCacheImpl($cache);
$doctrineConfiguration->setQueryCacheImpl($cache);
// database configuration parameters
$conn = array('driver' => $this->configuration['database']['driver'], 'user' => $this->configuration['database']['username'], 'password' => $this->configuration['database']['password'], 'dbname' => $this->configuration['database']['dbname'], 'host' => $this->configuration['database']['host']);
// obtaining the entity manager
$evm = new \Doctrine\Common\EventManager();
$this->entityManager = \Doctrine\ORM\EntityManager::create($conn, $doctrineConfiguration, $evm);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/_files');
$config->setProxyNamespace('DoctrineExtensions\\LargeCollections\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
#$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Article'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Tag'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Comment')));
$article = new Article();
$tag1 = new Tag();
$tag2 = new Tag();
$comment1 = new Comment();
$comment2 = new Comment();
$article->addComment($comment1);
$article->addComment($comment2);
$article->addTag($tag1);
$article->addTag($tag2);
$this->em->persist($article);
$this->em->persist($tag1);
$this->em->persist($tag2);
$this->em->persist($comment1);
$this->em->persist($comment2);
$this->em->flush();
$this->articleId = $article->id();
$this->em->clear();
}
protected static function getEntityManager($options)
{
$config = new \Doctrine\ORM\Configuration();
// Handling for class names specified as platform types.
if ($options['conn']['platform']) {
$class_obj = new \ReflectionClass($options['conn']['platform']);
$options['conn']['platform'] = $class_obj->newInstance();
}
// Special handling for the utf8mb4 type.
if ($options['conn']['driver'] == 'pdo_mysql' && $options['conn']['charset'] == 'utf8mb4') {
$options['conn']['platform'] = new \DF\Doctrine\Platform\MysqlUnicode();
}
$metadata_driver = $config->newDefaultAnnotationDriver($options['modelPath']);
$config->setMetadataDriverImpl($metadata_driver);
$cache = new \DF\Doctrine\Cache();
// $cache->setNamespace('doctrine_');
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir($options['proxyPath']);
$config->setProxyNamespace($options['proxyNamespace']);
if (isset($options['conn']['debug']) && $options['conn']['debug']) {
$config->setSQLLogger(new \DF\Doctrine\Logger\EchoSQL());
}
$config->addFilter('softdelete', '\\DF\\Doctrine\\Filter\\SoftDelete');
$config->addCustomNumericFunction('RAND', '\\DF\\Doctrine\\Functions\\Rand');
$evm = new \Doctrine\Common\EventManager();
$em = \Doctrine\ORM\EntityManager::create($options['conn'], $config, $evm);
$em->getFilters()->enable("softdelete");
// Try the connection before rendering the page.
$em->getConnection()->connect();
return $em;
}
public function init()
{
$bootstrapOptions = $this->getBootstrap()->getOptions();
$options = $this->getOptions();
$memcache = null;
$doctrineConfig = new \Doctrine\ORM\Configuration();
if (!empty($options['options']['metadataCache'])) {
$metaCache = new $options['options']['metadataCache']();
if ($metaCache instanceof \Doctrine\Common\Cache\MemcacheCache) {
$memcache = new Memcache();
$memcache->connect('localhost', 11211);
$metaCache->setMemcache($memcache);
}
$doctrineConfig->setMetadataCacheImpl($metaCache);
}
if (!empty($options['options']['queryCache'])) {
$queryCache = new $options['options']['queryCache']();
if ($queryCache instanceof \Doctrine\Common\Cache\MemcacheCache) {
if (is_null($memcache)) {
$memcache = new Memcache();
$memcache->connect('localhost', 11211);
}
$queryCache->setMemcache($memcache);
}
$doctrineConfig->setQueryCacheImpl($queryCache);
}
$driverImpl = $doctrineConfig->newDefaultAnnotationDriver(array($options['paths']['entities']));
$doctrineConfig->setMetadataDriverImpl($driverImpl);
//$doctrineConfig->setEntityNamespaces(
// $options['entitiesNamespaces']);
$doctrineConfig->setProxyDir($options['paths']['proxies']);
$doctrineConfig->setProxyNamespace($options['options']['proxiesNamespace']);
$this->getBootstrap()->em = \Doctrine\ORM\EntityManager::create($options['connections']['doctrine'], $doctrineConfig);
return $this->getBootstrap()->em;
}
/**
* Creates an EntityManager for testing purposes.
*
* NOTE: The created EntityManager will have its dependant DBAL parts completely
* mocked out using a DriverMock, ConnectionMock, etc. These mocks can then
* be configured in the tests to simulate the DBAL behavior that is desired
* for a particular test,
*
* @return Doctrine\ORM\EntityManager
*/
protected function _getTestEntityManager($conn = null, $conf = null, $eventManager = null, $withSharedMetadata = true)
{
$config = new \Doctrine\ORM\Configuration();
if($withSharedMetadata) {
$config->setMetadataCacheImpl(self::getSharedMetadataCacheImpl());
} else {
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache);
}
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setQueryCacheImpl(self::getSharedQueryCacheImpl());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Doctrine\Tests\Proxies');
$eventManager = new \Doctrine\Common\EventManager();
if ($conn === null) {
$conn = array(
'driverClass' => 'Doctrine\Tests\Mocks\DriverMock',
'wrapperClass' => 'Doctrine\Tests\Mocks\ConnectionMock',
'user' => 'john',
'password' => 'wayne'
);
}
if (is_array($conn)) {
$conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager);
}
return \Doctrine\Tests\Mocks\EntityManagerMock::create($conn, $config, $eventManager);
}
/**
* Initialize Doctrine
* @return Doctrine_Manager
*/
public function _initDoctrine()
{
// include and register Doctrine's class loader
require_once 'Doctrine/Common/ClassLoader.php';
$classLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPLICATION_PATH . '/../library/');
$classLoader->register();
// create the Doctrine configuration
$config = new \Doctrine\ORM\Configuration();
// setting the cache ( to ArrayCache. Take a look at
// the Doctrine manual for different options ! )
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// choosing the driver for our database schema
// we'll use annotations
$driver = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/models');
$config->setMetadataDriverImpl($driver);
// set the proxy dir and set some options
$config->setProxyDir(APPLICATION_PATH . '/models/Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setProxyNamespace('App\\Proxies');
// now create the entity manager and use the connection
// settings we defined in our application.ini
$connectionSettings = $this->getOption('doctrine');
$conn = array('driver' => $connectionSettings['conn']['driv'], 'user' => $connectionSettings['conn']['user'], 'password' => $connectionSettings['conn']['pass'], 'dbname' => $connectionSettings['conn']['dbname'], 'host' => $connectionSettings['conn']['host']);
$entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
// push the entity manager into our registry for later use
$registry = Zend_Registry::getInstance();
$registry->entitymanager = $entityManager;
return $entityManager;
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ApcCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(TESTS_TEMP_DIR);
$config->setProxyNamespace('Gedmo\\Mapping\\Proxy');
$chainDriverImpl = new DriverChain();
$chainDriverImpl->addDriver(new YamlDriver(array(__DIR__ . '/Driver/Yaml')), 'Mapping\\Fixture\\Yaml');
$chainDriverImpl->addDriver($config->newDefaultAnnotationDriver(), 'Tree\\Fixture');
$chainDriverImpl->addDriver($config->newDefaultAnnotationDriver(), 'Gedmo\\Tree');
$config->setMetadataDriverImpl($chainDriverImpl);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$evm = new \Doctrine\Common\EventManager();
$evm->addEventSubscriber(new TreeListener());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config, $evm);
}
private function configure()
{
$connectionParams = $this->getDbConfigs();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($this->entityFolder));
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir($this->entityFolder . DIRECTORY_SEPARATOR . 'proxies');
$config->setProxyNamespace('Proxies');
$this->em = \Doctrine\ORM\EntityManager::create($connectionParams, $config);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/_files');
$config->setProxyNamespace('DoctrineExtensions\\Paginate\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$this->entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
}
protected static function createConfiguration($dsn)
{
$conf = new \Doctrine\ORM\Configuration();
$cache = new $CONFIG['doctrine.cache']();
$conf->setQueryCacheImpl($cache);
$conf->setMetadataCacheImpl($cache);
$conf->setMetadataDriverImpl($conf->newDefaultAnnotationDriver(array(patchworkPath($CONFIG['doctrine.entities.dir']))));
$conf->setProxyDir(patchworkPath($CONFIG['doctrine.proxy.dir']));
$conf->setAutoGenerateProxyClasses($CONFIG['doctrine.proxy.generate']);
$conf->setProxyNamespace($CONFIG['doctrine.proxy.namespace']);
return $conf;
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\Tests\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../Entities'));
$config->setCustomStringFunctions(array('LISTAGG' => 'DoctrineExtensions\\Query\\Oracle\\Listagg'));
$this->entityManager = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
}
/**
* @return EntityManager
*/
protected function createTestEntityManager()
{
$config = new \Doctrine\ORM\Configuration();
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(\sys_get_temp_dir());
$config->setProxyNamespace('SymfonyTests\\Doctrine');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$params = array('driver' => 'pdo_sqlite', 'memory' => true);
return EntityManager::create($params, $config);
}
/**
* Mock factory method to create an EntityManager.
*
* {@inheritdoc}
* @param \Doctrine\DBAL\Connection $conn
*/
public static function create($conn, \Doctrine\ORM\Configuration $config = null, \Doctrine\Common\EventManager $eventManager = null)
{
if (is_null($config)) {
$config = new \Doctrine\ORM\Configuration();
$config->setProxyDir(__DIR__ . '/../Proxies');
$config->setProxyNamespace('Doctrine\\Tests\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(array(), true));
}
if (is_null($eventManager)) {
$eventManager = new \Doctrine\Common\EventManager();
}
return new EntityManagerMock($conn, $config, $eventManager);
}
protected function createEntityManager()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\PHPUnit\\Proxies');
$eventManager = new \Doctrine\Common\EventManager();
$eventManager->addEventListener(array("preTestSetUp", "postTestSetUp"), $this);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
return \Doctrine\ORM\EntityManager::create($conn, $config, $eventManager);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\Tests\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../Entities'));
$config->setCustomStringFunctions(array('STR_TO_DATE' => 'DoctrineExtensions\\Query\\Postgresql\\StrToDate', 'COUNT_FILTER' => 'DoctrineExtensions\\Query\\Postgresql\\CountFilterFunction'));
$config->setCustomDateTimeFunctions(array('DATE_FORMAT' => 'DoctrineExtensions\\Query\\Postgresql\\DateFormat', 'AT_TIME_ZONE' => 'DoctrineExtensions\\Query\\Postgresql\\AtTimeZoneFunction'));
$this->entityManager = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
}
public function setUp()
{
if (!class_exists('Doctrine\\ORM\\EntityManager')) {
$this->markTestSkipped('Doctrine ORM is not available');
}
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/_files');
$config->setProxyNamespace('Pagerfanta\\Tests\\Adapter\\DoctrineORM\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$this->entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\Tests\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../Entities'));
$config->setCustomDatetimeFunctions(array('DATEADD' => 'DoctrineExtensions\\Query\\Mysql\\DateAdd', 'DATEDIFF' => 'DoctrineExtensions\\Query\\Mysql\\DateDiff', 'DATESUB' => 'DoctrineExtensions\\Query\\Mysql\\DateSub', 'FROM_UNIXTIME' => 'DoctrineExtensions\\Query\\Mysql\\FromUnixtime', 'UNIX_TIMESTAMP' => 'DoctrineExtensions\\Query\\Mysql\\UnixTimestamp'));
$config->setCustomNumericFunctions(array('ACOS' => 'DoctrineExtensions\\Query\\Mysql\\Acos', 'ASIN' => 'DoctrineExtensions\\Query\\Mysql\\Asin', 'ATAN' => 'DoctrineExtensions\\Query\\Mysql\\Atan', 'ATAN2' => 'DoctrineExtensions\\Query\\Mysql\\Atan2', 'COS' => 'DoctrineExtensions\\Query\\Mysql\\Cos', 'COT' => 'DoctrineExtensions\\Query\\Mysql\\Cot', 'DEGREES' => 'DoctrineExtensions\\Query\\Mysql\\Degrees', 'RADIANS' => 'DoctrineExtensions\\Query\\Mysql\\Radians', 'SIN' => 'DoctrineExtensions\\Query\\Mysql\\Sin', 'TAN' => 'DoctrineExtensions\\Query\\Mysql\\Tan'));
$config->setCustomStringFunctions(array('ASCII' => 'DoctrineExtensions\\Query\\Mysql\\Ascii', 'CHAR_LENGTH' => 'DoctrineExtensions\\Query\\Mysql\\CharLength', 'CONCAT_WS' => 'DoctrineExtensions\\Query\\Mysql\\ConcatWs', 'FIELD' => 'DoctrineExtensions\\Query\\Mysql\\Field', 'FIND_IN_SET' => 'DoctrineExtensions\\Query\\Mysql\\FindInSet', 'LEAST' => 'DoctrineExtensions\\Query\\Mysql\\Least', 'REPLACE' => 'DoctrineExtensions\\Query\\Mysql\\Replace', 'SOUNDEX' => 'DoctrineExtensions\\Query\\Mysql\\Soundex', 'STR_TO_DATE' => 'DoctrineExtensions\\Query\\Mysql\\StrToDate', 'SUBSTRING_INDEX' => 'DoctrineExtensions\\Query\\Mysql\\SubstringIndex'));
$this->entityManager = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
}
protected function createEntityManager($conn)
{
$config = new \Doctrine\ORM\Configuration();
$config->setProxyDir(__DIR__ . '/../../../Proxies');
$config->setProxyNamespace('MyProject\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$annotDriver = $config->newDefaultAnnotationDriver(array(__DIR__ . '/../../../Models/'));
$config->setMetadataDriverImpl($annotDriver);
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$em = \Doctrine\ORM\EntityManager::create($conn, $config);
return $em;
}
static function initializeTestEntityManager($app, $applicationMode = "development")
{
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl($cache);
//Load this paths from config file
$driverImpl = $config->newDefaultAnnotationDriver(EntityManagerFactory::prepareEntityFoldersPaths($app));
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
$config->setProxyDir(rtrim($app['rootFolderPath']) . DIRECTORY_SEPARATOR . "temp" . DIRECTORY_SEPARATOR);
$config->setProxyNamespace('FCMS2\\DoctrineProxy');
$config->setAutoGenerateProxyClasses(true);
$em = EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => 'true'), $config);
return $em;
}
public static function createEntityManager()
{
$config = new Doctrine\ORM\Configuration();
// annotations
$annotationDriver = $config->newDefaultAnnotationDriver(APP_DIR . '/models');
$config->setMetadataDriverImpl($annotationDriver);
$config->setProxyNamespace('GriditoExample\\Doctrine\\Proxy');
$config->setProxyDir(TEMP_DIR . '/cache');
// cache
$cache = new Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// entity manager
return Doctrine\ORM\EntityManager::create(array("driver" => "pdo_sqlite", "path" => APP_DIR . "/models/users.s3db"), $config);
}
protected function setUp()
{
if (!class_exists('\\Doctrine\\ORM\\Configuration')) {
$this->markTestSkipped('Doctrine is not available');
}
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Intaro\\HStore\\Tests\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/Entities'));
$config->addEntityNamespace('E', 'Intaro\\HStore\\Tests\\Doctrine\\Entities');
$config->setCustomStringFunctions(array('contains' => 'Intaro\\HStore\\Doctrine\\Query\\ContainsFunction', 'defined' => 'Intaro\\HStore\\Doctrine\\Query\\DefinedFunction', 'existsAny' => 'Intaro\\HStore\\Doctrine\\Query\\ExistsAnyFunction', 'fetchval' => 'Intaro\\HStore\\Doctrine\\Query\\FetchvalFunction', 'hstoreDifference' => 'Intaro\\HStore\\Doctrine\\Query\\HstoreDifferenceFunction'));
$this->entityManager = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('DoctrineExtensions\\Tests\\PHPUnit\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/../../Entities'));
$this->em = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
$schemaTool = new SchemaTool($this->em);
$schemaTool->dropDatabase();
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\Tests\\Entities\\ZendDate')));
$this->em->persist(new \DoctrineExtensions\Tests\Entities\ZendDate(1, new \Zend_Date(array('year' => 2012, 'month' => 11, 'day' => 10, 'hour' => 9, 'minute' => 8, 'second' => 7))));
$this->em->flush();
}
/**
* @return EntityManager
*/
public function createEntityManager()
{
$appConfig = $this->getConfig();
$paths = array(DIR . $appConfig['main']['entities']);
$cache = new \Doctrine\Common\Cache\FilesystemCache(DIR . '/tmp/Cache');
$config = new \Doctrine\ORM\Configuration();
$config->setProxyDir(DIR . '/tmp');
$config->setProxyNamespace('Mev\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$driverImpl = $config->newDefaultAnnotationDriver($paths, false);
$config->setMetadataDriverImpl($driverImpl);
$config->setMetadataCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setQueryCacheImpl($cache);
return EntityManager::create($appConfig['database'], $config);
}
public function __construct()
{
// include our CodeIgniter application's database configuration
require APPPATH . 'config/database.php';
// include Doctrine's fancy ClassLoader class
require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php';
// load the Doctrine classes
$doctrineClassLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPPATH . 'libraries');
$doctrineClassLoader->register();
// load Symfony2 helpers
// Don't be alarmed, this is necessary for YAML mapping files
$symfonyClassLoader = new \Doctrine\Common\ClassLoader('Symfony', APPPATH . 'libraries/Doctrine');
$symfonyClassLoader->register();
// load the entities
$entityClassLoader = new \Doctrine\Common\ClassLoader('Entities', APPPATH . 'models');
$entityClassLoader->register();
// load the proxy entities
$proxyClassLoader = new \Doctrine\Common\ClassLoader('Proxies', APPPATH . 'models');
$proxyClassLoader->register();
// set up the configuration
$config = new \Doctrine\ORM\Configuration();
if (ENVIRONMENT == 'development') {
// set up simple array caching for development mode
$cache = new \Doctrine\Common\Cache\ArrayCache();
} else {
// set up caching with APC for production mode
$cache = new \Doctrine\Common\Cache\ApcCache();
}
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// set up proxy configuration
$config->setProxyDir(APPPATH . 'models/Proxies');
$config->setProxyNamespace('Proxies');
// auto-generate proxy classes if we are in development mode
$config->setAutoGenerateProxyClasses(ENVIRONMENT == 'development');
// set up annotation driver
// $yamlDriver = new \Doctrine\ORM\Mapping\Driver\YamlDriver(APPPATH.'models/Mappings');
// $config->setMetadataDriverImpl($yamlDriver);
$driverImpl = $config->newDefaultAnnotationDriver(APPPATH . 'models');
$config->setMetadataDriverImpl($driverImpl);
// Database connection information
$connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
// create the EntityManager
$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);
// store it as a member, for use in our CodeIgniter controllers.
$this->em = $em;
}
/**
* Creates an EntityManager for testing purposes.
*
* @return \Admingenerator\GeneratorBundle\Tests\Mocks\Doctrine\EntityManagerMock
*/
protected function _getTestEntityManager($conn = null, $conf = null, $eventManager = null)
{
$metadataCache = new \Doctrine\Common\Cache\ArrayCache();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl($metadataCache);
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Doctrine\\Tests\\Proxies');
if ($conn === null) {
$conn = array('driverClass' => '\\Admingenerator\\GeneratorBundle\\Tests\\Mocks\\Doctrine\\DriverMock', 'wrapperClass' => '\\Admingenerator\\GeneratorBundle\\Tests\\Mocks\\Doctrine\\ConnectionMock', 'user' => 'john', 'password' => 'wayne');
}
if (is_array($conn)) {
$conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager);
}
return \Admingenerator\GeneratorBundle\Tests\Mocks\Doctrine\EntityManagerMock::create($conn, $config, $eventManager);
}
private function initDoctrine()
{
$this->modelPath = APPLICATION_PATH . '/configs/models';
$classLoader = new \Doctrine\Common\ClassLoader('Entities', $this->modelPath);
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Symfony', BASE_PATH . '/library/Doctrine');
$classLoader->register();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$driverImpl = $config->newDefaultAnnotationDriver($this->modelPath);
$config->setMetadataDriverImpl($driverImpl);
$config->setProxyDir(BASE_PATH . '/library/Orm/Proxies');
$config->setProxyNamespace('\\Orm\\Proxies');
$em = \Doctrine\ORM\EntityManager::create($this->connectionOptions, $config);
$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array('db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()), 'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)));
$this->entityManager = $em;
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir($GLOBALS['doctrine2-proxies-path']);
$config->setProxyNamespace($GLOBALS['doctrine2-proxies-namespace']);
$config->setAutoGenerateProxyClasses(true);
$driver = $config->newDefaultAnnotationDriver($GLOBALS['doctrine2-entities-path']);
$config->setMetadataDriverImpl($driver);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$config->addCustomNumericFunction('DATEDIFF', 'DoctrineExtensions\\Query\\Mysql\\DateDiff');
$config->addCustomDatetimeFunction('DATE_ADD', 'DoctrineExtensions\\Query\\Mysql\\DateAdd');
$config->addCustomStringFunction('STR_TO_DATE', 'DoctrineExtensions\\Query\\MySql\\StrToDate');
$config->addCustomStringFunction('FIND_IN_SET', 'DoctrineExtensions\\Query\\MySql\\FindInSet');
$this->entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
}
public static function getConn()
{
$conn = array('driverClass' => 'Doctrine\\DBAL\\Driver\\PDOMySql\\Driver', 'host' => 'localhost', 'user' => 'root', 'password' => '123', 'dbname' => 'imobiliaria');
// $conn = array(
// 'driverClass' => 'Doctrine\DBAL\Driver\PDOMySql\Driver',
// //'wrapperClass' => 'Doctrine\Tests\Mocks\ConnectionMock',
// 'host' => 'mysql.grupo-gpa.com',
// 'user' => 'grupogpa01',
// 'password' => 'j6k9r8p9',
// 'dbname' => 'grupogpa01',
// );
$config = new \Doctrine\ORM\Configuration();
$config->setProxyDir(__DIR__ . '/../Entities/Proxies');
$config->setProxyNamespace('MyClasses\\Entities\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(array(), true));
$eventManager = new \Doctrine\Common\EventManager();
return EntityManager::create($conn, $config, $eventManager);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/Proxy');
$config->setProxyNamespace('DoctrineExtensions\\Taggable\\Proxies');
$driverImpl = new \Doctrine\ORM\Mapping\Driver\DriverChain();
$driverImpl->addDriver(new \Doctrine\ORM\Mapping\Driver\XmlDriver(__DIR__ . '/../../../../metadata'), 'DoctrineExtensions\\Taggable\\Entity');
$driverImpl->addDriver($config->newDefaultAnnotationDriver(), 'Tests\\DoctrineExtensions\\Taggable\\Fixtures');
$config->setMetadataDriverImpl($driverImpl);
$this->em = \Doctrine\ORM\EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->dropSchema(array());
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\Taggable\\Entity\\Tag'), $this->em->getClassMetadata('DoctrineExtensions\\Taggable\\Entity\\Tagging'), $this->em->getClassMetadata('Tests\\DoctrineExtensions\\Taggable\\Fixtures\\Article')));
$this->manager = new TagManager($this->em);
$this->em->getEventManager()->addEventSubscriber(new TagListener($this->manager));
}
/**
* Setup system, not included in benchmark.
*/
public function setUp()
{
require_once $this->rootPath . "/lib/Doctrine/ORM/Version.php";
if (version_compare(\Doctrine\ORM\Version::VERSION, '2.3.99') > 0) {
require_once $this->rootPath . "/vendor/autoload.php";
$config = \Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/Orm"));
} else {
if (version_compare(\Doctrine\ORM\Version::VERSION, '2.2.99') > 0) {
require_once $this->rootPath . "/lib/Doctrine/ORM/Tools/Setup.php";
\Doctrine\ORM\Tools\Setup::registerAutoloadGit($this->rootPath);
$config = \Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/Orm"));
} else {
require_once $this->rootPath . "/lib/vendor/doctrine-common/lib/Doctrine/Common/ClassLoader.php";
$loader = new \Doctrine\Common\ClassLoader("Doctrine\\ORM", $this->rootPath . "/lib/");
$loader->register();
$loader = new \Doctrine\Common\ClassLoader("Doctrine\\DBAL", $this->rootPath . "/lib/vendor/doctrine-dbal/lib");
$loader->register();
$loader = new \Doctrine\Common\ClassLoader("Doctrine\\Common", $this->rootPath . "/lib/vendor/doctrine-common/lib");
$loader->register();
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . "/Orm"));
}
}
$cache = new \Doctrine\Common\Cache\ArrayCache();
$this->queryCount = new DbalQueryCountLogger();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// not sql query cache, but dql query parsing cache.
$config->setProxyDir(__DIR__ . "/proxies");
$config->setProxyNamespace('Proxies');
$config->setAutoGenerateProxyClasses(false);
$config->setSQLLogger($this->queryCount);
$dbParams = array('driver' => 'pdo_sqlite', 'memory' => true);
$this->em = \Doctrine\ORM\EntityManager::create($dbParams, $config);
$classes = $this->em->getMetadataFactory()->getAllMetadata();
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
try {
$schemaTool->dropSchema($classes);
} catch (Exception $e) {
echo $e->getMessage();
}
$schemaTool->createSchema($classes);
$this->em->getProxyFactory()->generateProxyClasses($classes, __DIR__ . '/proxies');
}
