Files
dbx-main/tests/test_asset_features.py
T
king e9be17faab fix(asset): allow registering a monitor of an already-registered model
Registration was blocked whenever same-model candidates existed, so a
second monitor of the same model (e.g. dual monitors) could not be added.
Now only an existing asset with the same serial blocks a new one; the
UI tells serial and model candidates apart and hides 'register' only
for serial matches.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 15:14:22 +09:00

184 lines
11 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_same_model_different_serial_can_be_registered(self):
# 같은 모델(듀얼 모니터 등)이 이미 있어도 시리얼이 다르면 새 자산으로 등록된다(2026-10-07)
other = self.store.create(AssetInput(name="Display", category="monitor", model="Display 24", serial="SN-OTHER"), "actor")
match = self.store._monitor_matches(self.conn, self.computer, self.parsed)[0]
self.assertIsNone(match["asset"]); self.assertEqual(match["candidate_by"], "model")
self.assertEqual([c["id"] for c in match["candidates"]], [other])
target = self.store.register_monitor(self.computer, 0, self.monitor_payload(asset=AssetInput(name="Second", category="monitor", model="Display 24")), "actor")
self.assertNotEqual(target, other); self.assertEqual(self.conn.assets[target]["serial"], "SN-1")
def test_same_serial_still_blocks_new_registration(self):
self.store.create(AssetInput(name="Other", category="monitor", serial="SN-1", model="Different Model", manufacturer="Another"), "actor")
self.assertEqual(self.store._monitor_matches(self.conn, self.computer, self.parsed)[0]["candidate_by"], "serial")
with self.assertRaises(AssetConflict):
self.store.register_monitor(self.computer, 0, self.monitor_payload(asset=AssetInput(name="Dup", category="monitor")), "actor")
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"])