| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425 |
- """The maintenance log: every reset with its comment, who did it, on which printer and when.
- Entries outlive the printer, the custom task and the user (their names are
- kept as they were), so the log stays an audit trail. It is read per printer
- and exported as CSV per printer or for the whole fleet; a printer-scoped
- caller sees only their printers, and not the entries of deleted ones.
- Entries can be deleted, by age or one at a time, with the history row of the
- same reset, so a deleted comment is gone from the database.
- """
- from __future__ import annotations
- import csv
- import io
- from datetime import datetime, timedelta, timezone
- import pytest
- from httpx import AsyncClient
- from backend.app.models.maintenance import MaintenanceHistory, MaintenanceLogEntry
- from backend.tests.integration.test_archives_last_per_printer import _admin_token, _auth, _user
- pytestmark = [pytest.mark.asyncio, pytest.mark.integration]
- BASE = "/api/v1/maintenance"
- async def _first_item(async_client: AsyncClient, printer_id: int) -> dict:
- overview = (await async_client.get(f"{BASE}/printers/{printer_id}")).json()
- return overview["maintenance_items"][0]
- async def _perform(async_client: AsyncClient, item_id: int, notes: str | None = None, headers=None):
- body = {} if notes is None else {"notes": notes}
- return await async_client.post(f"{BASE}/items/{item_id}/perform", json=body, headers=headers)
- async def _log(async_client: AsyncClient, printer_id: int, headers=None, **params) -> dict:
- response = await async_client.get(f"{BASE}/printers/{printer_id}/log", params=params, headers=headers)
- assert response.status_code == 200, response.text
- return response.json()
- def _csv_rows(response) -> list[list[str]]:
- assert response.status_code == 200, response.text
- assert response.headers["content-type"].startswith("text/csv")
- assert "attachment" in response.headers["content-disposition"]
- text = response.content.decode("utf-8")
- assert text.startswith(""), "Excel needs the BOM to read UTF-8"
- return list(csv.reader(io.StringIO(text[1:])))
- async def _entry(db_session, entry_id: int) -> MaintenanceLogEntry:
- db_session.expire_all()
- entry = await db_session.get(MaintenanceLogEntry, entry_id)
- assert entry is not None
- return entry
- async def _age(db_session, entry_id: int, days: int) -> int:
- """Move an entry ``days`` into the past; returns its history row's id."""
- entry = await _entry(db_session, entry_id)
- entry.performed_at = datetime.now(timezone.utc).replace(tzinfo=None) - timedelta(days=days)
- history_id = entry.history_id
- await db_session.commit()
- assert history_id is not None
- return history_id
- async def _history_exists(db_session, history_id: int) -> bool:
- db_session.expire_all()
- return await db_session.get(MaintenanceHistory, history_id) is not None
- async def _logged(async_client, printer_factory, name: str, *notes: str) -> tuple[int, list[int]]:
- """A printer with one reset per note; returns its id and the entry ids, oldest first."""
- printer_id = (await printer_factory(name=name)).id
- item = await _first_item(async_client, printer_id)
- for note in notes:
- await _perform(async_client, item["id"], note)
- entries = (await _log(async_client, printer_id))["items"]
- return printer_id, [e["id"] for e in reversed(entries)]
- class TestLogging:
- async def test_a_reset_logs_the_task_the_printer_and_the_comment(self, async_client, printer_factory):
- printer = await printer_factory(name="Log Printer")
- item = await _first_item(async_client, printer.id)
- response = await _perform(async_client, item["id"], " Rails cleaned, new grease ")
- assert response.status_code == 200, response.text
- log = await _log(async_client, printer.id)
- assert log["total"] == 1
- entry = log["items"][0]
- assert entry["printer_id"] == printer.id
- assert entry["printer_name"] == "Log Printer"
- assert entry["maintenance_type_id"] == item["maintenance_type_id"]
- assert entry["maintenance_type_name"] == item["maintenance_type_name"]
- assert entry["notes"] == "Rails cleaned, new grease"
- assert entry["performed_at"] is not None
- # Authentication is off: nobody to name.
- assert entry["performed_by_id"] is None
- assert entry["performed_by_username"] is None
- async def test_the_comment_is_optional_and_blank_is_none(self, async_client, printer_factory):
- printer = await printer_factory(name="No Comment Printer")
- item = await _first_item(async_client, printer.id)
- assert (await _perform(async_client, item["id"])).status_code == 200
- assert (await _perform(async_client, item["id"], " ")).status_code == 200
- notes = [e["notes"] for e in (await _log(async_client, printer.id))["items"]]
- assert notes == [None, None]
- async def test_a_comment_over_the_limit_is_refused(self, async_client, printer_factory):
- printer = await printer_factory(name="Long Comment Printer")
- item = await _first_item(async_client, printer.id)
- response = await _perform(async_client, item["id"], "x" * 10001)
- assert response.status_code == 422
- assert (await _log(async_client, printer.id))["total"] == 0
- async def test_a_long_report_fits(self, async_client, printer_factory):
- """Automations post whole reports; the endpoint took any length before."""
- printer = await printer_factory(name="Report Printer")
- item = await _first_item(async_client, printer.id)
- response = await _perform(async_client, item["id"], "x" * 10000)
- assert response.status_code == 200, response.text
- assert len((await _log(async_client, printer.id))["items"][0]["notes"]) == 10000
- async def test_surrounding_whitespace_does_not_count_against_the_limit(self, async_client, printer_factory):
- printer = await printer_factory(name="Padded Printer")
- item = await _first_item(async_client, printer.id)
- response = await _perform(async_client, item["id"], "x" * 9995 + " " * 20 + "\n")
- assert response.status_code == 200, response.text
- assert (await _log(async_client, printer.id))["items"][0]["notes"] == "x" * 9995
- async def test_the_log_is_newest_first_and_paged(self, async_client, printer_factory):
- printer = await printer_factory(name="Paged Printer")
- item = await _first_item(async_client, printer.id)
- for n in range(3):
- await _perform(async_client, item["id"], f"reset {n}")
- first = await _log(async_client, printer.id, limit=2)
- rest = await _log(async_client, printer.id, limit=2, offset=2)
- assert first["total"] == rest["total"] == 3
- assert [e["notes"] for e in first["items"]] == ["reset 2", "reset 1"]
- assert [e["notes"] for e in rest["items"]] == ["reset 0"]
- async def test_another_printer_s_resets_are_not_in_its_log(self, async_client, printer_factory):
- mine, other = await printer_factory(name="Mine"), await printer_factory(name="Other")
- await _perform(async_client, (await _first_item(async_client, other.id))["id"], "other's")
- assert (await _log(async_client, mine.id))["total"] == 0
- async def test_the_log_of_an_unknown_printer_is_not_found(self, async_client):
- response = await async_client.get(f"{BASE}/printers/999999/log")
- assert response.status_code == 404
- class TestOutlivingDeletes:
- async def test_entries_outlive_their_printer(self, async_client, printer_factory, db_session):
- printer = await printer_factory(name="Doomed Printer")
- await _perform(async_client, (await _first_item(async_client, printer.id))["id"], "before the end")
- entry_id = (await _log(async_client, printer.id))["items"][0]["id"]
- deleted = await async_client.delete(f"/api/v1/printers/{printer.id}")
- assert deleted.status_code == 200, deleted.text
- entry = await _entry(db_session, entry_id)
- assert entry.printer_id is None
- assert entry.printer_name == "Doomed Printer"
- assert entry.notes == "before the end"
- rows = _csv_rows(await async_client.get(f"{BASE}/log/export"))
- assert ["Doomed Printer", "before the end"] in [[r[1], r[5]] for r in rows[1:]]
- async def test_entries_outlive_a_deleted_custom_task(self, async_client, printer_factory, db_session):
- printer_id = (await printer_factory(name="Custom Task Printer")).id
- task = (
- await async_client.post(
- f"{BASE}/types",
- json={"name": "Replace Hotend", "default_interval_hours": 500, "interval_type": "hours"},
- )
- ).json()
- item = (await async_client.post(f"{BASE}/printers/{printer_id}/assign/{task['id']}")).json()
- await _perform(async_client, item["id"], "0.4 mm hardened")
- entry_id = (await _log(async_client, printer_id))["items"][0]["id"]
- assert (await async_client.delete(f"{BASE}/types/{task['id']}")).status_code == 200
- entry = await _entry(db_session, entry_id)
- assert entry.maintenance_type_id is None
- assert entry.maintenance_type_name == "Replace Hotend"
- assert (await _log(async_client, printer_id))["total"] == 1
- class TestExport:
- async def test_a_printer_s_log_exports_as_csv(self, async_client, printer_factory):
- printer = await printer_factory(name="Drucker Übung")
- item = await _first_item(async_client, printer.id)
- await _perform(async_client, item["id"], "Düse gewechselt")
- response = await async_client.get(f"{BASE}/printers/{printer.id}/log/export")
- rows = _csv_rows(response)
- assert rows[0] == ["Performed at (UTC)", "Printer", "Task", "Performed by", "Print hours", "Comment"]
- assert len(rows) == 2
- performed_at, name, task, by, hours, comment = rows[1]
- assert performed_at.endswith("Z")
- assert (name, task, by, comment) == ("Drucker Übung", item["maintenance_type_name"], "", "Düse gewechselt")
- assert float(hours) == pytest.approx(0.0)
- assert "maintenance_log_Drucker" in response.headers["content-disposition"]
- async def test_a_formula_in_a_comment_stays_text(self, async_client, printer_factory):
- printer = await printer_factory(name="Formula Printer")
- await _perform(async_client, (await _first_item(async_client, printer.id))["id"], '=HYPERLINK("x")')
- rows = _csv_rows(await async_client.get(f"{BASE}/printers/{printer.id}/log/export"))
- assert rows[1][5] == '\'=HYPERLINK("x")'
- async def test_the_fleet_export_has_every_printer(self, async_client, printer_factory):
- a, b = await printer_factory(name="Fleet A"), await printer_factory(name="Fleet B")
- for printer in (a, b):
- await _perform(async_client, (await _first_item(async_client, printer.id))["id"], printer.name)
- rows = _csv_rows(await async_client.get(f"{BASE}/log/export"))
- assert {r[1] for r in rows[1:]} >= {"Fleet A", "Fleet B"}
- class TestCleanup:
- async def test_a_printer_s_old_entries_go_with_their_history(self, async_client, printer_factory, db_session):
- printer_id, (old, recent, _today) = await _logged(
- async_client, printer_factory, "Cleanup", "old", "recent", "today"
- )
- other_id, (other_old,) = await _logged(async_client, printer_factory, "Cleanup Other", "other old")
- old_history = await _age(db_session, old, 400)
- recent_history = await _age(db_session, recent, 10)
- other_history = await _age(db_session, other_old, 400)
- response = await async_client.delete(f"{BASE}/printers/{printer_id}/log", params={"older_than_days": 30})
- assert response.status_code == 200, response.text
- assert response.json() == {"deleted": 1}
- assert [e["notes"] for e in (await _log(async_client, printer_id))["items"]] == ["today", "recent"]
- assert not await _history_exists(db_session, old_history)
- assert await _history_exists(db_session, recent_history)
- # Another printer's entries are not touched.
- assert (await _log(async_client, other_id))["total"] == 1
- assert await _history_exists(db_session, other_history)
- async def test_the_age_must_be_given_and_at_least_a_day(self, async_client, printer_factory):
- printer_id, _ = await _logged(async_client, printer_factory, "Cleanup Age", "kept")
- for params in ({}, {"older_than_days": 0}, {"older_than_days": -5}):
- assert (await async_client.delete(f"{BASE}/printers/{printer_id}/log", params=params)).status_code == 422
- assert (await async_client.delete(f"{BASE}/log", params=params)).status_code == 422
- assert (await _log(async_client, printer_id))["total"] == 1
- async def test_cleaning_up_an_unknown_printer_is_not_found(self, async_client):
- response = await async_client.delete(f"{BASE}/printers/999999/log", params={"older_than_days": 1})
- assert response.status_code == 404
- async def test_the_fleet_cleanup_covers_every_printer_and_deleted_ones(
- self, async_client, printer_factory, db_session
- ):
- a_id, (a_old, a_new) = await _logged(async_client, printer_factory, "Fleet Clean A", "a old", "a new")
- b_id, (b_old,) = await _logged(async_client, printer_factory, "Fleet Clean B", "b old")
- gone_id, (gone_old,) = await _logged(async_client, printer_factory, "Fleet Clean Gone", "gone old")
- for entry_id in (a_old, b_old, gone_old):
- await _age(db_session, entry_id, 100)
- assert (await async_client.delete(f"/api/v1/printers/{gone_id}")).status_code == 200
- response = await async_client.delete(f"{BASE}/log", params={"older_than_days": 30})
- assert response.status_code == 200, response.text
- assert response.json() == {"deleted": 3}
- assert [e["id"] for e in (await _log(async_client, a_id))["items"]] == [a_new]
- assert (await _log(async_client, b_id))["total"] == 0
- db_session.expire_all()
- assert await db_session.get(MaintenanceLogEntry, gone_old) is None
- async def test_one_entry_goes_with_its_history_and_the_reset_stays(self, async_client, printer_factory, db_session):
- printer_id, (kept, mistaken) = await _logged(async_client, printer_factory, "Mistake", "kept", "by mistake")
- history_id = (await _entry(db_session, mistaken)).history_id
- before = await _first_item(async_client, printer_id)
- response = await async_client.delete(f"{BASE}/log/{mistaken}")
- assert response.status_code == 200, response.text
- assert [e["id"] for e in (await _log(async_client, printer_id))["items"]] == [kept]
- assert history_id is not None
- assert not await _history_exists(db_session, history_id)
- # Deleting the entry does not undo the reset.
- assert (await _first_item(async_client, printer_id))["last_performed_at"] == before["last_performed_at"]
- async def test_an_entry_whose_history_is_gone_leaves_a_later_reset_s_history_alone(
- self, async_client, printer_factory, db_session
- ):
- # The deleted printer's history row had the highest id, so on SQLite the
- # next reset is given it. Deleting the old entry must not take that
- # reset's history with it.
- doomed = (await printer_factory(name="Doomed")).id
- await _perform(async_client, (await _first_item(async_client, doomed))["id"], "before the end")
- old_entry = (await _log(async_client, doomed))["items"][0]["id"]
- old_history = (await _entry(db_session, old_entry)).history_id
- assert (await async_client.delete(f"/api/v1/printers/{doomed}")).status_code == 200
- assert (await _entry(db_session, old_entry)).history_id is None
- survivor_id, (new_entry,) = await _logged(async_client, printer_factory, "Survivor", "after")
- new_history = (await _entry(db_session, new_entry)).history_id
- assert new_history is not None
- assert (await async_client.delete(f"{BASE}/log/{old_entry}")).status_code == 200
- assert await _history_exists(db_session, new_history)
- assert (await _log(async_client, survivor_id))["total"] == 1
- if db_session.bind.dialect.name == "sqlite":
- # The case this is about: SQLite gave the later reset the freed id.
- # PostgreSQL never reuses one, so there it can only pass.
- assert new_history == old_history
- async def test_deleting_an_unknown_entry_is_not_found(self, async_client):
- assert (await async_client.delete(f"{BASE}/log/999999")).status_code == 404
- class TestWithAuthentication:
- PERMISSIONS = ["maintenance:read", "maintenance:update", "printers:read"]
- async def test_the_log_names_who_reset(self, async_client, printer_factory):
- printer = await printer_factory(name="Auth Printer")
- admin = await _admin_token(async_client)
- jwt, user_id = await _user(async_client, admin, "mechanic", self.PERMISSIONS)
- overview = (await async_client.get(f"{BASE}/printers/{printer.id}", headers=_auth(jwt))).json()
- item = overview["maintenance_items"][0]
- response = await _perform(async_client, item["id"], "done", headers=_auth(jwt))
- assert response.status_code == 200, response.text
- entry = (await _log(async_client, printer.id, headers=_auth(jwt)))["items"][0]
- assert (entry["performed_by_id"], entry["performed_by_username"]) == (user_id, "mechanic")
- rows = _csv_rows(await async_client.get(f"{BASE}/printers/{printer.id}/log/export", headers=_auth(jwt)))
- assert rows[1][3] == "mechanic"
- async def test_a_scoped_user_exports_only_their_printers(self, async_client, printer_factory):
- mine, theirs, gone = (
- await printer_factory(name="Scoped Mine"),
- await printer_factory(name="Scoped Theirs"),
- await printer_factory(name="Scoped Gone"),
- )
- for printer in (mine, theirs, gone):
- await _perform(async_client, (await _first_item(async_client, printer.id))["id"], printer.name)
- assert (await async_client.delete(f"/api/v1/printers/{gone.id}")).status_code == 200
- admin = await _admin_token(async_client)
- jwt, _ = await _user(async_client, admin, "scoped", self.PERMISSIONS, printer_ids=[mine.id])
- rows = _csv_rows(await async_client.get(f"{BASE}/log/export", headers=_auth(jwt)))
- admin_rows = _csv_rows(await async_client.get(f"{BASE}/log/export", headers=_auth(admin)))
- assert [r[1] for r in rows[1:]] == ["Scoped Mine"]
- assert {"Scoped Mine", "Scoped Theirs", "Scoped Gone"} <= {r[1] for r in admin_rows[1:]}
- async def test_a_scoped_user_cannot_read_another_printer_s_log(self, async_client, printer_factory):
- mine, theirs = await printer_factory(name="Scope A"), await printer_factory(name="Scope B")
- admin = await _admin_token(async_client)
- jwt, _ = await _user(async_client, admin, "scoped_reader", self.PERMISSIONS, printer_ids=[mine.id])
- log = await async_client.get(f"{BASE}/printers/{theirs.id}/log", headers=_auth(jwt))
- export = await async_client.get(f"{BASE}/printers/{theirs.id}/log/export", headers=_auth(jwt))
- assert log.status_code in (403, 404)
- assert export.status_code in (403, 404)
- async def test_cleanup_needs_the_delete_permission(self, async_client, printer_factory):
- printer_id, (entry_id,) = await _logged(async_client, printer_factory, "No Delete", "kept")
- admin = await _admin_token(async_client)
- jwt, _ = await _user(async_client, admin, "no_delete", self.PERMISSIONS)
- for path, params in (
- (f"{BASE}/printers/{printer_id}/log", {"older_than_days": 1}),
- (f"{BASE}/log", {"older_than_days": 1}),
- (f"{BASE}/log/{entry_id}", {}),
- ):
- response = await async_client.delete(path, params=params, headers=_auth(jwt))
- assert response.status_code == 403, (path, response.text)
- assert (await _log(async_client, printer_id, headers=_auth(admin)))["total"] == 1
- async def test_a_scoped_user_cleans_up_only_their_printers(self, async_client, printer_factory, db_session):
- mine, (mine_old,) = await _logged(async_client, printer_factory, "Clean Mine", "mine")
- theirs, (theirs_old,) = await _logged(async_client, printer_factory, "Clean Theirs", "theirs")
- gone, (gone_old,) = await _logged(async_client, printer_factory, "Clean Gone", "gone")
- for entry_id in (mine_old, theirs_old, gone_old):
- await _age(db_session, entry_id, 100)
- assert (await async_client.delete(f"/api/v1/printers/{gone}")).status_code == 200
- admin = await _admin_token(async_client)
- jwt, _ = await _user(
- async_client, admin, "scoped_cleaner", [*self.PERMISSIONS, "maintenance:delete"], printer_ids=[mine]
- )
- fleet = await async_client.delete(f"{BASE}/log", params={"older_than_days": 30}, headers=_auth(jwt))
- other_printer = await async_client.delete(
- f"{BASE}/printers/{theirs}/log", params={"older_than_days": 30}, headers=_auth(jwt)
- )
- other_entry = await async_client.delete(f"{BASE}/log/{theirs_old}", headers=_auth(jwt))
- deleted_printer_entry = await async_client.delete(f"{BASE}/log/{gone_old}", headers=_auth(jwt))
- assert fleet.status_code == 200, fleet.text
- assert fleet.json() == {"deleted": 1}
- assert other_printer.status_code in (403, 404)
- assert other_entry.status_code == 404
- assert deleted_printer_entry.status_code == 404
- db_session.expire_all()
- assert await db_session.get(MaintenanceLogEntry, mine_old) is None
- assert await db_session.get(MaintenanceLogEntry, theirs_old) is not None
- assert await db_session.get(MaintenanceLogEntry, gone_old) is not None
|