mitai-jinkendo/.claude/commands/test.md

# Test – Vollständige Test-Suite

Führt Backend-Tests (API + Logs) und Frontend-Tests (Playwright) durch.
Claude Code schreibt, führt aus und korrigiert bis alle Tests grün sind.

## Workflow für neue Features

Nach jeder Implementierung:
1. Backend-Tests schreiben und ausführen
2. Frontend-Tests schreiben und ausführen  
3. Logs auf Fehler prüfen
4. Alle grün → committen

---

## TEIL 1: Backend API-Tests (schnell, immer zuerst)

### 1.1 Login + Token holen
```bash
TOKEN=$(curl -s -X POST https://dev.mitai.jinkendo.de/api/auth/login \
  -H "Content-Type: application/json" \
  -d "{\"email\":\"$TEST_EMAIL\",\"pin\":\"$TEST_PASSWORD\"}" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('token','KEIN_TOKEN'))")
echo "Token: ${TOKEN:0:30}..."
```

### 1.2 Basis-Endpoints prüfen
```bash
# Version
curl -sf https://dev.mitai.jinkendo.de/api/version \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print('Version:', d.get('app_version'), '| DB:', d.get('db_schema_version'))"

# Auth Status
curl -sf https://dev.mitai.jinkendo.de/api/auth/status \
  && echo "Auth OK" || echo "Auth FEHLER"

# Stats (mit Token)
curl -sf https://dev.mitai.jinkendo.de/api/stats \
  -H "X-Auth-Token: $TOKEN" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print('Stats OK:', list(d.keys())[:5])"
```

### 1.3 CRUD-Test für neues Modul
Template für jeden neuen Router:
```bash
# CREATE
ID=$(curl -s -X POST https://dev.mitai.jinkendo.de/api/MODUL \
  -H "Content-Type: application/json" \
  -H "X-Auth-Token: $TOKEN" \
  -d '{"date":"2026-01-01","FELD":"WERT"}' \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('id','FEHLER'))")
echo "CREATE: ID=$ID"

# READ
curl -sf https://dev.mitai.jinkendo.de/api/MODUL?limit=5 \
  -H "X-Auth-Token: $TOKEN" \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print('READ: Einträge:', len(d))"

# DELETE (Test-Eintrag aufräumen)
curl -s -X DELETE https://dev.mitai.jinkendo.de/api/MODUL/$ID \
  -H "X-Auth-Token: $TOKEN" \
  && echo "DELETE OK" || echo "DELETE FEHLER"
```

### 1.4 Auth-Schutz prüfen
```bash
# Endpoint OHNE Token muss 401 zurückgeben
STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://dev.mitai.jinkendo.de/api/stats)
[ "$STATUS" = "401" ] && echo "Auth-Schutz OK (401)" || echo "WARNUNG: Auth-Schutz fehlt! ($STATUS)"
```

### 1.5 Admin-Endpoint prüfen
```bash
# Admin-Endpoint mit normalem Token muss 403 zurückgeben
STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  https://dev.mitai.jinkendo.de/api/admin/profiles \
  -H "X-Auth-Token: $TOKEN")
echo "Admin-Schutz: $STATUS (erwartet 403 für nicht-Admin)"
```

---

## TEIL 2: Backend Logs prüfen

### 2.1 Letzte Logs auf Fehler prüfen
```bash
ssh pi "docker logs dev-mitai-api --tail 50 2>&1 | grep -i 'error\|exception\|traceback\|warning' | head -20"
```

### 2.2 Nach Test-Requests: Logs prüfen
```bash
# Direkt nach API-Tests ausführen
ssh pi "docker logs dev-mitai-api --tail 20 --timestamps 2>&1"
```

### 2.3 Alle neuen Endpoints im Log sichtbar?
```bash
# Prüft ob Router korrekt registriert
ssh pi "docker logs dev-mitai-api 2>&1 | grep 'router\|route\|endpoint' | head -10"
```

### 2.4 DB-Verbindung gesund?
```bash
ssh pi "docker exec dev-mitai-postgres pg_isready -U mitai_dev && echo 'DB OK'"
```

### 2.5 Neue Tabellen vorhanden?
```bash
ssh pi "docker exec dev-mitai-postgres psql -U mitai_dev -d mitai_dev -c '\dt' 2>/dev/null | grep -E 'TABELLEN_NAME'"
```

---

## TEIL 3: Frontend Playwright-Tests

### 3.1 Alle Smoke Tests
```bash
npx playwright test
```

### 3.2 Nur neues Feature testen
```bash
npx playwright test --grep "FEATURE_NAME"
```

### 3.3 Mit sichtbarem Browser
```bash
npx playwright test --headed
```

### 3.4 Screenshot bei Fehler ansehen
```bash
start test-results\TESTNAME\test-failed-1.png
```

---

## TEIL 4: Tests schreiben

### Backend-Test Template (in test-Abschnitt einfügen)
```bash
# Für jeden neuen Endpoint:
echo "=== Test: MODUL_NAME ==="
TOKEN=$(curl -s -X POST https://dev.mitai.jinkendo.de/api/auth/login \
  -H "Content-Type: application/json" \
  -d "{\"email\":\"$TEST_EMAIL\",\"pin\":\"$TEST_PASSWORD\"}" \
  | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))")

# GET Test
curl -sf https://dev.mitai.jinkendo.de/api/MODUL \
  -H "X-Auth-Token: $TOKEN" \
  && echo "GET OK" || echo "GET FEHLER"

# POST Test
curl -s -X POST https://dev.mitai.jinkendo.de/api/MODUL \
  -H "Content-Type: application/json" \
  -H "X-Auth-Token: $TOKEN" \
  -d '{"date":"2026-01-01"}' \
  | python3 -c "import sys,json; d=json.load(sys.stdin); print('POST OK, id:', d.get('id'))"

# Auth-Schutz
STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://dev.mitai.jinkendo.de/api/MODUL)
[ "$STATUS" = "401" ] && echo "Auth-Schutz OK" || echo "Auth-Schutz FEHLER ($STATUS)"
```

### Frontend-Test Template (in dev-smoke-test.spec.js)
```javascript
test('MODUL: Seite lädt und Grundfunktion', async ({ page }) => {
  await login(page);
  
  // Navigation
  await page.click('text=NAV_TEXT');
  await page.waitForLoadState('networkidle');
  await expect(page.locator('.spinner')).toHaveCount(0, { timeout: 10000 });
  
  // Formular ausfüllen
  await page.fill('input[name="FELD"]', 'TESTWERT');
  await page.click('button:has-text("Speichern")');
  
  // Ergebnis prüfen
  await expect(page.locator('text=gespeichert')).toBeVisible({ timeout: 5000 });
  await page.screenshot({ path: 'screenshots/MODUL-test.png' });
  console.log('MODUL OK');
});
```

---

## TEIL 5: Vollständiger Test-Lauf (vor jedem Deploy)

```bash
echo "=== BACKEND TESTS ===" && \
TOKEN=$(curl -s -X POST https://dev.mitai.jinkendo.de/api/auth/login \
  -H "Content-Type: application/json" \
  -d "{\"email\":\"$TEST_EMAIL\",\"pin\":\"$TEST_PASSWORD\"}" \
  | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))") && \
curl -sf https://dev.mitai.jinkendo.de/api/version | python3 -c "import sys,json; d=json.load(sys.stdin); print('Version:', d.get('app_version'))" && \
curl -sf https://dev.mitai.jinkendo.de/api/stats -H "X-Auth-Token: $TOKEN" > /dev/null && echo "Stats OK" && \
echo "" && \
echo "=== LOGS PRUEFEN ===" && \
ssh pi "docker logs dev-mitai-api --tail 20 2>&1 | grep -i 'error\|exception' | head -5 || echo 'Keine Fehler in Logs'" && \
echo "" && \
echo "=== FRONTEND TESTS ===" && \
npx playwright test && \
echo "" && \
echo "=== ALLE TESTS BESTANDEN ==="
```

---

## Credentials setzen (einmalig pro Session)
```bash
$env:TEST_EMAIL="lars@stommer.com"
$env:TEST_PASSWORD="5112"
```

---

## Prod-Schutz
Tests laufen AUSSCHLIESSLICH gegen:
- https://dev.mitai.jinkendo.de
- http://192.168.2.49:8099

NIEMALS gegen:
- https://mitai.jinkendo.de
- http://192.168.2.49:8002