feat(asset): add inventory and HWiNFO reports

Requires asset_db initialized with scripts/sql/asset_db_init.sql and ASSET_DB_URL configured before enabling storage.
This commit is contained in:
2026-10-06 02:09:10 +09:00
parent 75c0370e54
commit bd0c47e6fc
25 changed files with 4185 additions and 3 deletions
+23
View File
@@ -0,0 +1,23 @@
"""Synthetic HWiNFO export; contains no company device identifiers."""
def prop(label, value, kind=""):
return f"<Property><Entry>{label}</Entry><Description>{value}</Description><PropertyType>{kind}</PropertyType></Property>"
def report_xml(english=False):
return ('''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE HWINFO SYSTEM "HWiNFO32log.dtd"><HWINFO><COMPUTER><NodeName>TEST-PC</NodeName><ScanTime>06.10.2026 01:10</ScanTime>'''
+ prop("Operating System" if english else "운영 체제", "Windows Test")
+ '<SubNodes><CPU><NodeName>CPU</NodeName>'
+ prop("Number of Processor Cores" if english else "프로세서 코어 수", "8", "CPU_COUNT")
+ prop("Number of Logical Processors" if english else "논리 프로세서 수", "16")
+ '<SubNode><NodeName>Test Processor</NodeName>' + prop("Processor Name", "Test Processor", "CPU_NAME")
+ '</SubNode></CPU><MOBO><NodeName>Mainboard</NodeName>' + prop("Motherboard", "Test Board", "SYSTEM_MAINBOARD")
+ prop("Product Serial Number", "System Serial Number") + '</MOBO><MEMORY><NodeName>Memory</NodeName>'
+ prop("Total Memory Size [MB]", "32768", "SYSTEM_MEMORY")
+ '<SubNode><NodeName>DIMM1</NodeName>' + prop("Module Part Number", "TEST-RAM") + prop("Module Size", "16 GiB") + '</SubNode>'
+ '<SubNode><NodeName>DIMM2</NodeName>' + prop("Module Part Number", "TEST-RAM") + prop("Module Size", "16 GiB") + '</SubNode>'
+ '</MEMORY><VIDEO><NodeName>Test GPU</NodeName>' + prop("Video Chipset", "Test GPU", "GFXCARD_CHIPSET")
+ '</VIDEO><DRIVES><NodeName>Drives</NodeName><SubNodes>'
+ '<SubNode><NodeName>SSD</NodeName>' + prop("Drive Model", "Same Model SSD", "HDD") + prop("Drive Serial Number", "synthetic-1") + '</SubNode>'
+ '<SubNode><NodeName>SSD</NodeName>' + prop("Drive Model", "Same Model SSD", "HDD") + prop("Drive Serial Number", "synthetic-2") + '</SubNode>'
+ '</SubNodes></DRIVES></SubNodes></COMPUTER></HWINFO>').encode()
+531
View File
@@ -0,0 +1,531 @@
// Actual Chrome, real ERP template/CSS/JS, synthetic assets and controlled APIs.
const assert = require("node:assert/strict");
const fs = require("node:fs");
const http = require("node:http");
const path = require("node:path");
const { chromium } = require("playwright");
const ROOT = path.resolve(__dirname, "../.."),
OUT = path.join(__dirname, ".out"),
STATIC = path.join(ROOT, "app/static");
const parsed = JSON.parse(
fs.readFileSync(path.join(OUT, "asset_report.json"), "utf8"),
);
let conflict = false,
slow = false,
mutations = [],
counter = 30;
const timestamp = "2026-10-06T01:00:00+09:00";
const records = Array.from({ length: 30 }, (_, i) => ({
id: "asset" + i,
tag: "AST-" + String(i + 1).padStart(6, "0"),
name: i === 0 ? "KING-DESKTOP" : `테스트 자산 ${i}`,
category: i % 3 === 0 ? "computer" : i % 3 === 1 ? "chair" : "mouse",
status: "available",
manufacturer: "",
model: i === 0 ? parsed.summary.motherboard : "",
serial: "",
location: "본사 3층",
department: "디자인팀",
assignee_email: "",
purchased_on: "2026-01-01",
purchase_cost: "1250000",
vendor: "",
warranty_until: "2026-10-20",
notes: "",
latest_report_id: i === 0 ? "report1" : null,
version: 1,
created_at: timestamp,
updated_at: timestamp,
specs: i === 0 ? parsed.summary : null,
}));
const users = [
{ email: "reader@test.local", name: "담당자" },
{ email: "staff@test.local", name: "직원" },
];
const events = [
{
id: 1,
asset_id: "asset0",
actor: "reader@test.local",
kind: "create",
note: "자산 등록",
changes: {},
created_at: timestamp,
},
];
const reports = [
{
id: "report1",
asset_id: "asset0",
filename: "KING-DESKTOP.XML",
uploaded_at: timestamp,
actor: "reader@test.local",
summary: parsed.summary,
scan_time: parsed.scan_time,
},
];
function json(res, value, code = 200) {
res.writeHead(code, { "Content-Type": "application/json" });
res.end(JSON.stringify(value));
}
function filter(p) {
let rows = records.filter(
(a) => !p.get("category") || a.category === p.get("category"),
);
for (const key of ["status", "location"])
rows = rows.filter((a) => !p.get(key) || a[key] === p.get(key));
if (p.get("assignee"))
rows = rows.filter((a) => a.assignee_email === p.get("assignee"));
if (p.get("group"))
rows = rows.filter(
(a) =>
(p.get("group") === "furniture") ===
["chair", "desk", "furniture"].includes(a.category),
);
if (p.get("q"))
rows = rows.filter((a) => (a.name + a.tag + a.notes).includes(p.get("q")));
return rows;
}
const server = http.createServer(async (req, res) => {
const url = new URL(req.url, "http://localhost");
if (url.pathname === "/asset/") {
res.setHeader("Content-Type", "text/html; charset=utf-8");
res.end(
fs.readFileSync(
path.join(
OUT,
url.searchParams.has("unconfigured")
? "asset_unconfigured.html"
: "asset_render.html",
),
),
);
return;
}
if (url.pathname.startsWith("/static/")) {
const file = path.resolve(
STATIC,
"." + decodeURIComponent(url.pathname.slice(7)),
);
if (
!file.startsWith(STATIC + path.sep) ||
!fs.existsSync(file) ||
!fs.statSync(file).isFile()
) {
res.writeHead(404);
res.end();
return;
}
const types = {
".css": "text/css",
".js": "text/javascript",
".woff2": "font/woff2",
".png": "image/png",
};
res.setHeader(
"Content-Type",
types[path.extname(file)] || "application/octet-stream",
);
fs.createReadStream(file).pipe(res);
return;
}
const route = url.pathname.slice("/asset/api/".length),
parts = route.split("/");
const chunks = [];
for await (const chunk of req) chunks.push(chunk);
const raw = Buffer.concat(chunks),
body = req.headers["content-type"]?.includes("application/json")
? JSON.parse(raw.toString())
: null;
if (req.method !== "GET") {
assert.equal(req.headers["x-asset-csrf"], "browser-test");
mutations.push({ route, body });
}
if (route === "bootstrap") {
const totals = {
total: records.length,
available: 0,
in_use: 0,
maintenance: 0,
lost: 0,
retired: 0,
warranty_soon: records.length,
purchase_total: "37500000",
};
records.forEach((a) => totals[a.status]++);
json(res, {
totals,
users,
locations: ["本社", "본사 3층"],
categories: ["computer", "chair", "mouse"].map((category) => ({
category,
count: records.filter((a) => a.category === category).length,
})),
activity: events
.slice(-12)
.reverse()
.map((e) => ({
...e,
tag: "AST-000001",
name: records.find((a) => a.id === e.asset_id)?.name || "Asset",
})),
});
return;
}
if (route === "assets" && req.method === "GET") {
const rows = filter(url.searchParams),
page = Number(url.searchParams.get("page") || 1),
result = {
items: rows.slice((page - 1) * 25, page * 25),
total: rows.length,
page,
page_size: 25,
};
if (slow && url.searchParams.get("q") === "테스트") {
setTimeout(() => json(res, result), 500);
return;
}
json(res, result);
return;
}
if (route === "assets" && req.method === "POST") {
const a = {
...records[1],
...body,
id: "asset" + counter++,
tag: body.tag || "AST-TEST",
specs: null,
latest_report_id: null,
};
records.push(a);
json(res, { id: a.id });
return;
}
if (route === "reports/preview") {
if (raw.toString().includes("invalid.xml")) {
json(res, { detail: "올바르지 않은 보고서입니다." }, 422);
return;
}
json(res, {
filename: "test.xml",
summary: parsed.summary,
property_count: parsed.property_count,
scan_time: parsed.scan_time,
warnings: [],
});
return;
}
if (route === "reports/import") {
const match = raw
.toString()
.match(/name="payload"\r\n\r\n([\s\S]*?)\r\n--/);
assert.ok(match, "multipart import must carry the asset payload");
const data = JSON.parse(match[1]);
const a = {
...records[0],
...data,
id: "asset" + counter++,
tag: "AST-IMPORT",
};
records.push(a);
json(res, { id: a.id });
return;
}
if (parts[0] === "assets" && parts[1]) {
const a = records.find((a) => a.id === parts[1]);
if (!a) {
json(res, { detail: "없음" }, 404);
return;
}
if (parts.length === 2 && req.method === "GET") {
json(res, {
asset: a,
report: a.latest_report_id ? { ...reports[0], parsed } : null,
reports: a.latest_report_id ? reports : [],
events: events.filter((e) => e.asset_id === a.id),
});
return;
}
if (parts.length === 2 && req.method === "PUT") {
if (conflict) {
conflict = false;
json(
res,
{ detail: "다른 사용자가 수정했습니다. 다시 확인하세요." },
409,
);
return;
}
assert.equal(body.version, a.version);
Object.assign(a, body, { version: a.version + 1 });
json(res, { ok: true });
return;
}
if (parts[2] === "actions") {
assert.equal(body.version, a.version);
a.version++;
a.status = {
checkout: "in_use",
checkin: "available",
maintenance: "maintenance",
available: "available",
lost: "lost",
retired: "retired",
}[body.action];
a.assignee_email = body.action === "checkout" ? body.assignee_email : "";
events.push({
id: events.length + 1,
asset_id: a.id,
kind: body.action,
note: body.note,
actor: users[0].email,
changes: {},
created_at: timestamp,
});
json(res, { ok: true });
return;
}
if (parts[2] === "reports" && parts.length === 3) {
a.latest_report_id = "report1";
a.specs = parsed.summary;
a.version++;
json(res, { id: "report1" });
return;
}
if (parts[2] === "reports" && parts.length === 4) {
json(res, { ...reports[0], parsed });
return;
}
}
res.writeHead(404);
res.end();
});
(async () => {
let browser;
try {
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
browser = await chromium.launch({
headless: true,
executablePath:
process.env.PJ_TEST_BROWSER ||
"C:/Program Files/Google/Chrome/Application/chrome.exe",
});
const page = await browser.newPage({
viewport: { width: 1600, height: 1050 },
});
const errors = [];
page.on("pageerror", (e) => errors.push(e.message));
const origin = `http://127.0.0.1:${server.address().port}`;
await page.goto(origin + "/asset/");
await page.locator("#am-total").filter({ hasText: "30" }).waitFor();
assert.equal(await page.locator("#am-rows tr").count(), 25);
await page.screenshot({
path: path.join(OUT, "asset-desktop.png"),
fullPage: true,
});
await page.locator("#am-next").click();
await page.waitForFunction(
() => document.querySelector("#am-page-number").textContent === "2 / 2",
);
assert.equal(await page.locator("#am-rows tr").count(), 5);
await page.locator('[data-view="furniture"]').click();
await page.waitForFunction(
() =>
document.querySelector("#am-result-count").textContent === "10개 자산",
);
assert.equal(await page.locator("#am-page-number").textContent(), "1 / 1");
await page.locator("#am-reset").click();
await page.waitForFunction(
() =>
document.querySelector("#am-result-count").textContent === "30개 자산",
);
slow = true;
await page.locator("#am-query").fill("테스트");
await page.waitForTimeout(300);
await page.locator("#am-query").fill("KING");
await page.waitForTimeout(800);
assert.equal(
await page.locator("#am-result-count").textContent(),
"1개 자산",
"late search response must not replace the newest result",
);
await page.locator('[data-open="asset0"][data-tab="specs"]').click();
await page.locator("#am-spec-query").waitFor();
assert.ok(
(await page.locator(".am-spec-card").first().textContent()).includes(
parsed.summary.cpu,
),
);
await page.locator("#am-spec-section").selectOption("MEMORY");
await page.locator("#am-detail").evaluate((el) => {
el.scrollTop = 0;
});
await page.screenshot({ path: path.join(OUT, "asset-specs.png") });
await page.locator("#am-spec-query").fill("M378A2K43EB1");
if (parsed.summary.computer_name === "KING-DESKTOP")
assert.equal(await page.locator(".am-node").count(), 2);
await page.locator('[data-detail-tab="overview"]').click();
await page.locator("[data-edit]").click();
await page
.locator('#am-editor-form [name="notes"]')
.fill("저장 전 초안 <script>window.assetInjected=true</script>");
conflict = true;
await page.locator('#am-editor-form [type="submit"]').click();
await page
.locator("#am-editor-form .am-form-error")
.filter({ hasText: "다른 사용자" })
.waitFor();
assert.ok(
(
await page.locator('#am-editor-form [name="notes"]').inputValue()
).includes("초안"),
);
await page.locator('#am-editor-form [type="submit"]').click();
await page.waitForFunction(
() => !document.querySelector("#am-editor").open,
);
await page.locator('[data-action="checkout"]').waitFor();
assert.equal(await page.evaluate(() => window.assetInjected), undefined);
await page.locator('[data-action="checkout"]').click();
await page.locator("#am-action-user").selectOption("staff@test.local");
await page.locator("#am-action-save").click();
await page.waitForFunction(
() => !document.querySelector("#am-action").open,
);
await page.locator('[data-action="checkin"]').waitFor();
assert.equal(
await page.locator('[data-action="retired"]').count(),
0,
"assigned assets cannot be retired directly",
);
await page.locator('[data-action="checkin"]').click();
await page.locator("#am-action-save").click();
await page.waitForFunction(
() => !document.querySelector("#am-action").open,
);
await page.locator('[data-action="checkout"]').waitFor();
await page.locator('[data-detail-tab="reports"]').click();
await page.locator("[data-report]").click();
await page.locator("#am-spec-query").waitFor();
assert.ok(
(await page.locator("#am-detail-content").textContent()).includes(
"선택한 보고서",
),
);
await page.locator('[data-close="am-detail"]').click();
await page.locator("#am-import").click();
await page.locator("#am-report-file").setInputFiles({
name: "invalid.xml",
mimeType: "text/xml",
buffer: Buffer.from("<broken/>"),
});
await page
.locator("#am-upload-form .am-form-error")
.filter({ hasText: "올바르지" })
.waitFor();
assert.equal(await page.locator("#am-import-save").isDisabled(), true);
await page
.locator("#am-report-file")
.setInputFiles(path.join(OUT, "asset_upload.xml"));
await page.locator("#am-report-preview").waitFor({ state: "visible" });
assert.equal(
await page.locator("#am-import-name").inputValue(),
parsed.summary.computer_name,
);
await page.screenshot({ path: path.join(OUT, "asset-import.png") });
await page.locator("#am-import-name").fill("Uploaded workstation");
await page.locator("#am-import-save").click();
await page.waitForFunction(
() => !document.querySelector("#am-upload").open,
);
await page
.locator("#am-detail-title")
.filter({ hasText: "Uploaded workstation" })
.waitFor();
await page.locator("#am-spec-query").waitFor();
await page.locator("[data-attach]").click();
await page
.locator("#am-report-file")
.setInputFiles(path.join(OUT, "asset_upload.xml"));
await page.locator("#am-report-preview").waitFor({ state: "visible" });
assert.equal(await page.locator("#am-import-fields").isVisible(), false);
await page.locator("#am-import-save").click();
await page.waitForFunction(
() => !document.querySelector("#am-upload").open,
);
await page
.locator("#am-detail-title")
.filter({ hasText: "Uploaded workstation" })
.waitFor();
await page.keyboard.press("Escape");
await page.locator("#am-create").click();
await page.locator('#am-editor-form [name="name"]').fill("테스트 의자");
await page
.locator('#am-editor-form [name="category"]')
.selectOption("chair");
await page.locator('#am-editor-form [type="submit"]').click();
await page.waitForFunction(
() => !document.querySelector("#am-editor").open,
);
await page
.locator("#am-detail-title")
.filter({ hasText: "테스트 의자" })
.waitFor();
assert.equal(await page.locator('[data-detail-tab="specs"]').count(), 0);
await page.keyboard.press("Escape");
await page.setViewportSize({ width: 390, height: 844 });
await page.locator("#am-reset").click();
await page.waitForTimeout(100);
assert.ok(
await page.evaluate(
() => document.documentElement.scrollWidth <= innerWidth + 1,
),
"mobile document should not overflow horizontally",
);
await page.screenshot({
path: path.join(OUT, "asset-mobile.png"),
fullPage: true,
});
await page.locator('[data-open="asset0"]').first().click();
await page
.locator("#am-detail-title")
.filter({ hasText: "KING-DESKTOP" })
.waitFor();
assert.ok(
await page.evaluate(
() =>
document.querySelector("#am-detail").scrollWidth <= innerWidth + 1,
),
);
await page.locator('.am-tabs [data-detail-tab="specs"]').click();
await page.locator("#am-spec-query").waitFor();
await page.locator("#am-spec-section").selectOption("MEMORY");
await page.screenshot({ path: path.join(OUT, "asset-mobile-specs.png") });
await page.keyboard.press("Escape");
await page.goto(origin + "/asset/?category=chair&q=테스트");
await page.waitForFunction(
() =>
document.querySelector("#am-result-count").textContent === "11개 자산",
);
assert.equal(await page.locator("#am-category").inputValue(), "chair");
await page.goto(origin + "/asset/?unconfigured=1");
assert.equal(await page.locator("#am-create").isDisabled(), true);
await page.locator("#am-import").click();
await page
.locator("#am-report-file")
.setInputFiles(path.join(OUT, "asset_upload.xml"));
await page.locator("#am-report-preview").waitFor({ state: "visible" });
assert.equal(await page.locator("#am-import-save").isDisabled(), true);
assert.deepEqual(errors, []);
console.log(
"ALL PASS: Chrome desktop/mobile, search races, paging, specs, XSS escaping, conflict draft, create, checkout/checkin, report preview, setup mode",
);
} finally {
await browser?.close();
await new Promise((resolve) => server.close(resolve));
}
})().catch((error) => {
console.error(error);
process.exitCode = 1;
});
+31
View File
@@ -0,0 +1,31 @@
"""Render the real asset workspace for browser validation; no DB or user data."""
import json
import sys
from pathlib import Path
import jinja2
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "tests"))
from app.modules.asset.store import CATEGORIES, STATUSES
from app.modules.asset.hwinfo import parse_hwinfo
from asset_fixtures import report_xml
env = jinja2.Environment(loader=jinja2.ChoiceLoader([
jinja2.FileSystemLoader(ROOT / "app/modules/asset/templates"),
jinja2.FileSystemLoader(ROOT / "app/templates"),
]), autoescape=True)
out = ROOT / "tests/js/.out"
out.mkdir(exist_ok=True, parents=True)
for configured in (True, False):
html = env.get_template("asset/index.html").render(
user={"email": "reader@test.local", "name": "Reader"}, nav_items=[], is_admin=False,
page_title="자산관리", page_subtitle="회사 자산을 한곳에서", categories=CATEGORIES, statuses=STATUSES,
csrf_token="browser-test", configured=configured)
(out / ("asset_render.html" if configured else "asset_unconfigured.html")).write_text(html, encoding="utf-8")
sample = ROOT / "KING-DESKTOP.XML"
raw = sample.read_bytes() if sample.exists() else report_xml()
(out / "asset_report.json").write_text(json.dumps(parse_hwinfo(raw), ensure_ascii=False), encoding="utf-8")
# Synthetic file for upload tests, never copy the private source XML into artifacts.
(out / "asset_upload.xml").write_bytes(report_xml())
print("Asset template and report analysis rendered to tests/js/.out")
+349
View File
@@ -0,0 +1,349 @@
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 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"]
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()
+41
View File
@@ -0,0 +1,41 @@
"""실제 앱의 메뉴·권한 화면·자산 라우터 연결을 격리된 환경에서 확인합니다."""
import os
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
class MainIntegrationTests(unittest.TestCase):
def test_registered_module_and_unconfigured_workspace(self):
env = dict(os.environ)
# 운영 DSN과 런타임 데이터는 사용하지 않습니다.
for key in ("ASSET", "CAFE24", "CUPANG", "VACATION", "PROJECT", "DISPATCH", "PERFORMANCE", "MALAYSIA_STOCK", "ITEMCODE", "EXPENSE"):
env[key + "_DB_URL"] = ""
env.update(SESSION_SECRET_KEY="local-asset-test-only", SESSION_COOKIE_SECURE="false")
with tempfile.TemporaryDirectory(prefix="asset-integration-") as directory:
env["DATA_DIR"] = directory
code = '''
from unittest.mock import patch
from fastapi.testclient import TestClient
import app.main as main
from app.store import MODULE_KEYS
user={"email":"admin@test.local","name":"Admin","role":"admin","is_super_admin":True,"modules":{}}
with patch.object(main,"get_current_user_record",return_value=user),patch.object(main,"get_session_user",return_value=user),patch.object(main.user_store,"get",return_value=user),patch.object(main.user_store,"list_all",return_value=[user]):
client=TestClient(main.app)
for path in ("/","/admin","/asset/"):
result=client.get(path)
assert result.status_code == 200,(path,result.status_code)
assert main.MODULE_LABELS["asset"] in result.text,path
assert client.get("/asset/health").status_code == 503
assert "asset" in MODULE_KEYS
assert any(x["key"] == "asset" and x["active"] for x in main.build_erp_nav(user,active="asset"))
print("Real app menu/admin/workspace registration OK")
'''
result = subprocess.run([sys.executable, "-c", code], cwd=Path(__file__).resolve().parents[1], env=env,
capture_output=True, text=True, encoding="utf-8", timeout=45)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
if __name__ == "__main__": unittest.main()