public function testSetGetEntityNamespace() { $this->configuration->addEntityNamespace('TestNamespace', __NAMESPACE__); $this->assertSame(__NAMESPACE__, $this->configuration->getEntityNamespace('TestNamespace')); $namespaces = array('OtherNamespace' => __NAMESPACE__); $this->configuration->setEntityNamespaces($namespaces); $this->assertSame($namespaces, $this->configuration->getEntityNamespaces()); $this->setExpectedException('Doctrine\\ORM\\ORMException'); $this->configuration->getEntityNamespace('NonExistingNamespace'); }
/** * @return array */ protected function prepareMocks() { $configuration = new Configuration(); $configuration->addEntityNamespace('Stub', 'Oro\\Bundle\\BatchBundle\\Tests\\Unit\\ORM\\Query\\Stub'); $classMetadata = new ClassMetadata('Entity'); $classMetadata->mapField(['fieldName' => 'a', 'columnName' => 'a']); $classMetadata->mapField(['fieldName' => 'b', 'columnName' => 'b']); $classMetadata->setIdentifier(['a']); $platform = $this->getMockBuilder('Doctrine\\DBAL\\Platforms\\AbstractPlatform')->setMethods([])->disableOriginalConstructor()->getMockForAbstractClass(); $statement = $this->getMockBuilder('Doctrine\\DBAL\\Statement')->setMethods(['fetch', 'fetchColumn', 'closeCursor'])->disableOriginalConstructor()->getMock(); $driverConnection = $this->getMockBuilder('Doctrine\\DBAL\\Driver\\Connection')->setMethods(['query'])->disableOriginalConstructor()->getMockForAbstractClass(); $driverConnection->expects($this->any())->method('query')->will($this->returnValue($statement)); $driver = $this->getMockBuilder('Doctrine\\DBAL\\Driver')->setMethods(['connect', 'getDatabasePlatform'])->disableOriginalConstructor()->getMockForAbstractClass(); $driver->expects($this->any())->method('connect')->will($this->returnValue($driverConnection)); $driver->expects($this->any())->method('getDatabasePlatform')->will($this->returnValue($platform)); $connection = $this->getMockBuilder('Doctrine\\DBAL\\Connection')->setMethods(['getDatabasePlatform', 'executeQuery'])->setConstructorArgs([[], $driver])->getMock(); $connection->expects($this->any())->method('getDatabasePlatform')->will($this->returnValue($platform)); /** @var UnitOfWork $unitOfWork */ $unitOfWork = $this->getMockBuilder('UnitOfWork')->setMethods(['getEntityPersister'])->disableOriginalConstructor()->getMock(); $entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->setMethods(['getConfiguration', 'getClassMetadata', 'getConnection', 'getUnitOfWork'])->disableOriginalConstructor()->getMock(); $entityManager->expects($this->any())->method('getConfiguration')->will($this->returnValue($configuration)); $entityManager->expects($this->any())->method('getClassMetadata')->will($this->returnValue($classMetadata)); $entityManager->expects($this->any())->method('getConnection')->will($this->returnValue($connection)); $entityManager->expects($this->any())->method('getUnitOfWork')->will($this->returnValue($unitOfWork)); return [$entityManager, $connection, $statement]; }
protected function setUp() { if (!class_exists('\\Doctrine\\ORM\\Configuration')) { $this->markTestSkipped('Doctrine is not available'); } $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setQueryCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Boldtrn\\JsonbBundle\\Tests\\Proxies'); $config->setAutoGenerateProxyClasses(true); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/Entities')); $config->addEntityNamespace('E', 'Boldtrn\\JsonbBundle\\Tests\\Entities'); $config->setCustomStringFunctions(array('JSONB_AG' => 'Boldtrn\\JsonbBundle\\Query\\JsonbAtGreater', 'JSONB_HGG' => 'Boldtrn\\JsonbBundle\\Query\\JsonbHashGreaterGreater', 'JSONB_EX' => 'Boldtrn\\JsonbBundle\\Query\\JsonbExistence')); $dbParams = array('driver' => 'pdo_pgsql', 'host' => 'localhost', 'port' => '5432', 'dbname' => 'jsonb_test', 'user' => 'postgres', 'password' => 'secret'); $this->entityManager = \Doctrine\ORM\EntityManager::create($dbParams, $config); }
protected function setUp() { if (!class_exists('\\Doctrine\\ORM\\Configuration')) { static::markTestSkipped('Doctrine is not available'); } $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setQueryCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Boldtrn\\JsonbBundle\\Tests\\Proxies'); $config->setAutoGenerateProxyClasses(true); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(__DIR__ . '/Entities')); $config->addEntityNamespace('E', 'Boldtrn\\JsonbBundle\\Tests\\Entities'); $config->setCustomStringFunctions(array('JSONB_AG' => 'Boldtrn\\JsonbBundle\\Query\\JsonbAtGreater', 'JSONB_HGG' => 'Boldtrn\\JsonbBundle\\Query\\JsonbHashGreaterGreater', 'JSONB_EX' => 'Boldtrn\\JsonbBundle\\Query\\JsonbExistence')); $this->entityManager = EntityManager::create($this->dbParams, $config); $this->connection = $this->entityManager->getConnection(); $this->setUpDBALTypes(); $tool = new SchemaTool($this->entityManager); $classes = $this->entityManager->getMetaDataFactory()->getAllMetaData(); // Drop all classes and re-build them for each test case $tool->dropSchema($classes); $tool->createSchema($classes); }
public function setUp() { parent::setUp(); //if (!in_array('sqlite', \PDO::getAvailableDrivers())) { if (!extension_loaded('pdo_sqlite')) { $this->markTestSkipped('This test requires the PHP extension "pdo_sqlite".'); } // this is the same as AnnotationRegistry::registerFile() require_once VENDOR_PATH . 'doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'; // setup Annotation Driver $driver = new AnnotationDriver(new AnnotationReader(), [__DIR__ . '/../../../tests/KochTest/Fixtures/Doctrine/Entity']); $config = new Configuration(); $config->setMetadataDriverImpl($driver); $config->addEntityNamespace('KochTest', 'KochTest\\Fixtures\\Doctrine\\Entity'); $config->setQueryCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/../../../tests/KochTest/Fixtures/Doctrine/Entity'); $config->setProxyNamespace('/KochTest/Fixtures/Doctrine/Entity'); $connectionParams = ['driver' => 'pdo_sqlite', 'memory' => true]; $em = EntityManager::create($connectionParams, $config); $tool = new SchemaTool($em); $tool->createSchema($em->getMetadataFactory()->getAllMetadata()); $this->entityManager = $em; }
private static function createEm(Connection $conn) { $config = new Configuration(); $config->setProxyDir($proxyDir = sys_get_temp_dir() . '/PhpAnalyzerProxies/' . uniqid('em', true)); if (!is_dir($proxyDir) && false === @mkdir($proxyDir, 0777, true)) { throw new \RuntimeException(sprintf('Could not create proxy directory "%s" for test entity manager.', $proxyDir)); } $config->setProxyNamespace('Scrutinizer\\PhpAnalyzer\\Model\\Proxies'); if (false === Type::hasType(PhpTypeType::NAME)) { Type::addType(PhpTypeType::NAME, 'Scrutinizer\\PhpAnalyzer\\Model\\Type\\PhpTypeType'); } if (false === Type::hasType('string_case')) { Type::addType('string_case', 'Scrutinizer\\PhpAnalyzer\\Model\\Type\\CaseSensitiveStringType'); } if (false === Type::hasType('string_nocase')) { Type::addType('string_nocase', 'Scrutinizer\\PhpAnalyzer\\Model\\Type\\CaseInsensitiveStringType'); } $driver = new AnnotationDriver(new AnnotationReader(), array(__DIR__ . '/../Model')); $config->setMetadataDriverImpl($driver); $config->addEntityNamespace('PhpAnalyzer', 'Scrutinizer\\PhpAnalyzer\\Model'); $em = EntityManager::create($conn, $config); $em->getEventManager()->addEventListener(array('prePersist'), new TestUuidListener()); return $em; }
public function register(Application $app) { $app['EM.sql-logger.file'] = $app->share(function (Application $app) { return $app['log.path'] . '/doctrine-log.log'; }); $app['EM.sql-logger.max-files'] = 5; $app['EM.sql-logger'] = $app->share(function (Application $app) { $logger = new $app['monolog.logger.class']('doctrine-logger'); $logger->pushHandler(new RotatingFileHandler($app['EM.sql-logger.file'], $app['EM.sql-logger.max-files'])); return new MonologSQLLogger($logger, 'yaml'); }); $app['EM.driver'] = $app->share(function (Application $app) { AnnotationRegistry::registerFile($app['root.path'] . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $annotationReader = new AnnotationReader(); $fileCacheReader = new FileCacheReader($annotationReader, $app['cache.path'] . '/doctrine', $app['debug']); $driverChain = new MappingDriverChain(); DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $fileCacheReader); $annotationDriver = new AnnotationDriver($annotationReader, [$app['root.path'] . '/lib/Alchemy/Phrasea/Model/Entities']); $driverChain->addDriver($annotationDriver, 'Alchemy\\Phrasea\\Model\\Entities'); return $driverChain; }); $app['EM.config'] = $app->share(function (Application $app) { $config = new ORMConfiguration(); if ($app->getEnvironment() === PhraseaApplication::ENV_DEV) { $config->setSQLLogger($app['EM.sql-logger']); } $config->setMetadataCacheImpl($app['phraseanet.cache-service']->factory('ORMmetadata', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options'])); $config->setQueryCacheImpl($app['phraseanet.cache-service']->factory('ORMquery', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options'])); $config->setResultCacheImpl($app['phraseanet.cache-service']->factory('ORMresult', $app['EM.cache-type'], $app['EM.cache-options'])); $config->setAutoGenerateProxyClasses($app['debug']); $config->setMetadataDriverImpl($app['EM.driver']); $config->setProxyDir($app['root.path'] . '/resources/proxies'); $config->setProxyNamespace('Alchemy\\Phrasea\\Model\\Proxies'); $config->setAutoGenerateProxyClasses($app['debug']); $config->addEntityNamespace('Phraseanet', 'Alchemy\\Phrasea\\Model\\Entities'); return $config; }); $app['EM.opcode-cache-type'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'opcodecache', 'type']); } return 'ArrayCache'; }); $app['EM.opcode-cache-options'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'opcodecache', 'options']); } return []; }); $app['EM.cache-type'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'cache', 'type']); } return 'ArrayCache'; }); $app['EM.cache-options'] = $app->share(function (Application $app) { if ($app['configuration.store']->isSetup()) { return $app['conf']->get(['main', 'cache', 'options']); } return []; }); $app['EM.events-manager'] = $app->share(function (Application $app) { $evm = new EventManager(); $evm->addEventSubscriber(new TimestampableListener()); return $evm; }); $app['EM.dbal-conf'] = $app->share(function (Application $app) { if ('test' === $app->getEnvironment()) { return $app['conf']->get(['main', 'database-test']); } return $app['conf']->get(['main', 'database']); }); $app['dbal.provider'] = $app->share(function (Application $app) { return new ConnectionProvider($app['EM.config'], $app['EM.events-manager'], isset($app['task-manager.logger']) ? $app['task-manager.logger'] : $app['monolog']); }); $app['EM'] = $app->share(function (Application $app) { try { $em = EntityManager::create($app['EM.dbal-conf'], $app['EM.config'], $app['EM.events-manager']); } catch (\Exception $e) { throw new RuntimeException("Unable to create database connection", $e->getCode(), $e); } $platform = $em->getConnection()->getDatabasePlatform(); $types = ['blob' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'enum' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'longblob' => 'Alchemy\\Phrasea\\Model\\Types\\LongBlob', 'varbinary' => 'Alchemy\\Phrasea\\Model\\Types\\VarBinary', 'binary' => 'Alchemy\\Phrasea\\Model\\Types\\Binary', 'binary_string' => 'Alchemy\\Phrasea\\Model\\Types\\BinaryString']; foreach ($types as $type => $class) { if (!Type::hasType($type)) { Type::addType($type, $class); } $platform->registerDoctrineTypeMapping($type, $type); } return $em; }); $app['EM.native-query'] = $app->share(function ($app) { return new NativeQueryProvider($app['EM']); }); }
/** * @return MetaInformationFactory */ private function setupMetaInformationFactory() { $ormConfiguration = new Configuration(); $ormConfiguration->addEntityNamespace('FSTest:ValidTestEntity', 'FS\\SolrBundle\\Tests\\Doctrine\\Mapper'); $ormConfiguration->addEntityNamespace('FSTest:EntityCore0', 'FS\\SolrBundle\\Tests\\Doctrine\\Mapper'); $ormConfiguration->addEntityNamespace('FSTest:EntityCore1', 'FS\\SolrBundle\\Tests\\Doctrine\\Mapper'); $knowNamespaces = new KnownNamespaceAliases(); $knowNamespaces->addEntityNamespaces($ormConfiguration); $classnameResolver = new ClassnameResolver($knowNamespaces); $reader = new AnnotationReader(new \Doctrine\Common\Annotations\AnnotationReader()); $metaFactory = new MetaInformationFactory($reader); $metaFactory->setClassnameResolver($classnameResolver); return $metaFactory; }
/** * @param array $settings * @param Configuration $configuration */ protected function setCustomMappingDriverChain(array $settings = [], Configuration $configuration) { $chain = new MappingDriverChain($configuration->getMetadataDriverImpl(), 'LaravelDoctrine'); foreach (array_get($settings, 'namespaces', []) as $alias => $namespace) { if (is_string($alias)) { $configuration->addEntityNamespace($alias, $namespace); } $chain->addNamespace($namespace); } $configuration->setMetadataDriverImpl($chain); }
} $cnf = PROJECT_DIRECTORY . '/config/namespaces.yml'; $temp = $yaml->parse(file_get_contents($cnf)); $namespaces = array(); if ($temp === null) { throw new \Exception("Your namspaces config file " . $cnf . " is not properly configured."); } foreach ($temp as $namespace => $data) { $namespaces[PROJECT_DIRECTORY . '/' . $data["path"]] = $namespace; } $temp = $yaml->parse(file_get_contents(PROJECT_DIRECTORY . '/app/config/parameters.yml')); $cnf = $temp["parameters"]; $connectionOptions = array('driver' => $cnf["database_driver"], 'host' => $cnf["database_host"], 'password' => $cnf["database_password"], 'dbname' => $cnf["database_name"], 'user' => $cnf["database_user"], 'port' => $cnf["database_port"]); $config = new Configuration(); $config->setMetadataDriverImpl(new SimplifiedYamlDriver($namespaces)); $config->setAutoGenerateProxyClasses(true); $config->setProxyDir(PROJECT_DIRECTORY . '/config/doctrine/orm/Proxies'); $config->setProxyNamespace('Proxies'); foreach ($namespaces as $key => $namespace) { $alias = $namespace; $alias = preg_replace('/\\W/', '', $alias); $alias = preg_replace('/Entity$/', '', $alias); $config->addEntityNamespace($alias, $namespace); } $em = EntityManager::create($connectionOptions, $config); if (array_key_exists('mapping_types', $dbcnf)) { foreach ($dbcnf['mapping_types'] as $key => $value) { $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($key, $value); } } $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)));
public function register(Container $c) { parent::register($c); $c['orm.options'] = array(); $c['orm.types'] = array(); $c['orm.proxies_dir'] = sys_get_temp_dir(); $c['orm.proxies_namespace'] = 'DoctrineProxy'; $c['orm.auto_generate_proxies'] = $c->factory(function ($c) { return $c['debug']; }); $c['orm.custom.functions.string'] = array(); $c['orm.custom.functions.numeric'] = array(); $c['orm.custom.functions.datetime'] = array(); $c['orm.custom.hydration_modes'] = array(); $c['orm.class_metadata_factory_name'] = 'Doctrine\\ORM\\Mapping\\ClassMetadataFactory'; $c['orm.default_repository_class'] = 'Doctrine\\ORM\\EntityRepository'; $c['orm.initialize'] = $c->protect(function () use($c) { static $initialized = false; if ($initialized) { return; } $initialized = true; if (!isset($c['orm.options'])) { $c['orm.options'] = array('default' => array()); } elseif (!is_array(reset($c['orm.options']))) { // Se o primeiro elemento do array de opções não for um array, // muito provavelmente o usuário está colocando as options de // uma única conexão, então usar como default $c['orm.options'] = array('default' => $c['orm.options']); } $tmp = $c['orm.options']; foreach ($tmp as $name => &$options) { if (!isset($options['connection'])) { throw new \LogicException("Missing 'connection' param in Doctrine ORM in {$name}."); } if (is_string($options['connection'])) { $options['connection'] = $c['dbal.options'][$options['connection']]; } elseif (!is_array($options['connection']) && !$options['connection'] instanceof Connection) { throw new \LogicException("Param 'connection' in {$name} must be a string, array or a Connection instance."); } } $c['orm.options'] = $tmp; $c['orm.defaultName'] = key($c['orm.options']); }); $c['orm.ems'] = function ($c) { $c['orm.initialize'](); $ems = new Container(); foreach ($c['orm.options'] as $name => $options) { $config = $c['orm.configs'][$name]; $connection = $options['connection']; $ems[$name] = function ($ems) use($connection, $config) { return EntityManager::create($connection, $config); }; } return $ems; }; $c['orm.configs'] = function ($c) { $c['orm.initialize'](); $configs = new Container(); foreach ($c['orm.options'] as $name => $options) { $configs[$name] = $config = new Configuration(); $config->setProxyDir($c['orm.proxies_dir']); $config->setProxyNamespace($c['orm.proxies_namespace']); $config->setAutoGenerateProxyClasses($c['orm.auto_generate_proxies']); $config->setCustomStringFunctions($c['orm.custom.functions.string']); $config->setCustomNumericFunctions($c['orm.custom.functions.numeric']); $config->setCustomDatetimeFunctions($c['orm.custom.functions.datetime']); $config->setCustomHydrationModes($c['orm.custom.hydration_modes']); $config->setClassMetadataFactoryName($c['orm.class_metadata_factory_name']); $config->setDefaultRepositoryClassName($c['orm.default_repository_class']); $config->setEntityListenerResolver($c['orm.entity_listener_resolver']); $config->setRepositoryFactory($c['orm.repository_factory']); $config->setNamingStrategy($c['orm.strategy.naming']); $config->setQuoteStrategy($c['orm.strategy.quote']); $chain = new MappingDriverChain(); $config->setMetadataDriverImpl($chain); foreach ((array) $options['mappings'] as $entity) { if (!is_array($entity)) { throw new \InvalidArgumentException("The 'orm.options' option 'mappings' should be an array of arrays."); } if (isset($entity['alias'])) { $config->addEntityNamespace($entity['alias'], $entity['namespace']); } switch ($entity['type']) { case 'annotation': if (isset($c['annotation.reader'])) { $driver = new AnnotationDriver($c['annotation.reader'], (array) $entity['path']); } else { $simple = isset($entity['use_simple_annotation_reader']) ? $entity['use_simple_annotation_reader'] : true; $driver = $config->newDefaultAnnotationDriver((array) $entity['path'], $simple); } break; case 'yml': $driver = new YamlDriver($entity['path']); break; case 'simple_yml': $driver = new SimplifiedYamlDriver(array($entity['path'] => $entity['namespace'])); break; case 'xml': $driver = new XmlDriver($entity['path']); break; case 'simple_xml': $driver = new SimplifiedXmlDriver(array($entity['path'] => $entity['namespace'])); break; case 'php': $driver = new StaticPHPDriver($entity['path']); break; default: throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $entity['type'])); } $chain->addDriver($driver, $entity['namespace']); } } foreach ((array) $c['orm.types'] as $typeName => $typeClass) { if (Type::hasType($typeName)) { Type::overrideType($typeName, $typeClass); } else { Type::addType($typeName, $typeClass); } } return $configs; }; $c['orm.strategy.naming'] = function ($c) { return new DefaultNamingStrategy(); }; $c['orm.strategy.quote'] = function ($c) { return new DefaultQuoteStrategy(); }; $c['orm.entity_listener_resolver'] = function ($c) { return new DefaultEntityListenerResolver(); }; $c['orm.repository_factory'] = function ($c) { return new DefaultRepositoryFactory(); }; $c->extend('doctrine.registry', function ($registry, $c) { $c['orm.initialize'](); return new OrmRegistry($c['dbal.conns'], $c['orm.ems'], 'Doctrine\\Common\\Persistence\\Proxy', array_keys($c['dbal.options']), array_keys($c['orm.options']), $c['dbal.defaultName'], $c['orm.defaultName']); }); // TODO passar pro Container\ValidatorExtensionableProviderInterface if (isset($c['validator.object_initializers'])) { $c->extend('validator.object_initializers', function ($initializers, $c) { $initializers[] = new DoctrineInitializer($c['doctrine.registry']); $c['doctrine.orm.validator.unique'] = new UniqueEntityValidator($c['doctrine.registry']); return $initializers; }); } }