b576dd1a38
Apply asset_db_002_photos_monitors.sql before rebuilding web. Restrict soft deletion to the super admin; retain reports and audit.
169 lines
9.6 KiB
Python
169 lines
9.6 KiB
Python
"""삭제 권한, 사진 검증, 모니터 중복과 동시 수정 보호를 확인합니다."""
|
|
import copy
|
|
import io
|
|
import unittest
|
|
from contextlib import contextmanager
|
|
from types import SimpleNamespace
|
|
|
|
from PIL import Image
|
|
|
|
import test_asset as fixtures
|
|
from app.modules.asset.db import AssetStore
|
|
from app.modules.asset.media import MAX_PHOTO_BYTES, prepare_photo
|
|
from app.modules.asset.monitors import monitor_devices
|
|
from app.modules.asset.store import AssetConflict, AssetInput, DeleteInput, MonitorInput
|
|
from asset_fixtures import report_xml
|
|
from app.modules.asset.hwinfo import parse_hwinfo
|
|
|
|
|
|
def monitor_report(serial="SN-1"):
|
|
parsed = parse_hwinfo(report_xml())
|
|
parsed["devices"]["MONITOR"] = [{"name": "Test Display", "properties": [
|
|
{"label": "Monitor Name (Manuf)", "value": "Display 24", "type": "MONITOR"},
|
|
{"label": "Serial Number", "value": serial, "type": ""}]}]
|
|
return parsed
|
|
|
|
|
|
class Result:
|
|
def __init__(self, rows): self.rows = rows
|
|
def fetchone(self): return self.rows[0] if self.rows else None
|
|
def fetchall(self): return self.rows
|
|
|
|
|
|
class FeatureConnection(fixtures.Connection):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.photos, self.links = {}, {}
|
|
|
|
@contextmanager
|
|
def transaction(self):
|
|
before = copy.deepcopy((self.photos, self.links))
|
|
try:
|
|
with super().transaction(): yield self
|
|
except Exception:
|
|
self.photos, self.links = before
|
|
raise
|
|
|
|
def execute(self, sql, params=()):
|
|
if sql.startswith("SELECT a.* FROM asset_monitor_links"):
|
|
target = self.links.get(tuple(params))
|
|
row = self.assets.get(target)
|
|
return Result([row] if row and not row.get("deleted_at") else [])
|
|
if sql.startswith("SELECT * FROM assets") and "FOR UPDATE" not in sql:
|
|
rows = [a for a in self.assets.values() if a["category"] == "monitor" and not a.get("deleted_at")]
|
|
if "btrim(serial)" in sql: rows = [a for a in rows if a["serial"].strip().casefold() == params[0]]
|
|
else: rows = [a for a in rows if a["model"].strip().casefold() == params[0] or a["name"].strip().casefold() == params[1]]
|
|
return Result(rows)
|
|
if sql.startswith("SELECT parsed FROM asset_reports"):
|
|
row=self.reports.get(params[1])
|
|
return Result([{"parsed": row["parsed"].obj}] if row and row["asset_id"] == params[0] else [])
|
|
if sql.startswith("SELECT pg_advisory"):
|
|
self.assert_tx(); return Result([])
|
|
if sql.startswith("SELECT count(*) AS n FROM asset_photos"):
|
|
return Result([{"n":sum(p["asset_id"] == params[0] for p in self.photos.values())}])
|
|
if sql.startswith("INSERT INTO asset_photos"):
|
|
self.photos[params[0]] = dict(zip(("id","asset_id","filename","image","mime","width","height","actor"),params))
|
|
return Result([])
|
|
if sql.startswith("INSERT INTO asset_monitor_links"):
|
|
self.links[tuple(params[:2])] = params[2]; return Result([])
|
|
if sql.startswith("UPDATE assets SET version="):
|
|
self.assets[params[0]]["version"] += 1; return Result([])
|
|
if sql.startswith("UPDATE assets SET deleted_at="):
|
|
self.assets[params[1]].update(deleted_at="deleted",deleted_by=params[0])
|
|
self.assets[params[1]]["version"] += 1; return Result([])
|
|
return super().execute(sql,params)
|
|
|
|
|
|
class FeatureStoreTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.conn=FeatureConnection(); self.store=object.__new__(AssetStore);self.store._pool=fixtures.Pool(self.conn)
|
|
self.computer=self.store.create(AssetInput(name="PC",category="computer"),"actor")
|
|
self.parsed=monitor_report()
|
|
self.report=self.store.attach_report(self.computer,1,"actor","report.xml",report_xml(),self.parsed)
|
|
|
|
def monitor_payload(self, **kwargs):
|
|
return MonitorInput(version=self.conn.assets[self.computer]["version"],report_id=self.report,**kwargs)
|
|
|
|
def test_registration_connects_and_prevents_duplicates(self):
|
|
target=self.store.register_monitor(self.computer,0,self.monitor_payload(asset=AssetInput(name="Monitor",category="monitor",model="Display 24")),"actor")
|
|
self.assertEqual(self.conn.assets[target]["serial"],"SN-1")
|
|
match=self.store._monitor_matches(self.conn,self.computer,self.parsed)[0]
|
|
self.assertEqual((match["asset"]["id"],match["match"]),(target,"linked"))
|
|
with self.assertRaises(AssetConflict):
|
|
self.store.register_monitor(self.computer,0,self.monitor_payload(asset=AssetInput(name="Duplicate",category="monitor")),"actor")
|
|
self.assertEqual(len(self.conn.assets),2)
|
|
|
|
def test_ambiguous_serial_and_model_require_selection(self):
|
|
for i in range(2): self.store.create(AssetInput(name="Display",category="monitor",model="Display 24",serial="SN-1"),"actor")
|
|
match=self.store._monitor_matches(self.conn,self.computer,self.parsed)[0]
|
|
self.assertIsNone(match["asset"]);self.assertEqual(len(match["candidates"]),2)
|
|
target=match["candidates"][1]["id"]
|
|
self.store.register_monitor(self.computer,0,self.monitor_payload(asset_id=target),"actor")
|
|
self.assertEqual(self.store._monitor_matches(self.conn,self.computer,self.parsed)[0]["asset"]["id"],target)
|
|
unknown=monitor_report("0")
|
|
match=self.store._monitor_matches(self.conn,"other-computer",unknown)[0]
|
|
self.assertIsNone(match["asset"]);self.assertEqual(len(match["candidates"]),2)
|
|
|
|
def test_existing_unique_serial_matches_automatically(self):
|
|
target=self.store.create(AssetInput(name="Existing",category="monitor",serial="sn-1"),"actor")
|
|
match=self.store._monitor_matches(self.conn,self.computer,self.parsed)[0]
|
|
self.assertEqual((match["asset"]["id"],match["match"]),(target,"serial"))
|
|
|
|
def test_different_model_same_serial_is_not_auto_linked(self):
|
|
self.store.create(AssetInput(name="Other",category="monitor",serial="SN-1",model="Different Model",manufacturer="Another"),"actor")
|
|
match=self.store._monitor_matches(self.conn,self.computer,self.parsed)[0]
|
|
self.assertIsNone(match["asset"]);self.assertEqual(len(match["candidates"]),1)
|
|
|
|
def test_stale_report_and_non_monitor_link_do_not_write(self):
|
|
before=copy.deepcopy(self.conn.assets)
|
|
for payload in (MonitorInput(version=2,report_id="old",asset_id=self.computer),MonitorInput(version=1,report_id=self.report,asset_id=self.computer)):
|
|
with self.assertRaises(AssetConflict): self.store.register_monitor(self.computer,0,payload,"actor")
|
|
with self.assertRaises(ValueError): self.store.register_monitor(self.computer,0,self.monitor_payload(asset_id=self.computer),"actor")
|
|
self.assertEqual(before,self.conn.assets);self.assertFalse(self.conn.links)
|
|
|
|
def test_link_and_creation_roll_back_if_audit_fails(self):
|
|
self.conn.fail_event=True
|
|
with self.assertRaises(RuntimeError):
|
|
self.store.register_monitor(self.computer,0,self.monitor_payload(asset=AssetInput(name="New",category="monitor")),"actor")
|
|
self.assertEqual(len(self.conn.assets),1);self.assertFalse(self.conn.links)
|
|
|
|
def test_photo_limit_version_and_transaction(self):
|
|
for i in range(10):
|
|
self.store.add_photo(self.computer,2+i,"actor","photo.jpg",b"image","image/jpeg",10,10)
|
|
with self.assertRaises(ValueError): self.store.add_photo(self.computer,12,"actor","photo.jpg",b"image","image/jpeg",10,10)
|
|
with self.assertRaises(AssetConflict): self.store.add_photo(self.computer,2,"actor","photo.jpg",b"image","image/jpeg",10,10)
|
|
self.assertEqual(len(self.conn.photos),10)
|
|
self.conn.photos.clear(); self.conn.fail_event=True
|
|
with self.assertRaises(RuntimeError): self.store.add_photo(self.computer,12,"actor","photo.jpg",b"image","image/jpeg",10,10)
|
|
self.assertFalse(self.conn.photos);self.assertEqual(self.conn.assets[self.computer]["version"],12)
|
|
|
|
def test_deletion_preserves_reports_and_blocks_later_writes(self):
|
|
self.store.delete(self.computer,2,"super","Wrong entry")
|
|
self.assertEqual(len(self.conn.reports),1)
|
|
self.assertEqual(self.conn.events[-1][2],"delete")
|
|
with self.assertRaises(KeyError): self.store.delete(self.computer,3,"super","Again")
|
|
with self.assertRaises(KeyError): self.store.attach_report(self.computer,3,"actor","x.xml",report_xml(),self.parsed)
|
|
|
|
|
|
class MediaTests(unittest.TestCase):
|
|
def test_images_reencoded_without_exif_and_resized(self):
|
|
original=Image.new("RGB",(3000,1000),"red");data=io.BytesIO()
|
|
exif=Image.Exif();exif[271]="Private camera"
|
|
original.save(data,"JPEG",exif=exif)
|
|
raw,mime,width,height=prepare_photo(data.getvalue())
|
|
self.assertEqual((mime,width,height),("image/jpeg",2400,800))
|
|
with Image.open(io.BytesIO(raw)) as result: self.assertFalse(result.getexif())
|
|
transparent=io.BytesIO();Image.new("RGBA",(10,10),(0,0,0,0)).save(transparent,"PNG")
|
|
self.assertEqual(prepare_photo(transparent.getvalue())[1],"image/png")
|
|
|
|
def test_fake_svg_oversized_and_large_dimensions_rejected(self):
|
|
for raw in (b"",b"not a photo",b"<svg/>",b"x"*(MAX_PHOTO_BYTES+1)):
|
|
with self.assertRaises(ValueError): prepare_photo(raw)
|
|
raw=io.BytesIO();Image.new("RGB",(5000,5000)).save(raw,"PNG")
|
|
with self.assertRaises(ValueError): prepare_photo(raw.getvalue())
|
|
|
|
def test_unknown_serial_does_not_identify_same_model(self):
|
|
self.assertEqual(monitor_devices(monitor_report("00000"))[0]["serial"],"")
|
|
one=monitor_report();two=monitor_report("SN-2")
|
|
self.assertNotEqual(monitor_devices(one)[0]["key"],monitor_devices(two)[0]["key"])
|