MABEA/backend/tests/test_geraet_instanz.py

import pytest
from sqlalchemy import select

from app.models.geraet_instanz import GeraetInstanz, GeraetStatus
from app.models.objektposition import Objektposition


@pytest.mark.asyncio
async def test_mehrere_geraete_instanzen_pro_position(db_session, objekt_mit_position):
    """Karte 14 Kernproblem: objektposition.seriennummer als Einzelfeld konnte nur
    EIN Gerät pro Materialtyp/Objekt abbilden - geraet_instanz erlaubt beliebig
    viele Exemplare (z.B. 2 Pulsoxymeter im selben Rucksack)."""
    objekt, material = objekt_mit_position
    result = await db_session.execute(
        select(Objektposition).where(
            Objektposition.objekt_id == objekt.id, Objektposition.material_id == material.id
        )
    )
    position = result.scalar_one()

    db_session.add(GeraetInstanz(objektposition_id=position.id, seriennummer="SN-001"))
    db_session.add(GeraetInstanz(objektposition_id=position.id, seriennummer="SN-002"))
    await db_session.flush()

    instanzen = (
        await db_session.execute(
            select(GeraetInstanz).where(GeraetInstanz.objektposition_id == position.id)
        )
    ).scalars().all()
    assert {i.seriennummer for i in instanzen} == {"SN-001", "SN-002"}
    assert all(i.status == GeraetStatus.einsatzbereit for i in instanzen)


@pytest.mark.asyncio
async def test_seriennummer_je_position_eindeutig(db_session, objekt_mit_position):
    from sqlalchemy.exc import IntegrityError

    objekt, material = objekt_mit_position
    result = await db_session.execute(
        select(Objektposition).where(
            Objektposition.objekt_id == objekt.id, Objektposition.material_id == material.id
        )
    )
    position = result.scalar_one()

    db_session.add(GeraetInstanz(objektposition_id=position.id, seriennummer="SN-001"))
    await db_session.flush()
    db_session.add(GeraetInstanz(objektposition_id=position.id, seriennummer="SN-001"))
    with pytest.raises(IntegrityError):
        await db_session.flush()


@pytest.mark.asyncio
async def test_gleiche_seriennummer_an_verschiedenen_positionen_erlaubt(
    db_session, objekt_mit_position, material_factory
):
    """UNIQUE(objektposition_id, seriennummer) greift nur je Position, nicht
    global - zwei verschiedene Objektpositionen dürfen dieselbe SN führen
    (z.B. baugleiche Geräte an unterschiedlichen Objekten)."""
    objekt, material = objekt_mit_position
    result = await db_session.execute(
        select(Objektposition).where(
            Objektposition.objekt_id == objekt.id, Objektposition.material_id == material.id
        )
    )
    position_a = result.scalar_one()

    material_b = await material_factory("Pulsoxymeter")
    position_b = Objektposition(objekt_id=objekt.id, material_id=material_b.id, istmenge=0)
    db_session.add(position_b)
    await db_session.flush()

    db_session.add(GeraetInstanz(objektposition_id=position_a.id, seriennummer="SN-GLEICH"))
    db_session.add(GeraetInstanz(objektposition_id=position_b.id, seriennummer="SN-GLEICH"))
    await db_session.flush()  # darf nicht scheitern

    anzahl = (
        await db_session.execute(select(GeraetInstanz).where(GeraetInstanz.seriennummer == "SN-GLEICH"))
    ).scalars().all()
    assert len(anzahl) == 2


@pytest.mark.asyncio
async def test_pruefintervall_monate_default_und_setzen(db_session, objekt_mit_position):
    """Karte 14: pruefintervall_monate individuell überschreibbar je
    Objektposition (wie sollmenge_override), NULL = kein Prüfintervall."""
    objekt, material = objekt_mit_position
    result = await db_session.execute(
        select(Objektposition).where(
            Objektposition.objekt_id == objekt.id, Objektposition.material_id == material.id
        )
    )
    position = result.scalar_one()
    assert position.pruefintervall_monate is None

    position.pruefintervall_monate = 24
    await db_session.flush()
    await db_session.refresh(position)
    assert position.pruefintervall_monate == 24


from tests.conftest import auth_header, login  # noqa: E402


@pytest.mark.asyncio
async def test_endpunkte_crud_und_pruefdatum(client, db_session, objekt_mit_position, materialverantwortlicher_user):
    objekt, material = objekt_mit_position
    token = await login(client, "materialverantwortlicher1")

    positionen = await client.get(f"/api/v1/objekte/{objekt.id}/positionen", headers=auth_header(token))
    position_id = positionen.json()[0]["id"]

    await client.patch(
        f"/api/v1/objekte/{objekt.id}/positionen/{position_id}",
        json={"pruefintervall_monate": 12},
        headers=auth_header(token),
    )

    erstellt = await client.post(
        f"/api/v1/objektpositionen/{position_id}/geraete",
        json={"seriennummer": "SN-100"},
        headers=auth_header(token),
    )
    assert erstellt.status_code == 201
    geraet_id = erstellt.json()["id"]
    assert erstellt.json()["status"] == "einsatzbereit"

    liste = await client.get(f"/api/v1/objektpositionen/{position_id}/geraete", headers=auth_header(token))
    assert len(liste.json()) == 1

    doppelt = await client.post(
        f"/api/v1/objektpositionen/{position_id}/geraete",
        json={"seriennummer": "SN-100"},
        headers=auth_header(token),
    )
    assert doppelt.status_code == 409

    geprueft = await client.patch(
        f"/api/v1/geraete/{geraet_id}",
        json={"status": "einsatzbereit", "pruefdatum": "2026-01-15"},
        headers=auth_header(token),
    )
    assert geprueft.status_code == 200
    assert geprueft.json()["naechste_pruefung"] == "2027-01-15"

    geloescht = await client.delete(f"/api/v1/geraete/{geraet_id}", headers=auth_header(token))
    assert geloescht.status_code == 204
    leer = await client.get(f"/api/v1/objektpositionen/{position_id}/geraete", headers=auth_header(token))
    assert leer.json() == []


@pytest.mark.asyncio
async def test_defekt_kann_fehlbestand_erzeugen(client, objekt_mit_position, materialverantwortlicher_user):
    objekt, material = objekt_mit_position
    token = await login(client, "materialverantwortlicher1")

    positionen = await client.get(f"/api/v1/objekte/{objekt.id}/positionen", headers=auth_header(token))
    position_id = positionen.json()[0]["id"]

    erstellt = await client.post(
        f"/api/v1/objektpositionen/{position_id}/geraete",
        json={"seriennummer": "SN-200"},
        headers=auth_header(token),
    )
    geraet_id = erstellt.json()["id"]

    ohne_fehlbestand = await client.patch(
        f"/api/v1/geraete/{geraet_id}",
        json={"status": "defekt", "bemerkung": "Display kaputt"},
        headers=auth_header(token),
    )
    assert ohne_fehlbestand.status_code == 200

    vorher = await client.get(
        "/api/v1/fehlbestaende", params={"objekt_id": objekt.id}, headers=auth_header(token)
    )
    anzahl_vorher = len(vorher.json())

    mit_fehlbestand = await client.patch(
        f"/api/v1/geraete/{geraet_id}",
        json={"status": "defekt", "bemerkung": "Display kaputt", "erzeuge_fehlbestand": True},
        headers=auth_header(token),
    )
    assert mit_fehlbestand.status_code == 200

    nachher = await client.get(
        "/api/v1/fehlbestaende", params={"objekt_id": objekt.id}, headers=auth_header(token)
    )
    assert len(nachher.json()) == anzahl_vorher + 1