# SSD Testing Module

## Übersicht

Das SSD Testing Module bietet umfassende Qualitätssicherung für USB-C SSDs mit 11 spezialisierten Tests, Performance-Messung und SMB-Bereitschaftsprüfung. Es gewährleistet die Zuverlässigkeit und Kompatibilität der Storage-Infrastruktur.

## Hauptkomponenten

### `ssd-test-suite.sh`
**Zweck**: Umfassende Qualitätssicherung und Performance-Messung

**Test-Kategorien**:
- **Hardware-Tests**: Connectivity, Power, Temperature
- **Filesystem-Tests**: NTFS-Integrität, Permissions, Capacity
- **Performance-Tests**: Read/Write Speed, IOPS, Latency
- **Integration-Tests**: SMB-Bereitschaft, Mount-Stabilität
- **Security-Tests**: Access-Control, Encryption-Support

## Test-Suite Übersicht

### Die 11 Kern-Tests

| Test-ID | Name | Zweck | Dauer |
|---------|------|-------|-------|
| `T01` | **Hardware Detection** | USB-C Connectivity und Device-Recognition | 5s |
| `T02` | **NTFS Filesystem** | Dateisystem-Integrität und Kompatibilität | 10s |
| `T03` | **Mount Stability** | Mount/Unmount Zyklen und Stabilität | 30s |
| `T04` | **Read Performance** | Sequential und Random Read-Geschwindigkeit | 60s |
| `T05` | **Write Performance** | Sequential und Random Write-Geschwindigkeit | 60s |
| `T06` | **File Operations** | Create, Copy, Delete, Rename Operationen | 45s |
| `T07` | **Permission System** | Linux-Permissions und NTFS-ACLs | 15s |
| `T08` | **SMB Readiness** | SMB-Freigabe Kompatibilität und Performance | 30s |
| `T09` | **Capacity Verification** | Verfügbarer Speicher und Fragmentierung | 20s |
| `T10` | **Error Handling** | Fehlerbehandlung und Recovery-Mechanismen | 25s |
| `T11` | **Security Scan** | Access-Control und Encryption-Support | 40s |

## Verwendung

### Grundlegende Test-Ausführung
```bash
# Alle Tests ausführen
./ssd-test-suite.sh all

# Spezifischen Test ausführen
./ssd-test-suite.sh T01

# Test-Kategorie ausführen
./ssd-test-suite.sh --category hardware
./ssd-test-suite.sh --category performance
./ssd-test-suite.sh --category integration
```

### Erweiterte Test-Optionen
```bash
# Schnelle Tests (nur kritische)
./ssd-test-suite.sh --quick

# Umfassende Tests (alle mit erweiterten Parametern)
./ssd-test-suite.sh --comprehensive

# Performance-Benchmark
./ssd-test-suite.sh --benchmark

# Kontinuierliche Tests
./ssd-test-suite.sh --continuous --interval 300
```

### Output-Formate
```bash
# Standard-Output (Human-readable)
./ssd-test-suite.sh all

# JSON-Output für Automation
./ssd-test-suite.sh all --output json

# XML-Report für CI/CD
./ssd-test-suite.sh all --output xml

# CSV für Datenanalyse
./ssd-test-suite.sh all --output csv
```

## Test-Konfiguration

### Environment Variables
```bash
# Test-Timeout (Sekunden)
export SSD_TEST_TIMEOUT=300

# Performance-Test Größe (MB)
export SSD_TEST_SIZE=100

# Test-Wiederholungen
export SSD_TEST_ITERATIONS=3

# Benchmark-Modus
export SSD_BENCHMARK_MODE=true
```

### Konfigurationsdatei
```bash
# /etc/ssd-test/config.conf
TEST_MOUNT_POINT="/mnt/ssd-storage"
TEST_DATA_SIZE="100MB"
PERFORMANCE_THRESHOLD_READ="50MB/s"
PERFORMANCE_THRESHOLD_WRITE="30MB/s"
SMB_TEST_ENABLED=true
SECURITY_SCAN_ENABLED=true
```

## Test-Details

### Hardware-Tests (T01-T03)

#### T01: Hardware Detection
```bash
# Prüft USB-C Connectivity
- Device-Erkennung im System
- USB-Version und Geschwindigkeit
- Power-Management Status
- Device-Descriptor Validierung
```

#### T02: NTFS Filesystem
```bash
# Validiert NTFS-Kompatibilität
- Dateisystem-Typ Verifikation
- NTFS-Version Kompatibilität
- Journal-Status Prüfung
- Cluster-Size Optimierung
```

#### T03: Mount Stability
```bash
# Testet Mount/Unmount Zyklen
- 10x Mount/Unmount Zyklen
- Concurrent-Access Tests
- Mount-Option Validierung
- Recovery nach Fehlern
```

### Performance-Tests (T04-T06)

#### T04: Read Performance
```bash
# Sequential Read Test
dd if=/mnt/ssd-storage/testfile of=/dev/null bs=1M count=100

# Random Read Test (4K Blocks)
fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=100M
```

#### T05: Write Performance
```bash
# Sequential Write Test
dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=100

# Random Write Test (4K Blocks)
fio --name=random-write --ioengine=libaio --rw=randwrite --bs=4k --size=100M
```

#### T06: File Operations
```bash
# Standard File-Operations
- 1000 kleine Dateien erstellen (1KB)
- 100 mittlere Dateien erstellen (1MB)
- 10 große Dateien erstellen (10MB)
- Copy, Move, Delete Operationen
- Symlink und Hardlink Tests
```

### Integration-Tests (T07-T09)

#### T07: Permission System
```bash
# Linux-Permissions testen
chmod 755 /mnt/ssd-storage/testdir
chown user:group /mnt/ssd-storage/testfile

# NTFS-ACL Kompatibilität
setfacl -m u:user:rwx /mnt/ssd-storage/testdir
```

#### T08: SMB Readiness
```bash
# SMB-Kompatibilität prüfen
- Windows-Filename Kompatibilität
- Extended Attributes Support
- Case-Sensitivity Tests
- Unicode-Filename Support
- SMB-Performance Simulation
```

#### T09: Capacity Verification
```bash
# Speicher-Analyse
df -h /mnt/ssd-storage
du -sh /mnt/ssd-storage/*

# Fragmentierung prüfen
fsck.ntfs -f /dev/sdb1
```

### Security-Tests (T10-T11)

#### T10: Error Handling
```bash
# Fehlerbehandlung testen
- Disk-Full Simulation
- Permission-Denied Scenarios
- Network-Interruption (bei SMB)
- Hardware-Disconnect Simulation
```

#### T11: Security Scan
```bash
# Security-Features prüfen
- Access-Control Lists (ACLs)
- Encryption-Support Detection
- Secure-Delete Capabilities
- Audit-Trail Funktionalität
```

## Benchmark-Modus

### Performance-Metriken
```bash
# Detaillierte Performance-Analyse
./ssd-test-suite.sh --benchmark --detailed

# Vergleich mit Referenz-Werten
./ssd-test-suite.sh --benchmark --compare baseline.json

# Performance-Trend Analyse
./ssd-test-suite.sh --benchmark --trend --days 30
```

### Benchmark-Output
```json
{
  "device": "/dev/sdb1",
  "timestamp": "2025-08-07T19:10:00Z",
  "performance": {
    "sequential_read": "120 MB/s",
    "sequential_write": "85 MB/s",
    "random_read_4k": "15000 IOPS",
    "random_write_4k": "8000 IOPS",
    "latency_avg": "2.5ms"
  },
  "health": {
    "temperature": "45°C",
    "wear_level": "2%",
    "error_count": 0
  }
}
```

## CI/CD Integration

### Jenkins Pipeline
```groovy
pipeline {
    agent any
    stages {
        stage('SSD Tests') {
            steps {
                sh './ssd-test-suite.sh all --output xml'
                publishTestResults testResultsPattern: 'ssd-test-results.xml'
            }
        }
    }
}
```

### GitHub Actions
```yaml
name: SSD Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run SSD Tests
        run: ./ssd-test-suite.sh all --output json
```

## Monitoring Integration

### Prometheus-Metriken
```bash
# Metriken exportieren
./ssd-test-suite.sh --prometheus-metrics

# Grafana-Dashboard
# Siehe examples/monitoring/grafana-dashboard.json
```

### Alerting
```bash
# Performance-Alerts
if [ $READ_SPEED -lt 50 ]; then
    alert "SSD Read Performance below threshold"
fi

# Health-Alerts
if [ $ERROR_COUNT -gt 0 ]; then
    alert "SSD Errors detected"
fi
```

## Troubleshooting

### Häufige Test-Fehler
1. **T01 Failed**: USB-Verbindung prüfen, Treiber aktualisieren
2. **T04/T05 Slow**: SSD-Health prüfen, USB-Port wechseln
3. **T08 Failed**: SMB-Packages installieren, Firewall prüfen

### Debug-Modus
```bash
# Erweiterte Diagnose
./ssd-test-suite.sh all --debug --verbose

# Test-Logs analysieren
tail -f /var/log/ssd-test.log
```

## Best Practices

### Produktionsumgebung
1. **Regelmäßige Tests** (täglich/wöchentlich) einrichten
2. **Performance-Baselines** etablieren und überwachen
3. **Test-Ergebnisse archivieren** für Trend-Analyse
4. **Automatische Alerts** bei Test-Fehlern konfigurieren

### Entwicklungsumgebung
1. **Quick-Tests** vor Code-Changes ausführen
2. **Comprehensive-Tests** vor Releases durchführen
3. **Benchmark-Vergleiche** für Performance-Regression
4. **Test-Coverage** für alle SSD-Typen sicherstellen

## Changelog

### Version 0.1.0
- 11 umfassende Test-Kategorien
- Performance-Benchmark Integration
- SMB-Bereitschaftsprüfung
- CI/CD Pipeline Support
- Prometheus-Metriken Export