Übungsaufgaben zum Gliedern von Methoden: Single Level of Abstraction, IOSP, eine Aufgabe je Methode und Fail fast

// Position.java
package de.csbrad.shop;

/** Eine Bestellposition; Preise sind Nettopreise in Cent, Gewichte in Gramm. */
public record Position(String artikelnr, String bezeichnung, int nettopreisCent, int menge, int gewichtGramm, boolean istRad) {
}

// Bestellanfrage.java
package de.csbrad.shop;

import java.util.List;

/** Parameterobjekt: alles, was der Bestellabschluss als Eingabe braucht. */
public record Bestellanfrage(List<Position> positionen, String versandart, String gutscheincode, String kundenEmail) {
}

// Shop.java
package de.csbrad.shop;

import java.util.ArrayList;
import java.util.List;

public class Shop {

    private static final int ERSTE_BESTELLNUMMER = 1001;
    private static final String GUTSCHEINCODE_KURIER = "KURIER10";
    private static final int GUTSCHEIN_RABATT_PROZENT = 10;
    private static final int PAKETPAUSCHALE_CENT = 690;
    private static final int HOECHSTGEWICHT_PAKET_GRAMM = 31500;
    private static final int VERSANDKOSTENFREI_AB_CENT = 10000;
    private static final int SPEDITION_JE_RAD_CENT = 4900;
    private static final int MEHRWERTSTEUER_PROZENT = 19;

    private int naechsteBestellnummer = ERSTE_BESTELLNUMMER;
    private final List<Object[]> bestellungen = new ArrayList<>();
    private final List<String> postausgang = new ArrayList<>();

    public List<Object[]> getBestellungen() {
        return bestellungen;
    }

    public List<String> getPostausgang() {
        return postausgang;
    }

    /**
     * Berechnet die Beträge einer Bestellung, verschickt die Bestätigungsmail und speichert die Bestellung.
     *
     * @return {Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag} in Cent
     */
    public int[] abschliessen(Bestellanfrage anfrage) {
        int warenwert = berechneWarenwert(anfrage.positionen());
        int rabatt = berechneRabatt(warenwert, anfrage.gutscheincode());
        int versandkosten = berechneVersandkosten(anfrage.positionen(), anfrage.versandart(), warenwert - rabatt);
        if (warenwert == 0) {
            throw new IllegalArgumentException("Bestellung ohne Warenwert");
        }
        int nettobetrag = warenwert - rabatt + versandkosten;
        int mehrwertsteuer = berechneMehrwertsteuer(nettobetrag);
        int gesamtbetrag = nettobetrag + mehrwertsteuer;
        int bestellnummer = vergibBestellnummer();
        postausgang.add(erstelleMailtext(anfrage, bestellnummer, gesamtbetrag));
        bestellungen.add(new Object[] {"CSB-" + bestellnummer, anfrage.kundenEmail(), anfrage.positionen(), gesamtbetrag});
        return new int[] {warenwert, rabatt, versandkosten, mehrwertsteuer, gesamtbetrag};
    }

    private int berechneWarenwert(List<Position> positionen) {
        int warenwert = 0;
        for (Position position : positionen) {
            if (position.menge() <= 0) {
                throw new IllegalArgumentException("Menge muss positiv sein: " + position.artikelnr());
            }
            warenwert = warenwert + position.nettopreisCent() * position.menge();
        }
        return warenwert;
    }

    private int berechneRabatt(int warenwert, String gutscheincode) {
        if (GUTSCHEINCODE_KURIER.equals(gutscheincode)) {
            return prozentKaufmaennischGerundet(warenwert, GUTSCHEIN_RABATT_PROZENT);
        }
        return 0;
    }

    private int berechneVersandkosten(List<Position> positionen, String versandart, int warenwertNachRabatt) {
        switch (versandart) {
            case "PAKET":
                int anzahlPakete = berechneAnzahlPakete(positionen);
                if (warenwertNachRabatt >= VERSANDKOSTENFREI_AB_CENT) {
                    return 0;
                }
                return anzahlPakete * PAKETPAUSCHALE_CENT;
            case "SPEDITION":
                // ohne Rad wird eine Speditionspauschale berechnet
                return Math.max(1, zaehleRaeder(positionen)) * SPEDITION_JE_RAD_CENT;
            case "ABHOLUNG":
                return 0;
            default:
                throw new IllegalArgumentException("Unbekannte Versandart: " + versandart);
        }
    }

    private int berechneAnzahlPakete(List<Position> positionen) {
        int gesamtgewicht = 0;
        for (Position position : positionen) {
            if (position.istRad()) {
                throw new IllegalArgumentException("Räder können nicht als Paket versandt werden");
            }
            gesamtgewicht = gesamtgewicht + position.gewichtGramm() * position.menge();
        }
        int anzahlPakete = (gesamtgewicht + HOECHSTGEWICHT_PAKET_GRAMM - 1) / HOECHSTGEWICHT_PAKET_GRAMM;
        return Math.max(1, anzahlPakete);
    }

    private int zaehleRaeder(List<Position> positionen) {
        int anzahlRaeder = 0;
        for (Position position : positionen) {
            if (position.istRad()) {
                anzahlRaeder = anzahlRaeder + position.menge();
            }
        }
        return anzahlRaeder;
    }

    private int berechneMehrwertsteuer(int nettobetrag) {
        return prozentKaufmaennischGerundet(nettobetrag, MEHRWERTSTEUER_PROZENT);
    }

    private static int prozentKaufmaennischGerundet(int betragCent, int prozent) {
        return (betragCent * prozent + 50) / 100;
    }

    private int vergibBestellnummer() {
        int bestellnummer = naechsteBestellnummer;
        naechsteBestellnummer = naechsteBestellnummer + 1;
        return bestellnummer;
    }

    private String erstelleMailtext(Bestellanfrage anfrage, int bestellnummer, int gesamtbetrag) {
        String mailtext = "An: " + anfrage.kundenEmail() + "\nBestellung CSB-" + bestellnummer + "\nGesamtbetrag: "
                + alsEuroText(gesamtbetrag);
        if (anfrage.versandart().equals("ABHOLUNG")) {
            return mailtext + "\nAbholung in der Werkstatt Bielefeld-Sennestadt";
        }
        return mailtext + "\nVersand: " + versandbezeichnung(anfrage.versandart());
    }

    private static String versandbezeichnung(String versandart) {
        return switch (versandart) {
            case "PAKET" -> "Paket";
            case "SPEDITION" -> "Spedition";
            default -> "Abholung";
        };
    }

    private static String alsEuroText(int betragCent) {
        return (betragCent / 100) + "," + String.format("%02d", betragCent % 100) + " EUR";
    }
}

# csbrad/position.py
from dataclasses import dataclass


@dataclass(frozen=True)
class Position:
    """Eine Bestellposition; Preise sind Nettopreise in Cent, Gewichte in Gramm."""

    artikelnr: str
    bezeichnung: str
    nettopreis_cent: int
    menge: int
    gewicht_gramm: int
    ist_rad: bool

# csbrad/bestellanfrage.py
from dataclasses import dataclass

from csbrad.position import Position


@dataclass(frozen=True)
class Bestellanfrage:
    """Parameterobjekt: alles, was der Bestellabschluss als Eingabe braucht."""

    positionen: list[Position]
    versandart: str
    gutscheincode: str | None
    kunden_email: str

# csbrad/shop.py
from csbrad.bestellanfrage import Bestellanfrage
from csbrad.position import Position

ERSTE_BESTELLNUMMER = 1001
GUTSCHEINCODE_KURIER = "KURIER10"
GUTSCHEIN_RABATT_PROZENT = 10
PAKETPAUSCHALE_CENT = 690
HOECHSTGEWICHT_PAKET_GRAMM = 31500
VERSANDKOSTENFREI_AB_CENT = 10000
SPEDITION_JE_RAD_CENT = 4900
MEHRWERTSTEUER_PROZENT = 19


class Shop:

    def __init__(self) -> None:
        self._naechste_bestellnummer = ERSTE_BESTELLNUMMER
        self._bestellungen: list[list[object]] = []
        self._postausgang: list[str] = []

    def get_bestellungen(self) -> list[list[object]]:
        return self._bestellungen

    def get_postausgang(self) -> list[str]:
        return self._postausgang

    def abschliessen(self, anfrage: Bestellanfrage) -> list[int]:
        """Berechnet die Beträge einer Bestellung, verschickt die Bestätigungsmail und speichert die Bestellung.

        Rückgabe: [Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag] in Cent.
        """
        warenwert = self._berechne_warenwert(anfrage.positionen)
        rabatt = self._berechne_rabatt(warenwert, anfrage.gutscheincode)
        versandkosten = self._berechne_versandkosten(anfrage.positionen, anfrage.versandart, warenwert - rabatt)
        if warenwert == 0:
            raise ValueError("Bestellung ohne Warenwert")
        nettobetrag = warenwert - rabatt + versandkosten
        mehrwertsteuer = self._berechne_mehrwertsteuer(nettobetrag)
        gesamtbetrag = nettobetrag + mehrwertsteuer
        bestellnummer = self._vergib_bestellnummer()
        self._postausgang.append(self._erstelle_mailtext(anfrage, bestellnummer, gesamtbetrag))
        self._bestellungen.append(["CSB-" + str(bestellnummer), anfrage.kunden_email, anfrage.positionen, gesamtbetrag])
        return [warenwert, rabatt, versandkosten, mehrwertsteuer, gesamtbetrag]

    def _berechne_warenwert(self, positionen: list[Position]) -> int:
        warenwert = 0
        for position in positionen:
            if position.menge <= 0:
                raise ValueError(f"Menge muss positiv sein: {position.artikelnr}")
            warenwert = warenwert + position.nettopreis_cent * position.menge
        return warenwert

    def _berechne_rabatt(self, warenwert: int, gutscheincode: str | None) -> int:
        if gutscheincode == GUTSCHEINCODE_KURIER:
            return _prozent_kaufmaennisch_gerundet(warenwert, GUTSCHEIN_RABATT_PROZENT)
        return 0

    def _berechne_versandkosten(self, positionen: list[Position], versandart: str, warenwert_nach_rabatt: int) -> int:
        match versandart:
            case "PAKET":
                anzahl_pakete = self._berechne_anzahl_pakete(positionen)
                if warenwert_nach_rabatt >= VERSANDKOSTENFREI_AB_CENT:
                    return 0
                return anzahl_pakete * PAKETPAUSCHALE_CENT
            case "SPEDITION":
                # ohne Rad wird eine Speditionspauschale berechnet
                return max(1, self._zaehle_raeder(positionen)) * SPEDITION_JE_RAD_CENT
            case "ABHOLUNG":
                return 0
            case _:
                raise ValueError(f"Unbekannte Versandart: {versandart}")

    def _berechne_anzahl_pakete(self, positionen: list[Position]) -> int:
        gesamtgewicht = 0
        for position in positionen:
            if position.ist_rad:
                raise ValueError("Räder können nicht als Paket versandt werden")
            gesamtgewicht = gesamtgewicht + position.gewicht_gramm * position.menge
        anzahl_pakete = (gesamtgewicht + HOECHSTGEWICHT_PAKET_GRAMM - 1) // HOECHSTGEWICHT_PAKET_GRAMM
        return max(1, anzahl_pakete)

    def _zaehle_raeder(self, positionen: list[Position]) -> int:
        anzahl_raeder = 0
        for position in positionen:
            if position.ist_rad:
                anzahl_raeder = anzahl_raeder + position.menge
        return anzahl_raeder

    def _berechne_mehrwertsteuer(self, nettobetrag: int) -> int:
        return _prozent_kaufmaennisch_gerundet(nettobetrag, MEHRWERTSTEUER_PROZENT)

    def _vergib_bestellnummer(self) -> int:
        bestellnummer = self._naechste_bestellnummer
        self._naechste_bestellnummer = self._naechste_bestellnummer + 1
        return bestellnummer

    def _erstelle_mailtext(self, anfrage: Bestellanfrage, bestellnummer: int, gesamtbetrag: int) -> str:
        mailtext = ("An: " + anfrage.kunden_email + "\nBestellung CSB-" + str(bestellnummer)
                    + "\nGesamtbetrag: " + _als_euro_text(gesamtbetrag))
        if anfrage.versandart == "ABHOLUNG":
            return mailtext + "\nAbholung in der Werkstatt Bielefeld-Sennestadt"
        return mailtext + "\nVersand: " + _versandbezeichnung(anfrage.versandart)


def _prozent_kaufmaennisch_gerundet(betrag_cent: int, prozent: int) -> int:
    return (betrag_cent * prozent + 50) // 100


def _versandbezeichnung(versandart: str) -> str:
    return {"PAKET": "Paket", "SPEDITION": "Spedition"}.get(versandart, "Abholung")


def _als_euro_text(betrag_cent: int) -> str:
    return f"{betrag_cent // 100},{betrag_cent % 100:02d} EUR"

// ShopCharakterisierungTest.java
package de.csbrad.shop;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Charakterisierungstests: halten fest, was der Code heute tut (seit Stand 04 im Testordner).
 * Ergebnis-Array: {Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag} in Cent.
 */
class ShopCharakterisierungTest {

    static final Position LICHTSET = new Position("LIC-SET-01", "Lichtset Nabendynamo StVZO", 7563, 1, 350, false);
    static final Position BREMSE = new Position("BRE-HYD-01", "Hydraulische Scheibenbremse (Paar)", 13361, 1, 750, false);
    static final Position BUEGELSCHLOSS = new Position("SCH-BUE-01", "Bügelschloss, gleichschließend", 6218, 1, 1300, false);
    static final Position RAHMENSCHLOSS = new Position("SCH-RAH-01", "Rahmenschloss, gleichschließend", 4118, 1, 450, false);
    static final Position STADTRAD = new Position("RAD-CITY-01", "Stadtrad „Promenade“ 7-Gang", 67143, 1, 16800, true);
    static final Position EBIKE = new Position("RAD-EB-02", "E-Bike „Kanal“ Mittelmotor 500 Wh", 252017, 1, 24500, true);
    static final String MAIL = "mira.engel@example.org";

    private Shop shop;

    @BeforeEach
    void neuerShop() {
        shop = new Shop();
    }

    static Position menge(Position p, int m) {
        return new Position(p.artikelnr(), p.bezeichnung(), p.nettopreisCent(), m, p.gewichtGramm(), p.istRad());
    }

    @Test
    void paketUnterFreigrenze() {
        assertArrayEquals(new int[] {7563, 0, 690, 1568, 9821}, shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL)));
    }

    @Test
    void paketAbFreigrenzeIstVersandfrei() {
        assertArrayEquals(new int[] {13361, 0, 0, 2539, 15900}, shop.abschliessen(new Bestellanfrage(List.of(BREMSE), "PAKET", null, MAIL)));
    }

    @Test
    void freigrenzeGiltNachRabatt() {
        assertArrayEquals(new int[] {10336, 1034, 690, 1898, 11890},
                shop.abschliessen(new Bestellanfrage(List.of(BUEGELSCHLOSS, RAHMENSCHLOSS), "PAKET", "KURIER10", MAIL)));
    }

    @Test
    void ohneRabattUeberFreigrenze() {
        assertArrayEquals(new int[] {10336, 0, 0, 1964, 12300},
                shop.abschliessen(new Bestellanfrage(List.of(BUEGELSCHLOSS, RAHMENSCHLOSS), "PAKET", null, MAIL)));
    }

    @Test
    void schwerePaketbestellungMitRabatt() {
        assertArrayEquals(new int[] {155450, 15545, 0, 26582, 166487},
                shop.abschliessen(new Bestellanfrage(List.of(menge(BUEGELSCHLOSS, 25)), "PAKET", "KURIER10", MAIL)));
    }

    @Test
    void speditionJeRad() {
        assertArrayEquals(new int[] {149412, 0, 9800, 30250, 189462},
                shop.abschliessen(new Bestellanfrage(List.of(menge(STADTRAD, 2), menge(LICHTSET, 2)), "SPEDITION", null, MAIL)));
    }

    @Test
    void speditionOhneRadKostetEinePauschale() {
        assertArrayEquals(new int[] {7563, 0, 4900, 2368, 14831}, shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "SPEDITION", null, MAIL)));
    }

    @Test
    void abholungMitRabattcode() {
        assertArrayEquals(new int[] {252017, 25202, 0, 43095, 269910}, shop.abschliessen(new Bestellanfrage(List.of(EBIKE), "ABHOLUNG", "KURIER10", MAIL)));
    }

    @Test
    void unbekannterCodeGibtKeinenRabatt() {
        assertArrayEquals(new int[] {7563, 0, 690, 1568, 9821}, shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", "SOMMER20", MAIL)));
    }

    @Test
    void radAlsPaketWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(new Bestellanfrage(List.of(STADTRAD), "PAKET", null, MAIL)));
        assertEquals(0, shop.getPostausgang().size());
        assertEquals(0, shop.getBestellungen().size());
    }

    @Test
    void leereBestellungWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(new Bestellanfrage(List.of(), "PAKET", null, MAIL)));
        assertEquals(0, shop.getPostausgang().size());
    }

    @Test
    void mengeNullWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(new Bestellanfrage(List.of(menge(LICHTSET, 0)), "PAKET", null, MAIL)));
    }

    @Test
    void unbekannteVersandartWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "BRIEF", null, MAIL)));
    }

    @Test
    void mailFuerPaketversand() {
        shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL));
        assertEquals("An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 98,21 EUR\nVersand: Paket", shop.getPostausgang().get(0));
    }

    @Test
    void mailFuerAbholung() {
        shop.abschliessen(new Bestellanfrage(List.of(EBIKE), "ABHOLUNG", "KURIER10", MAIL));
        assertEquals("An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 2699,10 EUR\nAbholung in der Werkstatt Bielefeld-Sennestadt",
                shop.getPostausgang().get(0));
    }

    @Test
    void bestellungenWerdenFortlaufendNummeriertUndGespeichert() {
        shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL));
        shop.abschliessen(new Bestellanfrage(List.of(BREMSE), "PAKET", null, MAIL));
        assertEquals(2, shop.getBestellungen().size());
        assertEquals("CSB-1001", shop.getBestellungen().get(0)[0]);
        assertEquals("CSB-1002", shop.getBestellungen().get(1)[0]);
        assertEquals(15900, shop.getBestellungen().get(1)[3]);
    }
}

# tests/test_shop_charakterisierung.py
"""Charakterisierungstests: halten fest, was der Code heute tut (seit Stand 04 im Testordner).

Ergebnis-Liste: [Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag] in Cent.
"""
from dataclasses import replace

import pytest

from csbrad.bestellanfrage import Bestellanfrage
from csbrad.position import Position
from csbrad.shop import Shop

LICHTSET = Position("LIC-SET-01", "Lichtset Nabendynamo StVZO", 7563, 1, 350, False)
BREMSE = Position("BRE-HYD-01", "Hydraulische Scheibenbremse (Paar)", 13361, 1, 750, False)
BUEGELSCHLOSS = Position("SCH-BUE-01", "Bügelschloss, gleichschließend", 6218, 1, 1300, False)
RAHMENSCHLOSS = Position("SCH-RAH-01", "Rahmenschloss, gleichschließend", 4118, 1, 450, False)
STADTRAD = Position("RAD-CITY-01", "Stadtrad „Promenade“ 7-Gang", 67143, 1, 16800, True)
EBIKE = Position("RAD-EB-02", "E-Bike „Kanal“ Mittelmotor 500 Wh", 252017, 1, 24500, True)
MAIL = "mira.engel@example.org"


@pytest.fixture
def shop() -> Shop:
    return Shop()


def test_paket_unter_freigrenze(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([LICHTSET], "PAKET", None, MAIL)) == [7563, 0, 690, 1568, 9821]


def test_paket_ab_freigrenze_ist_versandfrei(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([BREMSE], "PAKET", None, MAIL)) == [13361, 0, 0, 2539, 15900]


def test_freigrenze_gilt_nach_rabatt(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([BUEGELSCHLOSS, RAHMENSCHLOSS], "PAKET", "KURIER10", MAIL)) == [10336, 1034, 690, 1898, 11890]


def test_ohne_rabatt_ueber_freigrenze(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([BUEGELSCHLOSS, RAHMENSCHLOSS], "PAKET", None, MAIL)) == [10336, 0, 0, 1964, 12300]


def test_schwere_paketbestellung_mit_rabatt(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([replace(BUEGELSCHLOSS, menge=25)], "PAKET", "KURIER10", MAIL)) == [155450, 15545, 0, 26582, 166487]


def test_spedition_je_rad(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([replace(STADTRAD, menge=2), replace(LICHTSET, menge=2)], "SPEDITION", None, MAIL)) == [149412, 0, 9800, 30250, 189462]


def test_spedition_ohne_rad_kostet_eine_pauschale(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([LICHTSET], "SPEDITION", None, MAIL)) == [7563, 0, 4900, 2368, 14831]


def test_abholung_mit_rabattcode(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([EBIKE], "ABHOLUNG", "KURIER10", MAIL)) == [252017, 25202, 0, 43095, 269910]


def test_unbekannter_code_gibt_keinen_rabatt(shop: Shop) -> None:
    assert shop.abschliessen(Bestellanfrage([LICHTSET], "PAKET", "SOMMER20", MAIL)) == [7563, 0, 690, 1568, 9821]


def test_rad_als_paket_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen(Bestellanfrage([STADTRAD], "PAKET", None, MAIL))
    assert shop.get_postausgang() == []
    assert shop.get_bestellungen() == []


def test_leere_bestellung_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen(Bestellanfrage([], "PAKET", None, MAIL))
    assert shop.get_postausgang() == []


def test_menge_null_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen(Bestellanfrage([replace(LICHTSET, menge=0)], "PAKET", None, MAIL))


def test_unbekannte_versandart_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen(Bestellanfrage([LICHTSET], "BRIEF", None, MAIL))


def test_mail_fuer_paketversand(shop: Shop) -> None:
    shop.abschliessen(Bestellanfrage([LICHTSET], "PAKET", None, MAIL))
    assert shop.get_postausgang()[0] == "An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 98,21 EUR\nVersand: Paket"


def test_mail_fuer_abholung(shop: Shop) -> None:
    shop.abschliessen(Bestellanfrage([EBIKE], "ABHOLUNG", "KURIER10", MAIL))
    assert shop.get_postausgang()[0] == "An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 2699,10 EUR\nAbholung in der Werkstatt Bielefeld-Sennestadt"


def test_bestellungen_werden_fortlaufend_nummeriert_und_gespeichert(shop: Shop) -> None:
    shop.abschliessen(Bestellanfrage([LICHTSET], "PAKET", None, MAIL))
    shop.abschliessen(Bestellanfrage([BREMSE], "PAKET", None, MAIL))
    assert len(shop.get_bestellungen()) == 2
    assert shop.get_bestellungen()[0][0] == "CSB-1001"
    assert shop.get_bestellungen()[1][0] == "CSB-1002"
    assert shop.get_bestellungen()[1][3] == 15900

// Fahrt.java
package de.mitfahrlabor;

import java.util.ArrayList;
import java.util.List;

public class Fahrt {

    private final String fahrer;
    private final int plaetze;
    private final int beitragJeKmCent;
    private final List<String> mitfahrende = new ArrayList<>();

    public Fahrt(String fahrer, int plaetze, int beitragJeKmCent) {
        this.fahrer = fahrer;
        this.plaetze = plaetze;
        this.beitragJeKmCent = beitragJeKmCent;
    }

    public String fahrer() {
        return fahrer;
    }

    public int beitragJeKmCent() {
        return beitragJeKmCent;
    }

    public int freiePlaetze() {
        return plaetze - mitfahrende.size();
    }

    public void belegePlatz(String name) {
        mitfahrende.add(name);
    }

    public List<String> mitfahrende() {
        return List.copyOf(mitfahrende);
    }
}

// Anfrageverwaltung.java
package de.mitfahrlabor;

import java.util.ArrayList;
import java.util.List;

public class Anfrageverwaltung {

    public static final int AUSGEBUCHT = -1;
    public static final int EINWILLIGUNG_FEHLT = -2;

    private final List<String> nachrichten = new ArrayList<>();

    public List<String> nachrichten() {
        return nachrichten;
    }

    /** Bestätigt eine Anfrage; Rückgabe: Kostenbeitrag in Cent oder ein negativer Fehlercode. */
    public int bestaetige(Fahrt fahrt, String name, boolean minderjaehrig, boolean einwilligung, int km, boolean perPush) {
        if (fahrt != null) {
            if (fahrt.freiePlaetze() > 0) {
                if (!minderjaehrig || einwilligung) {
                    int beitrag = km * fahrt.beitragJeKmCent();
                    fahrt.belegePlatz(name);
                    String betrag = (beitrag / 100) + "," + String.format("%02d", beitrag % 100) + " EUR";
                    if (perPush) {
                        nachrichten.add("Push an " + name + ": Mitfahrt bei " + fahrt.fahrer() + " bestätigt, Kostenbeitrag " + betrag);
                    } else {
                        nachrichten.add("Mail an " + name + ": Deine Mitfahrt bei " + fahrt.fahrer() + " ist bestätigt. Kostenbeitrag: " + betrag);
                    }
                    return beitrag;
                } else {
                    return EINWILLIGUNG_FEHLT;
                }
            } else {
                return AUSGEBUCHT;
            }
        }
        return 0;
    }
}

# mitfahrlabor/fahrt.py
from dataclasses import dataclass, field


@dataclass
class Fahrt:
    fahrer: str
    plaetze: int
    beitrag_je_km_cent: int
    mitfahrende: list[str] = field(default_factory=list)

    def freie_plaetze(self) -> int:
        return self.plaetze - len(self.mitfahrende)

    def belege_platz(self, name: str) -> None:
        self.mitfahrende.append(name)

# mitfahrlabor/anfrageverwaltung.py
from mitfahrlabor.fahrt import Fahrt

AUSGEBUCHT = -1
EINWILLIGUNG_FEHLT = -2


class Anfrageverwaltung:

    def __init__(self) -> None:
        self.nachrichten: list[str] = []

    def bestaetige(self, fahrt: Fahrt | None, name: str, minderjaehrig: bool, einwilligung: bool,
                   km: int, per_push: bool) -> int:
        """Bestätigt eine Anfrage; Rückgabe: Kostenbeitrag in Cent oder ein negativer Fehlercode."""
        if fahrt is not None:
            if fahrt.freie_plaetze() > 0:
                if not minderjaehrig or einwilligung:
                    beitrag = km * fahrt.beitrag_je_km_cent
                    fahrt.belege_platz(name)
                    betrag = f"{beitrag // 100},{beitrag % 100:02d} EUR"
                    if per_push:
                        self.nachrichten.append(
                            f"Push an {name}: Mitfahrt bei {fahrt.fahrer} bestätigt, Kostenbeitrag {betrag}")
                    else:
                        self.nachrichten.append(
                            f"Mail an {name}: Deine Mitfahrt bei {fahrt.fahrer} ist bestätigt. Kostenbeitrag: {betrag}")
                    return beitrag
                else:
                    return EINWILLIGUNG_FEHLT
            else:
                return AUSGEBUCHT
        return 0

// Anfrage.java
package de.mitfahrlabor;

/** Anfrage zu einer Fahrt; status ist "OFFEN", "BESTAETIGT" oder "ABGELEHNT". */
public record Anfrage(String name, String status) {
}

// Fahrt.java
package de.mitfahrlabor;

import java.time.LocalDateTime;
import java.util.List;

public class Fahrt {

    private final String fahrer;
    private final String haltepunkt;
    private final LocalDateTime abfahrt;
    private final List<Anfrage> anfragen;
    private boolean erinnert = false;

    public Fahrt(String fahrer, String haltepunkt, LocalDateTime abfahrt, List<Anfrage> anfragen) {
        this.fahrer = fahrer;
        this.haltepunkt = haltepunkt;
        this.abfahrt = abfahrt;
        this.anfragen = List.copyOf(anfragen);
    }

    public String fahrer() {
        return fahrer;
    }

    public String haltepunkt() {
        return haltepunkt;
    }

    public LocalDateTime abfahrt() {
        return abfahrt;
    }

    public List<Anfrage> anfragen() {
        return anfragen;
    }

    public boolean istErinnert() {
        return erinnert;
    }

    public void markiereErinnert() {
        erinnert = true;
    }
}

// Erinnerungsdienst.java
package de.mitfahrlabor;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

public class Erinnerungsdienst {

    private final List<String> postausgang = new ArrayList<>();

    public List<String> postausgang() {
        return postausgang;
    }

    public void sendeErinnerungen(List<Fahrt> fahrten, LocalDateTime jetzt) {
        for (Fahrt fahrt : fahrten) {
            if (!fahrt.istErinnert() && fahrt.abfahrt().isAfter(jetzt) && fahrt.abfahrt().isBefore(jetzt.plusHours(12))) {
                fahrt.markiereErinnert();
                String uhrzeit = String.format("%02d:%02d", fahrt.abfahrt().getHour(), fahrt.abfahrt().getMinute());
                for (Anfrage anfrage : fahrt.anfragen()) {
                    if (!anfrage.status().equals("ABGELEHNT")) {
                        postausgang.add("An: " + anfrage.name() + "\nErinnerung: Abfahrt um " + uhrzeit + " ab " + fahrt.haltepunkt());
                    }
                }
            }
        }
    }
}