import copy import importlib import io import os import sys import unittest from contextlib import contextmanager from datetime import datetime, timezone from pathlib import Path from types import SimpleNamespace from unittest.mock import patch from fastapi import FastAPI, Request from fastapi.responses import HTMLResponse from fastapi.testclient import TestClient from openpyxl import load_workbook from pydantic import ValidationError from starlette.middleware.sessions import SessionMiddleware from asset_fixtures import prop, report_xml from app.modules.asset.db import AssetStore, FIELDS, filters from app.modules.asset.hwinfo import MAX_REPORT_BYTES, parse_hwinfo from app.modules.asset.store import ActionInput, AssetConflict, AssetInput, AssetUpdate, transition api = importlib.import_module("app.modules.asset.router") class ParserTests(unittest.TestCase): def test_korean_and_english(self): for english in (False, True): p = parse_hwinfo(report_xml(english)) s = p["summary"] self.assertEqual((s["cpu"], s["memory"], s["cores"], s["threads"]), ("Test Processor", "32 GiB", "8", "16")) self.assertEqual(s["serial"], "") self.assertEqual(p["scan_time"], "2026-10-06T01:10") self.assertEqual(s["drive_count"], 2) self.assertEqual(len(p["devices"]["MEMORY"]), 2) self.assertNotEqual(p["devices"]["DRIVES"][0]["properties"], p["devices"]["DRIVES"][1]["properties"]) def test_actual_sample(self): path = Path(os.getenv("ASSET_SAMPLE_XML") or Path(__file__).resolve().parents[1] / "KING-DESKTOP.XML") if not path.exists(): self.skipTest("Real report is not present; synthetic tests still run") p = parse_hwinfo(path.read_bytes()) s = p["summary"] self.assertEqual(s["computer_name"], "KING-DESKTOP") self.assertEqual(s["cpu"], "AMD Ryzen 7 5800X") self.assertEqual(s["memory"], "32 GiB") self.assertEqual((s["drive_count"], s["monitor_count"]), (4, 3)) self.assertEqual(s["gpu"], "NVIDIA GeForce RTX 4060 Ti") self.assertEqual(len(p["devices"]["MEMORY"]), 2) self.assertGreater(p["property_count"], 3000) self.assertEqual(s["serial"], "") def test_dtd_is_never_fetched(self): xml = report_xml().replace(b'HWiNFO32log.dtd', b'file:///does-not-exist.dtd') self.assertEqual(parse_hwinfo(xml)["summary"]["computer_name"], "TEST-PC") def test_entities_rejected_in_utf8_and_utf16(self): attacks = [']>', ']>'] for declaration in attacks: text = declaration + '&x;' for raw in (text.encode(), ('' + text).encode("utf-16")): with self.assertRaises(ValueError): parse_hwinfo(raw) def test_bad_input(self): for raw in (b"", b"", b"", b"", b"X", b"x" * (MAX_REPORT_BYTES + 1)): with self.assertRaises(ValueError): parse_hwinfo(raw) def test_deep_tree_rejected(self): raw = b'X' + b'' * 70 + b'' * 70 + b'' with self.assertRaises(ValueError): parse_hwinfo(raw) def test_properties_preserve_blank_labels_unicode_and_html_as_text(self): xml = report_xml().replace(b'', (prop("", "<script>bad</script>") + '').encode()) p = parse_hwinfo(xml) properties = [p for s in p["sections"] for n in s["nodes"] for p in n["properties"]] self.assertIn({"label": "", "value": "", "type": ""}, properties) class RuleTests(unittest.TestCase): def test_invalid_category_cost_dates_extra(self): for values in ({"category": "unknown"}, {"purchase_cost": -1}, {"purchased_on": "2026-10-06", "warranty_until": "2026-01-01"}, {"status": "in_use"}, {"name": " "}, {"purchase_cost": "nan"}): with self.assertRaises(ValidationError): AssetInput.model_validate({"name": "Asset", "category": "desk", **values}) def test_required_reason(self): for action in ("lost", "retired"): with self.assertRaises(ValidationError): ActionInput(version=1, action=action) def test_lifecycle_and_assignment(self): a = {"status": "available", "assignee_email": ""} self.assertEqual(transition(a, ActionInput(version=1, action="checkout", assignee_email="Reader@Test.Local")), ("in_use", "reader@test.local")) a.update(status="in_use", assignee_email="reader@test.local") self.assertEqual(transition(a, ActionInput(version=1, action="lost", note="lost")), ("lost", "reader@test.local")) for action in ("maintenance", "retired", "checkout", "available"): with self.assertRaises(ValueError): transition(a, ActionInput(version=1, action=action, note="test", assignee_email="other@test.local")) self.assertEqual(transition(a, ActionInput(version=1, action="checkin")), ("available", "")) def test_search_parameterized_and_group(self): clause, params = filters(q="100%_\\'", group="furniture", location="HQ", warranty=True) self.assertNotIn("100%", clause) self.assertEqual(params[0], "%100\\%\\_\\\\'%") self.assertIn("IN ('desk','chair','furniture')", clause) self.assertIn("Asia/Seoul", clause) class Rows: def __init__(self, row=None): self.row = row def fetchone(self): return self.row class Connection: """Transaction model verifies rollback, versions and lock-before-write in actual store methods.""" def __init__(self): self.assets, self.reports, self.events, self.calls = {}, {}, [], [] self.in_tx, self.locked, self.fail_event, self.sequence = False, set(), False, 0 @contextmanager def transaction(self): before = copy.deepcopy((self.assets, self.reports, self.events)) self.in_tx = True; self.locked = set() try: yield self except Exception: self.assets, self.reports, self.events = before raise finally: self.in_tx = False def execute(self, sql, params=()): self.calls.append((sql, params)) if sql.startswith("SELECT nextval"): self.sequence += 1; return Rows({"n": self.sequence}) if sql.startswith("SELECT * FROM assets"): self.assert_tx() assert "FOR UPDATE" in sql self.locked.add(params[0]); return Rows(copy.deepcopy(self.assets.get(params[0]))) if sql.startswith("INSERT INTO assets"): self.assert_tx() row = dict(zip(("id", *FIELDS), params)) row.update(status="available", assignee_email="", version=1, latest_report_id=None) self.assets[row["id"]] = row; self.locked.add(row["id"]); return Rows() if sql.startswith("SELECT id FROM asset_reports"): return Rows(next((r for r in self.reports.values() if r["asset_id"] == params[0] and r["sha256"] == params[1]), None)) if sql.startswith("INSERT INTO asset_reports"): self.assert_tx(); assert params[1] in self.locked self.reports[params[0]] = dict(zip(("id", "asset_id", "filename", "sha256", "raw_xml", "parsed", "actor"), params)); return Rows() if sql.startswith("UPDATE assets SET latest_report_id"): self.assert_tx(); assert params[-1] in self.locked self.assets[params[-1]]["latest_report_id"] = params[0]; self.assets[params[-1]]["version"] += 1; return Rows() if sql.startswith("UPDATE assets SET status="): self.assert_tx(); assert params[-1] in self.locked self.assets[params[-1]].update(zip(("status", "assignee_email", "location"), params[:3])) self.assets[params[-1]]["version"] += 1; return Rows() if sql.startswith("UPDATE assets SET tag="): self.assert_tx(); assert params[-1] in self.locked self.assets[params[-1]].update(zip(FIELDS, params[:-1])); self.assets[params[-1]]["version"] += 1; return Rows() if sql.startswith("INSERT INTO asset_events"): self.assert_tx(); assert params[0] in self.locked if self.fail_event: raise RuntimeError("event write failed") self.events.append(params); return Rows() raise AssertionError(sql) def assert_tx(self): assert self.in_tx class Pool: def __init__(self, conn): self.conn = conn @contextmanager def connection(self): yield self.conn class TransactionTests(unittest.TestCase): def setUp(self): self.conn = Connection(); self.store = object.__new__(AssetStore); self.store._pool = Pool(self.conn) self.payload = AssetInput(name="Computer", category="computer", location="HQ") self.raw = report_xml(); self.parsed = parse_hwinfo(self.raw) self.asset_id = self.store.create(self.payload, "actor@test.local") def test_create_auto_tag_and_log(self): self.assertEqual(self.conn.assets[self.asset_id]["tag"], "AST-000001") self.assertEqual(self.conn.events[0][2], "create") def test_stale_version_no_writes(self): before = copy.deepcopy(self.conn.assets) with self.assertRaises(AssetConflict): self.store.action(self.asset_id, ActionInput(version=9, action="checkout", assignee_email="user@test.local"), "actor") self.assertEqual(before, self.conn.assets) def test_checkout_checkin_atomic_and_log(self): self.store.action(self.asset_id, ActionInput(version=1, action="checkout", assignee_email="user@test.local", location="Desk"), "actor") a = self.conn.assets[self.asset_id] self.assertEqual((a["status"], a["version"], a["location"]), ("in_use", 2, "Desk")) self.store.action(self.asset_id, ActionInput(version=2, action="checkin"), "actor") self.assertEqual(a["assignee_email"], "") self.assertEqual(len(self.conn.events), 3) def test_event_failure_rolls_back_action(self): self.conn.fail_event = True with self.assertRaises(RuntimeError): self.store.action(self.asset_id, ActionInput(version=1, action="maintenance"), "actor") self.assertEqual(self.conn.assets[self.asset_id]["status"], "available") self.assertEqual(self.conn.assets[self.asset_id]["version"], 1) def test_report_preserves_manual_data_and_old_versions(self): first = self.store.attach_report(self.asset_id, 1, "actor", "first.xml", self.raw, self.parsed) raw = self.raw.replace(b"Test Processor", b"Updated Processor") second = self.store.attach_report(self.asset_id, 2, "actor", "second.xml", raw, parse_hwinfo(raw)) a = self.conn.assets[self.asset_id] self.assertEqual((a["name"], a["location"], a["latest_report_id"], a["version"]), ("Computer", "HQ", second, 3)) self.assertIn(first, self.conn.reports) self.assertEqual(len(self.conn.reports), 2) def test_duplicate_report_no_version_increment(self): self.store.attach_report(self.asset_id, 1, "actor", "x.xml", self.raw, self.parsed) with self.assertRaises(AssetConflict): self.store.attach_report(self.asset_id, 2, "actor", "x.xml", self.raw, self.parsed) self.assertEqual(self.conn.assets[self.asset_id]["version"], 2) def test_report_and_asset_roll_back_when_log_fails(self): self.conn.fail_event = True with self.assertRaises(RuntimeError): self.store.attach_report(self.asset_id, 1, "actor", "x.xml", self.raw, self.parsed) self.assertFalse(self.conn.reports) self.assertIsNone(self.conn.assets[self.asset_id]["latest_report_id"]) with self.assertRaises(RuntimeError): self.store.create(self.payload, "actor", ("x.xml", self.raw, self.parsed)) self.assertEqual(len(self.conn.assets), 1) def test_category_cannot_detach_existing_reports(self): self.store.attach_report(self.asset_id, 1, "actor", "x.xml", self.raw, self.parsed) with self.assertRaises(ValueError): self.store.update(self.asset_id, AssetUpdate(name="Desk", category="desk", version=2), "actor") self.assertEqual(self.conn.assets[self.asset_id]["category"], "computer") def test_update_keeps_assignment(self): self.store.action(self.asset_id, ActionInput(version=1, action="checkout", assignee_email="user@test.local"), "actor") self.store.update(self.asset_id, AssetUpdate(name="Renamed", category="computer", version=2), "actor") a = self.conn.assets[self.asset_id] self.assertEqual((a["name"], a["status"], a["assignee_email"], a["tag"]), ("Renamed", "in_use", "user@test.local", "AST-000001")) class APITests(unittest.TestCase): def test_delete_requires_true_super_admin_csrf_reason_and_version(self): calls=[] self.app.state.asset_store=SimpleNamespace(delete=lambda *args: calls.append(args)) payload={"version":1,"note":"Duplicate entry"} for user in ({"email":"admin@test.local","role":"admin","is_super_admin":True},self.user): self.user=user self.assertEqual(self.client.request("DELETE","/asset/api/assets/a",json=payload,headers=self.headers).status_code,403) from app.store import SUPER_ADMIN_EMAIL self.user={"email":SUPER_ADMIN_EMAIL,"role":"admin","is_super_admin":True} self.assertEqual(self.client.request("DELETE","/asset/api/assets/a",json=payload).status_code,403) self.assertEqual(self.client.request("DELETE","/asset/api/assets/a",json={"version":1,"note":" "},headers=self.headers).status_code,422) self.assertEqual(self.client.request("DELETE","/asset/api/assets/a",json=payload,headers=self.headers).status_code,200) self.assertEqual(calls,[("a",1,SUPER_ADMIN_EMAIL,"Duplicate entry")]) def test_photos_validated_authorized_and_bound_to_asset(self): from PIL import Image image=io.BytesIO();Image.new("RGB",(10,20),"blue").save(image,"PNG") calls=[] self.app.state.asset_store=SimpleNamespace(add_photo=lambda *args: calls.append(args) or "p",photo=lambda *args: {"image":image.getvalue(),"mime":"image/png"}) path="/asset/api/assets/a/photos" self.assertEqual(self.client.post(path,files={"file":("fake.jpg",b"")},data={"version":1},headers=self.headers).status_code,422) self.assertEqual(self.client.post(path,files={"file":("photo.png",image.getvalue())},data={"version":1}).status_code,403) result=self.client.post(path,files={"file":("photo.png",image.getvalue())},data={"version":1},headers=self.headers) self.assertEqual(result.status_code,200);self.assertEqual(calls[0][:4],("a",1,self.user["email"],"photo.png")) self.assertEqual(self.client.get(path+"/p").headers["content-type"],"image/png") self.user=None self.assertEqual(self.client.get(path+"/p").status_code,401) def test_monitor_registration_permission_payload_and_version(self): calls=[] self.app.state.asset_store=SimpleNamespace(register_monitor=lambda *args:calls.append(args) or "monitor") path="/asset/api/assets/pc/monitors/0" data={"version":3,"report_id":"r","asset":{"name":"Display","category":"monitor"}} self.assertEqual(self.client.post(path,json=data).status_code,403) self.assertEqual(self.client.post(path,json=data,headers=self.headers).status_code,200) self.assertEqual((calls[0][0],calls[0][1],calls[0][2].version),("pc",0,3)) data["asset"]["category"]="desk" self.assertEqual(self.client.post(path,json=data,headers=self.headers).status_code,422) def setUp(self): self.user = {"email": "reader@test.local", "name": "Reader", "role": "user", "modules": {"asset": True}} self.user_store = SimpleNamespace(get=lambda email: self.user if email == self.user["email"] else None, list_all=lambda: [self.user]) self.main = SimpleNamespace(get_current_user_record=lambda req: self.user, user_store=self.user_store, render_template=lambda *a, **kw: HTMLResponse("page", status_code=kw.get("status_code", 200)), build_erp_nav=lambda *a, **kw: []) self.patch = patch.dict(sys.modules, {"app.main": self.main}); self.patch.start(); self.addCleanup(self.patch.stop) self.app = FastAPI(); self.app.add_middleware(SessionMiddleware, secret_key="test-only-secret") self.app.state.asset_store = None; self.app.include_router(api.router) @self.app.get("/test-session") def session(request: Request): request.session["asset_csrf"] = "test-token"; return {"ok": True} self.client = TestClient(self.app) self.client.get("/test-session"); self.headers = {"X-Asset-CSRF": "test-token"} def test_login_and_permission_required_every_read(self): paths = ["/asset/health", "/asset/api/bootstrap", "/asset/api/assets", "/asset/api/assets/a", "/asset/api/export", "/asset/api/assets/a/reports/r", "/asset/api/assets/a/reports/r/download", "/asset/api/assets/a/photos/p", "/asset/api/assets/a/reports/r/monitors"] self.user = None for path in paths: self.assertEqual(self.client.get(path).status_code, 401) self.user = {"role": "user", "email": "x", "modules": {}} for path in paths: self.assertEqual(self.client.get(path).status_code, 403) def test_missing_csrf_and_no_db(self): payload = {"name": "Desk", "category": "desk"} self.assertEqual(self.client.post("/asset/api/assets", json=payload).status_code, 403) self.assertEqual(self.client.post("/asset/api/assets", json=payload, headers=self.headers).status_code, 503) self.assertEqual(self.client.get("/asset/api/assets").status_code, 503) def test_preview_without_database(self): result = self.client.post("/asset/api/reports/preview", files={"file": ("test.xml", report_xml())}, headers=self.headers) self.assertEqual(result.status_code, 200, result.text) self.assertEqual(result.json()["summary"]["memory"], "32 GiB") def test_preview_security(self): for filename, raw in (("x.html", report_xml()), ("x.xml", b"")): self.assertEqual(self.client.post("/asset/api/reports/preview", files={"file": (filename, raw)}, headers=self.headers).status_code, 422) self.assertEqual(self.client.post("/asset/api/reports/preview", files={"file": ("test.xml", report_xml())}).status_code, 403) def test_import_stores_asset_and_report_together(self): conn = Connection() store = object.__new__(AssetStore) store._pool = Pool(conn) self.app.state.asset_store = store result = self.client.post("/asset/api/reports/import", data={"payload": '{"name":"Imported PC","category":"computer","location":"HQ"}'}, files={"file": ("report.xml", report_xml())}, headers=self.headers) self.assertEqual(result.status_code, 200, result.text) asset = conn.assets[result.json()["id"]] self.assertEqual((asset["name"], asset["location"], asset["version"]), ("Imported PC", "HQ", 2)) self.assertIn(asset["latest_report_id"], conn.reports) self.assertEqual(len(conn.events), 2) def test_upload_existing_validates_target_and_version(self): conn = Connection() store = object.__new__(AssetStore) store._pool = Pool(conn) self.app.state.asset_store = store asset_id = store.create(AssetInput(name="Desk", category="desk"), "actor") result = self.client.post(f"/asset/api/assets/{asset_id}/reports", data={"version": "1"}, files={"file": ("report.xml", report_xml())}, headers=self.headers) self.assertEqual(result.status_code, 422) asset_id = store.create(AssetInput(name="PC", category="computer"), "actor") result = self.client.post(f"/asset/api/assets/{asset_id}/reports", data={"version": "99"}, files={"file": ("report.xml", report_xml())}, headers=self.headers) self.assertEqual(result.status_code, 409) self.assertFalse(conn.reports) def test_unknown_assignment_rejected(self): result = self.client.post("/asset/api/assets/a/actions", json={"version": 1, "action": "checkout", "assignee_email": "outsider@test.local"}, headers=self.headers) self.assertEqual(result.status_code, 422) def test_conflict_and_missing_entity(self): def conflict(*args): raise AssetConflict("conflict") self.app.state.asset_store = SimpleNamespace(update=conflict) self.assertEqual(self.client.put("/asset/api/assets/a", json={"name": "Asset", "category": "desk", "version": 1}, headers=self.headers).status_code, 409) def missing(*args): raise KeyError("no") self.app.state.asset_store = SimpleNamespace(detail=missing) self.assertEqual(self.client.get("/asset/api/assets/a").status_code, 404) def test_export_literal_formulas_and_filters(self): record = {**AssetInput(name="=2+2", category="desk", purchase_cost=0).model_dump(mode="json"), "status": "available", "assignee_email": "", "specs": {}} seen = [] def listing(**kwargs): seen.append(kwargs); return {"items": [record], "total": 1} self.app.state.asset_store = SimpleNamespace(list_assets=listing) response = self.client.get("/asset/api/export?group=furniture&location=HQ") self.assertEqual(response.status_code, 200) book = load_workbook(io.BytesIO(response.content)); cell = book.active["B2"] self.assertEqual((cell.value, cell.data_type), ("=2+2", "s")) self.assertEqual(book.active["L2"].value, 0) self.assertEqual((seen[0]["group"], seen[0]["location"]), ("furniture", "HQ")) def test_download_bound_to_asset_and_attachment(self): args = [] def report(*values, **kwargs): args.append((values, kwargs)); return {"filename": "테스트.xml", "raw_xml": report_xml()} self.app.state.asset_store = SimpleNamespace(report=report) response = self.client.get("/asset/api/assets/own/reports/report/download") self.assertEqual(response.content, report_xml()) self.assertIn("attachment", response.headers["content-disposition"]) self.assertEqual(args[0], (("own", "report"), {"raw": True})) if __name__ == "__main__": unittest.main()