Angebrochene Packungen, Teilverbrauch und Hausmasse (Backend)

Eine Teilmenge auszulagern ging rechnerisch schon, aber es blieb keine Spur
davon: Eine Charge mit 900 von urspruenglich 1000 ml war von einer frisch
eingelagerten 900-ml-Charge nicht zu unterscheiden, und eine geoeffnete
Milch galt weiter bis zum aufgedruckten MHD.

Anbrechen spaltet jetzt eine Packung ab. Aus 4 x 1 l wird eine offene
Charge mit 1 l und eine ungeoeffnete mit 3 l - sonst truegen die
restlichen 3 l das kurze Verbrauchsdatum mit, obwohl sie noch zu sind. Der
Gesamtbestand aendert sich dabei nicht, es ist eine Umbuchung wie das
Aufteilen und schreibt wie dieses keine Bewegung.

Verbrauchen geht in einem Schritt: Wer "100 ml verbraucht" eintraegt,
bricht die Charge dabei an (abschaltbar ueber auto_open). Gerechnet wird
vor dem Anbrechen - scheitert die Einheit, soll keine Packung grundlos
offen stehen.

MHD und "zu verbrauchen bis" stehen nebeneinander und bleiben beide
sichtbar; gewarnt wird nach dem FRUEHEREN (Lot.faellig_am). Dafuer musste
in /expiring die Vorbedingung "best_before IS NOT NULL" weg, sonst fehlte
ausgerechnet die angebrochene Packung ohne aufgedrucktes MHD. ExpiringItem
traegt beide Daten plus warn_date und warn_source, und best_before ist dort
jetzt optional.

Die Frist kommt aus drei Ebenen: Artikel schlaegt Kategorie, Kategorie
schlaegt ueber ihre Oberkategorien hinweg den globalen Wert. Der Helfer
dafuer (services/vererbung.py) liest die Kategoriekette von
services/fields.py rueckwaerts - dort werden Felder ALLER Vorfahren
gesammelt, hier gewinnt der naechste. Dieselbe Mechanik traegt die
Hausmasse.

Hausmasse sind der zweite Teil: "2 EL Mehl" liess sich bisher nicht
buchen, weil eine globale Einheit "Essloeffel" bei Mehl und Zucker
zwangslaeufig gleich schwer waere. Der Name ist deshalb global, die Menge
haengt an Kategorie und Artikel. to_base loest sie nur mit hausmasse=True
auf - beim Auslagern und Verbrauchen ja, beim Einlagern und bei
Mindestbestaenden ausdruecklich nicht, denn ein Loeffel ist ein
Schaetzwert. Verwaltete Einheiten werden zuerst geprueft, damit ein Mass
namens "Liter" die echte Einheit nicht verdeckt.

Zwei Stellen waeren sonst still kaputtgegangen:

- Die Konsolidierung haette die offene Packung beim naechsten Einlagern am
  selben Ort einkassiert und ihr Verbrauchsdatum verschluckt. Angebrochene
  Chargen werden deshalb nie zusammengefasst - in consolidate_lot_group
  und im Start-Aufraeumer, beide bisher ohne jeden Test. Das Netz dafuer
  ist jetzt da (test_konsolidierung.py).
- FEFO sortiert nach dem wirksamen Datum statt nur nach dem MHD. Eine
  offene Packung kommt damit meist von selbst zuerst, aber eine
  ungeoeffnete, die morgen ablaeuft, geht vor - Verderb schlaegt
  Bequemlichkeit. Erst bei gleichem Datum wird das Angebrochene vorgezogen.

Dashboard bekommt "angebrochen" als fuenften Zustand, mit Vorrang
abgelaufen > bald > angebrochen > in Ordnung: Was offen ist und morgen
ablaeuft, gehoert in die Warnung, nicht in den ruhigeren Zustand.

Oberflaechen in Web und App folgen in eigenen Commits.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/tests/conftest.py

@@ -5,7 +5,7 @@ from sqlalchemy.pool import StaticPool
 
 from app.database import Base
 from app.models import BaseUnit, Product
-from app.seed import ensure_builtin_units
+from app.seed import ensure_builtin_measures, ensure_builtin_units
 
 
 @pytest.fixture()
@@ -19,6 +19,7 @@ def db():
     TestingSession = sessionmaker(bind=engine, autoflush=False, autocommit=False)
     session = TestingSession()
     ensure_builtin_units(session)  # Einheiten (Gramm, Kilogramm, …) für Umrechnung
+    ensure_builtin_measures(session)  # Hausmaße (EL, TL, Tasse …) – ohne Mengen
     try:
         yield session
     finally:

backend/tests/test_ablauf_zwei_daten.py

@@ -0,0 +1,173 @@
+"""Zwei Daten an einer Charge: aufgedrucktes MHD und „zu verbrauchen bis".
+
+Beide bleiben getrennt sichtbar, gewarnt wird nach dem früheren. Der heikle
+Fall ist die angebrochene Packung **ohne** aufgedrucktes MHD – die fiel vorher
+durch den Filter `best_before IS NOT NULL`.
+"""
+
+from datetime import date, timedelta
+
+import pytest
+
+from app.models import BaseUnit, Lot, Product, Role, User
+from app.routers.dashboard import _zustand
+from app.routers.stock import open_lot
+from app.routers.views import expiring
+from app.schemas import LotOpen
+from app.services.stock import _fefo_lots
+
+
+@pytest.fixture()
+def user(db):
+    person = User(username="tester", password_hash="x", role=Role.admin)
+    db.add(person)
+    db.commit()
+    db.refresh(person)
+    return person
+
+
+@pytest.fixture()
+def milch(db):
+    product = Product(
+        name="Vollmilch", base_unit=BaseUnit.milliliter, package_size=1000,
+        source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _lot(db, product, menge, best_before=None, opened_on=None, consume_by=None):
+    lot = Lot(
+        product_id=product.id, quantity=menge, best_before=best_before,
+        opened_on=opened_on, consume_by=consume_by,
+    )
+    db.add(lot)
+    db.commit()
+    db.refresh(lot)
+    return lot
+
+
+# --------------------------------------------------------------------------
+# Ablaufliste
+# --------------------------------------------------------------------------
+def test_angebrochene_charge_ohne_mhd_taucht_auf(db, user, milch):
+    """Der Fall, den der alte Filter verschluckt hätte."""
+    _lot(db, milch, 500, best_before=None,
+         opened_on=date.today(), consume_by=date.today() + timedelta(days=2))
+
+    liste = expiring(days=7, db=db, _=user)
+
+    assert len(liste) == 1
+    assert liste[0].best_before is None
+    assert liste[0].warn_source == "consume_by"
+    assert liste[0].days_left == 2
+
+
+def test_beide_daten_stehen_getrennt_in_der_liste(db, user, milch):
+    mhd = date.today() + timedelta(days=30)
+    verbrauch = date.today() + timedelta(days=3)
+    _lot(db, milch, 500, best_before=mhd, opened_on=date.today(), consume_by=verbrauch)
+
+    eintrag = expiring(days=7, db=db, _=user)[0]
+
+    assert eintrag.best_before == mhd          # bleibt sichtbar
+    assert eintrag.consume_by == verbrauch
+    assert eintrag.warn_date == verbrauch      # gewarnt wird nach dem früheren
+    assert eintrag.days_left == 3
+
+
+def test_frueheres_mhd_gewinnt_gegen_verbrauchsdatum(db, user, milch):
+    mhd = date.today() + timedelta(days=1)
+    _lot(db, milch, 500, best_before=mhd,
+         opened_on=date.today(), consume_by=date.today() + timedelta(days=5))
+
+    eintrag = expiring(days=7, db=db, _=user)[0]
+
+    assert eintrag.warn_date == mhd
+    assert eintrag.warn_source == "best_before"
+
+
+def test_ungeoeffnete_charge_verhaelt_sich_wie_bisher(db, user, milch):
+    mhd = date.today() + timedelta(days=3)
+    _lot(db, milch, 1000, best_before=mhd)
+
+    eintrag = expiring(days=7, db=db, _=user)[0]
+
+    assert eintrag.warn_date == mhd
+    assert eintrag.warn_source == "best_before"
+    assert eintrag.consume_by is None
+
+
+def test_ausserhalb_der_frist_bleibt_draussen(db, user, milch):
+    _lot(db, milch, 500, opened_on=date.today(),
+         consume_by=date.today() + timedelta(days=30))
+
+    assert expiring(days=7, db=db, _=user) == []
+
+
+def test_liste_ist_nach_dem_wirksamen_datum_sortiert(db, user, milch):
+    _lot(db, milch, 100, best_before=date.today() + timedelta(days=6))
+    _lot(db, milch, 100, opened_on=date.today(), consume_by=date.today() + timedelta(days=1))
+    _lot(db, milch, 100, best_before=date.today() + timedelta(days=3))
+
+    tage = [e.days_left for e in expiring(days=7, db=db, _=user)]
+
+    assert tage == [1, 3, 6]
+
+
+# --------------------------------------------------------------------------
+# Zustand fürs Dashboard
+# --------------------------------------------------------------------------
+def test_zustand_angebrochen_ist_ein_eigener(db):
+    heute = date.today()
+    assert _zustand(heute + timedelta(days=30), heute, 7, angebrochen=True) == "opened"
+
+
+def test_dringlichkeit_schlaegt_angebrochen(db):
+    heute = date.today()
+    # Angebrochen UND bald ablaufend: die Warnung muss gewinnen.
+    assert _zustand(heute + timedelta(days=2), heute, 7, angebrochen=True) == "soon"
+    assert _zustand(heute - timedelta(days=1), heute, 7, angebrochen=True) == "expired"
+
+
+def test_zustand_ohne_daten_bleibt_no_date(db):
+    heute = date.today()
+    assert _zustand(None, heute, 7) == "no_date"
+    # Angebrochen ohne jedes Datum ist trotzdem angebrochen.
+    assert _zustand(None, heute, 7, angebrochen=True) == "opened"
+
+
+# --------------------------------------------------------------------------
+# FEFO
+# --------------------------------------------------------------------------
+def test_fefo_nimmt_das_fruehere_wirksame_datum(db, milch):
+    spaet = _lot(db, milch, 1000, best_before=date.today() + timedelta(days=30))
+    offen = _lot(db, milch, 500, best_before=date.today() + timedelta(days=30),
+                 opened_on=date.today(), consume_by=date.today() + timedelta(days=2))
+
+    reihenfolge = [lot.id for lot in _fefo_lots(db, milch.id)]
+
+    assert reihenfolge == [offen.id, spaet.id]
+
+
+def test_knappes_mhd_geht_vor_der_offenen_packung(db, milch):
+    """Verderb schlägt Bequemlichkeit: Was morgen abläuft, kommt zuerst."""
+    morgen = _lot(db, milch, 1000, best_before=date.today() + timedelta(days=1))
+    offen = _lot(db, milch, 500, opened_on=date.today(),
+                 consume_by=date.today() + timedelta(days=5))
+
+    reihenfolge = [lot.id for lot in _fefo_lots(db, milch.id)]
+
+    assert reihenfolge == [morgen.id, offen.id]
+
+
+def test_bei_gleichem_datum_gewinnt_das_angebrochene(db, milch):
+    gleich = date.today() + timedelta(days=3)
+    zu = _lot(db, milch, 1000, best_before=gleich)
+    offen = _lot(db, milch, 500, opened_on=date.today(), consume_by=gleich)
+
+    reihenfolge = [lot.id for lot in _fefo_lots(db, milch.id)]
+
+    assert reihenfolge == [offen.id, zu.id]

backend/tests/test_anbrechen.py

@@ -0,0 +1,276 @@
+"""Angebrochene Packungen: Abspalten, Verbrauchsdatum, Teilverbrauch, Frist-Vererbung."""
+
+from datetime import date, timedelta
+
+import pytest
+from fastapi import HTTPException
+
+from app.models import (
+    BaseUnit,
+    Category,
+    CategoryTracking,
+    Lot,
+    Movement,
+    MovementType,
+    Product,
+    Role,
+    Setting,
+    User,
+)
+from app.routers.stock import consume_lot, open_lot
+from app.schemas import LotConsume, LotOpen
+from app.services.stock import check_in, current_stock
+from app.services.vererbung import frist_herkunft, oeffnungsfrist
+
+
+@pytest.fixture()
+def user(db):
+    person = User(username="tester", password_hash="x", role=Role.admin)
+    db.add(person)
+    db.commit()
+    db.refresh(person)
+    return person
+
+
+@pytest.fixture()
+def milch(db):
+    """Milliliter-Artikel mit 1000 ml je Packung, in einer Lebensmittel-Kategorie."""
+    cat = Category(name="Molkereiprodukte", tracking=CategoryTracking.food.value)
+    db.add(cat)
+    db.flush()
+    product = Product(
+        name="Vollmilch", base_unit=BaseUnit.milliliter, package_size=1000,
+        category_id=cat.id, source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _charge(db, product, menge_base, best_before=None):
+    lot = Lot(product_id=product.id, quantity=menge_base, best_before=best_before)
+    db.add(lot)
+    db.commit()
+    db.refresh(lot)
+    return lot
+
+
+# --------------------------------------------------------------------------
+# Anbrechen spaltet eine Packung ab
+# --------------------------------------------------------------------------
+def test_anbrechen_spaltet_eine_packung_ab(db, user, milch):
+    lot = _charge(db, milch, 4000)          # 4 x 1 l in einer Zeile
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.quantity == 1000
+    assert offen.opened_on == date.today()
+    assert offen.opened_quantity == 1000
+    # Der Rest bleibt zu – sonst trüge er das kurze Verbrauchsdatum mit.
+    rest = db.query(Lot).filter(Lot.id != offen.id).one()
+    assert rest.quantity == 3000
+    assert rest.opened_on is None
+    assert rest.consume_by is None
+    # Der Gesamtbestand ändert sich beim Anbrechen nicht.
+    assert current_stock(db, milch.id) == 4000
+
+
+def test_anbrechen_einer_einzelnen_packung_spaltet_nichts(db, user, milch):
+    lot = _charge(db, milch, 1000)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.id == lot.id
+    assert db.query(Lot).count() == 1
+    assert offen.quantity == 1000
+
+
+def test_anbrechen_nimmt_hoechstens_die_ganze_charge(db, user, milch):
+    lot = _charge(db, milch, 400)            # weniger als eine Packung
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.quantity == 400
+    assert db.query(Lot).count() == 1
+
+
+def test_anbrechen_mit_eigener_menge(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    offen = open_lot(lot.id, LotOpen(quantity=500), db=db, _=user)
+
+    assert offen.quantity == 500
+    assert db.query(Lot).filter(Lot.id != offen.id).one().quantity == 3500
+
+
+def test_zweimal_anbrechen_aendert_nichts(db, user, milch):
+    lot = _charge(db, milch, 4000)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    nochmal = open_lot(offen.id, LotOpen(), db=db, _=user)
+
+    assert nochmal.id == offen.id
+    assert nochmal.quantity == 1000
+    assert db.query(Lot).count() == 2
+
+
+def test_verbrauchsdatum_kommt_aus_der_frist(db, user, milch):
+    db.add(Setting(key="open_days", value="5"))
+    db.commit()
+    lot = _charge(db, milch, 1000)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.consume_by == date.today() + timedelta(days=5)
+
+
+def test_mhd_bleibt_neben_dem_verbrauchsdatum_stehen(db, user, milch):
+    mhd = date.today() + timedelta(days=20)
+    lot = _charge(db, milch, 1000, best_before=mhd)
+
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    assert offen.best_before == mhd            # unangetastet
+    assert offen.consume_by is not None
+    # Gewarnt wird nach dem früheren der beiden.
+    frisch = db.get(Lot, offen.id)
+    assert frisch.faellig_am == frisch.consume_by
+
+
+def test_frueheres_mhd_schlaegt_das_verbrauchsdatum(db, user, milch):
+    mhd = date.today() + timedelta(days=1)     # läuft vor der Öffnungsfrist ab
+    lot = _charge(db, milch, 1000, best_before=mhd)
+
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    frisch = db.query(Lot).one()
+    assert frisch.faellig_am == mhd
+
+
+# --------------------------------------------------------------------------
+# Verbrauchen
+# --------------------------------------------------------------------------
+def test_verbrauchen_oeffnet_in_einem_schritt(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    ergebnis = consume_lot(lot.id, LotConsume(quantity=100, unit="ml"), db=db, user=user)
+
+    assert ergebnis.opened is True
+    assert ergebnis.lot is not None
+    assert ergebnis.lot.quantity == 900       # 1000 geöffnet, 100 verbraucht
+    assert ergebnis.lot.opened_quantity == 1000
+    assert current_stock(db, milch.id) == 3900
+    # Der Verbrauch ist eine Bewegung, das Anbrechen allein nicht.
+    bewegungen = db.query(Movement).all()
+    assert len(bewegungen) == 1
+    assert bewegungen[0].type == MovementType.out
+    assert bewegungen[0].quantity == 100
+
+
+def test_verbrauchen_ohne_anbrechen_wenn_abgewaehlt(db, user, milch):
+    lot = _charge(db, milch, 4000)
+
+    ergebnis = consume_lot(
+        lot.id, LotConsume(quantity=100, unit="ml", auto_open=False), db=db, user=user
+    )
+
+    assert ergebnis.opened is False
+    assert db.query(Lot).count() == 1
+    assert db.query(Lot).one().opened_on is None
+    assert current_stock(db, milch.id) == 3900
+
+
+def test_weiterer_verbrauch_nutzt_die_offene_packung(db, user, milch):
+    lot = _charge(db, milch, 4000)
+    consume_lot(lot.id, LotConsume(quantity=100, unit="ml"), db=db, user=user)
+    offen = db.query(Lot).filter(Lot.opened_on.isnot(None)).one()
+
+    consume_lot(offen.id, LotConsume(quantity=200, unit="ml"), db=db, user=user)
+
+    assert db.get(Lot, offen.id).quantity == 700
+    assert db.query(Lot).count() == 2
+
+
+def test_leere_offene_packung_verschwindet(db, user, milch):
+    lot = _charge(db, milch, 1000)
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    ergebnis = consume_lot(lot.id, LotConsume(quantity=1000, unit="ml"), db=db, user=user)
+
+    assert ergebnis.lot is None
+    assert db.query(Lot).count() == 0
+    assert current_stock(db, milch.id) == 0
+
+
+def test_mehr_verbrauchen_als_drin_ist_scheitert(db, user, milch):
+    lot = _charge(db, milch, 1000)
+
+    with pytest.raises(HTTPException) as fehler:
+        consume_lot(lot.id, LotConsume(quantity=2000, unit="ml"), db=db, user=user)
+    assert fehler.value.status_code == 409
+
+
+def test_unbekannte_einheit_bricht_nichts_an(db, user, milch):
+    """Erst rechnen, dann anbrechen – sonst stünde eine Packung grundlos offen."""
+    lot = _charge(db, milch, 4000)
+
+    with pytest.raises(HTTPException) as fehler:
+        consume_lot(lot.id, LotConsume(quantity=1, unit="furlong"), db=db, user=user)
+
+    assert fehler.value.status_code == 400
+    assert db.query(Lot).one().opened_on is None
+
+
+def test_verbrauchen_in_packungen(db, user, rice, milch):
+    """„1 Packung" muss weiter gehen – die Hausmaße dürfen das nicht verdrängen."""
+    lot = check_in(db, rice, 3, "package", None, None, None)
+    db.commit()
+
+    consume_lot(lot.id, LotConsume(quantity=1, unit="package"), db=db, user=user)
+
+    assert current_stock(db, rice.id) == 1000
+
+
+# --------------------------------------------------------------------------
+# Frist: Artikel > Kategorie > Oberkategorie > global
+# --------------------------------------------------------------------------
+def test_frist_vererbung_ueber_die_ebenen(db, milch):
+    # 1. Ohne alles gilt der Standard aus der Konfiguration.
+    assert oeffnungsfrist(db, milch) == 3
+    assert frist_herkunft(db, milch)[1] == "Einstellungen"
+
+    # 2. Globale Einstellung.
+    db.add(Setting(key="open_days", value="7"))
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 7
+
+    # 3. Oberkategorie.
+    ober = db.get(Category, milch.category_id)
+    unter = Category(name="Frischmilch", parent_id=ober.id,
+                     tracking=CategoryTracking.food.value)
+    db.add(unter)
+    db.flush()
+    milch.category_id = unter.id
+    ober.open_days = 4
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 4
+    assert frist_herkunft(db, milch)[1] == "Kategorie: Molkereiprodukte"
+
+    # 4. Die nähere Kategorie gewinnt.
+    unter.open_days = 2
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 2
+    assert frist_herkunft(db, milch)[1] == "Kategorie: Frischmilch"
+
+    # 5. Der Artikel schlägt alles.
+    milch.open_days = 1
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 1
+    assert frist_herkunft(db, milch)[1] == "Artikel"
+
+
+def test_kaputte_globale_einstellung_faellt_auf_den_standard(db, milch):
+    db.add(Setting(key="open_days", value="viele"))
+    db.commit()
+    assert oeffnungsfrist(db, milch) == 3

backend/tests/test_hausmasse.py

@@ -0,0 +1,255 @@
+"""Hausmaße: „2 EL" wiegt bei Mehl anders als bei Zucker.
+
+Die Menge gehört an die Kategorie bzw. den Artikel, nicht an den Namen – ein
+globaler Faktor wie bei den verwalteten Einheiten wäre hier zwangsläufig falsch.
+"""
+
+import pytest
+
+from app.models import (
+    BaseUnit,
+    Category,
+    CategoryMeasure,
+    CategoryTracking,
+    Measure,
+    Product,
+    ProductMeasure,
+)
+from app.seed import ensure_builtin_measures
+from app.services.conversion import ConversionError, to_base
+from app.services.stock import check_in, check_out, current_stock
+from app.services.vererbung import mass_aufloesen, verfuegbare_masse
+
+
+@pytest.fixture()
+def masse(db):
+    ensure_builtin_measures(db)
+    return {m.name: m for m in db.query(Measure).all()}
+
+
+def _kategorie(db, name, parent=None):
+    cat = Category(
+        name=name,
+        parent_id=parent.id if parent else None,
+        tracking=CategoryTracking.food.value,
+    )
+    db.add(cat)
+    db.commit()
+    db.refresh(cat)
+    return cat
+
+
+def _artikel(db, name, cat, base=BaseUnit.gram, package_size=1000):
+    product = Product(
+        name=name, base_unit=base, package_size=package_size,
+        category_id=cat.id, source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _mass_an_kategorie(db, measure, cat, amount, base=BaseUnit.gram):
+    db.add(CategoryMeasure(
+        measure_id=measure.id, category_id=cat.id, amount=amount, base=base.value
+    ))
+    db.commit()
+
+
+# --------------------------------------------------------------------------
+# Derselbe Löffel, zwei Gewichte
+# --------------------------------------------------------------------------
+def test_esslöffel_wiegt_je_kategorie_anders(db, masse):
+    el = masse["Esslöffel"]
+    mehl_kat = _kategorie(db, "Mehl")
+    zucker_kat = _kategorie(db, "Zucker")
+    mehl = _artikel(db, "Weissmehl", mehl_kat)
+    zucker = _artikel(db, "Kristallzucker", zucker_kat)
+    _mass_an_kategorie(db, el, mehl_kat, 10)
+    _mass_an_kategorie(db, el, zucker_kat, 12)
+
+    assert to_base(db, mehl, 2, "EL", hausmasse=True) == 20
+    assert to_base(db, zucker, 2, "EL", hausmasse=True) == 24
+
+
+def test_kurzform_und_grossschreibung(db, masse):
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+    _mass_an_kategorie(db, el, kat, 10)
+
+    for token in ("EL", "el", "Esslöffel", "esslöffel", " EL "):
+        assert to_base(db, mehl, 1, token, hausmasse=True) == 10
+
+
+def test_tasse_in_millilitern(db, masse):
+    tasse = masse["Tasse"]
+    kat = _kategorie(db, "Molkerei")
+    milch = _artikel(db, "Vollmilch", kat, base=BaseUnit.milliliter)
+    _mass_an_kategorie(db, tasse, kat, 200, base=BaseUnit.milliliter)
+
+    assert to_base(db, milch, 1.5, "Tasse", hausmasse=True) == 300
+
+
+# --------------------------------------------------------------------------
+# Vererbung: Artikel > nächste Kategorie > Oberkategorie
+# --------------------------------------------------------------------------
+def test_unterkategorie_erbt_von_oben(db, masse):
+    el = masse["Esslöffel"]
+    trocken = _kategorie(db, "Trockenwaren")
+    mehl_kat = _kategorie(db, "Mehl", parent=trocken)
+    mehl = _artikel(db, "Weissmehl", mehl_kat)
+    _mass_an_kategorie(db, el, trocken, 11)
+
+    assert to_base(db, mehl, 1, "EL", hausmasse=True) == 11
+    angabe = mass_aufloesen(db, mehl, "EL")
+    assert angabe.herkunft == "Kategorie: Trockenwaren"
+
+
+def test_naehere_kategorie_schlaegt_die_obere(db, masse):
+    el = masse["Esslöffel"]
+    trocken = _kategorie(db, "Trockenwaren")
+    mehl_kat = _kategorie(db, "Mehl", parent=trocken)
+    mehl = _artikel(db, "Weissmehl", mehl_kat)
+    _mass_an_kategorie(db, el, trocken, 11)
+    _mass_an_kategorie(db, el, mehl_kat, 9)
+
+    assert to_base(db, mehl, 1, "EL", hausmasse=True) == 9
+
+
+def test_artikel_schlaegt_die_kategorie(db, masse):
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Zucker")
+    puder = _artikel(db, "Puderzucker", kat)
+    _mass_an_kategorie(db, el, kat, 12)
+    db.add(ProductMeasure(
+        measure_id=el.id, product_id=puder.id, amount=8, base=BaseUnit.gram.value
+    ))
+    db.commit()
+
+    assert to_base(db, puder, 1, "EL", hausmasse=True) == 8
+    assert mass_aufloesen(db, puder, "EL").herkunft == "Artikel"
+
+
+# --------------------------------------------------------------------------
+# Lücken und Fehler
+# --------------------------------------------------------------------------
+def test_mass_ohne_menge_meldet_sich_deutlich(db, masse):
+    """Die Meldung ist die Grundlage für „Maß jetzt anlegen" im Rezeptabgleich."""
+    kat = _kategorie(db, "Hülsenfrüchte")
+    linsen = _artikel(db, "Berglinsen", kat)
+
+    with pytest.raises(ConversionError) as fehler:
+        to_base(db, linsen, 1, "Tasse", hausmasse=True)
+    assert "kein Maß 'Tasse' hinterlegt" in str(fehler.value)
+
+
+def test_voellig_unbekannte_einheit_bleibt_unbekannte_einheit(db, masse):
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+
+    with pytest.raises(ConversionError) as fehler:
+        to_base(db, mehl, 1, "furlong", hausmasse=True)
+    assert "Unbekannte Einheit" in str(fehler.value)
+
+
+def test_artfremdes_mass_braucht_die_zweiteinheit(db, masse):
+    """Ein Gramm-Maß an einem Stück-Artikel geht nur über die Brücke."""
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Backwaren")
+    broetchen = _artikel(db, "Brötchen", kat, base=BaseUnit.piece, package_size=6)
+    _mass_an_kategorie(db, el, kat, 20)      # in Gramm
+
+    with pytest.raises(ConversionError) as fehler:
+        to_base(db, broetchen, 1, "EL", hausmasse=True)
+    assert "Zweiteinheit" in str(fehler.value)
+
+    # Mit Brücke „3 Stück ≙ 150 g" sind 20 g dann 0,4 Stück.
+    broetchen.secondary_base = BaseUnit.gram.value
+    broetchen.secondary_count = 3
+    broetchen.secondary_amount = 150
+    db.commit()
+    assert to_base(db, broetchen, 1, "EL", hausmasse=True) == pytest.approx(0.4)
+
+
+def test_packung_schlaegt_das_hausmass(db, masse):
+    """„package" wird zuerst geprüft – daran darf ein Hausmaß nichts ändern."""
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat, package_size=1000)
+    neu = Measure(name="Packung", short="Pck", position=99)
+    db.add(neu)
+    db.commit()
+    _mass_an_kategorie(db, neu, kat, 7)
+
+    assert to_base(db, mehl, 1, "package", hausmasse=True) == 1000
+
+
+def test_ohne_schalter_gilt_das_hausmass_nicht(db, masse):
+    """Einlagern und Mindestbestände dürfen keine Schätzwerte annehmen."""
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+    _mass_an_kategorie(db, el, kat, 10)
+
+    with pytest.raises(ConversionError) as fehler:
+        to_base(db, mehl, 2, "EL")              # ohne hausmasse=True
+    assert "Unbekannte Einheit" in str(fehler.value)
+
+
+def test_einlagern_nimmt_kein_hausmass(db, masse):
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+    _mass_an_kategorie(db, el, kat, 10)
+
+    with pytest.raises(ConversionError):
+        check_in(db, mehl, 2, "EL", None, None, None)
+
+
+def test_auslagern_nimmt_ein_hausmass(db, masse):
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+    _mass_an_kategorie(db, el, kat, 10)
+    check_in(db, mehl, 1, "package", None, None, None)
+    db.commit()
+
+    check_out(db, mehl, 2, "EL", None)
+    db.commit()
+
+    assert current_stock(db, mehl.id) == 980
+
+
+def test_einheit_schlaegt_gleichnamiges_hausmass(db, masse):
+    """Ein Maß „Liter" darf die echte Einheit nicht verdecken."""
+    kat = _kategorie(db, "Getränke")
+    saft = _artikel(db, "Apfelsaft", kat, base=BaseUnit.milliliter, package_size=1000)
+    liter_mass = Measure(name="Liter", short="Ltr", position=99)
+    db.add(liter_mass)
+    db.commit()
+    _mass_an_kategorie(db, liter_mass, kat, 5, base=BaseUnit.milliliter)
+
+    assert to_base(db, saft, 1, "Liter", hausmasse=True) == 1000
+
+
+def test_verfuegbare_masse_listet_nur_hinterlegte(db, masse):
+    el = masse["Esslöffel"]
+    kat = _kategorie(db, "Mehl")
+    mehl = _artikel(db, "Weissmehl", kat)
+    _mass_an_kategorie(db, el, kat, 10)
+
+    liste = verfuegbare_masse(db, mehl)
+
+    assert [a.measure.name for a in liste] == ["Esslöffel"]
+    assert liste[0].amount == 10
+    assert liste[0].herkunft == "Kategorie: Mehl"
+
+
+def test_artikel_ohne_kategorie_hat_keine_masse(db, masse):
+    product = Product(name="Irgendwas", base_unit=BaseUnit.gram, source="manual")
+    db.add(product)
+    db.commit()
+
+    assert verfuegbare_masse(db, product) == []
+    assert mass_aufloesen(db, product, "EL") is None

backend/tests/test_konsolidierung.py

@@ -0,0 +1,182 @@
+"""Zusammenfassen gleichartiger Chargen – und die Ausnahme für angebrochene.
+
+Diese Logik war bisher ungetestet, obwohl vier Stellen sie aufrufen
+(`check_in`, `bulk_lot_location`, `split_lot`, `update_lot`). Mit dem Anbrechen
+wird sie gefährlich: Ohne die Ausnahme würde eine offene Packung beim nächsten
+Einlagern am selben Ort still mit einer ungeöffneten verschmolzen und ihr
+kürzeres Verbrauchsdatum verlieren.
+"""
+
+from datetime import date, timedelta
+
+import pytest
+
+from app.models import BaseUnit, Location, Lot, Movement, MovementType, Product, Role, User
+from app.routers.stock import bulk_lot_location, open_lot
+from app.schemas import BulkLotLocation, LotOpen
+from app.services.stock import (
+    check_in,
+    consolidate_duplicate_lots,
+    consolidate_lot_group,
+    current_stock,
+)
+
+
+@pytest.fixture()
+def user(db):
+    person = User(username="tester", password_hash="x", role=Role.admin)
+    db.add(person)
+    db.commit()
+    db.refresh(person)
+    return person
+
+
+@pytest.fixture()
+def keller(db):
+    ort = Location(name="Keller")
+    db.add(ort)
+    db.commit()
+    db.refresh(ort)
+    return ort
+
+
+@pytest.fixture()
+def milch(db):
+    product = Product(
+        name="Vollmilch", base_unit=BaseUnit.milliliter, package_size=1000,
+        source="manual",
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+def _lot(db, product, menge, best_before=None, ort=None):
+    lot = Lot(
+        product_id=product.id, quantity=menge, best_before=best_before,
+        location_id=ort.id if ort else None,
+    )
+    db.add(lot)
+    db.commit()
+    db.refresh(lot)
+    return lot
+
+
+# --------------------------------------------------------------------------
+# Das bisherige Verhalten muss bleiben
+# --------------------------------------------------------------------------
+def test_gleiche_chargen_werden_zusammengefasst(db, milch, keller):
+    mhd = date.today() + timedelta(days=10)
+    _lot(db, milch, 1000, mhd, keller)
+    _lot(db, milch, 2000, mhd, keller)
+
+    survivor = consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert survivor.quantity == 3000
+    assert db.query(Lot).count() == 1
+
+
+def test_verschiedenes_mhd_bleibt_getrennt(db, milch, keller):
+    _lot(db, milch, 1000, date.today() + timedelta(days=5), keller)
+    _lot(db, milch, 1000, date.today() + timedelta(days=9), keller)
+
+    consolidate_duplicate_lots(db)
+
+    assert db.query(Lot).count() == 2
+
+
+def test_bewegungen_haengen_an_der_verbleibenden_charge(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=10)
+    alt = _lot(db, milch, 1000, mhd, keller)
+    neu = _lot(db, milch, 1000, mhd, keller)
+    db.add(Movement(product_id=milch.id, lot_id=neu.id, type=MovementType.in_,
+                    quantity=1000, unit_used="ml"))
+    db.commit()
+
+    survivor = consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert survivor.id == alt.id
+    assert db.query(Movement).one().lot_id == alt.id
+
+
+def test_einlagern_fasst_mit_der_bestehenden_charge_zusammen(db, milch, keller):
+    mhd = date.today() + timedelta(days=10)
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    db.commit()
+
+    assert db.query(Lot).count() == 1
+    assert current_stock(db, milch.id) == 2000
+
+
+# --------------------------------------------------------------------------
+# Die Ausnahme: Angebrochenes bleibt für sich
+# --------------------------------------------------------------------------
+def test_angebrochene_charge_wird_nicht_eingesammelt(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+    verbrauchsdatum = offen.consume_by
+
+    consolidate_lot_group(db, milch.id, mhd, "day", keller.id)
+    db.commit()
+
+    assert db.query(Lot).count() == 2
+    frisch = db.get(Lot, offen.id)
+    assert frisch is not None
+    assert frisch.consume_by == verbrauchsdatum
+
+
+def test_einlagern_laesst_die_offene_packung_in_ruhe(db, milch, keller, user):
+    """Der gefährlichste Pfad: nachkaufen, während eine Packung offen ist."""
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+
+    check_in(db, milch, 1, "package", mhd, keller.id, None)
+    db.commit()
+
+    frisch = db.get(Lot, offen.id)
+    assert frisch.quantity == 1000
+    assert frisch.opened_on is not None
+    # Die zugekaufte Packung verschmilzt mit der verbliebenen ungeöffneten.
+    zu = db.query(Lot).filter(Lot.opened_on.is_(None)).all()
+    assert len(zu) == 1
+    assert zu[0].quantity == 2000
+    assert current_stock(db, milch.id) == 3000
+
+
+def test_umlagern_mehrerer_chargen_laesst_offenes_getrennt(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 3000, mhd, None)
+    offen = open_lot(lot.id, LotOpen(), db=db, _=user)
+    zweite = _lot(db, milch, 1000, mhd, None)
+
+    bulk_lot_location(
+        BulkLotLocation(lot_ids=[offen.id, zweite.id, lot.id], location_id=keller.id),
+        db=db, _=user,
+    )
+
+    offene = db.query(Lot).filter(Lot.opened_on.isnot(None)).all()
+    assert len(offene) == 1
+    assert offene[0].quantity == 1000
+    assert offene[0].location_id == keller.id
+    assert current_stock(db, milch.id) == 4000
+
+
+def test_start_aufraeumer_ruehrt_offenes_nicht_an(db, milch, keller, user):
+    mhd = date.today() + timedelta(days=20)
+    lot = _lot(db, milch, 2000, mhd, keller)
+    open_lot(lot.id, LotOpen(), db=db, _=user)
+    # Zwei ungeöffnete Dubletten dazu, die zusammengefasst werden sollen.
+    _lot(db, milch, 500, mhd, keller)
+
+    entfernt = consolidate_duplicate_lots(db)
+
+    assert entfernt == 1
+    assert db.query(Lot).filter(Lot.opened_on.isnot(None)).count() == 1
+    assert db.query(Lot).filter(Lot.opened_on.is_(None)).count() == 1
+    assert current_stock(db, milch.id) == 2500