coolify/tests/Unit/DatabaseImport/DatabaseImportCommandBuilderTest.php

<?php

use App\Models\ServiceDatabase;
use App\Models\StandaloneMariadb;
use App\Models\StandaloneMongodb;
use App\Models\StandaloneMysql;
use App\Models\StandalonePostgresql;
use App\Models\StandaloneRedis;
use App\Support\DatabaseImport\DatabaseImportCommandBuilder;

function importResource(string $class, ?string $databaseType = null): object
{
    $resource = Mockery::mock($class);
    $resource->shouldReceive('getMorphClass')->andReturn($class);
    if ($class === ServiceDatabase::class) {
        $resource->shouldReceive('databaseType')->andReturn($databaseType);
    }

    return $resource;
}

test('builds database-specific restore commands', function (string $class, ?string $type, string $needle) {
    $builder = new DatabaseImportCommandBuilder;

    $command = $builder->buildRestoreCommand(importResource($class, $type), '/tmp/restore file', false);

    expect($command)->toContain($needle)->toContain("'/tmp/restore file'");
})->with([
    'postgresql' => [StandalonePostgresql::class, null, 'pg_restore'],
    'mysql' => [StandaloneMysql::class, null, 'mysql -u $MYSQL_USER'],
    'mariadb' => [StandaloneMariadb::class, null, 'mariadb -u $MARIADB_USER'],
    'mongodb' => [StandaloneMongodb::class, null, 'mongorestore'],
    'service postgres' => [ServiceDatabase::class, 'postgresql', 'pg_restore'],
    'service mysql' => [ServiceDatabase::class, 'mysql', 'mysql -u $MYSQL_USER'],
    'service mariadb' => [ServiceDatabase::class, 'mariadb', 'mariadb -u $MARIADB_USER'],
    'service mongo' => [ServiceDatabase::class, 'mongodb', 'mongorestore'],
]);

test('builds dump-all commands and postgres safety scan', function () {
    $builder = new DatabaseImportCommandBuilder;
    $postgres = importResource(StandalonePostgresql::class);

    expect($builder->buildRestoreCommand($postgres, '/tmp/dump.sql.gz', true))
        ->toContain('pg_terminate_backend')
        ->toContain("gunzip -cf '/tmp/dump.sql.gz'")
        ->and($builder->buildPostgresSafetyCommand($postgres, 'postgres-safe', '/tmp/dump.sql.gz'))
        ->toContain('COPY ... PROGRAM')
        ->toContain('docker exec postgres-safe');
});

test('dump-all mysql and mariadb commands use valid shell parameter expansions', function (string $class, string $binary, string $prefix) {
    $builder = new DatabaseImportCommandBuilder;

    $command = $builder->buildRestoreCommand(importResource($class), '/tmp/dump.sql.gz', true);

    $rootPassword = '${'.$prefix.'_ROOT_PASSWORD}';
    $database = '${'.$prefix.'_DATABASE:-default}';

    expect($command)
        ->toContain($binary)
        ->toContain("gunzip -cf '/tmp/dump.sql.gz'")
        ->toContain('-p'.$rootPassword)
        ->toContain('CREATE DATABASE IF NOT EXISTS \`'.$database.'\`')
        ->and(substr_count($command, $rootPassword))->toBe(6)
        ->and(substr_count($command, $database))->toBe(2)
        ->and($command)->not->toContain('${{');
})->with([
    'mysql' => [StandaloneMysql::class, 'mysql', 'MYSQL'],
    'mariadb' => [StandaloneMariadb::class, 'mariadb', 'MARIADB'],
]);

test('stops PostgreSQL restores on the first error without replacing existing objects by default', function () {
    $builder = new DatabaseImportCommandBuilder;
    $postgres = importResource(StandalonePostgresql::class);

    expect($builder->buildRestoreCommand($postgres, '/tmp/backup.dump', false, false))
        ->toContain('--exit-on-error')
        ->not->toContain('--clean')
        ->not->toContain('--if-exists');
});

test('replaces existing PostgreSQL objects when requested', function () {
    $builder = new DatabaseImportCommandBuilder;
    $postgres = importResource(StandalonePostgresql::class);

    expect($builder->buildRestoreCommand($postgres, '/tmp/backup.dump', false, true))
        ->toContain('--clean')
        ->toContain('--if-exists')
        ->toContain('--exit-on-error');
});

test('rejects unsupported database types', function () {
    $builder = new DatabaseImportCommandBuilder;
    $redis = importResource(StandaloneRedis::class);

    expect(fn () => $builder->buildRestoreCommand($redis, '/tmp/backup', false))
        ->toThrow(InvalidArgumentException::class, 'not supported');
});