123 lines
4.9 KiB
Bash
123 lines
4.9 KiB
Bash
#!/usr/bin/env bash
|
|
# ==============================================================================
|
|
# Bash 15: BATS Automatisiertes Unit-Testing & Mocking
|
|
# ==============================================================================
|
|
# In diesem Modul lernst du modernes Test-Driven Development (TDD) für Shell-Skripte
|
|
# mit dem BATS-Framework (Bash Automated Testing System), Mock-Environments und TAP.
|
|
# ==============================================================================
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 1: BATS Test-Datei (.bats) dynamisch generieren
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `generate_bats_test_file`.
|
|
# Parameter:
|
|
# $1: Name des Tests (z.B. "Check if server responds with 200")
|
|
# $2: Auszuführender Befehl (z.B. "curl -s http://localhost")
|
|
# $3: Erwarteter Exit-Status (z.B. 0)
|
|
# $4: Erwarteter Text in der Ausgabe (z.B. "OK")
|
|
# Verhalten:
|
|
# - Gibt den Inhalt einer standardkonformen BATS-Testdatei aus:
|
|
# setup() {
|
|
# # Optional setup logic
|
|
# true
|
|
# }
|
|
#
|
|
# @test "<test_name>" {
|
|
# run <command>
|
|
# [ "$status" -eq <expected_exit> ]
|
|
# [[ "$output" =~ "<expected_text>" ]]
|
|
# }
|
|
# - Bei fehlenden Parametern: Return 1.
|
|
# ------------------------------------------------------------------------------
|
|
generate_bats_test_file() {
|
|
local test_name="${1:-}"
|
|
local target_cmd="${2:-}"
|
|
local expected_exit="${3:-0}"
|
|
local expected_text="${4:-}"
|
|
|
|
# TODO: Validiere Parameter
|
|
# TODO: Gib BATS Syntax aus
|
|
echo "TODO: Implementiere generate_bats_test_file"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 2: Ausführbares Mock-Binary erstellen
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `create_executable_mock`.
|
|
# Parameter:
|
|
# $1: Zielverzeichnis für Mocks (z.B. "/tmp/mocks")
|
|
# $2: Name des zu mockenden Befehls (z.B. "docker" oder "curl")
|
|
# $3: Zu simulierender Exit-Code (z.B. 0 oder 1)
|
|
# $4: Zu simulierende Standardausgabe (z.B. "healthy")
|
|
# Verhalten:
|
|
# - Erstellt das Verzeichnis $1 falls noch nicht vorhanden.
|
|
# - Schreibt ein Shell-Skript nach "$1/$2" mit folgendem Inhalt:
|
|
# #!/usr/bin/env bash
|
|
# echo "<output>"
|
|
# exit <exit_code>
|
|
# - Setzt Ausführungsrechte mit `chmod +x "$1/$2"`.
|
|
# - Return 0 bei Erfolg.
|
|
# ------------------------------------------------------------------------------
|
|
create_executable_mock() {
|
|
local mock_dir="${1:-}"
|
|
local cmd_name="${2:-}"
|
|
local exit_code="${3:-0}"
|
|
local output_text="${4:-}"
|
|
|
|
# TODO: Erstelle Verzeichnis & Mock-Datei
|
|
# TODO: chmod +x
|
|
echo "TODO: Implementiere create_executable_mock"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 3: TAP (Test Anything Protocol) Ausgabe parsen
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `parse_tap_test_summary`.
|
|
# Parameter:
|
|
# $1: TAP-Ergebnisstream (mehrzeiliger Text)
|
|
# Beispiel:
|
|
# 1..3
|
|
# ok 1 Check backup exists
|
|
# not ok 2 Check disk space
|
|
# ok 3 Check network connectivity
|
|
# Verhalten:
|
|
# - Zählt Zeilen die mit `ok ` (Bestanden) beginnen.
|
|
# - Zählt Zeilen die mit `not ok ` (Fehlgeschlagen) beginnen.
|
|
# - Ermittelt die Gesamtzahl = Bestanden + Fehlgeschlagen.
|
|
# - Gibt formatiertes Ergebnis aus:
|
|
# "TOTAL: <total> | PASSED: <passed> | FAILED: <failed>"
|
|
# - Bei leerem Input: Return 1.
|
|
# ------------------------------------------------------------------------------
|
|
parse_tap_test_summary() {
|
|
local tap_stream="${1:-}"
|
|
|
|
# TODO: Validiere Input
|
|
# TODO: Zähle ok vs not ok und formatiere Ausgabe
|
|
echo "TODO: Implementiere parse_tap_test_summary"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 4: Test in isolierter Mock-Umgebung ausführen
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `run_sandboxed_test_runner`.
|
|
# Parameter:
|
|
# $1: Auszuführendes Test-Kommando (z.B. "docker ps")
|
|
# $2: Pfad zum Mock-Verzeichnis (wird an erste Stelle in PATH gesetzt)
|
|
# Verhalten:
|
|
# - Führt $1 in einer isolierten Subshell aus, in der `PATH="$2:$PATH"` gilt.
|
|
# - Fängt Exit-Status und stdout/stderr ab.
|
|
# - Gibt formatiert aus: "STATUS: <status> | OUTPUT: <ausgabe>"
|
|
# - Return-Code der Funktion ist immer 0.
|
|
# ------------------------------------------------------------------------------
|
|
run_sandboxed_test_runner() {
|
|
local test_cmd="${1:-}"
|
|
local mock_dir="${2:-}"
|
|
|
|
# TODO: Validiere Parameter
|
|
# TODO: Führe in Subshell mit PATH="$mock_dir:$PATH" aus
|
|
echo "TODO: Implementiere run_sandboxed_test_runner"
|
|
return 1
|
|
}
|