1
0
Fork 0
mirror of https://github.com/archtechx/tenancy.git synced 2025-12-12 09:14:03 +00:00

[4.x] Migrate tests to Pest (#884)

* Add Pest dependencies

* Add base Pest file

* Convert test cases

* Remove non-compound imports

* Adopt expectation API

* Optimize uses

* Shift cleanup

* phpunit -> pest

* Fix tests in PR #884 PHPUnit to Pest Converter  (#885)

* fixed tests, remove method duplications, restore necessary inner classes

* Update CommandsTest.php

* temporary checks run on `shift-64622` on branch.

* fixed `TestSeeder` class not resolved

* fixed messed up names

* removed `uses` from individual files and add it in `Pest`

* extract tests to helpers

* use pest dataset

* Update AutomaticModeTest.php

* newline

* todo convention

* resolve reviews

* added `// todo@tests`

* remove shift branch from CI workflow

Co-authored-by: Samuel Štancl <samuel@archte.ch>

* check if I have write permission

* Convert newly added tests to Pest

Co-authored-by: Shift <shift@laravelshift.com>
Co-authored-by: Abrar Ahmad <abrar.dev99@gmail.com>
This commit is contained in:
Samuel Štancl 2022-07-22 19:26:59 +02:00 committed by GitHub
parent 69de181b7d
commit b47c5549ef
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
32 changed files with 3010 additions and 3478 deletions

View file

@ -2,13 +2,10 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use PDO;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
use Stancl\Tenancy\Database\DatabaseManager;
@ -27,252 +24,228 @@ use Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager;
use Stancl\Tenancy\TenantDatabaseManagers\SQLiteDatabaseManager;
use Stancl\Tenancy\Tests\Etc\Tenant;
class TenantDatabaseManagerTest extends TestCase
test('databases can be created and deleted', function ($driver, $databaseManager) {
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
config()->set([
"tenancy.database.managers.$driver" => $databaseManager,
]);
$name = 'db' . $this->randomString();
$manager = app($databaseManager);
$manager->setConnection($driver);
expect($manager->databaseExists($name))->toBeFalse();
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => $driver,
]);
expect($manager->databaseExists($name))->toBeTrue();
$manager->deleteDatabase($tenant);
expect($manager->databaseExists($name))->toBeFalse();
})->with('database_manager_provider');
test('dbs can be created when another driver is used for the central db', function () {
expect(config('database.default'))->toBe('central');
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$database = 'db' . $this->randomString();
$mysqlmanager = app(MySQLDatabaseManager::class);
$mysqlmanager->setConnection('mysql');
expect($mysqlmanager->databaseExists($database))->toBeFalse();
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'mysql',
]);
expect($mysqlmanager->databaseExists($database))->toBeTrue();
$postgresManager = app(PostgreSQLDatabaseManager::class);
$postgresManager->setConnection('pgsql');
$database = 'db' . $this->randomString();
expect($postgresManager->databaseExists($database))->toBeFalse();
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'pgsql',
]);
expect($postgresManager->databaseExists($database))->toBeTrue();
});
test('the tenant connection is fully removed', function () {
config([
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
$tenant = Tenant::create();
expect(array_keys(app('db')->getConnections()))->toBe(['central']);
$this->assertArrayNotHasKey('tenant', config('database.connections'));
tenancy()->initialize($tenant);
createUsersTable();
expect(array_keys(app('db')->getConnections()))->toBe(['central', 'tenant']);
$this->assertArrayHasKey('tenant', config('database.connections'));
tenancy()->end();
expect(array_keys(app('db')->getConnections()))->toBe(['central']);
expect(config('database.connections.tenant'))->toBeNull();
});
test('db name is prefixed with db path when sqlite is used', function () {
if (file_exists(database_path('foodb'))) {
unlink(database_path('foodb')); // cleanup
}
config([
'database.connections.fooconn.driver' => 'sqlite',
]);
$tenant = Tenant::create([
'tenancy_db_name' => 'foodb',
'tenancy_db_connection' => 'fooconn',
]);
app(DatabaseManager::class)->createTenantConnection($tenant);
expect(database_path('foodb'))->toBe(config('database.connections.tenant.database'));
});
test('schema manager uses schema to separate tenant dbs', function () {
config([
'tenancy.database.managers.pgsql' => \Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager::class,
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$originalDatabaseName = config(['database.connections.pgsql.database']);
$tenant = Tenant::create([
'tenancy_db_connection' => 'pgsql',
]);
tenancy()->initialize($tenant);
$schemaConfig = version_compare(app()->version(), '9.0', '>=') ?
config('database.connections.' . config('database.default') . '.search_path') :
config('database.connections.' . config('database.default') . '.schema');
expect($schemaConfig)->toBe($tenant->database()->getName());
expect(config(['database.connections.pgsql.database']))->toBe($originalDatabaseName);
});
test('a tenants database cannot be created when the database already exists', function () {
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
]);
$manager = $tenant->database()->manager();
expect($manager->databaseExists($tenant->database()->getName()))->toBeTrue();
$this->expectException(TenantDatabaseAlreadyExistsException::class);
$tenant2 = Tenant::create([
'tenancy_db_name' => $name,
]);
});
test('tenant database can be created on a foreign server', function () {
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'database.connections.mysql2' => [
'driver' => 'mysql',
'host' => 'mysql2', // important line
'port' => 3306,
'database' => 'main',
'username' => 'root',
'password' => 'password',
'unix_socket' => env('DB_SOCKET', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'prefix_indexes' => true,
'strict' => true,
'engine' => null,
'options' => extension_loaded('pdo_mysql') ? array_filter([
PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
]) : [],
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => 'mysql2',
]);
/** @var PermissionControlledMySQLDatabaseManager $manager */
$manager = $tenant->database()->manager();
$manager->setConnection('mysql');
expect($manager->databaseExists($name))->toBeFalse();
$manager->setConnection('mysql2');
expect($manager->databaseExists($name))->toBeTrue();
});
test('path used by sqlite manager can be customized', function () {
$this->markTestIncomplete();
});
// Datasets
dataset('database_manager_provider', [
['mysql', MySQLDatabaseManager::class],
['mysql', PermissionControlledMySQLDatabaseManager::class],
['sqlite', SQLiteDatabaseManager::class],
['pgsql', PostgreSQLDatabaseManager::class],
['pgsql', PostgreSQLSchemaManager::class],
['sqlsrv', MicrosoftSQLDatabaseManager::class]
]);
function createUsersTable()
{
/**
* @test
* @dataProvider database_manager_provider
*/
public function databases_can_be_created_and_deleted($driver, $databaseManager)
{
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
config()->set([
"tenancy.database.managers.$driver" => $databaseManager,
]);
$name = 'db' . $this->randomString();
$manager = app($databaseManager);
$manager->setConnection($driver);
$this->assertFalse($manager->databaseExists($name));
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => $driver,
]);
$this->assertTrue($manager->databaseExists($name));
$manager->deleteDatabase($tenant);
$this->assertFalse($manager->databaseExists($name));
}
/** @test */
public function dbs_can_be_created_when_another_driver_is_used_for_the_central_db()
{
$this->assertSame('central', config('database.default'));
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$database = 'db' . $this->randomString();
$mysqlmanager = app(MySQLDatabaseManager::class);
$mysqlmanager->setConnection('mysql');
$this->assertFalse($mysqlmanager->databaseExists($database));
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'mysql',
]);
$this->assertTrue($mysqlmanager->databaseExists($database));
$postgresManager = app(PostgreSQLDatabaseManager::class);
$postgresManager->setConnection('pgsql');
$database = 'db' . $this->randomString();
$this->assertFalse($postgresManager->databaseExists($database));
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'pgsql',
]);
$this->assertTrue($postgresManager->databaseExists($database));
}
public function database_manager_provider()
{
return [
['mysql', MySQLDatabaseManager::class],
['mysql', PermissionControlledMySQLDatabaseManager::class],
['sqlite', SQLiteDatabaseManager::class],
['pgsql', PostgreSQLDatabaseManager::class],
['pgsql', PostgreSQLSchemaManager::class],
['sqlsrv', MicrosoftSQLDatabaseManager::class],
];
}
/** @test */
public function the_tenant_connection_is_fully_removed()
{
config([
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
$tenant = Tenant::create();
$this->assertSame(['central'], array_keys(app('db')->getConnections()));
$this->assertArrayNotHasKey('tenant', config('database.connections'));
tenancy()->initialize($tenant);
$this->createUsersTable();
$this->assertSame(['central', 'tenant'], array_keys(app('db')->getConnections()));
$this->assertArrayHasKey('tenant', config('database.connections'));
tenancy()->end();
$this->assertSame(['central'], array_keys(app('db')->getConnections()));
$this->assertNull(config('database.connections.tenant'));
}
protected function createUsersTable()
{
Schema::create('users', function (Blueprint $table) {
$table->increments('id');
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}
/** @test */
public function db_name_is_prefixed_with_db_path_when_sqlite_is_used()
{
if (file_exists(database_path('foodb'))) {
unlink(database_path('foodb')); // cleanup
}
config([
'database.connections.fooconn.driver' => 'sqlite',
]);
$tenant = Tenant::create([
'tenancy_db_name' => 'foodb',
'tenancy_db_connection' => 'fooconn',
]);
app(DatabaseManager::class)->createTenantConnection($tenant);
$this->assertSame(config('database.connections.tenant.database'), database_path('foodb'));
}
/** @test */
public function schema_manager_uses_schema_to_separate_tenant_dbs()
{
config([
'tenancy.database.managers.pgsql' => \Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager::class,
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$originalDatabaseName = config(['database.connections.pgsql.database']);
$tenant = Tenant::create([
'tenancy_db_connection' => 'pgsql',
]);
tenancy()->initialize($tenant);
$schemaConfig = version_compare(app()->version(), '9.0', '>=') ?
config('database.connections.' . config('database.default') . '.search_path') :
config('database.connections.' . config('database.default') . '.schema');
$this->assertSame($tenant->database()->getName(), $schemaConfig);
$this->assertSame($originalDatabaseName, config(['database.connections.pgsql.database']));
}
/** @test */
public function a_tenants_database_cannot_be_created_when_the_database_already_exists()
{
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
]);
$manager = $tenant->database()->manager();
$this->assertTrue($manager->databaseExists($tenant->database()->getName()));
$this->expectException(TenantDatabaseAlreadyExistsException::class);
$tenant2 = Tenant::create([
'tenancy_db_name' => $name,
]);
}
/** @test */
public function tenant_database_can_be_created_on_a_foreign_server()
{
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'database.connections.mysql2' => [
'driver' => 'mysql',
'host' => 'mysql2', // important line
'port' => 3306,
'database' => 'main',
'username' => 'root',
'password' => 'password',
'unix_socket' => env('DB_SOCKET', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'prefix_indexes' => true,
'strict' => true,
'engine' => null,
'options' => extension_loaded('pdo_mysql') ? array_filter([
PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
]) : [],
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => 'mysql2',
]);
/** @var PermissionControlledMySQLDatabaseManager $manager */
$manager = $tenant->database()->manager();
$manager->setConnection('mysql');
$this->assertFalse($manager->databaseExists($name));
$manager->setConnection('mysql2');
$this->assertTrue($manager->databaseExists($name));
}
/** @test */
public function path_used_by_sqlite_manager_can_be_customized()
{
$this->markTestIncomplete();
}
Schema::create('users', function (Blueprint $table) {
$table->increments('id');
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}