Files
king b576dd1a38 feat(asset): add photos, monitor links and deletion
Apply asset_db_002_photos_monitors.sql before rebuilding web.

Restrict soft deletion to the super admin; retain reports and audit.
2026-10-06 02:29:19 +09:00

389 lines
22 KiB
Python

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 = ['<!DOCTYPE HWINFO [<!ENTITY x SYSTEM "file:///private">]>', '<!DOCTYPE HWINFO [<!ENTITY x "secret">]>']
for declaration in attacks:
text = declaration + '<HWINFO><COMPUTER><NodeName>&x;</NodeName></COMPUTER></HWINFO>'
for raw in (text.encode(), ('<?xml version="1.0" encoding="UTF-16"?>' + text).encode("utf-16")):
with self.assertRaises(ValueError):
parse_hwinfo(raw)
def test_bad_input(self):
for raw in (b"", b"<broken>", b"<html/>", b"<HWINFO><COMPUTER/><COMPUTER/></HWINFO>", b"<HWINFO><COMPUTER><NodeName>X</NodeName></COMPUTER></HWINFO>", b"x" * (MAX_REPORT_BYTES + 1)):
with self.assertRaises(ValueError):
parse_hwinfo(raw)
def test_deep_tree_rejected(self):
raw = b'<HWINFO><COMPUTER><NodeName>X</NodeName><SubNodes><CPU>' + b'<SubNode>' * 70 + b'</SubNode>' * 70 + b'</CPU></SubNodes></COMPUTER></HWINFO>'
with self.assertRaises(ValueError):
parse_hwinfo(raw)
def test_properties_preserve_blank_labels_unicode_and_html_as_text(self):
xml = report_xml().replace(b'</MOBO>', (prop("", "&lt;script&gt;bad&lt;/script&gt;") + '</MOBO>').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": "<script>bad</script>", "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"<svg/>")},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"<html/>")):
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()