michaelschiemer/deployment/docs/guides/test-execution-plan.md

Test Execution Plan - Staging Setup

Übersicht

Dieser Plan beschreibt die schrittweise Ausführung der Tests für das neue Staging-Setup mit separaten Datenbank-Stacks.

Voraussetzungen prüfen

1. Lokale Verifikation (WSL/Local)

# Syntax-Checks
cd /home/michael/dev/michaelschiemer

# Ansible-Playbook-Syntax (falls Ansible installiert)
ansible-playbook --syntax-check deployment/ansible/playbooks/verify-staging.yml

# Docker Compose-Syntax
docker compose -f deployment/stacks/postgresql-production/docker-compose.yml config > /dev/null
docker compose -f deployment/stacks/postgresql-staging/docker-compose.yml config > /dev/null
docker compose -f deployment/stacks/staging/docker-compose.base.yml -f deployment/stacks/staging/docker-compose.staging.yml config > /dev/null

2. Server-Verfügbarkeit

• SSH-Zugriff auf Production-Server
• Docker und Docker Compose installiert
• Ansible auf Control-Node installiert (optional)

Test-Phasen

Phase 1: Lokale Syntax-Verifikation

Ziel: Sicherstellen, dass alle Konfigurationsdateien syntaktisch korrekt sind.

Schritte:

1. ✅ Ansible-Playbook-Syntax prüfen
2. ✅ Docker Compose-Syntax prüfen
3. ✅ YAML-Validierung
4. ✅ Template-Syntax prüfen

Erwartetes Ergebnis: Alle Syntax-Checks erfolgreich

Phase 2: PostgreSQL-Stacks testen (auf Server)

Ziel: Separate PostgreSQL-Stacks funktionieren korrekt.

2.1 PostgreSQL-Production Stack

Schritte:

# Auf Production-Server
cd ~/deployment/stacks/postgresql-production

# .env-Datei prüfen/erstellen
cat .env  # Sollte POSTGRES_PASSWORD enthalten

# Stack starten
docker compose up -d

# Status prüfen
docker compose ps

# Health-Check
docker exec postgres-production pg_isready -U postgres -d michaelschiemer

Erwartetes Ergebnis:

• Container läuft
• PostgreSQL akzeptiert Verbindungen
• Datenbank michaelschiemer existiert

2.2 PostgreSQL-Staging Stack

Schritte:

# Auf Production-Server
cd ~/deployment/stacks/postgresql-staging

# .env-Datei prüfen/erstellen
cat .env  # Sollte POSTGRES_PASSWORD enthalten

# Stack starten
docker compose up -d

# Status prüfen
docker compose ps

# Health-Check
docker exec postgres-staging pg_isready -U postgres -d michaelschiemer_staging

Erwartetes Ergebnis:

• Container läuft
• PostgreSQL akzeptiert Verbindungen
• Datenbank michaelschiemer_staging existiert

Phase 3: Networks verifizieren

Ziel: Alle benötigten Docker-Networks existieren.

Schritte:

# Auf Production-Server
docker network ls | grep -E "(traefik-public|staging-internal|postgres-production-internal|postgres-staging-internal|app-internal)"

Erwartetes Ergebnis: Alle Networks existieren

Falls fehlend: Networks werden beim Stack-Start automatisch erstellt

Phase 4: Ansible-Setup testen

Ziel: Ansible-Playbooks funktionieren korrekt.

4.1 Staging-Setup ausführen

Schritte:

# Auf Control-Node (lokal in WSL)
cd ~/dev/michaelschiemer/deployment/ansible

# Dry-Run (Check-Mode)
ansible-playbook -i inventory/production.yml \
  playbooks/setup-staging.yml \
  --check \
  --ask-vault-pass

# Echt ausführen
ansible-playbook -i inventory/production.yml \
  playbooks/setup-staging.yml \
  --ask-vault-pass

Erwartetes Ergebnis:

• Playbook läuft durch ohne Fehler
• PostgreSQL-Staging Stack deployed
• Staging Application Stack deployed
• Alle Services laufen

4.2 Verifikations-Playbook ausführen

Schritte:

# Auf Control-Node
cd ~/dev/michaelschiemer/deployment/ansible

ansible-playbook -i inventory/production.yml \
  playbooks/verify-staging.yml

Erwartetes Ergebnis:

• Alle Verifikationen erfolgreich
• PostgreSQL-Staging: RUNNING
• staging-app: RUNNING
• Health-Checks: SUCCESS

Phase 5: Datenbank-Verbindungen testen

Ziel: Application-Container können auf ihre jeweiligen Datenbanken zugreifen.

5.1 Staging-Datenbank-Verbindung

Schritte:

# Auf Production-Server
docker exec staging-app php -r "
\$dsn = 'pgsql:host=postgres-staging;port=5432;dbname=michaelschiemer_staging';
\$pdo = new PDO(\$dsn, 'postgres', trim(file_get_contents('/var/www/html/storage/secrets/db_user_password')));
echo 'Connection successful: ' . \$pdo->query('SELECT version()')->fetchColumn();
"

Erwartetes Ergebnis: Connection successful mit PostgreSQL-Version

5.2 Production-Datenbank-Verbindung

Schritte:

# Auf Production-Server
docker exec php php -r "
\$dsn = 'pgsql:host=postgres-production;port=5432;dbname=michaelschiemer';
\$pdo = new PDO(\$dsn, 'postgres', trim(file_get_contents('/var/www/html/storage/secrets/db_user_password')));
echo 'Connection successful: ' . \$pdo->query('SELECT version()')->fetchColumn();
"

Erwartetes Ergebnis: Connection successful mit PostgreSQL-Version

Phase 6: Health-Checks

Ziel: Application-Endpoints sind erreichbar und funktionieren.

6.1 Basic Health Check

Schritte:

# Staging
curl -f -k https://staging.michaelschiemer.de/health

# Production
curl -f -k https://michaelschiemer.de/health

Erwartetes Ergebnis: HTTP 200 OK

6.2 Extended Health Check

Schritte:

# Staging
curl -f -k https://staging.michaelschiemer.de/admin/health/api/summary | jq .

# Production
curl -f -k https://michaelschiemer.de/admin/health/api/summary | jq .

Erwartetes Ergebnis: JSON mit "overall_status": "healthy"

Phase 7: CI/CD-Workflow testen

Ziel: Automatisches Deployment funktioniert.

Schritte:

1. Kleine Änderung im Code vornehmen
2. Commit auf staging-Branch pushen
3. Gitea Actions Workflow beobachten
4. Nach erfolgreichem Deployment:
   • Health-Check prüfen
   • Code-Änderung verifizieren

Erwartetes Ergebnis:

• Workflow läuft erfolgreich durch
• Deployment erfolgreich
• Health-Checks bestehen

Phase 8: Datenbank-Isolation testen

Ziel: Staging und Production haben getrennte Datenbanken.

Schritte:

# Auf Production-Server

# Test-Daten in Staging-DB schreiben
docker exec staging-app php -r "
\$dsn = 'pgsql:host=postgres-staging;port=5432;dbname=michaelschiemer_staging';
\$pdo = new PDO(\$dsn, 'postgres', trim(file_get_contents('/var/www/html/storage/secrets/db_user_password')));
\$pdo->exec('CREATE TABLE IF NOT EXISTS test_isolation (id SERIAL PRIMARY KEY, env VARCHAR(50))');
\$pdo->exec('INSERT INTO test_isolation (env) VALUES (\'staging\')');
echo 'Staging data inserted.';
"

# Prüfen, dass Test-Daten NICHT in Production-DB sind
docker exec postgres-production psql -U postgres -d michaelschiemer -c "SELECT * FROM test_isolation;" || echo "✅ Isolation confirmed: test_isolation table not in production"

Erwartetes Ergebnis:

• Test-Daten in Staging-DB vorhanden
• Test-Daten NICHT in Production-DB vorhanden

Fehlerbehebung

Häufige Probleme

1. PostgreSQL-Container startet nicht

   • Prüfe .env-Datei (POSTGRES_PASSWORD gesetzt?)
   • Prüfe Logs: docker logs postgres-production oder docker logs postgres-staging
   • Prüfe Volumes: docker volume ls

2. Network-Verbindung fehlgeschlagen

   • Prüfe Networks: docker network ls
   • Prüfe Container-Networks: docker inspect <container> | grep -A 10 Networks
   • Stelle sicher, dass Container im richtigen Network sind

3. Datenbank-Verbindung fehlgeschlagen

   • Prüfe DB_HOST in Application-Container
   • Prüfe DB_PASSWORD (Docker Secret)
   • Prüfe Network-Verbindung (siehe oben)

4. Health-Check fehlgeschlagen

   • Prüfe Container-Status: docker ps
   • Prüfe Application-Logs: docker logs staging-app
   • Prüfe Nginx-Logs: docker logs staging-nginx

Test-Ergebnisse dokumentieren

Nach jedem Test:

• ✅ Erfolgreich
• ❌ Fehlgeschlagen (mit Fehlerbeschreibung)
• ⚠️ Teilweise erfolgreich (mit Details)

Nächste Schritte nach erfolgreichen Tests

1. ✅ Alle Tests bestanden
2. Dokumentation aktualisieren (falls nötig)
3. Production-Deployment vorbereiten
4. Monitoring einrichten