Deploymentcenter/tests/server/testctl.php

<?php

/**
 * Steuerung der Testinstanz.
 *
 * ACHTUNG: Diese Datei liegt NUR auf der Testinstanz. scripts/deploy_dev.py
 * laedt sie eigens nach /testctl.php hoch; scripts/deploy.py schliesst das
 * ganze Verzeichnis tests/ aus. Sie darf nie Teil eines Produktivstands
 * werden - deshalb steht sie hier und nicht unter public/.
 *
 * Warum es sie ueberhaupt gibt: Ein automatisierter Testlauf braucht einen
 * definierten Ausgangszustand. Ohne den prueft der zweite Lauf etwas anderes
 * als der erste, und ein Fehlschlag sagt nichts mehr darueber aus, ob die
 * Anwendung kaputt ist oder nur der Datenbestand gewachsen. Das Zuruecksetzen
 * muss dort passieren, wo die Datenbank steht - also auf dem Server.
 *
 * Drei Schloesser sitzen davor, und jedes einzelne wuerde reichen:
 *   1. Basic-Auth der Testinstanz (die Datei liegt nicht unter /api/)
 *   2. testing.enabled = true UND app.env = 'test' in der config.php.
 *      Die Produktivkonfiguration hat beides nicht.
 *   3. Der Shared Key der Instanz, per Header. Kein Session-Zugang: ein
 *      Browserfenster, das noch offen ist, soll keine Tabellen loeschen.
 * Fuer die zerstoerenden Aktionen kommt der Name der Datenbank als
 * Bestaetigung dazu - so laesst sich "reset" nicht versehentlich gegen die
 * falsche Instanz absetzen.
 */

declare(strict_types=1);

require_once __DIR__ . '/src/bootstrap.php';

use Deploymentcenter\Core\Config;
use Deploymentcenter\Core\Db;
use Deploymentcenter\Core\Http;
use Deploymentcenter\Core\Migrator;
use Deploymentcenter\Core\TokenManager;

Http::beginJson(['GET', 'POST', 'OPTIONS']);

// --- Schloss 2: Diese Instanz muss sich selbst als Testinstanz ausweisen ---
if (Config::get('testing.enabled') !== true || Config::get('app.env') !== 'test') {
    Http::fail(
        403,
        'not_a_test_instance',
        'testctl steht nur auf einer Instanz mit testing.enabled = true und app.env = "test" zur Verfuegung.'
    );
}

// --- Schloss 3: Shared Key, ohne Umweg ueber Sitzung oder Sub-Token ---
$sharedKey = (string)Config::get('security.shared_key', '');
$presented = (string)(Http::bearerToken() ?? '');
if ($sharedKey === '' || !hash_equals($sharedKey, $presented)) {
    Http::fail(401, 'unauthorized', 'Shared Key erforderlich (Header X-Master-Token oder Authorization: Bearer).');
}

$db = Db::init();
$dbName = (string)Config::get('db.dbname', '');
$action = strtolower(trim((string)(Http::str('action') ?? 'status')));

/** Bestaetigung fuer alles, was Daten vernichtet. */
$requireConfirmation = static function () use ($dbName): void {
    if ((string)(Http::str('confirm') ?? '') !== $dbName) {
        Http::fail(
            400,
            'confirmation_required',
            sprintf('Zur Bestaetigung muss confirm den Datenbanknamen enthalten ("%s").', $dbName)
        );
    }
};

/** Alle Tabellen der Testdatenbank entfernen. */
$wipe = static function () use ($db): array {
    $tables = $db->query('SHOW TABLES')->fetchAll(PDO::FETCH_COLUMN) ?: [];
    if ($tables === []) {
        return [];
    }

    // Fremdschluessel vorruebergehend aus: sonst haengt die Reihenfolge des
    // Loeschens von der Reihenfolge der Tabellen ab, und die ist nicht stabil.
    $db->exec('SET FOREIGN_KEY_CHECKS = 0');
    try {
        foreach ($tables as $table) {
            $db->exec('DROP TABLE IF EXISTS `' . str_replace('`', '', (string)$table) . '`');
        }
    } finally {
        $db->exec('SET FOREIGN_KEY_CHECKS = 1');
    }

    return array_map('strval', $tables);
};

/** Zustand der Instanz - der Blick, den ein Testlauf vor und nach sich wirft. */
$status = static function () use ($db, $dbName): array {
    $tables = $db->query('SHOW TABLES')->fetchAll(PDO::FETCH_COLUMN) ?: [];
    $counts = [];
    foreach ($tables as $table) {
        $name = (string)$table;
        try {
            $counts[$name] = (int)$db->query('SELECT COUNT(*) FROM `' . str_replace('`', '', $name) . '`')->fetchColumn();
        } catch (Throwable $e) {
            $counts[$name] = null;
        }
    }

    $migrations = [];
    if (in_array('dc_migrations', array_map('strval', $tables), true)) {
        $migrations = $db->query('SELECT version FROM dc_migrations ORDER BY version')
            ->fetchAll(PDO::FETCH_COLUMN) ?: [];
    }

    return [
        'database'    => $dbName,
        'php'         => PHP_VERSION,
        'app_version' => Config::get('app.version'),
        'debug'       => Config::isDebug(),
        'tables'      => count($tables),
        'rows'        => $counts,
        'migrations'  => array_map('strval', $migrations),
        'log_dir'     => is_writable(DC_VAR . '/log'),
        'signing_key' => is_readable((string)Config::get('security.release_private_key', '')),
    ];
};

switch ($action) {
    // ------------------------------------------------------------------
    case 'status':
        Http::ok($status());
        break;

    // ------------------------------------------------------------------
    case 'wipe':
        $requireConfirmation();
        Http::ok(['dropped' => $wipe(), 'state' => $status()]);
        break;

    // ------------------------------------------------------------------
    case 'migrate':
        $result = Migrator::migrate($db);
        if ($result['failed'] !== null) {
            Http::fail(500, 'migration_failed', 'Migration abgebrochen.', null, $result);
        }
        Http::ok(['migration' => $result, 'state' => $status()]);
        break;

    // ------------------------------------------------------------------
    // Ausgangszustand herstellen: leere Datenbank, frisches Schema, ein
    // Administrator und ein Master-Token mit allen Rechten. Beides gibt der
    // Aufruf zurueck - der Testlauf soll sich seine Zugaenge selbst holen
    // koennen und nicht darauf warten, dass jemand im WebUI etwas anklickt.
    // ------------------------------------------------------------------
    case 'reset':
        $requireConfirmation();

        $dropped = $wipe();

        $result = Migrator::migrate($db);
        if ($result['failed'] !== null) {
            Http::fail(500, 'migration_failed', 'Migration nach dem Zuruecksetzen abgebrochen.', null, $result);
        }

        $adminUser = (string)(Http::str('admin_user') ?? 'admin');
        $adminPass = (string)(Http::str('admin_pass') ?? 'test02763!');

        $db->prepare('DELETE FROM dc_users WHERE username = :u')->execute([':u' => $adminUser]);
        $db->prepare('
            INSERT INTO dc_users (username, password_hash, created_at)
            VALUES (:u, :h, UTC_TIMESTAMP())
        ')->execute([':u' => $adminUser, ':h' => password_hash($adminPass, PASSWORD_DEFAULT)]);

        // Rolle setzen, falls die Spalte existiert (Migration 012).
        try {
            $db->prepare('UPDATE dc_users SET role = "admin" WHERE username = :u')->execute([':u' => $adminUser]);
        } catch (Throwable $e) {
            // Ohne Rollenspalte ist jeder Benutzer Administrator - nichts zu tun.
        }

        $manager = new TokenManager($db);
        $master = $manager->createMasterToken(
            'Testlauf (automatisch)',
            null,
            null,
            'custom',
            'testkit',
            ['*'],
            'all'
        );

        Http::ok([
            'dropped'   => $dropped,
            'migration' => $result,
            'admin'     => ['username' => $adminUser, 'password' => $adminPass],
            'master'    => ['token_id' => $master['token_id'], 'raw_token' => $master['raw_token']],
            'state'     => $status(),
        ]);
        break;

    // ------------------------------------------------------------------
    // Signierschluessel fuer den Updateservice. Er wird auf der Testinstanz
    // erzeugt und nie von der Produktion kopiert - ein Testlauf darf mit dem
    // Schluessel, mit dem echte Releases signiert werden, nichts zu tun haben.
    // ------------------------------------------------------------------
    case 'genkey':
        $target = (string)Config::get('security.release_private_key', DC_ROOT . '/config/release-signing.pem');

        if (is_readable($target) && (string)(Http::str('force') ?? '') !== '1') {
            Http::ok(['created' => false, 'path' => basename($target), 'message' => 'Schluessel vorhanden.']);
        }

        $res = openssl_pkey_new([
            'private_key_bits' => 4096,
            'private_key_type' => OPENSSL_KEYTYPE_RSA,
        ]);
        if ($res === false) {
            Http::fail(500, 'keygen_failed', 'Schluesselerzeugung fehlgeschlagen: ' . openssl_error_string());
        }

        $pem = '';
        openssl_pkey_export($res, $pem);
        if (file_put_contents($target, $pem) === false) {
            Http::fail(500, 'keygen_failed', 'Schluessel konnte nicht geschrieben werden.');
        }
        @chmod($target, 0600);

        $details = openssl_pkey_get_details($res);
        Http::ok([
            'created' => true,
            'path'    => basename($target),
            'bits'    => $details['bits'] ?? null,
            'public'  => $details['key'] ?? null,
        ]);
        break;

    // ------------------------------------------------------------------
    // Protokoll lesen. Ohne diese Aktion endet jeder fehlgeschlagene Testlauf
    // bei "500" und dem Ratespiel, was dahinter stand - die Logdatei liegt
    // unter var/log/ und ist per .htaccess zu Recht gesperrt.
    // ------------------------------------------------------------------
    case 'log':
        $lines = max(1, min(500, (int)(Http::str('lines') ?? 80)));
        $dir = DC_VAR . '/log';
        $files = glob($dir . '/*.log') ?: [];
        usort($files, static fn($a, $b) => filemtime($b) <=> filemtime($a));

        $out = [];
        foreach (array_slice($files, 0, 3) as $file) {
            $content = file($file, FILE_IGNORE_NEW_LINES) ?: [];
            $out[basename($file)] = array_slice($content, -$lines);
        }
        Http::ok(['log' => $out]);
        break;

    // ------------------------------------------------------------------
    case 'clearlog':
        foreach (glob(DC_VAR . '/log/*.log') ?: [] as $file) {
            file_put_contents($file, '');
        }
        Http::ok(['cleared' => true]);
        break;

    // ------------------------------------------------------------------
    default:
        Http::fail(400, 'unknown_action', sprintf('Unbekannte Aktion "%s".', $action), null, [
            'actions' => ['status', 'wipe', 'migrate', 'reset', 'genkey', 'log', 'clearlog'],
        ]);
}