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:
@@ -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()
|
||||
@@ -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;
|
||||
});
|
||||
@@ -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")
|
||||
@@ -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("", "<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 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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user