Creates the database schema for the given array of ClassMetadata instances.
| public createSchema ( array $classes ) | ||
| $classes | array | |
public static function doSetUpBeforeClass()
{
self::$st = new SchemaTool(self::$em);
self::$st->createSchema([self::$em->getClassMetadata(Language::clazz())]);
self::$st->createSchema([self::$em->getClassMetadata(TranslationToken::clazz())]);
self::$st->createSchema([self::$em->getClassMetadata(LanguageTranslationToken::clazz())]);
}
public function setUpSchema(array $classes)
{
foreach ($classes as $k => $class) {
$classes[$k] = $this->em->getClassMetadata($class);
}
$this->dropSchemas($classes);
$this->createdSchemas = array_merge($this->createdSchemas, $classes);
$this->schemaTool->createSchema($classes);
}
/**
* Create the schema!
*
* @return void
*/
public function setUpSchema(EntityManager $em)
{
$this->classes = array($em->getClassMetadata('EasyBib\\Doctrine\\Types\\Test\\Entity\\Note'));
$this->tool = new SchemaTool($em);
if (false === $this->isTravis) {
return;
}
$this->tool->createSchema($this->classes);
}
public static function setUpBeforeClass()
{
$em = self::getEntityManager();
$metaData = $em->getMetadataFactory()->getAllMetadata();
self::$schemaTool = new SchemaTool($em);
self::$schemaTool->dropSchema($metaData);
self::$schemaTool->createSchema($metaData);
static::prepareTestData($em);
}
public function createSchema($table)
{
foreach (self::$classes as $meta) {
if ($table === $meta->getTableName() || ".{$table}" === substr($meta->getTableName(), -strlen(".{$table}"))) {
self::$tool->dropSchema([$meta]);
self::$tool->createSchema([$meta]);
}
}
}
protected function setUp()
{
parent::setUp();
if (!isset(static::$_sharedConn)) {
static::$_sharedConn = $this->_getDefaultConnection();
}
$this->_em = $this->_getTestEntityManager(static::$_sharedConn);
$this->_schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->_em);
$this->_schemaTool->createSchema($this->_em->getMetadataFactory()->getAllMetadata());
}
public static function setUpBeforeClass()
{
static::$kernel = static::createKernel();
static::$kernel->boot();
self::$em = static::$kernel->getContainer()->get('doctrine')->getManager();
self::$tool = new SchemaTool(self::$em);
self::$userClasses = [self::$em->getClassMetaData('Sulu\\Bundle\\TestBundle\\Entity\\TestContact'), self::$em->getClassMetaData('Sulu\\Bundle\\TestBundle\\Entity\\TestUser')];
self::$tool->dropSchema(self::$userClasses);
self::$tool->createSchema(self::$userClasses);
static::$kernel->getContainer()->set('sulu_security.user_repository', static::$kernel->getContainer()->get('test_user_provider'));
}
/**
* Execute the console command.
*
* @return void
*/
public function fire()
{
if ($this->option('sql')) {
$this->info('Outputting create query:');
$sql = $this->tool->getCreateSchemaSql($this->metadata->getAllMetadata());
$this->info(implode(';' . PHP_EOL, $sql));
} else {
$this->info('Creating database schema...');
$this->tool->createSchema($this->metadata->getAllMetadata());
$this->info('Schema has been created!');
}
}
/**
* {@inheritdoc}
*/
public static function doSetUpBeforeClass()
{
static::$schemaTool = new SchemaTool(static::$em);
static::$schemaTool->dropSchema(static::getTablesMetadata());
static::$schemaTool->createSchema(static::getTablesMetadata());
static::$encoder = static::$container->get('security.encoder_factory');
static::$user = new User();
static::$user->setEmail('*****@*****.**');
static::$user->setPassword(static::$encoder->getEncoder(static::$user)->encodePassword('1234', static::$user->getSalt()));
static::$user->setUsername('testUser');
$entityPermissionCategory = new PermissionCategory();
$entityPermissionCategory->setName('backend_user');
$entityPermissionCategory->setTechnicalName('backend_user');
static::$em->persist($entityPermissionCategory);
$entityPermission = new Permission();
$entityPermission->setRoleName('IS_AUTHENTICATED_FULLY');
$entityPermission->setDescription('IS_AUTHENTICATED_FULLY');
$entityPermission->setName('IS_AUTHENTICATED_FULLY');
$entityPermission->setCategory($entityPermissionCategory);
$entityPermission2 = new Permission();
$entityPermission2->setRoleName('ROLE_MANAGE_PERMISSIONS');
$entityPermission2->setDescription('ROLE_MANAGE_PERMISSIONS');
$entityPermission2->setName('ROLE_MANAGE_PERMISSIONS');
$entityPermission2->setCategory($entityPermissionCategory);
$entityPermission3 = new Permission();
$entityPermission3->setRoleName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
$entityPermission3->setDescription('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
$entityPermission3->setName('ROLE_ACCESS_BACKEND_TOOLS_SECURITY_SECTION');
$entityPermission3->setCategory($entityPermissionCategory);
$entityPermission4 = new Permission();
$entityPermission4->setRoleName('ROLE_MANAGE_USER_PROFILES');
$entityPermission4->setDescription('ROLE_MANAGE_USER_PROFILES');
$entityPermission4->setName('ROLE_MANAGE_USER_PROFILES');
$entityPermission4->setCategory($entityPermissionCategory);
static::$em->persist($entityPermission);
static::$em->persist($entityPermission2);
static::$em->persist($entityPermission3);
static::$em->persist($entityPermission4);
static::$em->flush();
$group = new Group();
$group->setRefName('BACKEND-USER');
$group->setName('backend-user');
$group->addPermission($entityPermission);
$group->addPermission($entityPermission2);
$group->addPermission($entityPermission3);
$group->addPermission($entityPermission4);
static::$user->addToGroup($group);
static::$em->persist($group);
static::$em->persist(static::$user);
static::$em->flush();
}
/**
* @see https://github.com/zfcampus/zf-apigility/issues/18
*/
public function testCreateReturnsRestServiceEntityWithControllerServiceNamePopulated()
{
$serviceManager = $this->getApplication()->getServiceManager();
$em = $serviceManager->get('doctrine.entitymanager.orm_default');
$tool = new SchemaTool($em);
$res = $tool->createSchema($em->getMetadataFactory()->getAllMetadata());
// Create DB
$resourceDefinition = array("objectManager" => "doctrine.entitymanager.orm_default", "serviceName" => "Artist", "entityClass" => "Db\\Entity\\Artist", "routeIdentifierName" => "artist_id", "entityIdentifierName" => "id", "routeMatch" => "/db-test/artist");
// Verify ORM is working
$artist = new \Db\Entity\Artist();
$artist->setName('TestInsert');
$artist->setCreatedAt(new \Datetime());
$em->persist($artist);
$em->flush();
$found = $em->getRepository('Db\\Entity\\Artist')->find($artist->getId());
$this->assertInstanceOf('Db\\Entity\\Artist', $found);
$this->resource = $serviceManager->get('ZF\\Apigility\\Doctrine\\Admin\\Model\\DoctrineRestServiceResource');
$this->resource->setModuleName('DbApi');
$entity = $this->resource->create($resourceDefinition);
$this->assertInstanceOf('ZF\\Apigility\\Doctrine\\Admin\\Model\\DoctrineRestServiceEntity', $entity);
$controllerServiceName = $entity->controllerServiceName;
$this->assertNotEmpty($controllerServiceName);
$this->assertContains('DbApi\\V1\\Rest\\Artist\\Controller', $controllerServiceName);
// $serviceManager = ServiceManagerFactory::getServiceManager();
// $config = $serviceManager->get('Config');
// $routerConfig = isset($config['router']) ? $config['router'] : array();
// $router = HttpRouter::factory($routerConfig);
// $routeMatch = new RouteMatch(array('controller' => $controllerServiceName));
// $event = new MvcEvent();
// $event->setRouter($router);
// $event->setRouteMatch($routeMatch);
// $this->getRequest()->setMethod('GET');
$request = $this->getRequest();
$request->setMethod('GET');
$request->getHeaders()->addHeaders(array('Accept' => 'application/json'));
$x = $this->dispatch('/db-api/artist');
$this->resource->delete('DbApi\\V1\\Rest\\Artist\\Controller');
print_r($x);
return;
// $controller->setEvent($event);
// $controller->setServiceLocator($serviceManager);
// $routeMatch = new RouteMatch(array('controller' => $controllerServiceName));
// print_r($config);
// print_r(get_class_methods($router));
$this->resource->delete('DbApi\\V1\\Rest\\Artist\\Controller');
return;
// $controller = new $controllerServiceName;
// $request = new Request();
$query = array();
$query[] = array('type' => 'eq', 'field' => 'id', 'value' => $found->getId());
// Fetch test runs
$routeMatch->setParam('action', 'index');
$result = $controller->dispatch($this->request);
$response = $controller->getResponse();
// $this->assertEquals(200, $response->getStatusCode());
$hal = $response->getBody();
$renderer = $this->getServiceLocator()->get('ZF\\Hal\\JsonRenderer');
$data = json_decode($renderer->render($hal), true);
print_r($data);
}
public function setUp()
{
parent::setUp();
$schemaTool = new SchemaTool($this->entityManager);
$schemaTool->createSchema(array($this->entityManager->getClassMetadata('Pagerfanta\\Tests\\Adapter\\DoctrineORM\\User'), $this->entityManager->getClassMetadata('Pagerfanta\\Tests\\Adapter\\DoctrineORM\\Group'), $this->entityManager->getClassMetadata('Pagerfanta\\Tests\\Adapter\\DoctrineORM\\Person')));
$this->user1 = $user = new User();
$this->user2 = $user2 = new User();
$group1 = new Group();
$group2 = new Group();
$group3 = new Group();
$user->groups[] = $group1;
$user->groups[] = $group2;
$user->groups[] = $group3;
$user2->groups[] = $group1;
$author1 = new Person();
$author1->name = 'Foo';
$author1->biography = 'Baz bar';
$author2 = new Person();
$author2->name = 'Bar';
$author2->biography = 'Bar baz';
$this->entityManager->persist($user);
$this->entityManager->persist($user2);
$this->entityManager->persist($group1);
$this->entityManager->persist($group2);
$this->entityManager->persist($group3);
$this->entityManager->persist($author1);
$this->entityManager->persist($author2);
$this->entityManager->flush();
}
public function testDoctrineService()
{
$serviceManager = $this->getApplication()->getServiceManager();
$em = $serviceManager->get('doctrine.entitymanager.orm_default');
$tool = new SchemaTool($em);
$res = $tool->createSchema($em->getMetadataFactory()->getAllMetadata());
// Create DB
$resourceDefinition = array("objectManager" => "doctrine.entitymanager.orm_default", "serviceName" => "Artist", "entityClass" => "Db\\Entity\\Artist", "routeIdentifierName" => "artist_id", "entityIdentifierName" => "id", "routeMatch" => "/db-test/artist");
$this->resource = $serviceManager->get('ZF\\Apigility\\Doctrine\\Admin\\Model\\DoctrineRestServiceResource');
$this->resource->setModuleName('DbApi');
$entity = $this->resource->create($resourceDefinition);
$this->assertInstanceOf('ZF\\Apigility\\Doctrine\\Admin\\Model\\DoctrineRestServiceEntity', $entity);
$controllerServiceName = $entity->controllerServiceName;
$this->assertNotEmpty($controllerServiceName);
$this->assertContains('DbApi\\V1\\Rest\\Artist\\Controller', $controllerServiceName);
$filter = new FilterChain();
$filter->attachByName('WordCamelCaseToUnderscore')->attachByName('StringToLower');
$em = $serviceManager->get('doctrine.entitymanager.orm_default');
$metadataFactory = $em->getMetadataFactory();
$entityMetadata = $metadataFactory->getMetadataFor("Db\\Entity\\Artist");
foreach ($entityMetadata->associationMappings as $mapping) {
switch ($mapping['type']) {
case 4:
$rpcServiceResource = $serviceManager->get('ZF\\Apigility\\Doctrine\\Admin\\Model\\DoctrineRpcServiceResource');
$rpcServiceResource->setModuleName('DbApi');
$rpcServiceResource->create(array('service_name' => 'Artist' . $mapping['fieldName'], 'route' => '/db-test/artist[/:parent_id]/' . $filter($mapping['fieldName']) . '[/:child_id]', 'http_methods' => array('GET', 'PUT', 'POST'), 'options' => array('target_entity' => $mapping['targetEntity'], 'source_entity' => $mapping['sourceEntity'], 'field_name' => $mapping['fieldName']), 'selector' => 'custom selector'));
break;
default:
break;
}
}
}
private function dropAndCreateSchema()
{
$schemaTool = new SchemaTool($this->getEntityManager());
$metadata = $this->getEntityManager()->getMetadataFactory()->getAllMetadata();
$schemaTool->dropSchema($metadata);
$schemaTool->createSchema($metadata);
}
public function setUp()
{
$this->_oldEntityManager = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager();
$this->_oldAuditedClassNames = \SoliantEntityAudit\Module::getModuleOptions()->getAuditedClassNames();
$this->_oldJoinClasses = \SoliantEntityAudit\Module::getModuleOptions()->resetJoinClasses();
$isDevMode = false;
$config = Setup::createConfiguration($isDevMode, null, null);
$chain = new DriverChain();
// Use ZFC User for authentication tests
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuser'), 'ZfcUser\\Entity');
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuserdoctrineorm'), 'ZfcUserDoctrineORM\\Entity');
$chain->addDriver(new StaticPHPDriver(__DIR__ . "/../Models"), 'SoliantEntityAuditTest\\Models\\LogRevision');
$chain->addDriver(new AuditDriver('.'), 'SoliantEntityAudit\\Entity');
$config->setMetadataDriverImpl($chain);
// Replace entity manager
$moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$moduleOptions->setAuditedClassNames(array('SoliantEntityAuditTest\\Models\\LogRevision\\Album' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Performer' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Song' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\SingleCoverArt' => array()));
$entityManager = EntityManager::create($conn, $config);
$moduleOptions->setEntityManager($entityManager);
$schemaTool = new SchemaTool($entityManager);
// Add auditing listener
$entityManager->getEventManager()->addEventSubscriber(new LogRevision());
$sql = $schemaTool->getUpdateSchemaSql($entityManager->getMetadataFactory()->getAllMetadata());
#print_r($sql);die();
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
$this->_em = $entityManager;
}
public function adminRefreshDatabaseAction(Request $request, Application $app)
{
$conn = $app['db'];
$em = $app['doctrine.orm.entity_manager'];
$params = $conn->getParams();
$name = isset($params['path']) ? $params['path'] : (isset($params['dbname']) ? $params['dbname'] : false);
try {
$conn->getSchemaManager()->dropDatabase($name);
$conn->getSchemaManager()->createDatabase($name);
$conn->close();
} catch (\Exception $e) {
return 1;
}
$classes = [];
foreach ($app['authbucket_oauth2.model'] as $class) {
$classes[] = $em->getClassMetadata($class);
}
PersistentObject::setObjectManager($em);
$tool = new SchemaTool($em);
$tool->dropSchema($classes);
$tool->createSchema($classes);
$purger = new ORMPurger();
$executor = new ORMExecutor($em, $purger);
$loader = new Loader();
$loader->loadFromDirectory(__DIR__ . '/../DataFixtures/ORM');
$executor->execute($loader->getFixtures());
return $app->redirect($app['url_generator']->generate('index'));
}
/**
* @param EntityManager $em
* @return SchemaTool
*/
private function createSchemaTool(EntityManager $em)
{
$schemaTool = new SchemaTool($em);
$schemaTool->dropDatabase();
$schemaTool->createSchema($em->getMetadataFactory()->getAllMetadata());
return $schemaTool;
}
public function testReferenceReconstruction()
{
$em = $this->getMockSqliteEntityManager();
$referenceRepository = new ProxyReferenceRepository($em);
$listener = new ORMReferenceListener($referenceRepository);
$em->getEventManager()->addEventSubscriber($listener);
$schemaTool = new SchemaTool($em);
$schemaTool->dropSchema(array());
$schemaTool->createSchema(array($em->getClassMetadata(self::TEST_ENTITY_ROLE)));
$roleFixture = new TestFixtures\RoleFixture();
$roleFixture->setReferenceRepository($referenceRepository);
$roleFixture->load($em);
// first test against managed state
$ref = $referenceRepository->getReference('admin-role');
$this->assertNotInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref);
// test reference reconstruction from serialized data (was managed)
$serializedData = $referenceRepository->serialize();
$proxyReferenceRepository = new ProxyReferenceRepository($em);
$proxyReferenceRepository->unserialize($serializedData);
$ref = $proxyReferenceRepository->getReference('admin-role');
$this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref);
// now test reference reconstruction from identity
$em->clear();
$ref = $referenceRepository->getReference('admin-role');
$this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref);
// test reference reconstruction from serialized data (was identity)
$serializedData = $referenceRepository->serialize();
$proxyReferenceRepository = new ProxyReferenceRepository($em);
$proxyReferenceRepository->unserialize($serializedData);
$ref = $proxyReferenceRepository->getReference('admin-role');
$this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $ref);
}
private function prepareDatabase()
{
/** @var EntityManager $em */
$em = $this->registry->getManager();
$tool = new SchemaTool($em);
$tool->createSchema($em->getMetadataFactory()->getAllMetadata());
}
/**
* @return Kdyby\Doctrine\EntityManager
*/
protected function createMemoryManager($classNames = NULL, $createSchema = TRUE)
{
$conf = ['driver' => 'pdo_sqlite', 'memory' => TRUE];
$connection = new Kdyby\Doctrine\Connection($conf, new Driver());
$config = new Kdyby\Doctrine\Configuration();
$cache = new ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setProxyDir(TEMP_DIR);
$config->setProxyNamespace('TestProxy');
$config->setDefaultRepositoryClassName('Kdyby\\Doctrine\\EntityRepository');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver([__DIR__ . '/Model/', VENDOR_DIR], FALSE));
$em = Kdyby\Doctrine\EntityManager::create($connection, $config);
$em->getEventManager()->addEventSubscriber(new SortableListener());
if ($createSchema === FALSE) {
return $em;
}
$schemaTool = new SchemaTool($em);
if ($classNames !== NULL) {
$meta = [];
foreach ((array) $classNames as $className) {
$meta[] = $em->getClassMetadata($className);
}
} else {
$meta = $em->getMetadataFactory()->getAllMetadata();
}
$schemaTool->createSchema($meta);
return $em;
}
function testCreateSchema()
{
/* @var $em \Doctrine\ORM\EntityManager */
$em = $this->app["orm.em"];
$tool = new SchemaTool($em);
//@note @doctrine générer les fichiers de classe à partir de métadonnées
/* generate entity classes */
$dmf = new DisconnectedClassMetadataFactory();
$dmf->setEntityManager($em);
$metadatas = $dmf->getAllMetadata();
//print_r($metadatas);
$generator = new EntityGenerator();
$generator->setGenerateAnnotations(TRUE);
$generator->setGenerateStubMethods(TRUE);
$generator->setRegenerateEntityIfExists(TRUE);
$generator->setUpdateEntityIfExists(TRUE);
$generator->generate($metadatas, ROOT_TEST_DIR);
$generator->setNumSpaces(4);
$this->assertFileExists(ROOT_TEST_DIR . "/Entity/Post.php");
/* @note @doctrine générer la base de donnée à partir des métadonnées */
/* @see Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand */
/* generate database */
$tool->dropSchema($metadatas);
$tool->createSchema($metadatas);
$post = new \Entity\Post();
$post->setTitle("the title");
$em->persist($post);
$em->flush();
$this->assertInternalType("int", $post->getId());
}
private function createSchema(ContainerInterface $container)
{
$entityManager = $container->get('doctrine.orm.entity_manager');
/** @var EntityManager $entityManager */
$schemaTool = new SchemaTool($entityManager);
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
}
/**
* Initializes the database (once).
*
* @throws \Doctrine\DBAL\DBALException
* @throws \Doctrine\ORM\ORMException
* @throws \Doctrine\ORM\Tools\ToolsException
*/
protected function setUp()
{
if (null === static::$_conn) {
$dbPath = __DIR__ . '/../../../db.sqlite';
if (file_exists($dbPath)) {
unlink($dbPath);
}
$params = ['driver' => 'pdo_sqlite', 'path' => $dbPath];
static::$_conn = DriverManager::getConnection($params);
static::$_conn->getConfiguration()->setSQLLogger(null);
}
if (null === static::$_em) {
$paths = [__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/ORM/Resources/mapping'];
$isDevMode = true;
$config = Setup::createXMLMetadataConfiguration($paths, $isDevMode);
$em = EntityManager::create(static::$_conn, $config);
$classes = [];
foreach (static::$_classes as $class) {
array_push($classes, $em->getClassMetadata($class));
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropSchema($classes);
$schemaTool->createSchema($classes);
// Load fixtures
$loader = new Loader();
$loader->loadFromDirectory(__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/Fixtures');
$purger = new ORMPurger();
$executor = new ORMExecutor($em, $purger);
$executor->execute($loader->getFixtures());
static::$_em = $em;
}
}
protected function setUp()
{
if (!class_exists('Symfony\\Component\\Form\\Form')) {
$this->markTestSkipped('The "Form" component is not available');
}
if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) {
$this->markTestSkipped('Doctrine DBAL is not available.');
}
if (!class_exists('Doctrine\\Common\\Version')) {
$this->markTestSkipped('Doctrine Common is not available.');
}
if (!class_exists('Doctrine\\ORM\\EntityManager')) {
$this->markTestSkipped('Doctrine ORM is not available.');
}
$this->em = DoctrineOrmTestCase::createTestEntityManager();
$this->emRegistry = $this->createRegistryMock('default', $this->em);
parent::setUp();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata(self::ITEM_GROUP_CLASS), $this->em->getClassMetadata(self::SINGLE_IDENT_CLASS), $this->em->getClassMetadata(self::SINGLE_STRING_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_IDENT_CLASS), $this->em->getClassMetadata(self::COMPOSITE_STRING_IDENT_CLASS));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
}
/**
* Creates schema for doctrine entities
*
* @throws \Doctrine\ORM\Tools\ToolsException
*/
protected function createDoctrineSchema()
{
$metadata = $this->entityManager->getMetadataFactory()->getAllMetadata();
$tool = new SchemaTool($this->entityManager);
$tool->dropSchema($metadata);
$tool->createSchema($metadata);
}
public function setUp()
{
parent::setUp();
$em = $this->client->getContainer()->get('doctrine.orm.entity_manager');
$schemaTool = new SchemaTool($em);
$schemaTool->createSchema($em->getMetadataFactory()->getAllMetadata());
}
protected function setUp()
{
parent::setUp();
if (!class_exists('Symfony\\Component\\Form\\Form')) {
$this->markTestSkipped('The "Form" component is not available');
}
if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) {
$this->markTestSkipped('Doctrine DBAL is not available.');
}
if (!class_exists('Doctrine\\Common\\Version')) {
$this->markTestSkipped('Doctrine Common is not available.');
}
if (!class_exists('Doctrine\\ORM\\EntityManager')) {
$this->markTestSkipped('Doctrine ORM is not available.');
}
$this->em = DoctrineTestHelper::createTestEntityManager();
$this->emRegistry = $this->createRegistryMock('default', $this->em);
$this->items = array();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata(self::SINGLE_INT_ID_CLASS));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
$this->createEntities();
$this->factory = Forms::createFormFactoryBuilder()->addExtensions($this->getExtensions())->addTypeExtension(new ChoiceSelect2TypeExtension($this->dispatcher, $this->requestStack, $this->router, $this->getExtensionTypeName(), 10))->addType(new EntityType($this->emRegistry))->addTypeExtension(new EntitySelect2TypeExtension())->getFormFactory();
$this->builder = new FormBuilder(null, null, $this->dispatcher, $this->factory);
}
protected function setUp()
{
if (!class_exists('Doctrine\\Common\\Version')) {
$this->markTestSkipped('Doctrine is not available.');
}
$this->em = DoctrineOrmTestCase::createTestEntityManager();
parent::setUp();
$schemaTool = new SchemaTool($this->em);
$classes = array(
$this->em->getClassMetadata(self::SINGLE_IDENT_CLASS),
$this->em->getClassMetadata(self::SINGLE_STRING_IDENT_CLASS),
$this->em->getClassMetadata(self::COMPOSITE_IDENT_CLASS),
$this->em->getClassMetadata(self::COMPOSITE_STRING_IDENT_CLASS),
);
try {
$schemaTool->dropSchema($classes);
} catch(\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch(\Exception $e) {
}
}
/**
* This is a functinoal test as there is a large integration necessary to get the validator working.
*/
public function testValidateUniqueness()
{
$entityManagerName = "foo";
$em = $this->createTestEntityManager();
$schemaTool = new SchemaTool($em);
$schemaTool->createSchema(array($em->getClassMetadata('Symfony\\Tests\\Bridge\\Doctrine\\Form\\Fixtures\\SingleIdentEntity')));
$entity1 = new SingleIdentEntity(1, 'Foo');
$registry = $this->createRegistryMock($entityManagerName, $em);
$uniqueValidator = new UniqueEntityValidator($registry);
$metadata = new ClassMetadata('Symfony\\Tests\\Bridge\\Doctrine\\Form\\Fixtures\\SingleIdentEntity');
$metadata->addConstraint(new UniqueEntity(array('fields' => array('name'), 'em' => $entityManagerName)));
$metadataFactory = $this->createMetadataFactoryMock($metadata);
$validatorFactory = $this->createValidatorFactory($uniqueValidator);
$validator = new Validator($metadataFactory, $validatorFactory);
$violationsList = $validator->validate($entity1);
$this->assertEquals(0, $violationsList->count(), "No violations found on entity before it is saved to the database.");
$em->persist($entity1);
$em->flush();
$violationsList = $validator->validate($entity1);
$this->assertEquals(0, $violationsList->count(), "No violations found on entity after it was saved to the database.");
$entity2 = new SingleIdentEntity(2, 'Foo');
$violationsList = $validator->validate($entity2);
$this->assertEquals(1, $violationsList->count(), "No violations found on entity after it was saved to the database.");
$violation = $violationsList[0];
$this->assertEquals('This value is already used.', $violation->getMessage());
$this->assertEquals('name', $violation->getPropertyPath());
$this->assertEquals('Foo', $violation->getInvalidValue());
}
protected function setUp()
{
if (!class_exists('Symfony\\Component\\Form\\Form')) {
$this->markTestSkipped('The "Form" component is not available');
}
if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) {
$this->markTestSkipped('Doctrine DBAL is not available.');
}
if (!class_exists('Doctrine\\Common\\Version')) {
$this->markTestSkipped('Doctrine Common is not available.');
}
if (!class_exists('Doctrine\\ORM\\EntityManager')) {
$this->markTestSkipped('Doctrine ORM is not available.');
}
$this->em = DoctrineOrmTestCase::createTestEntityManager();
parent::setUp();
$schemaTool = new SchemaTool($this->em);
$classes = array($this->em->getClassMetadata(self::ENTITY_CLASS));
try {
$schemaTool->dropSchema($classes);
} catch (\Exception $e) {
}
try {
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
$ids = range(1, 300);
foreach ($ids as $id) {
$name = 65 + chr($id % 57);
$this->em->persist(new SingleIdentEntity($id, $name));
}
$this->em->flush();
}
/**
* Creates a connection to the test database, if there is none yet, and
* creates the necessary tables.
*/
protected function setUp()
{
$forceCreateTables = false;
if (!isset($this->sharedFixture['conn'])) {
if (!isset(static::$_sharedConn)) {
static::$_sharedConn = TestUtil::getConnection();
}
$this->sharedFixture['conn'] = static::$_sharedConn;
if ($this->sharedFixture['conn']->getDriver() instanceof \Doctrine\DBAL\Driver\PDOSqlite\Driver) {
$forceCreateTables = true;
}
}
if (!$this->_em) {
$this->_em = $this->_getEntityManager();
$this->_schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->_em);
}
$classes = array();
foreach ($this->_usedModelSets as $setName => $bool) {
if (!isset(static::$_tablesCreated[$setName])) {
foreach (static::$_modelSets[$setName] as $className) {
$classes[] = $this->_em->getClassMetadata($className);
}
static::$_tablesCreated[$setName] = true;
}
}
if ($classes) {
$this->_schemaTool->createSchema($classes);
}
$this->_sqlLoggerStack->enabled = true;
}
