Übungsaufgaben zum Erweitern statt Ändern: Open Closed Principle und Interface Segregation Principle

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

public enum Fahrzeugtyp { PKW, KLEINBUS, MOTORRAD }

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

/** Ein Angebot für eine einfache Fahrt; Entfernung in ganzen Kilometern. */
public record Fahrtangebot(Fahrzeugtyp fahrzeugtyp, int entfernungKm, int mitfahrende) {
}

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

/** Kostenbeitrag je mitfahrender Person in Cent, höchstens 10 Cent je km. */
public class Kostenbeitragsrechner {

    public int jePersonCent(Fahrtangebot angebot) {
        switch (angebot.fahrzeugtyp()) {
            case PKW:
                return angebot.entfernungKm() * 8;
            case KLEINBUS:
                int centJeKm = angebot.mitfahrende() >= 5 ? 5 : 6;
                return angebot.entfernungKm() * centJeKm;
            case MOTORRAD:
                return angebot.entfernungKm() * 10;
            default:
                throw new IllegalArgumentException("Unbekannter Fahrzeugtyp: " + angebot.fahrzeugtyp());
        }
    }
}

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

/** Prüft ein Angebot, bevor es veröffentlicht wird. */
public class Angebotspruefung {

    public void pruefe(Fahrtangebot angebot) {
        if (angebot.mitfahrende() < 1) {
            throw new IllegalArgumentException("Mindestens eine Person muss mitfahren");
        }
        switch (angebot.fahrzeugtyp()) {
            case MOTORRAD:
                if (angebot.mitfahrende() > 1) {
                    throw new IllegalArgumentException("Auf dem Motorrad fährt nur eine Person mit");
                }
                break;
            case PKW:
            case KLEINBUS:
                break;
            default:
                throw new IllegalArgumentException("Unbekannter Fahrzeugtyp: " + angebot.fahrzeugtyp());
        }
    }
}

# Paket mitfahrlabor, Stand vor dem Umbau
# ===== mitfahrlabor/kostenbeitrag.py =====
from dataclasses import dataclass
from enum import Enum


class Fahrzeugtyp(Enum):
    PKW = "PKW"
    KLEINBUS = "Kleinbus"
    MOTORRAD = "Motorrad"


@dataclass(frozen=True)
class Fahrtangebot:
    """Ein Angebot für eine einfache Fahrt; Entfernung in ganzen Kilometern."""

    fahrzeugtyp: Fahrzeugtyp
    entfernung_km: int
    mitfahrende: int


class Kostenbeitragsrechner:
    """Kostenbeitrag je mitfahrender Person in Cent, höchstens 10 Cent je km."""

    def je_person_cent(self, angebot: Fahrtangebot) -> int:
        if angebot.fahrzeugtyp == Fahrzeugtyp.PKW:
            return angebot.entfernung_km * 8
        elif angebot.fahrzeugtyp == Fahrzeugtyp.KLEINBUS:
            cent_je_km = 5 if angebot.mitfahrende >= 5 else 6
            return angebot.entfernung_km * cent_je_km
        elif angebot.fahrzeugtyp == Fahrzeugtyp.MOTORRAD:
            return angebot.entfernung_km * 10
        else:
            raise ValueError(f"Unbekannter Fahrzeugtyp: {angebot.fahrzeugtyp}")


class Angebotspruefung:
    """Prüft ein Angebot, bevor es veröffentlicht wird."""

    def pruefe(self, angebot: Fahrtangebot) -> None:
        if angebot.mitfahrende < 1:
            raise ValueError("Mindestens eine Person muss mitfahren")
        if angebot.fahrzeugtyp == Fahrzeugtyp.MOTORRAD:
            if angebot.mitfahrende > 1:
                raise ValueError("Auf dem Motorrad fährt nur eine Person mit")
        elif angebot.fahrzeugtyp not in (Fahrzeugtyp.PKW, Fahrzeugtyp.KLEINBUS):
            raise ValueError(f"Unbekannter Fahrzeugtyp: {angebot.fahrzeugtyp}")

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

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

import org.junit.jupiter.api.Test;

class KostenbeitragTest {

    private final Kostenbeitragsrechner rechner = new Kostenbeitragsrechner();
    private final Angebotspruefung pruefung = new Angebotspruefung();

    @Test
    void pkwAchtCentJeKm() {
        assertEquals(144, rechner.jePersonCent(new Fahrtangebot(Fahrzeugtyp.PKW, 18, 3)));
    }

    @Test
    void kleinbusGuenstigerAbFuenfMitfahrenden() {
        assertEquals(108, rechner.jePersonCent(new Fahrtangebot(Fahrzeugtyp.KLEINBUS, 18, 4)));
        assertEquals(90, rechner.jePersonCent(new Fahrtangebot(Fahrzeugtyp.KLEINBUS, 18, 5)));
    }

    @Test
    void motorradZehnCentJeKm() {
        assertEquals(130, rechner.jePersonCent(new Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 1)));
    }

    @Test
    void motorradNimmtNurEinePersonMit() {
        assertDoesNotThrow(() -> pruefung.pruefe(new Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 1)));
        assertThrows(IllegalArgumentException.class,
                () -> pruefung.pruefe(new Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 2)));
    }

    @Test
    void ohneMitfahrendeAbgelehnt() {
        assertThrows(IllegalArgumentException.class,
                () -> pruefung.pruefe(new Fahrtangebot(Fahrzeugtyp.PKW, 18, 0)));
    }
}

# ===== tests/test_kostenbeitrag.py =====
import pytest

from mitfahrlabor.kostenbeitrag import Angebotspruefung, Fahrtangebot, Fahrzeugtyp, Kostenbeitragsrechner

rechner = Kostenbeitragsrechner()
pruefung = Angebotspruefung()


def test_pkw_acht_cent_je_km() -> None:
    assert rechner.je_person_cent(Fahrtangebot(Fahrzeugtyp.PKW, 18, 3)) == 144


def test_kleinbus_guenstiger_ab_fuenf_mitfahrenden() -> None:
    assert rechner.je_person_cent(Fahrtangebot(Fahrzeugtyp.KLEINBUS, 18, 4)) == 108
    assert rechner.je_person_cent(Fahrtangebot(Fahrzeugtyp.KLEINBUS, 18, 5)) == 90


def test_motorrad_zehn_cent_je_km() -> None:
    assert rechner.je_person_cent(Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 1)) == 130


def test_motorrad_nimmt_nur_eine_person_mit() -> None:
    pruefung.pruefe(Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 1))
    with pytest.raises(ValueError):
        pruefung.pruefe(Fahrtangebot(Fahrzeugtyp.MOTORRAD, 13, 2))


def test_ohne_mitfahrende_abgelehnt() -> None:
    with pytest.raises(ValueError):
        pruefung.pruefe(Fahrtangebot(Fahrzeugtyp.PKW, 18, 0))

// Kata CSB-Rad, Stand 07, 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 Versandarten der CSB-Rad GmbH und verteilt auf die jeweiligen Regeln. */
public class Versandkostenrechner {

    private static final Set<String> VERSANDARTEN = Set.of("PAKET", "SPEDITION", "ABHOLUNG", "KURIER");
    private static final int SPEDITION_JE_RAD_CENT = 4900;

    private final Paketversand paketversand = new Paketversand();
    private final Kurierzustellung kurierzustellung = new Kurierzustellung();

    public void pruefeVersandmoeglich(Bestellung bestellung) {
        if (!VERSANDARTEN.contains(bestellung.versandart())) {
            throw new IllegalArgumentException("Unbekannte Versandart: " + bestellung.versandart());
        }
        switch (bestellung.versandart()) {
            case "PAKET" -> paketversand.pruefe(bestellung);
            case "KURIER" -> kurierzustellung.pruefe(bestellung);
            default -> { }
        }
    }

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

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

/** Versandregeln für Pakete: Pauschale je angefangene 31,5 kg, frei ab 100 Euro Warenwert nach Rabatt. */
public class Paketversand {

    static final int PAKETPAUSCHALE_CENT = 690;
    static final int HOECHSTGEWICHT_PAKET_GRAMM = 31500;
    static final int VERSANDKOSTENFREI_AB_CENT = 10000;

    public void pruefe(Bestellung bestellung) {
        if (bestellung.enthaeltRad()) {
            throw new IllegalArgumentException("Räder können nicht als Paket versandt werden");
        }
    }

    public int anzahlPakete(Bestellung bestellung) {
        return Math.max(1, (bestellung.gesamtgewichtGramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) / HOECHSTGEWICHT_PAKET_GRAMM);
    }

    public int kosten(Bestellung bestellung) {
        if (bestellung.warenwertNachRabatt() >= VERSANDKOSTENFREI_AB_CENT) {
            return 0;
        }
        return anzahlPakete(bestellung) * PAKETPAUSCHALE_CENT;
    }
}

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

/**
 * Neu in Stand 07: Zustellung per Lastenradkurier im Stadtgebiet, Pauschale, höchstens 25 kg, keine Räder.
 * Bewusst KEINE Unterklasse von Paketversand: Sie würde die Vorbedingung verschärfen (25 kg statt beliebig vieler Pakete)
 * und damit das Liskovsche Substitutionsprinzip verletzen. Gemeinsames (Rad-Prüfung) wird per Komposition genutzt.
 */
public class Kurierzustellung {

    static final int KURIERPAUSCHALE_CENT = 1290;
    static final int HOECHSTGEWICHT_KURIER_GRAMM = 25000;

    private final Paketversand paketregeln = new Paketversand();

    public void pruefe(Bestellung bestellung) {
        paketregeln.pruefe(bestellung);
        if (bestellung.gesamtgewichtGramm() > HOECHSTGEWICHT_KURIER_GRAMM) {
            throw new IllegalArgumentException("Kurierzustellung nur bis 25 kg");
        }
    }

    public int kosten(Bestellung bestellung) {
        return KURIERPAUSCHALE_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";
            case "KURIER" -> "Versand: Kurier (Lastenrad)";
            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 07, Paket csbrad
# ===== 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/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


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

from typing import TYPE_CHECKING

from csbrad.kurierzustellung import Kurierzustellung
from csbrad.paketversand import Paketversand

if TYPE_CHECKING:
    from csbrad.bestellung import Bestellung

VERSANDARTEN = {"PAKET", "SPEDITION", "ABHOLUNG", "KURIER"}
SPEDITION_JE_RAD_CENT = 4900


class Versandkostenrechner:
    """Kennt die Versandarten der CSB-Rad GmbH und verteilt auf die jeweiligen Regeln."""

    def __init__(self) -> None:
        self._paketversand = Paketversand()
        self._kurierzustellung = Kurierzustellung()

    def pruefe_versand_moeglich(self, bestellung: Bestellung) -> None:
        if bestellung.versandart not in VERSANDARTEN:
            raise ValueError(f"Unbekannte Versandart: {bestellung.versandart}")
        match bestellung.versandart:
            case "PAKET":
                self._paketversand.pruefe(bestellung)
            case "KURIER":
                self._kurierzustellung.pruefe(bestellung)

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


# ===== csbrad/paketversand.py =====
from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from csbrad.bestellung import Bestellung

PAKETPAUSCHALE_CENT = 690
HOECHSTGEWICHT_PAKET_GRAMM = 31500
VERSANDKOSTENFREI_AB_CENT = 10000


class Paketversand:
    """Versandregeln für Pakete: Pauschale je angefangene 31,5 kg, frei ab 100 Euro Warenwert nach Rabatt."""

    def pruefe(self, bestellung: Bestellung) -> None:
        if bestellung.enthaelt_rad():
            raise ValueError("Räder können nicht als Paket versandt werden")

    def anzahl_pakete(self, bestellung: Bestellung) -> int:
        return max(1, (bestellung.gesamtgewicht_gramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) // HOECHSTGEWICHT_PAKET_GRAMM)

    def kosten(self, bestellung: Bestellung) -> int:
        if bestellung.warenwert_nach_rabatt() >= VERSANDKOSTENFREI_AB_CENT:
            return 0
        return self.anzahl_pakete(bestellung) * PAKETPAUSCHALE_CENT


# ===== csbrad/kurierzustellung.py =====
from __future__ import annotations

from typing import TYPE_CHECKING

from csbrad.paketversand import Paketversand

if TYPE_CHECKING:
    from csbrad.bestellung import Bestellung

KURIERPAUSCHALE_CENT = 1290
HOECHSTGEWICHT_KURIER_GRAMM = 25000


class Kurierzustellung:
    """Neu in Stand 07: Zustellung per Lastenradkurier im Stadtgebiet, Pauschale, höchstens 25 kg, keine Räder.

    Bewusst KEINE Unterklasse von Paketversand: Sie würde die Vorbedingung verschärfen (25 kg statt beliebig
    vieler Pakete) und damit das Liskovsche Substitutionsprinzip verletzen. Gemeinsames wird per Komposition genutzt.
    """

    def __init__(self) -> None:
        self._paketregeln = Paketversand()

    def pruefe(self, bestellung: Bestellung) -> None:
        self._paketregeln.pruefe(bestellung)
        if bestellung.gesamtgewicht_gramm() > HOECHSTGEWICHT_KURIER_GRAMM:
            raise ValueError("Kurierzustellung nur bis 25 kg")

    def kosten(self, bestellung: Bestellung) -> int:
        return KURIERPAUSCHALE_CENT


# ===== csbrad/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 "KURIER":
            return "Versand: Kurier (Lastenrad)"
        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"


# ===== csbrad/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)


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

// Kata CSB-Rad, Stand 07, src/test/java/de/csbrad/shop
// ===== BestellabschlussTest.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 (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());
    }

    // ---- neue Anforderung in Stand 07: Kurierzustellung ----

    @Test
    void kurierKostetPauschale() {
        assertArrayEquals(new int[] {19579, 0, 1290, 3965, 24834},
                betraege(abschluss.abschliessen(new Bestellanfrage(List.of(BREMSE, BUEGELSCHLOSS), "KURIER", null, MAIL))));
        assertEquals("An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 248,34 EUR\nVersand: Kurier (Lastenrad)",
                abschluss.mailversand().postausgang().get(0));
    }

    @Test
    void kurierUeber25KiloWirdAbgelehnt() {
        assertThrows(IllegalArgumentException.class,
                () -> abschluss.abschliessen(new Bestellanfrage(List.of(menge(BUEGELSCHLOSS, 20)), "KURIER", null, MAIL)));
        assertEquals(0, abschluss.repository().alle().size());
    }

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

# Kata CSB-Rad, Stand 07
# ===== tests/test_bestellabschluss.py =====
"""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


# ---- neue Anforderung in Stand 07: Kurierzustellung ----

def test_kurier_kostet_pauschale(abschluss: Bestellabschluss) -> None:
    assert betraege(abschluss.abschliessen(Bestellanfrage([BREMSE, BUEGELSCHLOSS], "KURIER", None, MAIL))) == [19579, 0, 1290, 3965, 24834]
    assert abschluss.mailversand.postausgang()[0] == "An: mira.engel@example.org\nBestellung CSB-1001\nGesamtbetrag: 248,34 EUR\nVersand: Kurier (Lastenrad)"


def test_kurier_ueber_25_kilo_wird_abgelehnt(abschluss: Bestellabschluss) -> None:
    with pytest.raises(ValueError):
        abschluss.abschliessen(Bestellanfrage([replace(BUEGELSCHLOSS, menge=20)], "KURIER", None, MAIL))
    assert abschluss.repository.alle() == []


def test_kurier_nimmt_keine_raeder(abschluss: Bestellabschluss) -> None:
    with pytest.raises(ValueError):
        abschluss.abschliessen(Bestellanfrage([STADTRAD], "KURIER", None, MAIL))