test_maintenance_log.py 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425
  1. """The maintenance log: every reset with its comment, who did it, on which printer and when.
  2. Entries outlive the printer, the custom task and the user (their names are
  3. kept as they were), so the log stays an audit trail. It is read per printer
  4. and exported as CSV per printer or for the whole fleet; a printer-scoped
  5. caller sees only their printers, and not the entries of deleted ones.
  6. Entries can be deleted, by age or one at a time, with the history row of the
  7. same reset, so a deleted comment is gone from the database.
  8. """
  9. from __future__ import annotations
  10. import csv
  11. import io
  12. from datetime import datetime, timedelta, timezone
  13. import pytest
  14. from httpx import AsyncClient
  15. from backend.app.models.maintenance import MaintenanceHistory, MaintenanceLogEntry
  16. from backend.tests.integration.test_archives_last_per_printer import _admin_token, _auth, _user
  17. pytestmark = [pytest.mark.asyncio, pytest.mark.integration]
  18. BASE = "/api/v1/maintenance"
  19. async def _first_item(async_client: AsyncClient, printer_id: int) -> dict:
  20. overview = (await async_client.get(f"{BASE}/printers/{printer_id}")).json()
  21. return overview["maintenance_items"][0]
  22. async def _perform(async_client: AsyncClient, item_id: int, notes: str | None = None, headers=None):
  23. body = {} if notes is None else {"notes": notes}
  24. return await async_client.post(f"{BASE}/items/{item_id}/perform", json=body, headers=headers)
  25. async def _log(async_client: AsyncClient, printer_id: int, headers=None, **params) -> dict:
  26. response = await async_client.get(f"{BASE}/printers/{printer_id}/log", params=params, headers=headers)
  27. assert response.status_code == 200, response.text
  28. return response.json()
  29. def _csv_rows(response) -> list[list[str]]:
  30. assert response.status_code == 200, response.text
  31. assert response.headers["content-type"].startswith("text/csv")
  32. assert "attachment" in response.headers["content-disposition"]
  33. text = response.content.decode("utf-8")
  34. assert text.startswith(""), "Excel needs the BOM to read UTF-8"
  35. return list(csv.reader(io.StringIO(text[1:])))
  36. async def _entry(db_session, entry_id: int) -> MaintenanceLogEntry:
  37. db_session.expire_all()
  38. entry = await db_session.get(MaintenanceLogEntry, entry_id)
  39. assert entry is not None
  40. return entry
  41. async def _age(db_session, entry_id: int, days: int) -> int:
  42. """Move an entry ``days`` into the past; returns its history row's id."""
  43. entry = await _entry(db_session, entry_id)
  44. entry.performed_at = datetime.now(timezone.utc).replace(tzinfo=None) - timedelta(days=days)
  45. history_id = entry.history_id
  46. await db_session.commit()
  47. assert history_id is not None
  48. return history_id
  49. async def _history_exists(db_session, history_id: int) -> bool:
  50. db_session.expire_all()
  51. return await db_session.get(MaintenanceHistory, history_id) is not None
  52. async def _logged(async_client, printer_factory, name: str, *notes: str) -> tuple[int, list[int]]:
  53. """A printer with one reset per note; returns its id and the entry ids, oldest first."""
  54. printer_id = (await printer_factory(name=name)).id
  55. item = await _first_item(async_client, printer_id)
  56. for note in notes:
  57. await _perform(async_client, item["id"], note)
  58. entries = (await _log(async_client, printer_id))["items"]
  59. return printer_id, [e["id"] for e in reversed(entries)]
  60. class TestLogging:
  61. async def test_a_reset_logs_the_task_the_printer_and_the_comment(self, async_client, printer_factory):
  62. printer = await printer_factory(name="Log Printer")
  63. item = await _first_item(async_client, printer.id)
  64. response = await _perform(async_client, item["id"], " Rails cleaned, new grease ")
  65. assert response.status_code == 200, response.text
  66. log = await _log(async_client, printer.id)
  67. assert log["total"] == 1
  68. entry = log["items"][0]
  69. assert entry["printer_id"] == printer.id
  70. assert entry["printer_name"] == "Log Printer"
  71. assert entry["maintenance_type_id"] == item["maintenance_type_id"]
  72. assert entry["maintenance_type_name"] == item["maintenance_type_name"]
  73. assert entry["notes"] == "Rails cleaned, new grease"
  74. assert entry["performed_at"] is not None
  75. # Authentication is off: nobody to name.
  76. assert entry["performed_by_id"] is None
  77. assert entry["performed_by_username"] is None
  78. async def test_the_comment_is_optional_and_blank_is_none(self, async_client, printer_factory):
  79. printer = await printer_factory(name="No Comment Printer")
  80. item = await _first_item(async_client, printer.id)
  81. assert (await _perform(async_client, item["id"])).status_code == 200
  82. assert (await _perform(async_client, item["id"], " ")).status_code == 200
  83. notes = [e["notes"] for e in (await _log(async_client, printer.id))["items"]]
  84. assert notes == [None, None]
  85. async def test_a_comment_over_the_limit_is_refused(self, async_client, printer_factory):
  86. printer = await printer_factory(name="Long Comment Printer")
  87. item = await _first_item(async_client, printer.id)
  88. response = await _perform(async_client, item["id"], "x" * 10001)
  89. assert response.status_code == 422
  90. assert (await _log(async_client, printer.id))["total"] == 0
  91. async def test_a_long_report_fits(self, async_client, printer_factory):
  92. """Automations post whole reports; the endpoint took any length before."""
  93. printer = await printer_factory(name="Report Printer")
  94. item = await _first_item(async_client, printer.id)
  95. response = await _perform(async_client, item["id"], "x" * 10000)
  96. assert response.status_code == 200, response.text
  97. assert len((await _log(async_client, printer.id))["items"][0]["notes"]) == 10000
  98. async def test_surrounding_whitespace_does_not_count_against_the_limit(self, async_client, printer_factory):
  99. printer = await printer_factory(name="Padded Printer")
  100. item = await _first_item(async_client, printer.id)
  101. response = await _perform(async_client, item["id"], "x" * 9995 + " " * 20 + "\n")
  102. assert response.status_code == 200, response.text
  103. assert (await _log(async_client, printer.id))["items"][0]["notes"] == "x" * 9995
  104. async def test_the_log_is_newest_first_and_paged(self, async_client, printer_factory):
  105. printer = await printer_factory(name="Paged Printer")
  106. item = await _first_item(async_client, printer.id)
  107. for n in range(3):
  108. await _perform(async_client, item["id"], f"reset {n}")
  109. first = await _log(async_client, printer.id, limit=2)
  110. rest = await _log(async_client, printer.id, limit=2, offset=2)
  111. assert first["total"] == rest["total"] == 3
  112. assert [e["notes"] for e in first["items"]] == ["reset 2", "reset 1"]
  113. assert [e["notes"] for e in rest["items"]] == ["reset 0"]
  114. async def test_another_printer_s_resets_are_not_in_its_log(self, async_client, printer_factory):
  115. mine, other = await printer_factory(name="Mine"), await printer_factory(name="Other")
  116. await _perform(async_client, (await _first_item(async_client, other.id))["id"], "other's")
  117. assert (await _log(async_client, mine.id))["total"] == 0
  118. async def test_the_log_of_an_unknown_printer_is_not_found(self, async_client):
  119. response = await async_client.get(f"{BASE}/printers/999999/log")
  120. assert response.status_code == 404
  121. class TestOutlivingDeletes:
  122. async def test_entries_outlive_their_printer(self, async_client, printer_factory, db_session):
  123. printer = await printer_factory(name="Doomed Printer")
  124. await _perform(async_client, (await _first_item(async_client, printer.id))["id"], "before the end")
  125. entry_id = (await _log(async_client, printer.id))["items"][0]["id"]
  126. deleted = await async_client.delete(f"/api/v1/printers/{printer.id}")
  127. assert deleted.status_code == 200, deleted.text
  128. entry = await _entry(db_session, entry_id)
  129. assert entry.printer_id is None
  130. assert entry.printer_name == "Doomed Printer"
  131. assert entry.notes == "before the end"
  132. rows = _csv_rows(await async_client.get(f"{BASE}/log/export"))
  133. assert ["Doomed Printer", "before the end"] in [[r[1], r[5]] for r in rows[1:]]
  134. async def test_entries_outlive_a_deleted_custom_task(self, async_client, printer_factory, db_session):
  135. printer_id = (await printer_factory(name="Custom Task Printer")).id
  136. task = (
  137. await async_client.post(
  138. f"{BASE}/types",
  139. json={"name": "Replace Hotend", "default_interval_hours": 500, "interval_type": "hours"},
  140. )
  141. ).json()
  142. item = (await async_client.post(f"{BASE}/printers/{printer_id}/assign/{task['id']}")).json()
  143. await _perform(async_client, item["id"], "0.4 mm hardened")
  144. entry_id = (await _log(async_client, printer_id))["items"][0]["id"]
  145. assert (await async_client.delete(f"{BASE}/types/{task['id']}")).status_code == 200
  146. entry = await _entry(db_session, entry_id)
  147. assert entry.maintenance_type_id is None
  148. assert entry.maintenance_type_name == "Replace Hotend"
  149. assert (await _log(async_client, printer_id))["total"] == 1
  150. class TestExport:
  151. async def test_a_printer_s_log_exports_as_csv(self, async_client, printer_factory):
  152. printer = await printer_factory(name="Drucker Übung")
  153. item = await _first_item(async_client, printer.id)
  154. await _perform(async_client, item["id"], "Düse gewechselt")
  155. response = await async_client.get(f"{BASE}/printers/{printer.id}/log/export")
  156. rows = _csv_rows(response)
  157. assert rows[0] == ["Performed at (UTC)", "Printer", "Task", "Performed by", "Print hours", "Comment"]
  158. assert len(rows) == 2
  159. performed_at, name, task, by, hours, comment = rows[1]
  160. assert performed_at.endswith("Z")
  161. assert (name, task, by, comment) == ("Drucker Übung", item["maintenance_type_name"], "", "Düse gewechselt")
  162. assert float(hours) == pytest.approx(0.0)
  163. assert "maintenance_log_Drucker" in response.headers["content-disposition"]
  164. async def test_a_formula_in_a_comment_stays_text(self, async_client, printer_factory):
  165. printer = await printer_factory(name="Formula Printer")
  166. await _perform(async_client, (await _first_item(async_client, printer.id))["id"], '=HYPERLINK("x")')
  167. rows = _csv_rows(await async_client.get(f"{BASE}/printers/{printer.id}/log/export"))
  168. assert rows[1][5] == '\'=HYPERLINK("x")'
  169. async def test_the_fleet_export_has_every_printer(self, async_client, printer_factory):
  170. a, b = await printer_factory(name="Fleet A"), await printer_factory(name="Fleet B")
  171. for printer in (a, b):
  172. await _perform(async_client, (await _first_item(async_client, printer.id))["id"], printer.name)
  173. rows = _csv_rows(await async_client.get(f"{BASE}/log/export"))
  174. assert {r[1] for r in rows[1:]} >= {"Fleet A", "Fleet B"}
  175. class TestCleanup:
  176. async def test_a_printer_s_old_entries_go_with_their_history(self, async_client, printer_factory, db_session):
  177. printer_id, (old, recent, _today) = await _logged(
  178. async_client, printer_factory, "Cleanup", "old", "recent", "today"
  179. )
  180. other_id, (other_old,) = await _logged(async_client, printer_factory, "Cleanup Other", "other old")
  181. old_history = await _age(db_session, old, 400)
  182. recent_history = await _age(db_session, recent, 10)
  183. other_history = await _age(db_session, other_old, 400)
  184. response = await async_client.delete(f"{BASE}/printers/{printer_id}/log", params={"older_than_days": 30})
  185. assert response.status_code == 200, response.text
  186. assert response.json() == {"deleted": 1}
  187. assert [e["notes"] for e in (await _log(async_client, printer_id))["items"]] == ["today", "recent"]
  188. assert not await _history_exists(db_session, old_history)
  189. assert await _history_exists(db_session, recent_history)
  190. # Another printer's entries are not touched.
  191. assert (await _log(async_client, other_id))["total"] == 1
  192. assert await _history_exists(db_session, other_history)
  193. async def test_the_age_must_be_given_and_at_least_a_day(self, async_client, printer_factory):
  194. printer_id, _ = await _logged(async_client, printer_factory, "Cleanup Age", "kept")
  195. for params in ({}, {"older_than_days": 0}, {"older_than_days": -5}):
  196. assert (await async_client.delete(f"{BASE}/printers/{printer_id}/log", params=params)).status_code == 422
  197. assert (await async_client.delete(f"{BASE}/log", params=params)).status_code == 422
  198. assert (await _log(async_client, printer_id))["total"] == 1
  199. async def test_cleaning_up_an_unknown_printer_is_not_found(self, async_client):
  200. response = await async_client.delete(f"{BASE}/printers/999999/log", params={"older_than_days": 1})
  201. assert response.status_code == 404
  202. async def test_the_fleet_cleanup_covers_every_printer_and_deleted_ones(
  203. self, async_client, printer_factory, db_session
  204. ):
  205. a_id, (a_old, a_new) = await _logged(async_client, printer_factory, "Fleet Clean A", "a old", "a new")
  206. b_id, (b_old,) = await _logged(async_client, printer_factory, "Fleet Clean B", "b old")
  207. gone_id, (gone_old,) = await _logged(async_client, printer_factory, "Fleet Clean Gone", "gone old")
  208. for entry_id in (a_old, b_old, gone_old):
  209. await _age(db_session, entry_id, 100)
  210. assert (await async_client.delete(f"/api/v1/printers/{gone_id}")).status_code == 200
  211. response = await async_client.delete(f"{BASE}/log", params={"older_than_days": 30})
  212. assert response.status_code == 200, response.text
  213. assert response.json() == {"deleted": 3}
  214. assert [e["id"] for e in (await _log(async_client, a_id))["items"]] == [a_new]
  215. assert (await _log(async_client, b_id))["total"] == 0
  216. db_session.expire_all()
  217. assert await db_session.get(MaintenanceLogEntry, gone_old) is None
  218. async def test_one_entry_goes_with_its_history_and_the_reset_stays(self, async_client, printer_factory, db_session):
  219. printer_id, (kept, mistaken) = await _logged(async_client, printer_factory, "Mistake", "kept", "by mistake")
  220. history_id = (await _entry(db_session, mistaken)).history_id
  221. before = await _first_item(async_client, printer_id)
  222. response = await async_client.delete(f"{BASE}/log/{mistaken}")
  223. assert response.status_code == 200, response.text
  224. assert [e["id"] for e in (await _log(async_client, printer_id))["items"]] == [kept]
  225. assert history_id is not None
  226. assert not await _history_exists(db_session, history_id)
  227. # Deleting the entry does not undo the reset.
  228. assert (await _first_item(async_client, printer_id))["last_performed_at"] == before["last_performed_at"]
  229. async def test_an_entry_whose_history_is_gone_leaves_a_later_reset_s_history_alone(
  230. self, async_client, printer_factory, db_session
  231. ):
  232. # The deleted printer's history row had the highest id, so on SQLite the
  233. # next reset is given it. Deleting the old entry must not take that
  234. # reset's history with it.
  235. doomed = (await printer_factory(name="Doomed")).id
  236. await _perform(async_client, (await _first_item(async_client, doomed))["id"], "before the end")
  237. old_entry = (await _log(async_client, doomed))["items"][0]["id"]
  238. old_history = (await _entry(db_session, old_entry)).history_id
  239. assert (await async_client.delete(f"/api/v1/printers/{doomed}")).status_code == 200
  240. assert (await _entry(db_session, old_entry)).history_id is None
  241. survivor_id, (new_entry,) = await _logged(async_client, printer_factory, "Survivor", "after")
  242. new_history = (await _entry(db_session, new_entry)).history_id
  243. assert new_history is not None
  244. assert (await async_client.delete(f"{BASE}/log/{old_entry}")).status_code == 200
  245. assert await _history_exists(db_session, new_history)
  246. assert (await _log(async_client, survivor_id))["total"] == 1
  247. if db_session.bind.dialect.name == "sqlite":
  248. # The case this is about: SQLite gave the later reset the freed id.
  249. # PostgreSQL never reuses one, so there it can only pass.
  250. assert new_history == old_history
  251. async def test_deleting_an_unknown_entry_is_not_found(self, async_client):
  252. assert (await async_client.delete(f"{BASE}/log/999999")).status_code == 404
  253. class TestWithAuthentication:
  254. PERMISSIONS = ["maintenance:read", "maintenance:update", "printers:read"]
  255. async def test_the_log_names_who_reset(self, async_client, printer_factory):
  256. printer = await printer_factory(name="Auth Printer")
  257. admin = await _admin_token(async_client)
  258. jwt, user_id = await _user(async_client, admin, "mechanic", self.PERMISSIONS)
  259. overview = (await async_client.get(f"{BASE}/printers/{printer.id}", headers=_auth(jwt))).json()
  260. item = overview["maintenance_items"][0]
  261. response = await _perform(async_client, item["id"], "done", headers=_auth(jwt))
  262. assert response.status_code == 200, response.text
  263. entry = (await _log(async_client, printer.id, headers=_auth(jwt)))["items"][0]
  264. assert (entry["performed_by_id"], entry["performed_by_username"]) == (user_id, "mechanic")
  265. rows = _csv_rows(await async_client.get(f"{BASE}/printers/{printer.id}/log/export", headers=_auth(jwt)))
  266. assert rows[1][3] == "mechanic"
  267. async def test_a_scoped_user_exports_only_their_printers(self, async_client, printer_factory):
  268. mine, theirs, gone = (
  269. await printer_factory(name="Scoped Mine"),
  270. await printer_factory(name="Scoped Theirs"),
  271. await printer_factory(name="Scoped Gone"),
  272. )
  273. for printer in (mine, theirs, gone):
  274. await _perform(async_client, (await _first_item(async_client, printer.id))["id"], printer.name)
  275. assert (await async_client.delete(f"/api/v1/printers/{gone.id}")).status_code == 200
  276. admin = await _admin_token(async_client)
  277. jwt, _ = await _user(async_client, admin, "scoped", self.PERMISSIONS, printer_ids=[mine.id])
  278. rows = _csv_rows(await async_client.get(f"{BASE}/log/export", headers=_auth(jwt)))
  279. admin_rows = _csv_rows(await async_client.get(f"{BASE}/log/export", headers=_auth(admin)))
  280. assert [r[1] for r in rows[1:]] == ["Scoped Mine"]
  281. assert {"Scoped Mine", "Scoped Theirs", "Scoped Gone"} <= {r[1] for r in admin_rows[1:]}
  282. async def test_a_scoped_user_cannot_read_another_printer_s_log(self, async_client, printer_factory):
  283. mine, theirs = await printer_factory(name="Scope A"), await printer_factory(name="Scope B")
  284. admin = await _admin_token(async_client)
  285. jwt, _ = await _user(async_client, admin, "scoped_reader", self.PERMISSIONS, printer_ids=[mine.id])
  286. log = await async_client.get(f"{BASE}/printers/{theirs.id}/log", headers=_auth(jwt))
  287. export = await async_client.get(f"{BASE}/printers/{theirs.id}/log/export", headers=_auth(jwt))
  288. assert log.status_code in (403, 404)
  289. assert export.status_code in (403, 404)
  290. async def test_cleanup_needs_the_delete_permission(self, async_client, printer_factory):
  291. printer_id, (entry_id,) = await _logged(async_client, printer_factory, "No Delete", "kept")
  292. admin = await _admin_token(async_client)
  293. jwt, _ = await _user(async_client, admin, "no_delete", self.PERMISSIONS)
  294. for path, params in (
  295. (f"{BASE}/printers/{printer_id}/log", {"older_than_days": 1}),
  296. (f"{BASE}/log", {"older_than_days": 1}),
  297. (f"{BASE}/log/{entry_id}", {}),
  298. ):
  299. response = await async_client.delete(path, params=params, headers=_auth(jwt))
  300. assert response.status_code == 403, (path, response.text)
  301. assert (await _log(async_client, printer_id, headers=_auth(admin)))["total"] == 1
  302. async def test_a_scoped_user_cleans_up_only_their_printers(self, async_client, printer_factory, db_session):
  303. mine, (mine_old,) = await _logged(async_client, printer_factory, "Clean Mine", "mine")
  304. theirs, (theirs_old,) = await _logged(async_client, printer_factory, "Clean Theirs", "theirs")
  305. gone, (gone_old,) = await _logged(async_client, printer_factory, "Clean Gone", "gone")
  306. for entry_id in (mine_old, theirs_old, gone_old):
  307. await _age(db_session, entry_id, 100)
  308. assert (await async_client.delete(f"/api/v1/printers/{gone}")).status_code == 200
  309. admin = await _admin_token(async_client)
  310. jwt, _ = await _user(
  311. async_client, admin, "scoped_cleaner", [*self.PERMISSIONS, "maintenance:delete"], printer_ids=[mine]
  312. )
  313. fleet = await async_client.delete(f"{BASE}/log", params={"older_than_days": 30}, headers=_auth(jwt))
  314. other_printer = await async_client.delete(
  315. f"{BASE}/printers/{theirs}/log", params={"older_than_days": 30}, headers=_auth(jwt)
  316. )
  317. other_entry = await async_client.delete(f"{BASE}/log/{theirs_old}", headers=_auth(jwt))
  318. deleted_printer_entry = await async_client.delete(f"{BASE}/log/{gone_old}", headers=_auth(jwt))
  319. assert fleet.status_code == 200, fleet.text
  320. assert fleet.json() == {"deleted": 1}
  321. assert other_printer.status_code in (403, 404)
  322. assert other_entry.status_code == 404
  323. assert deleted_printer_entry.status_code == 404
  324. db_session.expire_all()
  325. assert await db_session.get(MaintenanceLogEntry, mine_old) is None
  326. assert await db_session.get(MaintenanceLogEntry, theirs_old) is not None
  327. assert await db_session.get(MaintenanceLogEntry, gone_old) is not None