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; }