Übungsaufgaben zum Einsatz von Vererbung: Liskov Substitution Principle und Favour Composition over Inheritance

// Paket de.mitfahrlabor, Stand vor dem Umbau
// ===== Person.java =====
package de.mitfahrlabor;

public record Person(String name, String email, boolean pushAktiv) {
}

// ===== Benachrichtigung.java =====
package de.mitfahrlabor;

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

/** Ein Kanal, über den die App Personen benachrichtigt. */
public abstract class Benachrichtigung {

    protected final List<String> ausgang = new ArrayList<>();

    /** Stellt der Person den Text zu; danach steht genau ein Eintrag mehr im Ausgang. */
    public abstract void sende(Person person, String text);

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

// ===== MailBenachrichtigung.java =====
package de.mitfahrlabor;

public class MailBenachrichtigung extends Benachrichtigung {

    @Override
    public void sende(Person person, String text) {
        ausgang.add("Mail an " + person.email() + ": " + text);
    }
}

// ===== PushBenachrichtigung.java =====
package de.mitfahrlabor;

public class PushBenachrichtigung extends Benachrichtigung {

    @Override
    public void sende(Person person, String text) {
        if (!person.pushAktiv()) {
            throw new IllegalStateException("Push ist für " + person.name() + " nicht aktiviert");
        }
        ausgang.add("Push an " + person.name() + ": " + text);
    }
}

// ===== FlurmonitorAnzeige.java =====
package de.mitfahrlabor;

public class FlurmonitorAnzeige extends Benachrichtigung {

    @Override
    public void sende(Person person, String text) {
        throw new UnsupportedOperationException("Flurmonitore zeigen keine persönlichen Nachrichten");
    }

    public void zeige(String haltepunkt, String abfahrt, int freiePlaetze) {
        ausgang.add(abfahrt + " ab " + haltepunkt + ": " + freiePlaetze + " Plätze frei");
    }
}

// ===== Erinnerungsdienst.java =====
package de.mitfahrlabor;

import java.util.List;

public class Erinnerungsdienst {

    private final List<Benachrichtigung> kanaele;

    public Erinnerungsdienst(List<Benachrichtigung> kanaele) {
        this.kanaele = List.copyOf(kanaele);
    }

    public void erinnere(List<Person> mitfahrende, String fahrt) {
        for (Benachrichtigung kanal : kanaele) {
            if (kanal instanceof FlurmonitorAnzeige) {
                continue;
            }
            for (Person person : mitfahrende) {
                if (kanal instanceof PushBenachrichtigung && !person.pushAktiv()) {
                    continue;
                }
                kanal.sende(person, "Erinnerung: " + fahrt);
            }
        }
    }
}

# Modul mitfahrlabor/benachrichtigung.py, Stand vor dem Umbau
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import override


@dataclass(frozen=True)
class Person:
    name: str
    email: str
    push_aktiv: bool


class Benachrichtigung(ABC):
    """Ein Kanal, über den die App Personen benachrichtigt."""

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

    @abstractmethod
    def sende(self, person: Person, text: str) -> None:
        """Stellt der Person den Text zu; danach steht genau ein Eintrag mehr im Ausgang."""

    def ausgang(self) -> list[str]:
        return list(self._ausgang)


class MailBenachrichtigung(Benachrichtigung):
    @override
    def sende(self, person: Person, text: str) -> None:
        self._ausgang.append(f"Mail an {person.email}: {text}")


class PushBenachrichtigung(Benachrichtigung):
    @override
    def sende(self, person: Person, text: str) -> None:
        if not person.push_aktiv:
            raise RuntimeError(f"Push ist für {person.name} nicht aktiviert")
        self._ausgang.append(f"Push an {person.name}: {text}")


class FlurmonitorAnzeige(Benachrichtigung):
    @override
    def sende(self, person: Person, text: str) -> None:
        raise NotImplementedError("Flurmonitore zeigen keine persönlichen Nachrichten")

    def zeige(self, haltepunkt: str, abfahrt: str, freie_plaetze: int) -> None:
        self._ausgang.append(f"{abfahrt} ab {haltepunkt}: {freie_plaetze} Plätze frei")


class Erinnerungsdienst:
    def __init__(self, kanaele: list[Benachrichtigung]) -> None:
        self._kanaele = list(kanaele)

    def erinnere(self, mitfahrende: list[Person], fahrt: str) -> None:
        for kanal in self._kanaele:
            if isinstance(kanal, FlurmonitorAnzeige):
                continue
            for person in mitfahrende:
                if isinstance(kanal, PushBenachrichtigung) and not person.push_aktiv:
                    continue
                kanal.sende(person, f"Erinnerung: {fahrt}")

package de.mitfahrlabor;

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

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

class ErinnerungsdienstTest {

    private static final Person AYLIN = new Person("Aylin Kaya", "aylin.kaya@example.org", true);
    private static final Person LUKAS = new Person("Lukas Hofmann", "lukas.hofmann@example.org", false);
    private static final String FAHRT = "Mo 07:15 ab Gütersloh Hbf";

    private final MailBenachrichtigung mail = new MailBenachrichtigung();
    private final PushBenachrichtigung push = new PushBenachrichtigung();

    @Test
    void mailErreichtAlle() {
        new Erinnerungsdienst(List.of(mail)).erinnere(List.of(AYLIN, LUKAS), FAHRT);
        assertEquals(List.of("Mail an aylin.kaya@example.org: Erinnerung: " + FAHRT,
                "Mail an lukas.hofmann@example.org: Erinnerung: " + FAHRT), mail.ausgang());
    }

    @Test
    void pushNurBeiAktiviertemPush() {
        new Erinnerungsdienst(List.of(mail, push)).erinnere(List.of(AYLIN, LUKAS), FAHRT);
        assertEquals(List.of("Push an Aylin Kaya: Erinnerung: " + FAHRT), push.ausgang());
        assertEquals(2, mail.ausgang().size());
    }

    @Test
    void flurmonitorZeigtNurAnonymeAngebote() {
        FlurmonitorAnzeige monitor = new FlurmonitorAnzeige();
        monitor.zeige("Gütersloh Hbf", "07:15", 2);
        assertEquals(List.of("07:15 ab Gütersloh Hbf: 2 Plätze frei"), monitor.ausgang());
    }

    // entfällt nach dem Umbau: Der Flurmonitor kann dann gar nicht mehr übergeben werden
    @Test
    void erinnerungsdienstUebergehtFlurmonitor() {
        FlurmonitorAnzeige monitor = new FlurmonitorAnzeige();
        new Erinnerungsdienst(List.of(mail, monitor)).erinnere(List.of(AYLIN), FAHRT);
        assertEquals(List.of(), monitor.ausgang());
    }
}

from mitfahrlabor.benachrichtigung import (Erinnerungsdienst, FlurmonitorAnzeige, MailBenachrichtigung, Person,
                                           PushBenachrichtigung)

AYLIN = Person("Aylin Kaya", "aylin.kaya@example.org", True)
LUKAS = Person("Lukas Hofmann", "lukas.hofmann@example.org", False)
FAHRT = "Mo 07:15 ab Gütersloh Hbf"


def test_mail_erreicht_alle() -> None:
    mail = MailBenachrichtigung()
    Erinnerungsdienst([mail]).erinnere([AYLIN, LUKAS], FAHRT)
    assert mail.ausgang() == [f"Mail an aylin.kaya@example.org: Erinnerung: {FAHRT}",
                              f"Mail an lukas.hofmann@example.org: Erinnerung: {FAHRT}"]


def test_push_nur_bei_aktiviertem_push() -> None:
    mail, push = MailBenachrichtigung(), PushBenachrichtigung()
    Erinnerungsdienst([mail, push]).erinnere([AYLIN, LUKAS], FAHRT)
    assert push.ausgang() == [f"Push an Aylin Kaya: Erinnerung: {FAHRT}"]
    assert len(mail.ausgang()) == 2


def test_flurmonitor_zeigt_nur_anonyme_angebote() -> None:
    monitor = FlurmonitorAnzeige()
    monitor.zeige("Gütersloh Hbf", "07:15", 2)
    assert monitor.ausgang() == ["07:15 ab Gütersloh Hbf: 2 Plätze frei"]


# entfällt nach dem Umbau: Der Flurmonitor ist dann keine Benachrichtigung mehr
def test_erinnerungsdienst_uebergeht_flurmonitor() -> None:
    mail, monitor = MailBenachrichtigung(), FlurmonitorAnzeige()
    Erinnerungsdienst([mail, monitor]).erinnere([AYLIN], FAHRT)
    assert monitor.ausgang() == []

// Kata CSB-Rad, Stand 06, Paket de.csbrad.shop (src/main/java)
// ===== 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) {
}

// ===== Bestellung.java =====
package de.csbrad.shop;

import java.util.List;

/** Eine Bestellung kennt ihre Positionen und berechnet ihre Beträge selbst (Tell, don't ask). */
public final class Bestellung {

    private static final String GUTSCHEINCODE_KURIER = "KURIER10";
    private static final int GUTSCHEIN_RABATT_PROZENT = 10;
    private static final int MEHRWERTSTEUER_PROZENT = 19;

    private final List<Position> positionen;
    private final String versandart;
    private final String gutscheincode;
    private final String kundenEmail;
    private final Versandkostenrechner versandkostenrechner;
    private String bestellnummer;

    public Bestellung(Bestellanfrage anfrage, Versandkostenrechner versandkostenrechner) {
        pruefePositionen(anfrage.positionen());
        this.positionen = List.copyOf(anfrage.positionen());
        this.versandart = anfrage.versandart();
        this.gutscheincode = anfrage.gutscheincode();
        this.kundenEmail = anfrage.kundenEmail();
        this.versandkostenrechner = versandkostenrechner;
        if (warenwert() == 0) {
            throw new IllegalArgumentException("Bestellung ohne Warenwert");
        }
    }

    private static void pruefePositionen(List<Position> positionen) {
        if (positionen.isEmpty()) {
            throw new IllegalArgumentException("Bestellung ohne Positionen");
        }
        for (Position position : positionen) {
            if (position.menge() <= 0) {
                throw new IllegalArgumentException("Menge muss positiv sein: " + position.artikelnr());
            }
        }
    }

    public int warenwert() {
        return positionen.stream().mapToInt(p -> p.nettopreisCent() * p.menge()).sum();
    }

    public int rabatt() {
        if (GUTSCHEINCODE_KURIER.equals(gutscheincode)) {
            return prozentKaufmaennischGerundet(warenwert(), GUTSCHEIN_RABATT_PROZENT);
        }
        return 0;
    }

    public int warenwertNachRabatt() {
        return warenwert() - rabatt();
    }

    public int versandkosten() {
        return versandkostenrechner.berechne(this);
    }

    public int mehrwertsteuer() {
        return prozentKaufmaennischGerundet(warenwertNachRabatt() + versandkosten(), MEHRWERTSTEUER_PROZENT);
    }

    public int gesamtbetrag() {
        return warenwertNachRabatt() + versandkosten() + mehrwertsteuer();
    }

    public int gesamtgewichtGramm() {
        return positionen.stream().mapToInt(p -> p.gewichtGramm() * p.menge()).sum();
    }

    public int anzahlRaeder() {
        return positionen.stream().filter(Position::istRad).mapToInt(Position::menge).sum();
    }

    public boolean enthaeltRad() {
        return positionen.stream().anyMatch(Position::istRad);
    }

    public String versandart() {
        return versandart;
    }

    public String kundenEmail() {
        return kundenEmail;
    }

    public String bestellnummer() {
        return bestellnummer;
    }

    void vergibNummer(String nummer) {
        if (bestellnummer != null) {
            throw new IllegalStateException("Bestellung hat schon eine Nummer: " + bestellnummer);
        }
        bestellnummer = nummer;
    }

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

// ===== Versandkostenrechner.java =====
package de.csbrad.shop;

import java.util.Set;

/** Kennt die Versandregeln der CSB-Rad GmbH. */
public class Versandkostenrechner {

    private static final Set<String> VERSANDARTEN = Set.of("PAKET", "SPEDITION", "ABHOLUNG");
    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;

    public void pruefeVersandmoeglich(Bestellung bestellung) {
        if (!VERSANDARTEN.contains(bestellung.versandart())) {
            throw new IllegalArgumentException("Unbekannte Versandart: " + bestellung.versandart());
        }
        if (bestellung.versandart().equals("PAKET") && bestellung.enthaeltRad()) {
            throw new IllegalArgumentException("Räder können nicht als Paket versandt werden");
        }
    }

    public int berechne(Bestellung bestellung) {
        return switch (bestellung.versandart()) {
            case "PAKET" -> paketkosten(bestellung);
            // ohne Rad wird eine Speditionspauschale berechnet
            case "SPEDITION" -> Math.max(1, bestellung.anzahlRaeder()) * SPEDITION_JE_RAD_CENT;
            default -> 0;
        };
    }

    private int paketkosten(Bestellung bestellung) {
        if (bestellung.warenwertNachRabatt() >= VERSANDKOSTENFREI_AB_CENT) {
            return 0;
        }
        int anzahlPakete = Math.max(1, (bestellung.gesamtgewichtGramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) / HOECHSTGEWICHT_PAKET_GRAMM);
        return anzahlPakete * PAKETPAUSCHALE_CENT;
    }
}

// ===== Mailversand.java =====
package de.csbrad.shop;

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

/** Verschickt Bestätigungsmails; hier nur in einen Postausgang (Liste). */
public class Mailversand {

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

    public void sendeBestaetigung(Bestellung bestellung) {
        postausgang.add("An: " + bestellung.kundenEmail() + "\nBestellung " + bestellung.bestellnummer()
                + "\nGesamtbetrag: " + alsEuroText(bestellung.gesamtbetrag()) + "\n" + versandzeile(bestellung.versandart()));
    }

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

    private static String versandzeile(String versandart) {
        return switch (versandart) {
            case "PAKET" -> "Versand: Paket";
            case "SPEDITION" -> "Versand: Spedition";
            default -> "Abholung in der Werkstatt Bielefeld-Sennestadt";
        };
    }

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

// ===== BestellRepository.java =====
package de.csbrad.shop;

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

/** Speichert Bestellungen (hier im Arbeitsspeicher) und vergibt fortlaufende Bestellnummern. */
public class BestellRepository {

    private static final int ERSTE_BESTELLNUMMER = 1001;

    private final List<Bestellung> bestellungen = new ArrayList<>();
    private int naechsteNummer = ERSTE_BESTELLNUMMER;

    public void speichere(Bestellung bestellung) {
        bestellung.vergibNummer("CSB-" + naechsteNummer);
        naechsteNummer = naechsteNummer + 1;
        bestellungen.add(bestellung);
    }

    public Optional<Bestellung> findeNachNummer(String bestellnummer) {
        return bestellungen.stream().filter(b -> b.bestellnummer().equals(bestellnummer)).findFirst();
    }

    public List<Bestellung> alle() {
        return List.copyOf(bestellungen);
    }
}

// ===== Bestellabschluss.java =====
package de.csbrad.shop;

/** Ablauf des Bestellabschlusses: prüfen, speichern, bestätigen. */
public class Bestellabschluss {

    private final Versandkostenrechner versandkostenrechner = new Versandkostenrechner();
    private final Mailversand mailversand = new Mailversand();
    private final BestellRepository repository = new BestellRepository();

    public Bestellung abschliessen(Bestellanfrage anfrage) {
        Bestellung bestellung = new Bestellung(anfrage, versandkostenrechner);
        versandkostenrechner.pruefeVersandmoeglich(bestellung);
        repository.speichere(bestellung);
        mailversand.sendeBestaetigung(bestellung);
        return bestellung;
    }

    public Mailversand mailversand() {
        return mailversand;
    }

    public BestellRepository repository() {
        return repository;
    }
}

# Kata CSB-Rad, Stand 06, Paket 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

# ===== 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

# ===== bestellung.py =====
from __future__ import annotations

from typing import TYPE_CHECKING

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

if TYPE_CHECKING:
    from csbrad.versandkostenrechner import Versandkostenrechner

GUTSCHEINCODE_KURIER = "KURIER10"
GUTSCHEIN_RABATT_PROZENT = 10
MEHRWERTSTEUER_PROZENT = 19


class Bestellung:
    """Eine Bestellung kennt ihre Positionen und berechnet ihre Beträge selbst (Tell, don't ask)."""

    def __init__(self, anfrage: Bestellanfrage, versandkostenrechner: Versandkostenrechner) -> None:
        _pruefe_positionen(anfrage.positionen)
        self._positionen = tuple(anfrage.positionen)
        self._versandart = anfrage.versandart
        self._gutscheincode = anfrage.gutscheincode
        self._kunden_email = anfrage.kunden_email
        self._versandkostenrechner = versandkostenrechner
        self._bestellnummer: str | None = None
        if self.warenwert() == 0:
            raise ValueError("Bestellung ohne Warenwert")

    def warenwert(self) -> int:
        return sum(p.nettopreis_cent * p.menge for p in self._positionen)

    def rabatt(self) -> int:
        if self._gutscheincode == GUTSCHEINCODE_KURIER:
            return _prozent_kaufmaennisch_gerundet(self.warenwert(), GUTSCHEIN_RABATT_PROZENT)
        return 0

    def warenwert_nach_rabatt(self) -> int:
        return self.warenwert() - self.rabatt()

    def versandkosten(self) -> int:
        return self._versandkostenrechner.berechne(self)

    def mehrwertsteuer(self) -> int:
        return _prozent_kaufmaennisch_gerundet(self.warenwert_nach_rabatt() + self.versandkosten(), MEHRWERTSTEUER_PROZENT)

    def gesamtbetrag(self) -> int:
        return self.warenwert_nach_rabatt() + self.versandkosten() + self.mehrwertsteuer()

    def gesamtgewicht_gramm(self) -> int:
        return sum(p.gewicht_gramm * p.menge for p in self._positionen)

    def anzahl_raeder(self) -> int:
        return sum(p.menge for p in self._positionen if p.ist_rad)

    def enthaelt_rad(self) -> bool:
        return any(p.ist_rad for p in self._positionen)

    @property
    def versandart(self) -> str:
        return self._versandart

    @property
    def kunden_email(self) -> str:
        return self._kunden_email

    @property
    def bestellnummer(self) -> str | None:
        return self._bestellnummer

    def vergib_nummer(self, nummer: str) -> None:
        if self._bestellnummer is not None:
            raise RuntimeError(f"Bestellung hat schon eine Nummer: {self._bestellnummer}")
        self._bestellnummer = nummer


def _pruefe_positionen(positionen: list[Position]) -> None:
    if not positionen:
        raise ValueError("Bestellung ohne Positionen")
    for position in positionen:
        if position.menge <= 0:
            raise ValueError(f"Menge muss positiv sein: {position.artikelnr}")


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

# ===== versandkostenrechner.py =====
from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from csbrad.bestellung import Bestellung

VERSANDARTEN = {"PAKET", "SPEDITION", "ABHOLUNG"}
PAKETPAUSCHALE_CENT = 690
HOECHSTGEWICHT_PAKET_GRAMM = 31500
VERSANDKOSTENFREI_AB_CENT = 10000
SPEDITION_JE_RAD_CENT = 4900


class Versandkostenrechner:
    """Kennt die Versandregeln der CSB-Rad GmbH."""

    def pruefe_versand_moeglich(self, bestellung: Bestellung) -> None:
        if bestellung.versandart not in VERSANDARTEN:
            raise ValueError(f"Unbekannte Versandart: {bestellung.versandart}")
        if bestellung.versandart == "PAKET" and bestellung.enthaelt_rad():
            raise ValueError("Räder können nicht als Paket versandt werden")

    def berechne(self, bestellung: Bestellung) -> int:
        match bestellung.versandart:
            case "PAKET":
                return self._paketkosten(bestellung)
            case "SPEDITION":
                # ohne Rad wird eine Speditionspauschale berechnet
                return max(1, bestellung.anzahl_raeder()) * SPEDITION_JE_RAD_CENT
            case _:
                return 0

    def _paketkosten(self, bestellung: Bestellung) -> int:
        if bestellung.warenwert_nach_rabatt() >= VERSANDKOSTENFREI_AB_CENT:
            return 0
        anzahl_pakete = max(1, (bestellung.gesamtgewicht_gramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) // HOECHSTGEWICHT_PAKET_GRAMM)
        return anzahl_pakete * PAKETPAUSCHALE_CENT

# ===== mailversand.py =====
from csbrad.bestellung import Bestellung


class Mailversand:
    """Verschickt Bestätigungsmails; hier nur in einen Postausgang (Liste)."""

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

    def sende_bestaetigung(self, bestellung: Bestellung) -> None:
        self._postausgang.append(
            f"An: {bestellung.kunden_email}\nBestellung {bestellung.bestellnummer}\n"
            f"Gesamtbetrag: {_als_euro_text(bestellung.gesamtbetrag())}\n{_versandzeile(bestellung.versandart)}")

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


def _versandzeile(versandart: str) -> str:
    match versandart:
        case "PAKET":
            return "Versand: Paket"
        case "SPEDITION":
            return "Versand: Spedition"
        case _:
            return "Abholung in der Werkstatt Bielefeld-Sennestadt"


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

# ===== bestell_repository.py =====
from csbrad.bestellung import Bestellung

ERSTE_BESTELLNUMMER = 1001


class BestellRepository:
    """Speichert Bestellungen (hier im Arbeitsspeicher) und vergibt fortlaufende Bestellnummern."""

    def __init__(self) -> None:
        self._bestellungen: list[Bestellung] = []
        self._naechste_nummer = ERSTE_BESTELLNUMMER

    def speichere(self, bestellung: Bestellung) -> None:
        bestellung.vergib_nummer(f"CSB-{self._naechste_nummer}")
        self._naechste_nummer = self._naechste_nummer + 1
        self._bestellungen.append(bestellung)

    def finde_nach_nummer(self, bestellnummer: str) -> Bestellung | None:
        return next((b for b in self._bestellungen if b.bestellnummer == bestellnummer), None)

    def alle(self) -> list[Bestellung]:
        return list(self._bestellungen)

# ===== bestellabschluss.py =====
from csbrad.bestell_repository import BestellRepository
from csbrad.bestellanfrage import Bestellanfrage
from csbrad.bestellung import Bestellung
from csbrad.mailversand import Mailversand
from csbrad.versandkostenrechner import Versandkostenrechner


class Bestellabschluss:
    """Ablauf des Bestellabschlusses: prüfen, speichern, bestätigen."""

    def __init__(self) -> None:
        self._versandkostenrechner = Versandkostenrechner()
        self._mailversand = Mailversand()
        self._repository = BestellRepository()

    def abschliessen(self, anfrage: Bestellanfrage) -> Bestellung:
        bestellung = Bestellung(anfrage, self._versandkostenrechner)
        self._versandkostenrechner.pruefe_versand_moeglich(bestellung)
        self._repository.speichere(bestellung)
        self._mailversand.sende_bestaetigung(bestellung)
        return bestellung

    @property
    def mailversand(self) -> Mailversand:
        return self._mailversand

    @property
    def repository(self) -> BestellRepository:
        return self._repository

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 (seit Stand 04), angepasst an die Klassen aus Stand 06.
 * betraege(): {Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag} in Cent.
 */
class BestellabschlussTest {

    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 Bestellabschluss abschluss;

    @BeforeEach
    void neuerAbschluss() {
        abschluss = new Bestellabschluss();
    }

    static int[] betraege(Bestellung b) {
        return new int[] {b.warenwert(), b.rabatt(), b.versandkosten(), b.mehrwertsteuer(), b.gesamtbetrag()};
    }

    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}, betraege(abschluss.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL))));
    }

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

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

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

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

    @Test
    void speditionJeRad() {
        assertArrayEquals(new int[] {149412, 0, 9800, 30250, 189462}, betraege(abschluss.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}, betraege(abschluss.abschliessen(new Bestellanfrage(List.of(LICHTSET), "SPEDITION", null, MAIL))));
    }

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

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

    @Test
    void radAlsPaketWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class, () -> abschluss.abschliessen(new Bestellanfrage(List.of(STADTRAD), "PAKET", null, MAIL)));
        assertEquals(0, abschluss.mailversand().postausgang().size());
        assertEquals(0, abschluss.repository().alle().size());
    }

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

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

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

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

    @Test
    void mailFuerAbholung() {
        abschluss.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",
                abschluss.mailversand().postausgang().get(0));
    }

    @Test
    void bestellungenWerdenFortlaufendNummeriertUndGespeichert() {
        abschluss.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL));
        abschluss.abschliessen(new Bestellanfrage(List.of(BREMSE), "PAKET", null, MAIL));
        assertEquals(2, abschluss.repository().alle().size());
        assertEquals("CSB-1001", abschluss.repository().alle().get(0).bestellnummer());
        assertEquals("CSB-1002", abschluss.repository().alle().get(1).bestellnummer());
        assertEquals(15900, abschluss.repository().alle().get(1).gesamtbetrag());
    }
}

"""Charakterisierungstests (seit Stand 04), angepasst an die Klassen aus Stand 06.

betraege(): [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.bestellabschluss import Bestellabschluss
from csbrad.bestellung import Bestellung

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 abschluss() -> Bestellabschluss:
    return Bestellabschluss()


def betraege(b: Bestellung) -> list[int]:
    return [b.warenwert(), b.rabatt(), b.versandkosten(), b.mehrwertsteuer(), b.gesamtbetrag()]


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


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


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


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


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


def test_spedition_je_rad(abschluss: Bestellabschluss) -> None:
    assert betraege(abschluss.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(abschluss: Bestellabschluss) -> None:
    assert betraege(abschluss.abschliessen(Bestellanfrage([LICHTSET], "SPEDITION", None, MAIL))) == [7563, 0, 4900, 2368, 14831]


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


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


def test_rad_als_paket_wird_abgelehnt(abschluss: Bestellabschluss) -> None:
    with pytest.raises(ValueError):
        abschluss.abschliessen(Bestellanfrage([STADTRAD], "PAKET", None, MAIL))
    assert abschluss.mailversand.postausgang() == []
    assert abschluss.repository.alle() == []


def test_leere_bestellung_wird_abgelehnt(abschluss: Bestellabschluss) -> None:
    with pytest.raises(ValueError):
        abschluss.abschliessen(Bestellanfrage([], "PAKET", None, MAIL))
    assert abschluss.mailversand.postausgang() == []


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


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


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


def test_mail_fuer_abholung(abschluss: Bestellabschluss) -> None:
    abschluss.abschliessen(Bestellanfrage([EBIKE], "ABHOLUNG", "KURIER10", MAIL))
    assert abschluss.mailversand.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(abschluss: Bestellabschluss) -> None:
    abschluss.abschliessen(Bestellanfrage([LICHTSET], "PAKET", None, MAIL))
    abschluss.abschliessen(Bestellanfrage([BREMSE], "PAKET", None, MAIL))
    assert len(abschluss.repository.alle()) == 2
    assert abschluss.repository.alle()[0].bestellnummer == "CSB-1001"
    assert abschluss.repository.alle()[1].bestellnummer == "CSB-1002"
    assert abschluss.repository.alle()[1].gesamtbetrag() == 15900

// Paket de.mitfahrlabor, Stand vor dem Umbau
// ===== Mitfahrer.java =====
package de.mitfahrlabor;

public record Mitfahrer(String name, boolean minderjaehrig, boolean einwilligungLiegtVor) {
}

// ===== Mitfahrerliste.java =====
package de.mitfahrlabor;

import java.util.ArrayList;

/** Bestätigte Mitfahrende einer Fahrt; erbt von ArrayList, „damit man nicht alles neu schreiben muss“. */
public class Mitfahrerliste extends ArrayList<Mitfahrer> {

    private final int plaetze;

    public Mitfahrerliste(int plaetze) {
        this.plaetze = plaetze;
    }

    public void bestaetige(Mitfahrer mitfahrer) {
        if (freiePlaetze() == 0) {
            throw new IllegalStateException("Die Fahrt ist voll");
        }
        if (mitfahrer.minderjaehrig() && !mitfahrer.einwilligungLiegtVor()) {
            throw new IllegalArgumentException("Einwilligung der Erziehungsberechtigten fehlt");
        }
        add(mitfahrer);
    }

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

// ===== Fahrtangebot.java =====
package de.mitfahrlabor;

/** Ein Fahrtangebot ist eine Mitfahrerliste mit Haltepunkt, Abfahrt und Kostenbeitrag. */
public class Fahrtangebot extends Mitfahrerliste {

    private final String haltepunkt;
    private final String abfahrt;
    private final int entfernungKm;
    private final int centJeKm;

    public Fahrtangebot(String haltepunkt, String abfahrt, int plaetze, int entfernungKm, int centJeKm) {
        super(plaetze);
        this.haltepunkt = haltepunkt;
        this.abfahrt = abfahrt;
        this.entfernungKm = entfernungKm;
        this.centJeKm = centJeKm;
    }

    public int kostenbeitragCent() {
        return entfernungKm * centJeKm;
    }

    public String monitorzeile() {
        return abfahrt + " ab " + haltepunkt + ": " + freiePlaetze() + " Plätze frei";
    }
}