b576dd1a38
Apply asset_db_002_photos_monitors.sql before rebuilding web. Restrict soft deletion to the super admin; retain reports and audit.
389 lines
22 KiB
Python
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("", "<script>bad</script>") + '</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()
|