protected function tearDown() { // Clean anything still idle in the UOW $this->_em->clear(); // Clear out anything set in the db (schema is recreated on setUp() $this->_schemaTool->dropDatabase(); }
/** * Builds the DB Schema * * @return void */ protected function rebuildDatabase() { # 2. Drop the existing database schema $this->schemaTool->dropDatabase(); # 3. Create the new database schema based on (1) $entityMeta = $this->em->getMetadataFactory()->getAllMetadata(); $this->schemaTool->updateSchema($entityMeta); }
protected function tearDown() { parent::tearDown(); $tool = new SchemaTool($this->em); $tool->dropDatabase(); unset($this->em); }
protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas) { $isFullDatabaseDrop = $input->getOption('full-database'); if ($input->getOption('dump-sql') === true) { if ($isFullDatabaseDrop) { $sqls = $schemaTool->getDropDatabaseSQL(); } else { $sqls = $schemaTool->getDropSchemaSQL($metadatas); } $output->write(implode(';' . PHP_EOL, $sqls) . PHP_EOL); } else { if ($input->getOption('force') === true) { $output->write('Dropping database schema...' . PHP_EOL); if ($isFullDatabaseDrop) { $schemaTool->dropDatabase(); } else { $schemaTool->dropSchema($metadatas); } $output->write('Database schema dropped successfully!' . PHP_EOL); } else { $output->write('ATTENTION: This operation should not be executed in a production environment.' . PHP_EOL . PHP_EOL); if ($isFullDatabaseDrop) { $sqls = $schemaTool->getDropDatabaseSQL(); } else { $sqls = $schemaTool->getDropSchemaSQL($metadatas); } if (count($sqls)) { $output->write('Schema-Tool would execute ' . count($sqls) . ' queries to drop the database.' . PHP_EOL); $output->write('Please run the operation with --force to execute these queries or use --dump-sql to see them.' . PHP_EOL); } else { $output->write('Nothing to drop. The database is empty!' . PHP_EOL); } } } }
protected function loadFixtures($client) { $container = $this->getContainer($client); $registry = $container->get('doctrine'); if ($registry instanceof ManagerRegistry) { $om = $registry->getManager(); } else { $om = $registry->getEntityManager(); } $cacheDriver = $om->getMetadataFactory()->getCacheDriver(); if ($cacheDriver) { $cacheDriver->deleteAll(); } $connection = $om->getConnection(); $params = $connection->getParams(); $name = isset($params['path']) ? $params['path'] : (isset($params['dbname']) ? $params['dbname'] : false); if (!$name) { throw new \InvalidArgumentException("Connection does not contain a 'path' or 'dbname' parameter and cannot be dropped."); } $metadatas = $om->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool($om); $schemaTool->dropDatabase($name); if (!empty($metadatas)) { $schemaTool->createSchema($metadatas); } }
/** * {@inheritDoc} */ public function dropSchema() { $this->foreachObjectManagers(function (ObjectManager $objectManager) { $schemaTool = new DoctrineSchemaTool($objectManager); $schemaTool->dropDatabase(); }); }
/** * @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 preTestSetUp(EntityManagerEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $classes = array($em->getClassMetadata(__NAMESPACE__ . '\\Date')); $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
public function testSchemaDown() { $schemaTool = new SchemaTool($this->entityManager); $schemaTool->dropDatabase(); $schemaManager = $this->entityManager->getConnection()->getSchemaManager(); $tables = $schemaManager->listTableNames(); $this->assertEmpty($tables); }
public function setUp() { parent::setUp(); $em = $this->client->getContainer()->get('doctrine.orm.entity_manager'); $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); $schemaTool->createSchema($em->getMetadataFactory()->getAllMetadata()); }
/** * Drops all databases * * @return void */ public function dropDatabases() { /** @var EntityManagerInterface[] $managers */ $managers = $this->get('doctrine')->getManagers(); foreach ($managers as $manager) { $tool = new SchemaTool($manager); $tool->dropDatabase(); } }
public function preTestSetUp(EntityManagerEventArgs $eventArgs) { $em = $eventArgs->getEntityManager(); $schemaTool = new SchemaTool($em); $cmf = $em->getMetadataFactory(); $classes = $cmf->getAllMetadata(); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
protected function initializeInMemoryDB() { $entityManager = $this->getEntityManager(); // try a real schema creation with the in memory sqlite driver $classes = $entityManager->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool($entityManager); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
public function setUp() { self::$kernel = $this->createKernel(array('environment' => 'test')); self::$kernel->boot(); $this->container = self::$kernel->getContainer(); $em = $this->container->get('doctrine')->getEntityManager(); $metadatas = $em->getMetadataFactory()->getAllMetadata(); $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); $schemaTool->createSchema($metadatas); }
private function setupDatabase() { $params = SqliteConfig::getParams(); $entityManager = EntityManagerFactory::create($params); $tmpConnection = DriverManager::getConnection($params); $tmpConnection->getSchemaManager()->createDatabase($params['path']); $schemaTool = new SchemaTool($entityManager); $schemaTool->dropDatabase(); $metadata = $entityManager->getMetadataFactory()->getAllMetadata(); $schemaTool->createSchema($metadata); }
public function createTestDb() { $em = $this->getEntityManager(); $tool = new SchemaTool($em); $classes = array($em->getClassMetadata('PandaTest\\ExampleBundle\\entity\\Test')); $tool->dropDatabase(); $tool->createSchema($classes); $testEntity = $this->newEntity('Test', array('id' => 1, 'label' => 'test')); $em->persist($testEntity); $em->flush(); }
/** * @before */ public function resetDatabase() { if (!property_exists($this, 'em')) { throw new \Exception('No \'em\' property exists for this test case.'); } if (!$this->em instanceof EntityManager) { throw new \Exception('The \'em\' property needs to be an entity manager'); } $schema = new SchemaTool($this->em); $schema->dropDatabase(); $schema->createSchema($this->em->getMetadataFactory()->getAllMetadata()); }
/** * setupBeforeClass * * @throws \Doctrine\ORM\Tools\ToolsException */ public static function setupBeforeClass() { static::$kernel = static::createKernel(); static::$kernel->boot(); // Creates the database schema $emn = static::$kernel->getContainer()->get('doctrine.orm.entity_manager'); $schemaTool = new SchemaTool($emn); $cmf = $emn->getMetadataFactory(); $classes = $cmf->getAllMetadata(); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
/** * Подготавливаем базу * */ protected function setUp() { /** @noinspection PhpIncludeInspection */ $this->setApplicationConfig(include TestPaths::getPathToBindObjectToWorkflowEntryIntegrationTest()); /** @var \Doctrine\ORM\EntityManager $em */ $em = $this->getApplication()->getServiceManager()->get('doctrine.entitymanager.test'); $tool = new SchemaTool($em); $tool->dropDatabase(); $metadata = $em->getMetadataFactory()->getAllMetadata(); $tool->createSchema($metadata); parent::setUp(); }
public static function createMysqlTestEntityManager($user, $pass, $db, $host) { $con = DriverManager::getConnection(array('driver' => 'pdo_mysql', 'user' => $user, 'password' => $pass, 'dbname' => $db, 'host' => $host)); $em = self::createEm($con); $tool = new SchemaTool($em); try { $tool->dropDatabase(); } catch (\Exception $ex) { // tables did not exist } $tool->createSchema($em->getMetadataFactory()->getAllMetadata()); return $em; }
public function setUp() { $em = $this->getContainer()->get('doctrine')->getManager(); if (!isset($metadatas)) { $metadatas = $em->getMetadataFactory()->getAllMetadata(); } $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); if (!empty($metadatas)) { $schemaTool->createSchema($metadatas); } $this->postFixtureSetup(); }
public static function setUpBeforeClass() { $isDevMode = true; $config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/../../../metadata/TestEntities"), $isDevMode, null, null, false); $connectionOptions = array('driver' => 'pdo_sqlite', 'memory' => true); // obtaining the entity manager self::$em = EntityManager::create($connectionOptions, $config); $schemaTool = new SchemaTool(self::$em); $cmf = self::$em->getMetadataFactory(); $classes = $cmf->getAllMetadata(); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
public function setUp() { // https://github.com/liip/LiipFunctionalTestBundle#non-sqlite $em = $this->getContainer()->get('doctrine')->getManager(); if (!isset($metadatas)) { $metadatas = $em->getMetadataFactory()->getAllMetadata(); } $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); if (!empty($metadatas)) { $schemaTool->createSchema($metadatas); } }
protected function generateSchema($em) { // Get the metadata from the application to create the schema. $metadatas = $this->getMetadatas($em); if (!empty($metadatas)) { // Create SchemaTool $tool = new SchemaTool($em); $tool->dropDatabase(); $tool->createSchema($metadatas); } else { throw \Exception('No Metadata Classes to process.'); } }
protected function createSchema() { // $classes = array(); // foreach (array_unique($this->entityClasses) as $className) { // $classes[] = $this->app['orm.em']->getClassMetadata($className); // } $em = $this->app['orm.em']; $classes = array_map(function ($className) use($em) { return $em->getClassMetadata($className); }, array_unique($this->entityClasses)); $schemaTool = new SchemaTool($this->app['orm.em']); $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); }
protected function resetDatabase() { $em = $this->getContainer()->get('doctrine')->getManager(); if (!isset($metadatas)) { $metadatas = $em->getMetadataFactory()->getAllMetadata(); } $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); if (!empty($metadatas)) { $schemaTool->createSchema($metadatas); } $this->postFixtureSetup(); $this->loadFixtures(['AppBundle\\DataFixtures\\ORM\\LoadCharacterData', 'AppBundle\\DataFixtures\\ORM\\LoadShipAndFactionData']); }
public function setUp() { // https://github.com/liip/LiipFunctionalTestBundle#non-sqlite $em = $this->getContainer()->get('doctrine')->getManager(); if (!isset($metadatas)) { $metadatas = $em->getMetadataFactory()->getAllMetadata(); } $schemaTool = new SchemaTool($em); $schemaTool->dropDatabase(); if (!empty($metadatas)) { $schemaTool->createSchema($metadatas); } // Needed to define the PHPCR root, used in fixtures. $this->runCommand('doctrine:phpcr:repository:init'); }
/** * @throws \Doctrine\ORM\Tools\ToolsException */ public static function setUpBeforeClass() { parent::setUpBeforeClass(); static::$kernel = static::createKernel(array()); static::$kernel->boot(); $metadata = static::getMetadata(); $tool = new SchemaTool(static::$em); $tool->dropDatabase(); $tool->createSchema($metadata); $validator = new SchemaValidator(static::$em); $errors = $validator->validateMapping(); static::assertCount(0, $errors, implode("\n\n", array_map(function ($l) { return implode("\n\n", $l); }, $errors))); }
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(); }
protected function setUp() { $this->client = self::createClient(array("debug" => false)); $container = $this->client->getContainer(); $doctrine = $container->get('doctrine'); $em = $doctrine->getEntityManager(); $schemaTool = new SchemaTool($em); $mdf = $em->getMetadataFactory(); $classes = $mdf->getAllMetadata(); list($msec, $sec) = explode(" ", microtime()); $start = $sec + $msec; $schemaTool->dropDatabase(); $schemaTool->createSchema($classes); list($msec, $sec) = explode(" ", microtime()); $stop = $sec + $msec; echo "\nDropping and creating schema time is " . round($stop - $start, 4) . " sec\n"; ob_flush(); }