diff --git a/composer.json b/composer.json index b895287..37c2fed 100644 --- a/composer.json +++ b/composer.json @@ -17,6 +17,8 @@ "doctrine/migrations": "1.*" }, "require-dev": { + "illuminate/container": "4.*|5.*", + "illuminate/console": "4.*|5.*", "mockery/mockery": "dev-master", "phpunit/phpunit": "3.7.*" }, diff --git a/phpunit.xml b/phpunit.xml index afa8d1d..01a41f1 100644 --- a/phpunit.xml +++ b/phpunit.xml @@ -14,5 +14,8 @@ ./tests/ + + ./tests/MultipleEntityManagersAndConnections/ + diff --git a/src/Console/DqlCommand.php b/src/Console/DqlCommand.php index 160a509..eea91a0 100644 --- a/src/Console/DqlCommand.php +++ b/src/Console/DqlCommand.php @@ -1,7 +1,7 @@ entityManager = $entityManager; + $this->entityManager = $registry->getManager(); } public function fire() @@ -53,4 +53,4 @@ protected function getOptions() ['hydrate', null, InputOption::VALUE_OPTIONAL, 'Hydrate type. Available: object, array, scalar, single_scalar, simpleobject'] ]; } -} +} diff --git a/src/Console/GenerateProxiesCommand.php b/src/Console/GenerateProxiesCommand.php index 3de3aa1..485a790 100644 --- a/src/Console/GenerateProxiesCommand.php +++ b/src/Console/GenerateProxiesCommand.php @@ -1,7 +1,8 @@ entityManager = $entityManager; + $this->registry = $registry; } public function fire() { $this->info('Starting proxy generation....'); - $metadata = $this->entityManager->getMetadataFactory()->getAllMetadata(); + + if ($this->option('em')) { + $manager = $this->registry->getManager($this->option('em')); + } else { + $manager = $this->registry->getManager(); + } + + $metadata = $manager->getMetadataFactory()->getAllMetadata(); if (empty($metadata)) { $this->error('No metadata found to generate any entities.'); exit; } - $directory = $this->laravel['config']['doctrine::doctrine.proxy.directory']; - if ( ! $directory) { + $directory = $manager->getConfiguration()->getProxyDir(); + if (! $directory) { $this->error('The proxy directory has not been set.'); exit; } @@ -50,7 +58,14 @@ public function fire() foreach ($metadata as $item) { $this->line($item->name); } - $this->entityManager->getProxyFactory()->generateProxyClasses($metadata, $directory); + $manager->getProxyFactory()->generateProxyClasses($metadata, $directory); $this->info('Proxies have been created.'); } -} + + protected function getOptions() + { + return [ + ['em', false, InputOption::VALUE_REQUIRED, 'Sets the entity manager when the default is not desired.'], + ]; + } +} diff --git a/src/Console/SchemaCreateCommand.php b/src/Console/SchemaCreateCommand.php index 1fd6c6a..55605b9 100644 --- a/src/Console/SchemaCreateCommand.php +++ b/src/Console/SchemaCreateCommand.php @@ -2,7 +2,7 @@ use Illuminate\Console\Command; use Doctrine\ORM\Tools\SchemaTool; -use Doctrine\ORM\Mapping\ClassMetadataFactory; +use Doctrine\Common\Persistence\ManagerRegistry; use Symfony\Component\Console\Input\InputOption; class SchemaCreateCommand extends Command @@ -22,25 +22,17 @@ class SchemaCreateCommand extends Command protected $description = 'Create database schema from models'; /** - * The schema tool. + * The ManagerRegistry * - * @var \Doctrine\ORM\Tools\SchemaTool + * @var \Doctrine\Common\Persistence\ManagerRegistry */ - private $tool; + private $registry; - /** - * The class metadata factory - * - * @var \Doctrine\ORM\Tools\SchemaTool - */ - private $metadata; - - public function __construct(SchemaTool $tool, ClassMetadataFactory $metadata) + public function __construct(ManagerRegistry $registry) { parent::__construct(); - $this->tool = $tool; - $this->metadata = $metadata; + $this->registry = $registry; } /** @@ -50,13 +42,21 @@ public function __construct(SchemaTool $tool, ClassMetadataFactory $metadata) */ public function fire() { + if ($this->option('em')) { + $manager = $this->registry->getManager($this->option('em')); + } else { + $manager = $this->registry->getManager(); + } + + $tool = new SchemaTool($manager); + if ($this->option('sql')) { $this->info('Outputting create query:'.PHP_EOL); - $sql = $this->tool->getCreateSchemaSql($this->metadata->getAllMetadata()); + $sql = $tool->getCreateSchemaSql($manager->getMetadataFactory()->getAllMetadata()); $this->info(implode(';'.PHP_EOL, $sql)); } else { $this->info('Creating database schema...'); - $this->tool->createSchema($this->metadata->getAllMetadata()); + $tool->createSchema($manager->getMetadataFactory()->getAllMetadata()); $this->info('Schema has been created!'); } } @@ -64,7 +64,8 @@ public function fire() protected function getOptions() { return [ - ['sql', false, InputOption::VALUE_NONE, 'Dumps SQL query and does not execute creation.'] + ['sql', false, InputOption::VALUE_NONE, 'Dumps SQL query and does not execute creation.'], + ['em', false, InputOption::VALUE_REQUIRED, 'Sets the entity manager when the default is not desired.'], ]; } -} +} diff --git a/src/Console/SchemaDropCommand.php b/src/Console/SchemaDropCommand.php index 4861b2b..eb90f69 100644 --- a/src/Console/SchemaDropCommand.php +++ b/src/Console/SchemaDropCommand.php @@ -1,8 +1,8 @@ -tool = $tool; - $this->metadata = $metadata; + $this->registry = $registry; } /** @@ -50,17 +42,26 @@ public function __construct(SchemaTool $tool, ClassMetadataFactory $metadata) */ public function fire() { - $sql = $this->tool->getDropSchemaSQL($this->metadata->getAllMetadata()); + if ($this->option('em')) { + $manager = $this->registry->getManager($this->option('em')); + } else { + $manager = $this->registry->getManager(); + } + + $tool = new SchemaTool($manager); + + $sql = $tool->getDropSchemaSQL($manager->getMetadataFactory()->getAllMetadata()); if (empty($sql)) { $this->info('Current models do not exist in schema.'); - return; + exit; } if ($this->option('sql')) { $this->info('Outputting drop query:'); + $sql = $tool->getDropSchemaSQL($manager->getMetadataFactory()->getAllMetadata()); $this->info(implode(';' . PHP_EOL, $sql)); } else { $this->info('Dropping database schema....'); - $this->tool->dropSchema($this->metadata->getAllMetadata()); + $tool->dropSchema($manager->getMetadataFactory()->getAllMetadata()); $this->info('Schema has been dropped!'); } } @@ -69,7 +70,7 @@ protected function getOptions() { return [ ['sql', false, InputOption::VALUE_NONE, 'Dumps SQL query and does not execute drop.'], + ['em', false, InputOption::VALUE_REQUIRED, 'Sets the entity manager when the default is not desired.'], ]; } } - diff --git a/src/Console/SchemaUpdateCommand.php b/src/Console/SchemaUpdateCommand.php index 2a10b83..3e83eec 100644 --- a/src/Console/SchemaUpdateCommand.php +++ b/src/Console/SchemaUpdateCommand.php @@ -1,8 +1,8 @@ -tool = $tool; - $this->metadata = $metadata; + $this->registry = $registry; } /** @@ -52,17 +51,27 @@ public function fire() { $this->info('Checking if database needs updating....'); $clean = $this->option('clean'); - $sql = $this->tool->getUpdateSchemaSql($this->metadata->getAllMetadata(), $clean); + + if ($this->option('em')) { + $manager = $this->registry->getManager($this->option('em')); + } else { + $manager = $this->registry->getManager(); + } + + $tool = new SchemaTool($manager); + + $sql = $tool->getUpdateSchemaSql($manager->getMetadataFactory()->getAllMetadata(), $clean); + if (empty($sql)) { $this->info('No updates found.'); - return; + exit; } if ($this->option('sql')) { $this->info('Outputting update query:'); $this->info(implode(';' . PHP_EOL, $sql)); } else { $this->info('Updating database schema....'); - $this->tool->updateSchema($this->metadata->getAllMetadata()); + $tool->updateSchema($manager->getMetadataFactory()->getAllMetadata()); $this->info('Schema has been updated!'); } } @@ -71,8 +80,8 @@ protected function getOptions() { return [ ['sql', false, InputOption::VALUE_NONE, 'Dumps SQL query and does not execute update.'], - ['clean', null, InputOption::VALUE_OPTIONAL, 'When using clean model all non-relevant to this metadata assets will be cleared.'] + ['clean', null, InputOption::VALUE_OPTIONAL, 'When using clean model all non-relevant to this metadata assets will be cleared.'], + ['em', false, InputOption::VALUE_REQUIRED, 'Sets the entity manager when the default is not desired.'], ]; } } - diff --git a/src/DoctrineUserProvider.php b/src/DoctrineUserProvider.php index 5fed043..b749732 100644 --- a/src/DoctrineUserProvider.php +++ b/src/DoctrineUserProvider.php @@ -1,6 +1,6 @@ hasher = $hasher; - $this->entityManager = $entityManager; + $this->entityManager = $registry->getManager(); $this->entity = $entity; } /** diff --git a/src/IlluminateRegistry.php b/src/IlluminateRegistry.php new file mode 100644 index 0000000..e47556d --- /dev/null +++ b/src/IlluminateRegistry.php @@ -0,0 +1,70 @@ +container = $container; + parent::__construct( + 'ORM', + $connections, + $entityManagers, + 'default', + 'default', + 'Doctrine\ORM\Proxy\Proxy' + ); + } + + /** + * Fetches/creates the given services. + * A service in this context is connection or a manager instance. + * @param string $name The name of the service. + * @return object The instance of the given service. + */ + protected function getService($name) + { + return $this->container->make($name); + } + + /** + * Resets the given services. + * A service in this context is connection or a manager instance. + * @param string $name The name of the service. + * @return void + */ + protected function resetService($name) + { + return $this->container->bind($name, null); + } + + /** + * Resolves a registered namespace alias to the full namespace. + * This method looks for the alias in all registered object managers. + * @param string $alias The alias. + * @throws ORMException + * @return string The full namespace. + */ + public function getAliasNamespace($alias) + { + foreach (array_keys($this->getManagers()) as $name) { + try { + return $this->getManager($name)->getConfiguration()->getEntityNamespace($alias); + } catch (ORMException $e) { + } + } + + throw ORMException::unknownEntityNamespace($alias); + } +} diff --git a/src/LaravelDoctrineServiceProvider.php b/src/LaravelDoctrineServiceProvider.php index d9ec430..a34a13a 100644 --- a/src/LaravelDoctrineServiceProvider.php +++ b/src/LaravelDoctrineServiceProvider.php @@ -1,6 +1,7 @@ registerConfigurationMapper(); $this->registerCacheManager(); + $this->registerManagerRegistry(); $this->registerEntityManager(); $this->registerClassMetadataFactory(); @@ -76,32 +78,148 @@ public function registerCacheManager() }); } - private function registerEntityManager() + private function createMetadataConfiguration( + array $paths, + $isDevMode = false, + $proxyDir = null, + \Doctrine\Common\Cache\Cache $cache = null, + $useSimpleAnnotationReader = true, + $autoGenerateProxyClasses = false, + $proxyNamespace = null, + $repository = 'Doctrine\ORM\EntityRepository', + $logger = null + ) { + $metadata = Setup::createAnnotationMetadataConfiguration( + $paths, + $isDevMode, + $proxyDir, + $cache, + $useSimpleAnnotationReader + ); + + $metadata->addFilter('trashed', TrashedFilter::class); + $metadata->setAutoGenerateProxyClasses($autoGenerateProxyClasses); + if ($proxyNamespace) { + $metadata->setProxyNamespace($config['proxy']['namespace']); + } + $metadata->setDefaultRepositoryClassName($repository); + $metadata->setSQLLogger($logger); + + return $metadata; + } + + private function mapEntityManagers($config, $defaultDatabase) { - $this->app->singleton(EntityManager::class, function ($app) { - $config = $app['config']['doctrine::doctrine']; - $metadata = Setup::createAnnotationMetadataConfiguration( - $config['metadata'], - $app['config']['app.debug'], + if (!isset($config['default_connection'])) { + $config['default_connection'] = $defaultDatabase; + } + + if (!isset($config['entity_managers'])) { + $config['entity_managers'] = [ + $defaultDatabase => [ + 'metadata' => $config['metadata'] + ] + ]; + } + + return $config; + } + + private function createManagerInstances($config, $databaseConnections, $debug, CacheManager $cacheManager) + { + $registryConnections = []; + $registryManagers = []; + + $proxyNamespace = isset($config['proxy']['namespace']) ? $config['proxy']['namespace'] : null; + + $eventManager = new EventManager; + $eventManager->addEventListener(Events::onFlush, new SoftDeletableListener); + + foreach ($config['entity_managers'] as $name => $managerConfig) { + $connectionName = isset($managerConfig['connection']) ? $managerConfig['connection'] : $name; + + // skip connection names not defined in Laravel's database configuration + if (!isset($databaseConnections[$connectionName])) { + continue; + } + + $databaseConfig = $databaseConnections[$connectionName]; + $cacheProvider = isset($managerConfig['cache_provider']) ? $managerConfig['cache_provider'] : $config['cache_provider']; + $repository = isset($managerConfig['repository']) ? $managerConfig['repository'] : $config['repository']; + $simpleAnnotations = isset($managerConfig['simple_annotations']) ? $managerConfig['simple_annotations'] : $config['simple_annotations']; + $logger = isset($managerConfig['logger']) ? $managerConfig['logger'] : $config['logger']; + + $metadata = $this->createMetadataConfiguration( + $managerConfig['metadata'], + $debug, $config['proxy']['directory'], - $app[CacheManager::class]->getCache($config['cache_provider']), - $config['simple_annotations'] + $cacheManager->getCache($cacheProvider), + $simpleAnnotations, + $config['proxy']['auto_generate'], + $proxyNamespace, + $repository, + $logger + ); + + $connection = DriverManager::getConnection( + $this->mapLaravelToDoctrineConfig($databaseConfig), + $metadata, + $eventManager ); - $metadata->addFilter('trashed', TrashedFilter::class); - $metadata->setAutoGenerateProxyClasses($config['proxy']['auto_generate']); - $metadata->setDefaultRepositoryClassName($config['repository']); - $metadata->setSQLLogger($config['logger']); - if (isset($config['proxy']['namespace'])) - $metadata->setProxyNamespace($config['proxy']['namespace']); + $registryConnections[$connectionName] = "doctrine.dbal.{$connectionName}_connection"; - $eventManager = new EventManager; - $eventManager->addEventListener(Events::onFlush, new SoftDeletableListener); - $entityManager = EntityManager::create($this->mapLaravelToDoctrineConfig($app['config']), $metadata, $eventManager); + $entityManager = EntityManager::create($connection, $metadata, $eventManager); $entityManager->getFilters()->enable('trashed'); - return $entityManager; + $registryManagers[$name] = "doctrine.orm.{$name}_entity_manager"; + + $this->app->instance($registryConnections[$connectionName], $connection); + $this->app->instance($registryManagers[$name], $entityManager); + + if ($connectionName === $config['default_connection']) { + $registryConnections['default'] = 'doctrine.dbal.default_connection'; + $registryManagers['default'] = 'doctrine.orm.default_entity_manager'; + + $this->app->instance('doctrine.dbal.default_connection', $connection); + $this->app->instance('doctrine.orm.default_entity_manager', $entityManager); + } + + } + + return [$registryConnections, $registryManagers]; + } + + private function registerManagerRegistry() + { + $this->app->singleton(IlluminateRegistry::class, function ($app) { + $config = $app['config']['doctrine::doctrine']; + $databaseConnections = $app['config']['database']['connections']; + $defaultDatabase = $app['config']['database']['default']; + + $config = $this->mapEntityManagers($config, $defaultDatabase); + + list($registryConnections, $registryManagers) = $this->createManagerInstances( + $config, + $databaseConnections, + $app['config']['app.debug'], + $app[CacheManager::class] + ); + + return new IlluminateRegistry( + $app, + $registryConnections, + $registryManagers + ); }); - $this->app->singleton(EntityManagerInterface::class, EntityManager::class); + $this->app->alias(IlluminateRegistry::class, ManagerRegistry::class); + } + + private function registerEntityManager() + { + $this->app->singleton(EntityManager::class, function ($app) { + return $app->make(IlluminateRegistry::class)->getManager(); + }); + $this->app->alias(EntityManager::class, EntityManagerInterface::class); } private function registerClassMetadataFactory() @@ -122,32 +240,14 @@ private function extendAuthManager() }); } - /** - * Get the services provided by the provider. - * @return array - */ - public function provides() - { - return [ - CacheManager::class, - EntityManagerInterface::class, - EntityManager::class, - ClassMetadataFactory::class, - DriverMapper::class, - AuthManager::class, - ]; - } - /** * Map Laravel's to Doctrine's database configuration requirements. - * @param $config + * @param $databaseConfig * @throws \Exception * @return array */ - private function mapLaravelToDoctrineConfig($config) + private function mapLaravelToDoctrineConfig($databaseConfig) { - $default = $config['database.default']; - $connection = $config["database.connections.{$default}"]; - return App::make(DriverMapper::class)->map($connection); + return $this->app->make(DriverMapper::class)->map($databaseConfig); } } diff --git a/tests/MultipleEntityManagersAndConnections/AbstractDatabaseMappingTest.php b/tests/MultipleEntityManagersAndConnections/AbstractDatabaseMappingTest.php new file mode 100644 index 0000000..46356fb --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/AbstractDatabaseMappingTest.php @@ -0,0 +1,137 @@ +getMethod($name); + $method->setAccessible(true); + return $method->invokeArgs($obj, $args); + } + + protected function createCacheManager($cacheConfig) + { + $manager = new CacheManager($cacheConfig); + $manager->add(new ApcProvider); + $manager->add(new MemcacheProvider); + $manager->add(new RedisProvider); + $manager->add(new XcacheProvider); + $manager->add(new NullProvider); + + return $manager; + } + + protected function getLaravelDBConfig() + { + return [ + 'default' => 'mysql', + + 'connections' => array( + 'sqlite' => array( + 'driver' => 'sqlite', + 'database' => ':memory:', + 'prefix' => '', + ), + 'mysql' => array( + 'driver' => 'mysql', + 'host' => 'localhost', + 'database' => 'laravel', + 'username' => 'root', + 'password' => 'root', + 'charset' => 'utf8', + 'collation' => 'utf8_unicode_ci', + 'prefix' => '', + ), + 'pgsql' => array( + 'driver' => 'pgsql', + 'host' => 'localhost', + 'database' => 'database', + 'username' => 'root', + 'password' => '', + 'charset' => 'utf8', + 'prefix' => '', + 'schema' => 'public', + ), + 'sqlsrv' => array( + 'driver' => 'sqlsrv', + 'host' => 'localhost', + 'database' => 'database', + 'username' => 'root', + 'password' => '', + 'prefix' => '', + ), + ), + ]; + } + + protected function getBasicDoctrineConfiguration() + { + return [ + 'simple_annotations' => false, + + 'metadata' => [ + __DIR__.DIRECTORY_SEPARATOR.'Models', + ], + + 'proxy' => [ + 'auto_generate' => false, + 'directory' => null, + 'namespace' => null + ], + + // Available: null, apc, xcache, redis, memcache + 'cache_provider' => null, + + 'cache' => [ + 'redis' => [ + 'host' => '127.0.0.1', + 'port' => 6379, + 'database' => 1 + ], + 'memcache' => [ + 'host' => '127.0.0.1', + 'port' => 11211 + ] + ], + + 'repository' => 'Doctrine\ORM\EntityRepository', + + 'repositoryFactory' => null, + + 'logger' => null + ]; + } + + public function setUp() + { + + $container = new Container(); + + $container->bind(DriverMapper::class, function () { + $mapper = new DriverMapper; + $mapper->registerMapper(new SqlMapper); + $mapper->registerMapper(new SqliteMapper); + return $mapper; + }); + + $this->sp = new LaravelDoctrineServiceProvider($container); + $this->container = $container; + } +} diff --git a/tests/MultipleEntityManagersAndConnections/DatabaseMappingTest.php b/tests/MultipleEntityManagersAndConnections/DatabaseMappingTest.php new file mode 100644 index 0000000..253b50c --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/DatabaseMappingTest.php @@ -0,0 +1,130 @@ +getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + $this->assertEquals($laravelDBConfig['default'], $doctrineEntityConfig['default_connection']); + $this->assertArrayHasKey('entity_managers', $doctrineEntityConfig); + $this->assertArrayHasKey($laravelDBConfig['default'], $doctrineEntityConfig['entity_managers']); + $this->assertSame( + $basicDoctrineConfig['metadata'], + $doctrineEntityConfig['entity_managers'][$laravelDBConfig['default']]['metadata'] + ); + } + + + public function testCreateManagerInstances() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $basicDoctrineConfig['default_connection'] = 'pgsql'; + $basicDoctrineConfig['entity_managers'] = [ + 'pgsqlEntityManager' => [ + 'connection' => 'pgsql', + 'metadata' => $basicDoctrineConfig['metadata'] + ] + ]; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $this->assertArrayHasKey('pgsql', $registryConnections); + $this->assertArrayHasKey('pgsqlEntityManager', $registryManagers); + } + + public function testRegistryInstances() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $em = $registry->getManager('mysql'); + + $this->assertSame($em, $registry->getManager()); + $this->assertSame($em, $registry->getManager('default')); + $this->assertSame($em, $this->container->make('doctrine.orm.mysql_entity_manager')); + $this->assertSame($em, $this->container->make('doctrine.orm.default_entity_manager')); + + $con = $registry->getConnection('mysql'); + $this->assertSame($con, $registry->getConnection()); + $this->assertSame($con, $registry->getConnection('default')); + $this->assertSame($con, $this->container->make('doctrine.dbal.mysql_connection')); + $this->assertSame($con, $this->container->make('doctrine.dbal.default_connection')); + } + + public function testUndefinedConnection() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $laravelDBConfig['default'] = 'misconfigure'; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $this->assertArrayNotHasKey('misconfigure', $registryConnections); + } +} diff --git a/tests/MultipleEntityManagersAndConnections/ExpectedOutput/GenerateProxiesCommandTestOutput.txt b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/GenerateProxiesCommandTestOutput.txt new file mode 100644 index 0000000..68e18ac --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/GenerateProxiesCommandTestOutput.txt @@ -0,0 +1,4 @@ +Starting proxy generation.... +Processing entities: +Tests\MultipleEntityManagersAndConnections\Models\User +Proxies have been created. diff --git a/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaCreateCommandTestOutput.txt b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaCreateCommandTestOutput.txt new file mode 100644 index 0000000..98dd586 --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaCreateCommandTestOutput.txt @@ -0,0 +1,3 @@ +Outputting create query: + +CREATE TABLE user (id INTEGER NOT NULL, name VARCHAR(255) NOT NULL, PRIMARY KEY(id)) diff --git a/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaDropCommandTestOutput.txt b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaDropCommandTestOutput.txt new file mode 100644 index 0000000..ebb11d2 --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaDropCommandTestOutput.txt @@ -0,0 +1,2 @@ +Outputting drop query: +DROP TABLE user diff --git a/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaUpdateCommandTestOutput.txt b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaUpdateCommandTestOutput.txt new file mode 100644 index 0000000..ad51d4c --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/ExpectedOutput/SchemaUpdateCommandTestOutput.txt @@ -0,0 +1,3 @@ +Checking if database needs updating.... +Outputting update query: +CREATE TABLE user (id INTEGER NOT NULL, name VARCHAR(255) NOT NULL, PRIMARY KEY(id)) diff --git a/tests/MultipleEntityManagersAndConnections/GenerateProxiesCommandTest.php b/tests/MultipleEntityManagersAndConnections/GenerateProxiesCommandTest.php new file mode 100644 index 0000000..10af2bd --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/GenerateProxiesCommandTest.php @@ -0,0 +1,121 @@ +expected = file_get_contents(__DIR__.DIRECTORY_SEPARATOR.'ExpectedOutput'.DIRECTORY_SEPARATOR.'GenerateProxiesCommandTestOutput.txt'); + } + + public function testDefaultGenerate() + { + + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $laravelDBConfig['default'] = 'sqlite'; + $basicDoctrineConfig['proxy']['directory'] = sys_get_temp_dir(); + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new GenerateProxiesCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput([]); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + } + + public function testSpecificGenerate() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + $basicDoctrineConfig['proxy']['directory'] = sys_get_temp_dir(); + + $basicDoctrineConfig['entity_managers'] = [ + 'pgsql' => [ + 'connection' => 'pgsql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'mysql' => [ + 'connection' => 'mysql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'sqlite' => [ + 'connection' => 'sqlite', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + + ]; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new GenerateProxiesCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--em' => 'sqlite']); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + } +} diff --git a/tests/MultipleEntityManagersAndConnections/Models/User.php b/tests/MultipleEntityManagersAndConnections/Models/User.php new file mode 100644 index 0000000..0bb9c2e --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/Models/User.php @@ -0,0 +1,32 @@ +name; + } + + public function setName($name) + { + $this->name = $name; + } +} diff --git a/tests/MultipleEntityManagersAndConnections/SchemaCreateCommandTest.php b/tests/MultipleEntityManagersAndConnections/SchemaCreateCommandTest.php new file mode 100644 index 0000000..7a6b7db --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/SchemaCreateCommandTest.php @@ -0,0 +1,137 @@ +expected = file_get_contents(__DIR__.DIRECTORY_SEPARATOR.'ExpectedOutput'.DIRECTORY_SEPARATOR.'SchemaCreateCommandTestOutput.txt'); + } + + public function testDefaultCreate() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $laravelDBConfig['default'] = 'sqlite'; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--sql' => null]); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput([]); + $command->run($input, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $command->run($input, $output); + } + + public function testSpecificCreate() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $basicDoctrineConfig['entity_managers'] = [ + 'pgsql' => [ + 'connection' => 'pgsql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'mysql' => [ + 'connection' => 'mysql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'sqlite' => [ + 'connection' => 'sqlite', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + + ]; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--sql' => null, '--em' => 'sqlite']); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--em' => 'sqlite']); + $command->run($input, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $command->run($input, $output); + } +} diff --git a/tests/MultipleEntityManagersAndConnections/SchemaDropCommandTest.php b/tests/MultipleEntityManagersAndConnections/SchemaDropCommandTest.php new file mode 100644 index 0000000..01c9df5 --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/SchemaDropCommandTest.php @@ -0,0 +1,137 @@ +expected = file_get_contents(__DIR__.DIRECTORY_SEPARATOR.'ExpectedOutput'.DIRECTORY_SEPARATOR.'SchemaDropCommandTestOutput.txt'); + } + + public function testDefaultDrop() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $laravelDBConfig['default'] = 'sqlite'; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $inputNoOptions = new ArrayInput([]); + $output = new BufferedOutput(); + + $command->run($inputNoOptions, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $inputSql = new ArrayInput(['--sql' => null]); + $output = new BufferedOutput(); + + $command->run($inputSql, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command->run($inputNoOptions, $output); + } + + public function testSpecificDrop() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $basicDoctrineConfig['entity_managers'] = [ + 'pgsql' => [ + 'connection' => 'pgsql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'mysql' => [ + 'connection' => 'mysql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'sqlite' => [ + 'connection' => 'sqlite', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + + ]; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaCreateCommand($registry); + $command->setLaravel($this->container); + $inputNoOptions = new ArrayInput(['--em' => 'sqlite']); + $output = new BufferedOutput(); + + $command->run($inputNoOptions, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $inputSql = new ArrayInput(['--sql' => null,'--em' => 'sqlite']); + $output = new BufferedOutput(); + + $command->run($inputSql, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command->run($inputNoOptions, $output); + } +} diff --git a/tests/MultipleEntityManagersAndConnections/SchemaUpdateCommandTest.php b/tests/MultipleEntityManagersAndConnections/SchemaUpdateCommandTest.php new file mode 100644 index 0000000..13d46a0 --- /dev/null +++ b/tests/MultipleEntityManagersAndConnections/SchemaUpdateCommandTest.php @@ -0,0 +1,138 @@ +expected = file_get_contents(__DIR__.DIRECTORY_SEPARATOR.'ExpectedOutput'.DIRECTORY_SEPARATOR.'SchemaUpdateCommandTestOutput.txt'); + } + + public function testDefaultUpdate() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $laravelDBConfig['default'] = 'sqlite'; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaUpdateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--sql' => null]); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command = new SchemaUpdateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput([]); + $command->run($input, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $command->run($input, $output); + } + + + public function testSpecificUpdate() + { + $laravelDBConfig = $this->getLaravelDBConfig(); + $basicDoctrineConfig = $this->getBasicDoctrineConfiguration(); + + $basicDoctrineConfig['entity_managers'] = [ + 'pgsql' => [ + 'connection' => 'pgsql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'mysql' => [ + 'connection' => 'mysql', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + 'sqlite' => [ + 'connection' => 'sqlite', + 'metadata' => $basicDoctrineConfig['metadata'] + ], + + ]; + + $doctrineEntityConfig = $this->callMethod( + $this->sp, + 'mapEntityManagers', + array($basicDoctrineConfig, $laravelDBConfig['default']) + ); + + list($registryConnections, $registryManagers) = $this->callMethod( + $this->sp, + 'createManagerInstances', + array( + $doctrineEntityConfig, + $laravelDBConfig['connections'], + false, + $this->createCacheManager($basicDoctrineConfig['cache']) + ) + ); + + $registry = new IlluminateRegistry( + $this->container, + $registryConnections, + $registryManagers + ); + + $command = new SchemaUpdateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--sql' => null, '--em' => 'sqlite']); + $output = new BufferedOutput(); + + $command->run($input, $output); + + $this->assertEquals( + $this->expected, + $output->fetch() + ); + + $command = new SchemaUpdateCommand($registry); + $command->setLaravel($this->container); + $input = new ArrayInput(['--em' => 'sqlite']); + $command->run($input, $output); + + $command = new SchemaDropCommand($registry); + $command->setLaravel($this->container); + $command->run($input, $output); + } +}