Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Fehler, Logging, Tests – checkcert

Ziel: Ein Tool checkcert bauen, 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 per raise ... from erhalten.
  • logging statt print für Diagnose: Modul-Logger, Level per --verbose, Ausgabe nach stderr.
  • 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"]
EOF

Erwartet (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"]))
EOF

Erwartet (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. Nie CERT_NONE setzen, um „schnell mal” ein Problem zu umgehen.
  • server_hostname sorgt 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__}")
EOF

Erwartet:

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. .invalid ist 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)
EOF
  • class CertError(Exception) mit Docstring reicht als eigene Exception. Aufrufer müssen nur noch einen Typ kennen statt sieben.
  • raise CertError(...) from err setzt __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, und max() findet den schlechtesten Status.
  • log = logging.getLogger(__name__) ergibt den Logger checkcert.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() bekommt now und fetch als 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 host statt checkcert main host.
  • logging.basicConfig einmal im CLI; ohne -v erscheinen nur Meldungen ab ERROR. Log-Ausgaben gehen nach stderr, die Tabelle nach stdout – checkcert ... > report.txt bleibt 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 rate

Erwartet (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_fetch ist 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 Modul checkcert.core, nicht im Modul socket an sich.
  • side_effect=TimeoutError lässt den Mock eine Exception werfen; return_value=ctx gibt 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 -rs

Erwartet:

.........s............                                                   [100%]
=========================== short test summary info ============================
SKIPPED [1] tests/test_cli.py:60: nur mit Netz
21 passed, 1 skipped in 0.05s
  • tmp_path liefert pro Test einen eigenen leeren Ordner – Hostlisten entstehen dort statt im Repo.
  • monkeypatch.setattr(cli, "check", ...) ersetzt check im Modul cli, weil cli den Namen per from ... import check an sich gebunden hat. Am Testende stellt pytest das Original wieder her.
  • Fixtures dürfen andere Fixtures anfordern (fake_check nutzt monkeypatch), und parametrisierte Tests nutzen Fixtures ganz normal.
  • skipif hält langsame oder netzabhängige Tests aus dem Standardlauf. Live prüfen:
CHECKCERT_LIVE=1 uv run pytest -q -k live

Erwartet:

.                                                                        [100%]
1 passed, 21 deselected in 0.06s

Achtung: monkeypatch.setattr(core, "fetch_cert", ...) würde hier nichts bewirken: Der Default fetch=fetch_cert wurde beim Definieren von check() gebunden. Deshalb injiziert check() 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.txt

Erwartet (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 == 1
uv 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 DEBUG

Erwartet:

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=...) oder SSL_CERT_FILE setzen – 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 urlcheck parallel mit asyncio.