Your Backup Ran.
But Would It Actually Restore?

class VerifyBackupIntegrityJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $timeout = 600;
    public int $tries   = 1; // failures need human eyes, not retries

    public function __construct(
        private readonly string $disk,
        private readonly string $backupPath,
    ) {}

    public function handle(): void
    {
        $tempDir = storage_path('app/backup-verification/' . uniqid());

        try {
            $this->extractBackup($tempDir);
            $this->restoreToShadow($tempDir);
            $this->runAssertions();

            Notification::route('slack', config('backup-verify.slack_webhook'))
                ->notify(new BackupVerificationPassed($this->disk, $this->backupPath));

        } catch (Exception $e) {
            Log::error('Backup verification FAILED', [
                'disk'  => $this->disk,
                'path'  => $this->backupPath,
                'error' => $e->getMessage(),
            ]);

            Notification::route('slack', config('backup-verify.slack_webhook'))
                ->notify(new BackupVerificationFailed($this->disk, $this->backupPath, $e->getMessage()));

            throw $e; // surfaces as failed in Horizon

        } finally {
            $this->cleanup($tempDir);
        }
    }

    private function extractBackup(string $tempDir): void
    {
        mkdir($tempDir, 0755, true);

        $localZip = $tempDir . '/backup.zip';
        $contents = Storage::disk($this->disk)->get($this->backupPath);

        if ($contents === null) {
            throw new Exception("Could not download backup from [{$this->disk}]:[{$this->backupPath}]");
        }

        file_put_contents($localZip, $contents);

        $zip    = new ZipArchive();
        $result = $zip->open($localZip);

        if ($result !== true) {
            throw new Exception("Archive failed to open — ZipArchive error: {$result}");
        }

        $zip->extractTo($tempDir . '/extracted');
        $zip->close();
    }

    private function restoreToShadow(string $tempDir): void
    {
        $dumps = glob($tempDir . '/extracted/*/db-dumps/*.sql');

        if (empty($dumps)) {
            throw new Exception('No SQL dump found in backup archive');
        }

        $conn = config('database.connections.shadow');

        DB::statement("DROP DATABASE IF EXISTS `{$conn['database']}`");
        DB::statement("CREATE DATABASE `{$conn['database']}`");

        $command = sprintf(
            'mysql -h%s -u%s -p%s %s < %s 2>&1',
            escapeshellarg($conn['host']),
            escapeshellarg($conn['username']),
            escapeshellarg($conn['password']),
            escapeshellarg($conn['database']),
            escapeshellarg($dumps[0])
        );

        exec($command, $output, $exitCode);

        if ($exitCode !== 0) {
            throw new Exception('mysql restore failed: ' . implode("\n", $output));
        }
    }

    private function runAssertions(): void
    {
        foreach (config('backup-verify.assertions', []) as $name => $assertion) {
            $assertion(DB::connection('shadow'), $name);
        }
    }

    private function cleanup(string $tempDir): void
    {
        if (is_dir($tempDir)) {
            exec('rm -rf ' . escapeshellarg($tempDir));
        }

        $db = config('database.connections.shadow.database');
        DB::statement("DROP DATABASE IF EXISTS `{$db}`");
        DB::statement("CREATE DATABASE `{$db}`");
    }
}

return [

    'slack_webhook' => env('BACKUP_VERIFY_SLACK_WEBHOOK'),

    'assertions' => [

        'users table is non-empty' => function (Connection $db, string $name): void {
            if ($db->table('users')->count() < 1) {
                throw new Exception("[{$name}] Expected users, found 0");
            }
        },

        'users exceed baseline' => function (Connection $db, string $name): void {
            $count = $db->table('users')->count();
            if ($count < 500) { // adjust to your production floor
                throw new Exception("[{$name}] users count {$count} below baseline 500");
            }
        },

        'orders placed in last 7 days' => function (Connection $db, string $name): void {
            $count = $db->table('orders')
                ->where('created_at', '>=', now()->subDays(7))
                ->count();

            if ($count < 10) {
                throw new Exception("[{$name}] Only {$count} orders in 7 days — data may be stale");
            }
        },

        'no orphaned order items' => function (Connection $db, string $name): void {
            $orphans = $db->table('order_items')
                ->leftJoin('orders', 'order_items.order_id', '=', 'orders.id')
                ->whereNull('orders.id')
                ->count();

            if ($orphans > 0) {
                throw new Exception("[{$name}] {$orphans} orphaned order_items — backup may be partial");
            }
        },

        'critical config keys present' => function (Connection $db, string $name): void {
            foreach (['app.version', 'features.checkout'] as $key) {
                if (! $db->table('settings')->where('key', $key)->exists()) {
                    throw new Exception("[{$name}] Missing settings key: {$key}");
                }
            }
        },

    ],

];

class VerifyBackups extends Command
{
    protected $signature   = 'backup:verify-integrity';
    protected $description = 'Dispatch backup verification jobs for all destinations';

    public function handle(): int
    {
        foreach (config('backup-verify.destinations') as $disk => $pathOverride) {
            $path = $pathOverride ?? $this->resolveLatestBackup($disk);

            if ($path === null) {
                $this->error("No backup found on disk [{$disk}]");
                continue;
            }

            VerifyBackupIntegrityJob::dispatch($disk, $path)
                ->onQueue('backup-verification');

            $this->info("Dispatched verification for [{$disk}]: {$path}");
        }

        return self::SUCCESS;
    }

    private function resolveLatestBackup(string $disk): ?string
    {
        $files = Storage::disk($disk)->files(config('app.name') . '/');

        if (empty($files)) {
            return null;
        }

        sort($files); // laravel-backup names with timestamps — latest is alphabetically last
        return end($files);
    }
}

// routes/console.php (Laravel 11+)

Schedule::command('backup:run')->dailyAt('02:00');
Schedule::command('backup:verify-integrity')->dailyAt('04:00');