Tag 4: Fehler, Logging, Tests – checkcert
Ziel: Ein Tool
checkcertbauen, das TLS-Zertifikate prüft und die Restlaufzeit in Tagen meldet – mit eigener Exception, Logging und einer pytest-Suite aus Fixtures, parametrize, tmp_path und Mocks · Dauer: ca. 150 min · Voraussetzung: Tag 3
Briefing
- Fehler werden an der Grenze übersetzt: Socket- und SSL-Exceptions
werden zu einer eigenen
CertError, die Ursache bleibt perraise ... fromerhalten. loggingstattprintfür Diagnose: Modul-Logger, Level per--verbose, Ausgabe nachstderr.- Exit-Codes nach Nagios-Konvention: 0 OK, 1 WARN, 2 CRIT, 3 ERROR – direkt in Monitoring und CI nutzbar.
- Tests laufen ohne Netz: Fixtures liefern feste Zeit und falsche Zertifikate, Mocks ersetzen Sockets.
checkcert host[:port] ... -f hosts.txt
└─ cli.main ──► core.check ──► fetch_cert ──► socket + ssl (Handshake, volle Prüfung)
│ └─ OSError/SSLError ──► CertError (from err)
└─► Result(status, days) ──► Tabelle + Exit = schlechtester Status
Drill 1: Projekt und erster Handshake
cd ~/py-lab
uv init -q --package --name checkcert tag04-checkcert
cd tag04-checkcert
uv add -q typer
uv add --dev pytest pytest-cov ruff
cat >> pyproject.toml <<'EOF'
[tool.ruff.lint]
extend-select = ["E501", "B", "UP", "SIM"]
[tool.pytest.ini_options]
testpaths = ["tests"]
EOFErwartet (gekürzt):
+ coverage==7.16.2
+ pytest==9.1.1
+ pytest-cov==7.1.0
+ ruff==0.17.0
Erst einmal von Hand, was das Tool später automatisch macht:
uv run python - <<'EOF'
import socket
import ssl
ctx = ssl.create_default_context()
with (
socket.create_connection(("github.com", 443), timeout=5) as sock,
ctx.wrap_socket(sock, server_hostname="github.com") as tls,
):
cert = tls.getpeercert()
print(tls.version(), tls.cipher()[0])
print(cert["notAfter"])
print(dict(x[0] for x in cert["issuer"])["organizationName"])
print(ssl.cert_time_to_seconds(cert["notAfter"]))
EOFErwartet (Daten ändern sich mit jedem Zertifikatswechsel):
TLSv1.3 TLS_AES_128_GCM_SHA256
Nov 29 23:59:59 2026 GMT
Sectigo Limited
1795996799
create_default_context()prüft Kette und Hostnamen gegen die System-CAs. NieCERT_NONEsetzen, um „schnell mal” ein Problem zu umgehen.server_hostnamesorgt für SNI und für die Hostnamen-Prüfung.- Die geklammerte
with-Form öffnet mehrere Kontexte und schließt sie in umgekehrter Reihenfolge.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Die Fehler kennenlernen
uv run python - <<'EOF'
import socket
import ssl
ziele = [("expired.badssl.com", 443), ("gibt-es-nicht.invalid", 443),
("localhost", 1), ("10.255.255.1", 443)]
for host, port in ziele:
try:
ctx = ssl.create_default_context()
with (
socket.create_connection((host, port), timeout=2) as sock,
ctx.wrap_socket(sock, server_hostname=host),
):
pass
except OSError as err:
print(f"{host:<22} {type(err).__name__:<25} {type(err).__mro__[1].__name__}")
EOFErwartet:
expired.badssl.com SSLCertVerificationError SSLError
gibt-es-nicht.invalid gaierror OSError
localhost ConnectionRefusedError ConnectionError
10.255.255.1 TimeoutError OSError
Vier völlig verschiedene Ursachen, eine gemeinsame Basisklasse:
OSError. Die Spalte rechts zeigt die direkte Elternklasse
aus der MRO (Method Resolution Order). Daraus folgt die Regel für
except: spezifisch vor allgemein – erst
SSLCertVerificationError (hat ein lesbares
verify_message), dann OSError für den Rest.
Nie ein nacktes except: oder
except Exception:, das auch Programmierfehler
verschluckt.
Tipp: badssl.com stellt absichtlich kaputte Zertifikate bereit – ideal für Lab-Tests.
.invalidist per RFC 2606 als nie existierende Domain reserviert.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Kernmodul mit eigener Exception und Logging
cat > src/checkcert/core.py <<'EOF'
"""TLS-Zertifikate abrufen und nach Restlaufzeit bewerten."""
import logging
import socket
import ssl
from collections.abc import Callable
from dataclasses import dataclass
from datetime import UTC, datetime
from enum import IntEnum
from typing import Any
log = logging.getLogger(__name__)
PeerCert = dict[str, Any]
Fetcher = Callable[[str, int, float], PeerCert]
class Status(IntEnum):
"""Nagios-Konvention: Wert = Exit-Code."""
OK = 0
WARN = 1
CRIT = 2
ERROR = 3
class CertError(Exception):
"""Zertifikat konnte nicht abgerufen oder geprüft werden."""
@dataclass(frozen=True)
class Result:
host: str
port: int
status: Status
days: int | None = None
expires: datetime | None = None
error: str = ""
def fetch_cert(host: str, port: int = 443, timeout: float = 5.0) -> PeerCert:
"""TLS-Handshake mit voller Prüfung (Kette + Hostname); liefert das Zertifikat."""
ctx = ssl.create_default_context()
try:
with (
socket.create_connection((host, port), timeout=timeout) as sock,
ctx.wrap_socket(sock, server_hostname=host) as tls,
):
log.debug("%s:%s verbunden mit %s", host, port, tls.version())
cert = tls.getpeercert()
except ssl.SSLCertVerificationError as err:
raise CertError(err.verify_message) from err
except OSError as err: # DNS, Timeout, Connection refused, TLS-Fehler
raise CertError(str(err) or type(err).__name__) from err
if not cert:
raise CertError("kein Zertifikat erhalten")
return cert
def expires_at(cert: PeerCert) -> datetime:
"""notAfter ('Nov 29 23:59:59 2026 GMT') als datetime in UTC."""
return datetime.fromtimestamp(ssl.cert_time_to_seconds(cert["notAfter"]), UTC)
def rate(days: int, warn: int = 30, crit: int = 7) -> Status:
if days < crit:
return Status.CRIT
if days < warn:
return Status.WARN
return Status.OK
def check(
host: str,
port: int = 443,
*,
warn: int = 30,
crit: int = 7,
timeout: float = 5.0,
now: datetime | None = None,
fetch: Fetcher = fetch_cert,
) -> Result:
"""Prüft einen Host. Wirft nie – Fehler landen als Status.ERROR im Result."""
try:
expires = expires_at(fetch(host, port, timeout))
except CertError as err:
log.warning("%s:%s nicht prüfbar: %s", host, port, err)
return Result(host, port, Status.ERROR, error=str(err))
days = (expires - (now or datetime.now(UTC))).days
log.debug("%s:%s läuft ab am %s (%d Tage)", host, port, expires, days)
return Result(host, port, rate(days, warn, crit), days, expires)
EOFclass CertError(Exception)mit Docstring reicht als eigene Exception. Aufrufer müssen nur noch einen Typ kennen statt sieben.raise CertError(...) from errsetzt__cause__: Der Traceback zeigt beide Fehler, Tests können die Ursache prüfen.Status(IntEnum): Namen für die Ausgabe, Zahlen für den Exit-Code, undmax()findet den schlechtesten Status.log = logging.getLogger(__name__)ergibt den Loggercheckcert.core. Bibliothekscode loggt nur, die Konfiguration (Level, Format) macht allein das CLI.log.debug("%s:%s ...", host, port)statt f-String: Die Formatierung passiert nur, wenn das Level aktiv ist.check()bekommtnowundfetchals Parameter. Diese Dependency Injection macht die Funktion ohne Netz und ohne echte Uhr testbar.
Fortschritt speichern? Kostenlos registrieren
Drill 4: CLI mit Exit-Codes
cat > src/checkcert/cli.py <<'EOF'
"""checkcert – Restlaufzeit von TLS-Zertifikaten prüfen (Exit-Code nach Nagios)."""
import logging
from pathlib import Path
from typing import Annotated
import typer
from checkcert.core import Result, Status, check
app = typer.Typer(help=__doc__, add_completion=False)
def parse_target(target: str) -> tuple[str, int]:
"""'host' oder 'host:port' -> (host, port)."""
host, sep, port = target.rpartition(":")
if not sep:
return target, 443
if not port.isdigit():
raise typer.BadParameter(f"ungültiger Port in {target!r}")
return host, int(port)
def read_targets(path: Path) -> list[str]:
"""Eine Adresse pro Zeile; Leerzeilen und #-Kommentare werden ignoriert."""
lines = path.read_text(encoding="utf-8").splitlines()
return [s for line in lines if (s := line.split("#", 1)[0].strip())]
def render(r: Result) -> str:
days = "-" if r.days is None else str(r.days)
expires = f"{r.expires:%Y-%m-%d}" if r.expires else "-"
line = f"{r.status.name:<6} {days:>5} {expires:<10} {r.host}:{r.port}"
return f"{line} ({r.error})" if r.error else line
@app.command()
def main(
targets: Annotated[list[str] | None, typer.Argument(help="host[:port]")] = None,
file: Annotated[
Path | None, typer.Option("--file", "-f", exists=True, help="Hostliste")
] = None,
warn: Annotated[int, typer.Option(help="WARN unter so vielen Tagen")] = 30,
crit: Annotated[int, typer.Option(help="CRIT unter so vielen Tagen")] = 7,
timeout: Annotated[float, typer.Option(help="Sekunden pro Host")] = 5.0,
verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
) -> None:
"""Prüft alle Ziele und endet mit dem schlechtesten Status als Exit-Code."""
logging.basicConfig(
level=logging.DEBUG if verbose else logging.ERROR,
format="%(levelname)s %(name)s: %(message)s",
)
all_targets = (targets or []) + (read_targets(file) if file else [])
if not all_targets:
raise typer.BadParameter("mindestens ein Host oder --file angeben")
pairs = [parse_target(t) for t in all_targets] # Fehler vor dem ersten Check
typer.echo(f"{'STATUS':<6} {'TAGE':>5} {'ABLAUF':<10} HOST")
worst = Status.OK
for host, port in pairs:
result = check(host, port, warn=warn, crit=crit, timeout=timeout)
typer.echo(render(result))
worst = max(worst, result.status)
raise typer.Exit(code=int(worst))
EOF
cat > src/checkcert/__init__.py <<'EOF'
"""checkcert – TLS-Zertifikate prüfen."""
from checkcert.cli import app
def main() -> None:
app()
EOF
cat > src/checkcert/__main__.py <<'EOF'
from checkcert import main
main()
EOF
mkdir -p lab
cat > lab/hosts.txt <<'EOF'
# Lab-Hostliste: echte öffentliche Testziele
github.com
example.com:443
expired.badssl.com # abgelaufen
wrong.host.badssl.com # falscher Hostname
EOF
uv run checkcert github.com example.com:443; echo "exit=$?"
uv run checkcert -f lab/hosts.txt; echo "exit=$?"Erwartet (Tage abhängig vom Datum, gekürzt):
STATUS TAGE ABLAUF HOST
OK 50 2026-11-29 github.com:443
OK 76 2026-12-25 example.com:443
exit=0
STATUS TAGE ABLAUF HOST
OK 50 2026-11-29 github.com:443
OK 76 2026-12-25 example.com:443
ERROR - - expired.badssl.com:443 (certificate has expired)
ERROR - - wrong.host.badssl.com:443 (Hostname mismatch, …)
exit=3
uv run checkcert github.com --warn 60 -v; echo "exit=$?"
uv run checkcert github.com:https; echo "exit=$?"Erwartet:
STATUS TAGE ABLAUF HOST
DEBUG checkcert.core: github.com:443 verbunden mit TLSv1.3
DEBUG checkcert.core: github.com:443 läuft ab am 2026-11-29 23:59:59+00:00 (50 Tage)
WARN 50 2026-11-29 github.com:443
exit=1
Usage: checkcert [OPTIONS] [targets]...
Try 'checkcert --help' for help.
╭─ Error ──────────────────────────────────────────────────────────────────────╮
│ Invalid value: ungültiger Port in 'github.com:https' │
╰──────────────────────────────────────────────────────────────────────────────╯
exit=2
- Eine Typer-App mit nur einem Befehl braucht keinen Unterbefehl:
checkcert hoststattcheckcert main host. logging.basicConfigeinmal im CLI; ohne-verscheinen nur Meldungen abERROR. Log-Ausgaben gehen nachstderr, die Tabelle nachstdout–checkcert ... > report.txtbleibt sauber.rpartition(":")trennt am letzten Doppelpunkt, deshalb funktioniert auch::1:8443.- Alle Ziele werden geparst, bevor der erste Handshake läuft: Ein Tippfehler in Zeile 50 der Hostliste bricht sofort ab, nicht nach 49 Netzwerkaufrufen.
Achtung: Exit 2 ist doppelt belegt: CRIT (Nagios) und Bedienfehler (typer). Für Monitoring ist das unkritisch – ein Bedienfehler soll dort ohnehin Alarm auslösen.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Fixtures, parametrize und Mocks
Gemeinsame Fixtures gehören in tests/conftest.py; pytest
lädt die Datei automatisch.
mkdir -p tests
cat > tests/conftest.py <<'EOF'
from collections.abc import Callable
from datetime import UTC, datetime
import pytest
from checkcert.core import Fetcher, PeerCert
NOW = datetime(2026, 10, 10, 12, 0, tzinfo=UTC)
@pytest.fixture
def now() -> datetime:
"""Feste Uhrzeit: Tests dürfen nicht vom Kalender abhängen."""
return NOW
@pytest.fixture
def fake_fetch() -> Callable[[str], Fetcher]:
"""Baut einen Fetcher, der ein Zertifikat mit gewünschtem notAfter liefert."""
def make(not_after: str) -> Fetcher:
def fetch(host: str, port: int, timeout: float) -> PeerCert:
return {"notAfter": not_after}
return fetch
return make
EOF
cat > tests/test_core.py <<'EOF'
import logging
import ssl
from datetime import UTC, datetime
from unittest.mock import MagicMock, patch
import pytest
from checkcert.core import CertError, Status, check, expires_at, fetch_cert, rate
@pytest.mark.parametrize(
("days", "expected"),
[
(60, Status.OK),
(30, Status.OK),
(29, Status.WARN),
(7, Status.WARN),
(6, Status.CRIT),
(-1, Status.CRIT),
],
)
def test_rate_grenzen(days, expected):
assert rate(days, warn=30, crit=7) is expected
def test_expires_at_ist_utc():
t = expires_at({"notAfter": "Nov 29 23:59:59 2026 GMT"})
assert t == datetime(2026, 11, 29, 23, 59, 59, tzinfo=UTC)
def test_check_ok(fake_fetch, now):
r = check("lab", fetch=fake_fetch("Nov 29 23:59:59 2026 GMT"), now=now)
assert (r.status, r.days) == (Status.OK, 50)
def test_check_warn_mit_eigener_schwelle(fake_fetch, now):
r = check("lab", warn=60, fetch=fake_fetch("Nov 29 23:59:59 2026 GMT"), now=now)
assert r.status is Status.WARN
def test_check_fehler_wird_error_und_geloggt(caplog, now):
def broken(host: str, port: int, timeout: float) -> dict:
raise CertError("certificate has expired")
with caplog.at_level(logging.WARNING):
r = check("expired.lab", fetch=broken, now=now)
assert r.status is Status.ERROR
assert r.error == "certificate has expired"
assert "expired.lab:443 nicht prüfbar" in caplog.text
def test_fetch_cert_timeout_wird_certerror():
with (
patch("checkcert.core.socket.create_connection", side_effect=TimeoutError),
pytest.raises(CertError, match="TimeoutError") as exc_info,
):
fetch_cert("langsam.lab", timeout=0.1)
assert isinstance(exc_info.value.__cause__, TimeoutError)
def test_fetch_cert_verify_fehler_nutzt_verify_message():
err = ssl.SSLCertVerificationError(1, "certificate verify failed")
err.verify_message = "self-signed certificate"
ctx = MagicMock()
ctx.wrap_socket.side_effect = err
with (
patch("checkcert.core.socket.create_connection"),
patch("checkcert.core.ssl.create_default_context", return_value=ctx),
pytest.raises(CertError, match="^self-signed certificate$"),
):
fetch_cert("selfsigned.lab")
ctx.wrap_socket.assert_called_once()
assert ctx.wrap_socket.call_args.kwargs == {"server_hostname": "selfsigned.lab"}
EOF
uv run pytest -q tests/test_core.py
uv run pytest -v -k rateErwartet (gekürzt):
............ [100%]
12 passed in 0.02s
tests/test_core.py::test_rate_grenzen[60-0] PASSED [ 16%]
tests/test_core.py::test_rate_grenzen[30-0] PASSED [ 33%]
tests/test_core.py::test_rate_grenzen[29-1] PASSED [ 50%]
tests/test_core.py::test_rate_grenzen[7-1] PASSED [ 66%]
tests/test_core.py::test_rate_grenzen[6-2] PASSED [ 83%]
tests/test_core.py::test_rate_grenzen[-1-2] PASSED [100%]
| Werkzeug | Wofür |
|---|---|
@pytest.fixture |
Testdaten und Setup; der Test fordert sie per Parametername an |
@pytest.mark.parametrize |
ein Test, viele Fälle – ideal für Grenzwerte (30, 29, 7, 6) |
caplog |
fängt Log-Meldungen ein, caplog.text enthält sie |
pytest.raises(..., match=) |
erwartete Exception, Meldung als Regex |
unittest.mock.patch |
ersetzt ein Objekt für die Dauer des with-Blocks |
MagicMock |
Attrappe, die jeden Aufruf mitschreibt
(assert_called_once) |
- Die Fixture
fake_fetchist eine Factory: Sie gibt eine Funktion zurück, die pro Test den gewünschten Fetcher baut. patch("checkcert.core.socket.create_connection", ...)patcht dort, wo der Name benutzt wird – im Modulcheckcert.core, nicht im Modulsocketan sich.side_effect=TimeoutErrorlässt den Mock eine Exception werfen;return_value=ctxgibt einen vorbereiteten Mock zurück.- Die Grenzwerttests dokumentieren nebenbei die Fachregel: Bei genau 30 Tagen ist noch alles OK.
Fortschritt speichern? Kostenlos registrieren
Drill 6: CLI testen mit tmp_path, monkeypatch und CliRunner
cat > tests/test_cli.py <<'EOF'
import os
import pytest
import typer
from typer.testing import CliRunner
from checkcert import cli
from checkcert.core import Result, Status
runner = CliRunner()
@pytest.mark.parametrize(
("target", "expected"),
[
("github.com", ("github.com", 443)),
("vault.lab:8200", ("vault.lab", 8200)),
("::1:8443", ("::1", 8443)),
],
)
def test_parse_target(target, expected):
assert cli.parse_target(target) == expected
def test_parse_target_falscher_port():
with pytest.raises(typer.BadParameter):
cli.parse_target("github.com:https")
def test_read_targets(tmp_path):
hosts = tmp_path / "hosts.txt"
hosts.write_text("# Kommentar\n\na.lab\nb.lab:8443 # mit Port\n", encoding="utf-8")
assert cli.read_targets(hosts) == ["a.lab", "b.lab:8443"]
@pytest.fixture
def fake_check(monkeypatch):
"""Ersetzt check() dort, wo cli es benutzt – kein Netzwerk im Test."""
results = {
"ok.lab": Result("ok.lab", 443, Status.OK, 90),
"bald.lab": Result("bald.lab", 443, Status.WARN, 12),
"kaputt.lab": Result("kaputt.lab", 443, Status.ERROR, error="refused"),
}
monkeypatch.setattr(cli, "check", lambda host, port, **kw: results[host])
@pytest.mark.parametrize(
("hosts", "code"),
[(["ok.lab"], 0), (["ok.lab", "bald.lab"], 1), (["bald.lab", "kaputt.lab"], 3)],
)
def test_exit_code_ist_schlechtester_status(fake_check, hosts, code):
result = runner.invoke(cli.app, hosts)
assert result.exit_code == code
def test_ohne_ziele_exit_2():
assert runner.invoke(cli.app, []).exit_code == 2
@pytest.mark.skipif(not os.environ.get("CHECKCERT_LIVE"), reason="nur mit Netz")
def test_live_github():
result = runner.invoke(cli.app, ["github.com"])
assert result.exit_code in (0, 1)
assert "github.com:443" in result.output
EOF
uv run pytest -q -rsErwartet:
.........s............ [100%]
=========================== short test summary info ============================
SKIPPED [1] tests/test_cli.py:60: nur mit Netz
21 passed, 1 skipped in 0.05s
tmp_pathliefert pro Test einen eigenen leeren Ordner – Hostlisten entstehen dort statt im Repo.monkeypatch.setattr(cli, "check", ...)ersetztcheckim Modulcli, weilcliden Namen perfrom ... import checkan sich gebunden hat. Am Testende stellt pytest das Original wieder her.- Fixtures dürfen andere Fixtures anfordern (
fake_checknutztmonkeypatch), und parametrisierte Tests nutzen Fixtures ganz normal. skipifhält langsame oder netzabhängige Tests aus dem Standardlauf. Live prüfen:
CHECKCERT_LIVE=1 uv run pytest -q -k liveErwartet:
. [100%]
1 passed, 21 deselected in 0.06s
Achtung:
monkeypatch.setattr(core, "fetch_cert", ...)würde hier nichts bewirken: Der Defaultfetch=fetch_certwurde beim Definieren voncheck()gebunden. Deshalb injiziertcheck()den Fetcher als Parameter.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Das Tool ist fertig
uv run pytest -q --cov=checkcert --cov-report=term-missing --cov-fail-under=85
uv run ruff check && uv run ruff format --check
uv run --with mypy mypy --strict src
uv run checkcert -f lab/hosts.txt --timeout 3 > report.txt; echo "exit=$?"
cut -c1-60 report.txt && rm report.txtErwartet (gekürzt):
Name Stmts Miss Cover Missing
---------------------------------------------------------
src/checkcert/__init__.py 3 1 67% 7
src/checkcert/__main__.py 2 2 0% 1-3
src/checkcert/cli.py 35 0 100%
src/checkcert/core.py 52 5 90% 49-50, 55-57
---------------------------------------------------------
TOTAL 92 8 91%
Required test coverage of 85% reached. Total coverage: 91.30%
21 passed, 1 skipped in 0.12s
All checks passed!
8 files already formatted
Success: no issues found in 4 source files
exit=3
STATUS TAGE ABLAUF HOST
OK 50 2026-11-29 github.com:443
OK 76 2026-12-25 example.com:443
ERROR - - expired.badssl.com:443 (certifica
ERROR - - wrong.host.badssl.com:443 (Hostna
term-missing zeigt die ungetesteten Zeilen: der echte
Handshake (49–50) – den deckt der Live-Test ab – und der Sonderfall
„kein Zertifikat” (55–57). 100 % sind kein Ziel; die Fachlogik
(rate, check, Exit-Codes) muss abgedeckt sein.
--cov-fail-under macht die Schwelle zum CI-Gate.
An Tag 5 wird aus checkcert ein installierbares Paket
mit Versionierung, pre-commit und uv tool install.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/py-lab/tag04-checkcert
check "Tests grün, Coverage >= 85 %" \
"uv run pytest -q --cov=checkcert --cov-fail-under=85"
check "ruff sauber" "uv run ruff check && uv run ruff format --check"
check "mypy --strict sauber" "uv run --with mypy mypy --strict src"
check "github.com ist OK oder WARN" "uv run checkcert github.com; test \$? -le 1"
check "abgelaufenes Zertifikat gibt Exit 3" \
"uv run checkcert expired.badssl.com; test \$? -eq 3"
check "--warn 400 erzwingt WARN" \
"uv run checkcert github.com --warn 400; test \$? -eq 1"
check "ohne Ziel Exit 2" "uv run checkcert; test \$? -eq 2"
check "Logging nur mit -v" \
"uv run checkcert github.com -v 2>&1 >/dev/null | grep -q DEBUG"Erwartet:
✔ Tests grün, Coverage >= 85 %
✔ ruff sauber
✔ mypy --strict sauber
✔ github.com ist OK oder WARN
✔ abgelaufenes Zertifikat gibt Exit 3
✔ --warn 400 erzwingt WARN
✔ ohne Ziel Exit 2
✔ Logging nur mit -v
Challenge
Ein Host, der beim ersten Versuch in einen Timeout läuft, soll einmal wiederholt werden – aber nur bei Timeouts, nie bei Zertifikatsfehlern. Beweise beides mit einem Test, ohne Netz.
Hinweis: CertError trägt die Ursache in
__cause__; ein MagicMock mit einer Liste als
side_effect liefert bei jedem Aufruf das nächste
Element.
Lösung
In src/checkcert/core.py bekommt check()
den Parameter retries: int = 1 (nach timeout),
und der try-Block wird zur Schleife:
for attempt in range(retries + 1):
try:
expires = expires_at(fetch(host, port, timeout))
break
except CertError as err:
if isinstance(err.__cause__, TimeoutError) and attempt < retries:
log.info("%s:%s Timeout, neuer Versuch", host, port)
continue
log.warning("%s:%s nicht prüfbar: %s", host, port, err)
return Result(host, port, Status.ERROR, error=str(err))Test in tests/test_core.py anhängen:
def test_check_wiederholt_nur_nach_timeout(now):
timeout = CertError("timed out")
timeout.__cause__ = TimeoutError()
fetch = MagicMock(side_effect=[timeout, {"notAfter": "Nov 29 23:59:59 2026 GMT"}])
assert check("wackelig.lab", fetch=fetch, now=now).status is Status.OK
assert fetch.call_count == 2
fetch = MagicMock(side_effect=CertError("certificate has expired"))
assert check("expired.lab", fetch=fetch, now=now).status is Status.ERROR
assert fetch.call_count == 1uv run pytest -q
uv run --with mypy mypy --strict src
uv run checkcert 10.255.255.1 --timeout 0.5 -v 2>&1 | grep -v DEBUGErwartet:
22 passed, 1 skipped in 0.20s
Success: no issues found in 4 source files
STATUS TAGE ABLAUF HOST
INFO checkcert.core: 10.255.255.1:443 Timeout, neuer Versuch
WARNING checkcert.core: 10.255.255.1:443 nicht prüfbar: timed out
ERROR - - 10.255.255.1:443 (timed out)
Warum ist expires nach der Schleife sicher gesetzt? Nach
erfolgreichem Abruf verlässt break die Schleife; jeder
Fehlerpfad endet mit return oder continue.
mypy erkennt das und meldet keinen möglicherweise ungebundenen
Namen.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Interne Hosts nutzen oft eine eigene CA:
ssl.create_default_context(cafile=...)oderSSL_CERT_FILEsetzen – niemals die Prüfung abschalten. - Nicht nur Ablaufdatum prüfen: vollständige Kette, Schlüssellänge,
Signaturalgorithmus und SANs. Für tiefere Analysen
cryptography(x509.load_der_x509_certificate) einsetzen. - Als Monitoring-Check laufen lassen (Nagios/Icinga-Exit-Codes) oder
besser als Prometheus-Metrik
cert_expiry_days; blackbox_exporter kann das bereits. - Logs strukturiert (JSON) und ohne Secrets; bei mTLS niemals private Schlüssel oder Passphrasen loggen.
- Hunderte Hosts nacheinander mit 5 s Timeout sind langsam – an Tag 7
prüft
urlcheckparallel mit asyncio.