862 lines
38 KiB
JavaScript
862 lines
38 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import "./DeploymentResult.test.js";
|
|
import test from "node:test";
|
|
import { nextTick, ref } from "vue";
|
|
import { useDashboard } from "./Dashboard.js";
|
|
import { useDashboardNavigation } from "./DashboardNavigation.js";
|
|
import { summarizeRuntime, runtimeTime, useRuntimeOverview } from "./RuntimeOverview.js";
|
|
import { aliyunProvider, deferred, mountComposable, verifiedResponse } from "../../test-support/mount.js";
|
|
|
|
test("板块导航默认只选中基本信息，超级管理员可切换全部板块", () => {
|
|
const navigation = useDashboardNavigation(ref({ role: "super_admin" }));
|
|
assert.equal(navigation.activeSection.value, "overview");
|
|
assert.equal(navigation.sections.value.length, 6);
|
|
for (const section of navigation.sections.value) {
|
|
navigation.selectSection(section.id);
|
|
assert.equal(navigation.activeSection.value, section.id);
|
|
assert.equal(navigation.activeLabel.value, section.label);
|
|
}
|
|
navigation.selectSection("invalid");
|
|
assert.equal(navigation.activeSection.value, "users");
|
|
});
|
|
|
|
test("用户管理导航按权限显示，权限变化后回到基本信息", () => {
|
|
const user = ref(null);
|
|
const navigation = useDashboardNavigation(user);
|
|
assert.equal(navigation.sections.value.some((section) => section.id === "users"), false);
|
|
navigation.selectSection("users");
|
|
assert.equal(navigation.activeSection.value, "overview");
|
|
user.value = { role: "super_admin" };
|
|
navigation.selectSection("users");
|
|
assert.equal(navigation.activeSection.value, "users");
|
|
user.value = { role: "admin" };
|
|
assert.equal(navigation.activeSection.value, "users");
|
|
assert.equal(navigation.sections.value.length, 6);
|
|
user.value = null;
|
|
assert.equal(navigation.activeSection.value, "overview");
|
|
assert.equal(navigation.sections.value.length, 5);
|
|
});
|
|
|
|
test("单板块布局使用互斥条件，切换重置滚动且保留弹窗入口", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./Dashboard.vue", import.meta.url), "utf8");
|
|
const stylesheet = await readFile(new URL("./DashboardLayout.css", import.meta.url), "utf8");
|
|
for (const id of ["overview", "activity", "domains", "servers", "keys", "users"]) {
|
|
assert.ok(template.includes(`v-if="activeSection === '${id}'"`));
|
|
}
|
|
assert.match(template, /:key="activeSection"/);
|
|
assert.match(template, /role="region"\s+:aria-label="activeLabel"\s+tabindex="0"/);
|
|
for (const modal of ["SettingsModal", "DomainModal", "ServerModal", "SSHKeyModal"]) {
|
|
assert.ok(template.includes(`<${modal} v-if=`));
|
|
}
|
|
assert.match(stylesheet, /height: 100dvh/);
|
|
assert.match(stylesheet, /\.dashboard-content\s*\{[^}]*overflow: auto/);
|
|
});
|
|
|
|
test("侧栏支持键盘焦点、当前项标记和悬浮说明", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./DashboardNavigation.vue", import.meta.url), "utf8");
|
|
const stylesheet = await readFile(new URL("./DashboardNavigation.css", import.meta.url), "utf8");
|
|
assert.match(template, /<button/);
|
|
assert.match(template, /:aria-current=/);
|
|
assert.match(template, /:title="section.hint"/);
|
|
assert.match(stylesheet, /\.navigation-item:focus-visible/);
|
|
});
|
|
|
|
test("证书导入使用组合式状态导出，避免点击时缺失处理函数", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./Dashboard.vue", import.meta.url), "utf8");
|
|
const script = template.split("</script>")[0];
|
|
for (const name of ["showCertificateImport", "openCertificateImport", "closeCertificateImport", "importCertificate", "selectCertificateImportFile"]) {
|
|
assert.ok(script.includes(` ${name},`));
|
|
}
|
|
});
|
|
test("完整页面逐个渲染六个板块，每次只有一个内容标题", async (t) => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const Vue = await import("vue");
|
|
const source = await readFile(new URL("./Dashboard.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
const compiled = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename: "Dashboard.vue",
|
|
id: "dashboard-panels",
|
|
compilerOptions: { mode: "function" },
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
state.closeSettings();
|
|
state.currentUser.value = { account: "test-admin", role: "super_admin" };
|
|
const navigation = useDashboardNavigation(state.currentUser);
|
|
const headings = {
|
|
overview: "基本信息",
|
|
activity: "运行概览",
|
|
domains: "托管域名",
|
|
servers: "部署服务器",
|
|
keys: "SSH 私钥",
|
|
users: "用户管理",
|
|
};
|
|
for (const section of navigation.sections.value) {
|
|
navigation.selectSection(section.id);
|
|
const app = Vue.createSSRApp({
|
|
render,
|
|
setup: () => ({ ...state, ...navigation, dashboard: state }),
|
|
});
|
|
for (const name of ["ChangePassword", "DashboardNavigation", "SettingsModal", "DomainModal", "ServerModal", "SSHKeyModal", "RuntimeOverview"]) {
|
|
app.component(name, { render: () => null });
|
|
}
|
|
app.component("UserManagement", { render: () => Vue.h("h2", headings.users) });
|
|
app.component("DeploymentResult", { render: () => null });
|
|
const warnings = [];
|
|
app.config.warnHandler = (message) => warnings.push(message);
|
|
const html = await renderToString(app);
|
|
assert.deepEqual([...html.matchAll(/<h2>(.*?)<\/h2>/g)].map((match) => match[1]), [headings[section.id]]);
|
|
assert.deepEqual(warnings, []);
|
|
if (section.id === "overview") {
|
|
assert.match(html, /test-admin/);
|
|
assert.doesNotMatch(html, /立即检查续期/);
|
|
}
|
|
}
|
|
});
|
|
|
|
async function setup(t, request) {
|
|
const mounted = await mountComposable(t, useDashboard, async (path) => {
|
|
if (path === "/api/v1/dns/test") return request();
|
|
if (path.endsWith("/dns/providers")) return Response.json({ items: [aliyunProvider] });
|
|
if (path.endsWith("/settings")) return Response.json({ dns: { provider: "aliyun", credential_configured: true, verification_state: "verified" } });
|
|
return Response.json({ items: [] });
|
|
});
|
|
const { state } = mounted;
|
|
state.openSettings();
|
|
await nextTick();
|
|
return mounted;
|
|
}
|
|
|
|
async function fill(state) {
|
|
state.settingsForm.value.dns.credentials = { access_key_id: "fake-key" };
|
|
state.settingsForm.value.dns.test_domain = "example.test";
|
|
await nextTick();
|
|
}
|
|
|
|
test("管理续期的任务类型、审计和阶段使用中文", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
assert.equal(state.taskTypeLabel("management_renewal"), "管理证书续期");
|
|
assert.equal(state.auditActionLabel("management_renewal"), "管理证书续期");
|
|
assert.equal(state.taskStageLabel("activate"), "激活管理证书");
|
|
assert.equal(state.taskStageLabel("retry_wait"), "等待续期重试");
|
|
});
|
|
|
|
test("已保存凭据不变可保存，输入新凭据必须重新验证", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
assert.equal(state.settingsForm.value.acme.propagation_timeout_secs, 300);
|
|
assert.equal(state.settingsForm.value.acme.propagation_polling_interval_secs, 5);
|
|
await fill(state);
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
await state.testDNS();
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
state.settingsForm.value.dns.credentials.access_key_id = "changed-key";
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
});
|
|
|
|
test("管理设置不接受旧输入的在途 DNS 响应", async (t) => {
|
|
const pending = deferred();
|
|
const { state } = await setup(t, () => pending.promise);
|
|
await fill(state);
|
|
const task = state.testDNS();
|
|
state.settingsForm.value.dns.test_domain = "other.test";
|
|
await nextTick();
|
|
pending.resolve(verifiedResponse());
|
|
await task;
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
assert.equal(state.settingsForm.value.dns.verification_token, "");
|
|
});
|
|
|
|
test("管理设置拒绝过期验证令牌", async (t) => {
|
|
const { state } = await setup(t, () => Response.json({ credential_ref: "secret://test/only", verification_token: "expired", expires_at: "2000-01-01T00:00:00Z" }));
|
|
await fill(state);
|
|
await state.testDNS();
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
});
|
|
|
|
test("管理设置变更阿里云凭据不能复用验证令牌", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
await fill(state);
|
|
await state.testDNS();
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
state.settingsForm.value.dns.credentials.access_key_id = "changed-key";
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
assert.equal(state.settingsForm.value.dns.verification_token, "");
|
|
});
|
|
|
|
test("关闭设置后不显示旧 DNS 请求的成功提示", async (t) => {
|
|
const pending = deferred();
|
|
const { state } = await setup(t, () => pending.promise);
|
|
await fill(state);
|
|
const task = state.testDNS();
|
|
state.closeSettings();
|
|
pending.resolve(verifiedResponse());
|
|
await task;
|
|
assert.equal(state.settingsForm.value.dns.verification_token, "");
|
|
assert.equal(state.notice.value, "");
|
|
});
|
|
|
|
test("管理设置新请求成功后旧失败不能删除令牌", async (t) => {
|
|
const first = deferred();
|
|
const second = deferred();
|
|
let count = 0;
|
|
const { state } = await setup(t, () => (++count === 1 ? first.promise : second.promise));
|
|
await fill(state);
|
|
const oldTask = state.testDNS();
|
|
const newTask = state.testDNS();
|
|
second.resolve(verifiedResponse("new-token"));
|
|
await newTask;
|
|
first.reject(new Error("旧请求失败"));
|
|
await oldTask;
|
|
assert.equal(state.settingsForm.value.dns.verification_token, "new-token");
|
|
assert.equal(state.dnsTestError.value, "");
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
});
|
|
|
|
test("管理设置 DNS 验证显示等待进度，并在结束后停止计时", async (t) => {
|
|
const pending = deferred();
|
|
const { state, runIntervals, advanceTime } = await setup(t, () => pending.promise);
|
|
await fill(state);
|
|
const task = state.testDNS();
|
|
|
|
assert.equal(state.dnsTesting.value, true);
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 0);
|
|
assert.equal(state.dnsVerificationTimeoutSeconds.value, 6);
|
|
advanceTime(3200);
|
|
runIntervals();
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 3);
|
|
|
|
pending.resolve(Response.json({
|
|
verified: true,
|
|
credential_ref: "secret://test/only",
|
|
verification_token: "test-token",
|
|
expires_at: new Date(Date.now() + 60000).toISOString(),
|
|
verification_timeout_secs: 6,
|
|
}));
|
|
await task;
|
|
assert.equal(state.dnsTesting.value, false);
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 0);
|
|
assert.equal(state.dnsVerificationTimeoutSeconds.value, 6);
|
|
advanceTime(1000);
|
|
runIntervals();
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 0);
|
|
});
|
|
|
|
test("关闭管理设置会停止 DNS 等待计时器", async (t) => {
|
|
const pending = deferred();
|
|
const { state, runIntervals, advanceTime } = await setup(t, () => pending.promise);
|
|
await fill(state);
|
|
const task = state.testDNS();
|
|
advanceTime(1000);
|
|
runIntervals();
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 1);
|
|
|
|
state.closeSettings();
|
|
assert.equal(state.dnsTesting.value, false);
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 0);
|
|
advanceTime(1000);
|
|
runIntervals();
|
|
assert.equal(state.dnsVerificationElapsedSeconds.value, 0);
|
|
|
|
pending.resolve(verifiedResponse());
|
|
await task;
|
|
});
|
|
|
|
test("auditActionLabel", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
const localized = state.auditActionLabels.settings_update;
|
|
assert.equal(state.auditActionLabel(localized), localized);
|
|
assert.equal(state.auditActionLabel(` ${localized} `), localized);
|
|
assert.equal(state.auditActionLabel("settings_update"), localized);
|
|
assert.equal(state.auditActionLabel("unmapped_action"), state.taskTypeLabel("unmapped_action"));
|
|
assert.equal(state.auditActionLabel(null), state.taskTypeLabel(null));
|
|
assert.equal(state.auditActionLabel(undefined), state.taskTypeLabel(undefined));
|
|
assert.equal(state.auditActionLabel(""), state.taskTypeLabel(""));
|
|
});
|
|
|
|
test("settings.savedDnsCredentialsRemainOptionalUntilChanged", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
assert.equal(state.dnsVerificationRequired.value, false);
|
|
state.settingsForm.value.acme.renewal_threshold_days = 91;
|
|
assert.equal(state.dnsVerificationRequired.value, false);
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
await fill(state);
|
|
assert.equal(state.dnsVerificationRequired.value, true);
|
|
assert.equal(state.dnsReadyToSave.value, false);
|
|
await state.testDNS();
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
});
|
|
|
|
|
|
test("settingsPayloadContract", async (t) => {
|
|
const { settingsPayload } = await import("./SettingsPayload.js");
|
|
const { readFile } = await import("node:fs/promises");
|
|
const contract = await readFile(
|
|
new URL("../../../../backend/internal/httpapi/settings_api.go", import.meta.url),
|
|
"utf8",
|
|
);
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
const form = JSON.parse(JSON.stringify(state.settingsForm.value));
|
|
form.notification.http_credential_configured = true;
|
|
form.notification.smtp_credential_configured = true;
|
|
form.notification.http_credentials = { token: "test-only" };
|
|
form.notification.recipients = ["owner@example.test"];
|
|
form.notification.retry_count = 0;
|
|
form.dns.credentials = { access_key_id: "not-for-settings" };
|
|
form.dns.credential_ref = "secret://test/new";
|
|
form.dns.verification_token = "verified-token";
|
|
form.dns.test_domain = "example.test";
|
|
const payload = settingsPayload(form);
|
|
for (const [section, type] of Object.entries({
|
|
server: "Server", web: "Web", paths: "Paths", acme: "ACME",
|
|
dns: "DNS", notification: "Notification",
|
|
})) {
|
|
const body = contract.split(`type settings${type}Request struct {`)[1].split("\n}")[0];
|
|
const allowed = [...body.matchAll(/json:"([^"]+)"/g)].map((match) => match[1]);
|
|
for (const key of Object.keys(payload[section])) {
|
|
assert.ok(allowed.includes(key), `${section}.${key}`);
|
|
}
|
|
}
|
|
assert.equal("smtp_credential_configured" in payload.notification, false);
|
|
assert.equal("http_credential_configured" in payload.notification, false);
|
|
assert.equal("credentials" in payload.dns, false);
|
|
assert.equal(payload.dns.verification_token, "verified-token");
|
|
assert.deepEqual(payload.notification.http_credentials, { token: "test-only" });
|
|
assert.deepEqual(payload.notification.recipients, ["owner@example.test"]);
|
|
assert.equal(payload.notification.retry_count, 0);
|
|
assert.equal(payload.web.enabled, true);
|
|
assert.equal(payload.notification.smtp_enabled, false);
|
|
assert.equal(form.notification.smtp_credential_configured, true);
|
|
});
|
|
|
|
test("settingsReadEditSaveContract", async (t) => {
|
|
const saved = {
|
|
server: { host: "127.0.0.1", port: 8443, https_mode: "proxy", proxy_https_port: 443 },
|
|
web: { enabled: true, hostname: "example.test", public_ip: "" },
|
|
paths: { certificate: "/var/lib/scert/certificates" },
|
|
acme: { renewal_threshold_days: 6 },
|
|
dns: { provider: "aliyun", credential_configured: true, verification_state: "verified" },
|
|
notification: {
|
|
smtp_credential_configured: true, http_credential_configured: true,
|
|
recipients: ["owner@example.test"], retry_intervals_secs: [30, 120, 600],
|
|
},
|
|
response_only: true,
|
|
};
|
|
let submitted;
|
|
const { state } = await mountComposable(t, useDashboard, async (path, options = {}) => {
|
|
if (path.endsWith("/settings")) {
|
|
if (options.method === "PUT") {
|
|
submitted = JSON.parse(options.body);
|
|
return Response.json({ settings: saved });
|
|
}
|
|
return Response.json(saved);
|
|
}
|
|
return Response.json({ items: [] });
|
|
});
|
|
state.openSettings();
|
|
state.settingsForm.value.acme.renewal_threshold_days = 91;
|
|
assert.equal(state.dnsReadyToSave.value, true);
|
|
await state.saveSettings();
|
|
assert.equal(state.settingsError.value, "");
|
|
assert.equal(state.showSettings.value, false);
|
|
assert.equal(submitted.acme.renewal_threshold_days, 91);
|
|
assert.deepEqual(submitted.dns, { provider: "aliyun" });
|
|
assert.equal("smtp_credential_configured" in submitted.notification, false);
|
|
assert.equal("http_credential_configured" in submitted.notification, false);
|
|
assert.equal("response_only" in submitted, false);
|
|
assert.deepEqual(submitted.notification.recipients, ["owner@example.test"]);
|
|
assert.deepEqual(submitted.notification.retry_intervals_secs, [30, 120, 600]);
|
|
});
|
|
|
|
|
|
test("statusClass", async (t) => {
|
|
const { state } = await setup(t, () => verifiedResponse());
|
|
for (const status of ["active", "success"]) {
|
|
assert.equal(state.statusClass(status), "success");
|
|
}
|
|
for (const status of ["error", "failed"]) {
|
|
assert.equal(state.statusClass(status), "danger");
|
|
}
|
|
for (const status of ["running", "queued", "cancelled", "unknown", null]) {
|
|
assert.equal(state.statusClass(status), "warning");
|
|
}
|
|
});
|
|
|
|
test("auditStatusRendering", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const { createSSRApp } = await import("vue");
|
|
const source = await readFile(new URL("./RuntimeOverview.vue", import.meta.url), "utf8");
|
|
const start = source.indexOf('<article v-for="item in auditLogs"');
|
|
assert.notEqual(start, -1);
|
|
const end = source.indexOf("</article>", start) + "</article>".length;
|
|
const compiled = compileTemplate({
|
|
source: source.slice(start, end),
|
|
filename: "AuditStatus.vue",
|
|
id: "audit-status-regression",
|
|
compilerOptions: { mode: "function" },
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
const Vue = await import("vue");
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
for (const status of ["running", "queued", "cancelled", "unknown"]) {
|
|
const html = await renderToString(createSSRApp({
|
|
render,
|
|
setup: () => ({
|
|
auditLogs: [{ id: status, action: "test", status, message: "test" }],
|
|
auditActionLabel: (value) => value,
|
|
statusClass: () => "warning",
|
|
taskStatusLabels: { [status]: `label-${status}` },
|
|
displayLabel: (labels, value) => labels[value],
|
|
}),
|
|
}));
|
|
assert.match(html, new RegExp(`label-${status}`));
|
|
assert.doesNotMatch(html, /danger/);
|
|
}
|
|
});
|
|
|
|
|
|
test("domainModal.compilesAndRendersSanFieldsWithoutLiteralNewline", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileScript, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const Vue = await import("vue");
|
|
const source = await readFile(new URL("./DomainModal.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
assert.ok(compileScript(descriptor, { id: "domain-modal" }));
|
|
const compiled = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename: "DomainModal.vue",
|
|
id: "domain-modal",
|
|
compilerOptions: { mode: "function" },
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
for (const certificateType of ["single", "wildcard", "san"]) {
|
|
const app = Vue.createSSRApp({
|
|
render,
|
|
setup: () => ({
|
|
showForm: true,
|
|
formTitle: "test-domain",
|
|
closeForm: () => {},
|
|
saveDomain: () => {},
|
|
form: {
|
|
name: "example.test",
|
|
certificate_type: certificateType,
|
|
sans: "",
|
|
acme_environment: "staging",
|
|
dns_provider: "aliyun",
|
|
auto_renew: true,
|
|
server_ids: [],
|
|
},
|
|
dnsProviders: [],
|
|
servers: [],
|
|
displayLabel: (_, value) => value,
|
|
webServerLabels: {},
|
|
formError: "",
|
|
saving: false,
|
|
}),
|
|
});
|
|
app.component("HelpTip", {
|
|
setup: (_, { slots }) => () => Vue.h("span", { class: "test-help-tip" }, slots.default?.()),
|
|
});
|
|
const html = await renderToString(app);
|
|
assert.match(html, /class="modal-card domain-modal"/);
|
|
assert.match(html, /type="submit"/);
|
|
assert.match(html, /class="test-help-tip"/);
|
|
assert.doesNotMatch(html, /www\.example\.com\\napi/);
|
|
assert.equal(html.includes('id="domain-sans"'), certificateType === "san");
|
|
if (certificateType === "san") {
|
|
assert.match(html, /rows="2"/);
|
|
assert.ok(html.includes("www.example.com\napi.example.com"));
|
|
}
|
|
}
|
|
});
|
|
|
|
test("serverModal.compilesAndPreservesDeploymentFields", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileScript, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const Vue = await import("vue");
|
|
const source = await readFile(new URL("./ServerModal.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
assert.ok(compileScript(descriptor, { id: "server-modal" }));
|
|
const compiled = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename: "ServerModal.vue",
|
|
id: "server-modal",
|
|
compilerOptions: { mode: "function" },
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
for (const webServer of ["nginx", "caddy", "apache", "custom"]) {
|
|
const app = Vue.createSSRApp({
|
|
render,
|
|
setup: () => ({
|
|
showServerForm: true,
|
|
closeServerForm: () => {},
|
|
serverEditingId: null,
|
|
serverForm: {
|
|
name: "test-server",
|
|
web_server: webServer,
|
|
address: "example.test",
|
|
port: 22,
|
|
username: "deploy",
|
|
private_key_ref: "key-ref",
|
|
host_key_fingerprint: "SHA256:test-fingerprint",
|
|
certificate_path: "/test/cert.pem",
|
|
certificate_chain_path: "/test/fullchain.pem",
|
|
private_key_path: "/test/key.pem",
|
|
validation_command: "nginx\n-t",
|
|
reload_command: "nginx\n-s\nreload",
|
|
},
|
|
sshKeys: [],
|
|
openSSHKeyCreate: () => {},
|
|
defaultCertificatePath: "",
|
|
defaultCertificateChainPath: "",
|
|
defaultPrivateKeyPath: "",
|
|
serverFormError: "test-validation-error",
|
|
serverSaving: false,
|
|
saveServer: () => {},
|
|
}),
|
|
});
|
|
app.component("HelpTip", {
|
|
setup: (_, { slots }) => () => Vue.h("span", { class: "test-help-tip" }, slots.default?.()),
|
|
});
|
|
const html = await renderToString(app);
|
|
assert.match(html, /class="modal-card server-modal"/);
|
|
assert.match(html, /class="server-paths"/);
|
|
assert.match(html, /type="submit"/);
|
|
assert.match(html, /SHA256:test-fingerprint/);
|
|
assert.match(html, /test-validation-error/);
|
|
assert.match(html, /value="22"/);
|
|
assert.match(html, /min="1"/);
|
|
assert.match(html, /max="65535"/);
|
|
assert.equal((html.match(/class="test-help-tip"/g) || []).length, 4);
|
|
for (const path of ["/test/cert.pem", "/test/fullchain.pem", "/test/key.pem"]) {
|
|
assert.ok(html.includes(path));
|
|
}
|
|
assert.ok(html.includes("nginx\n-t"));
|
|
assert.ok(html.includes("nginx\n-s\nreload"));
|
|
}
|
|
});
|
|
|
|
test("changePassword.loadsScopedBaseStylesAndCompiles", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileScript, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const source = await readFile(new URL("../components/ChangePassword/ChangePassword.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
assert.ok(compileScript(descriptor, { id: "change-password" }));
|
|
const compiled = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename: "ChangePassword.vue",
|
|
id: "change-password",
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
assert.ok(descriptor.styles.some(style => style.scoped && style.src === "../../Dashboard/Dashboard.css"));
|
|
assert.ok(descriptor.styles.some(style => style.scoped && style.src === "./ChangePassword.css"));
|
|
assert.match(source, /<HelpTip>/);
|
|
const base = await readFile(new URL("./Dashboard.css", import.meta.url), "utf8");
|
|
assert.match(base, /\.modal-backdrop\s*\{[^}]*position:\s*fixed;/);
|
|
assert.match(base, /\.field\s*\{/);
|
|
});
|
|
|
|
test("sshKeyModal.compilesAndPreservesCredentialFields", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileScript, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const Vue = await import("vue");
|
|
const source = await readFile(new URL("./SSHKeyModal.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
assert.ok(compileScript(descriptor, { id: "ssh-key-modal" }));
|
|
const compiled = compileTemplate({
|
|
source: descriptor.template.content,
|
|
filename: "SSHKeyModal.vue",
|
|
id: "ssh-key-modal",
|
|
compilerOptions: { mode: "function" },
|
|
});
|
|
assert.deepEqual(compiled.errors, []);
|
|
assert.ok(descriptor.styles.some(style => style.scoped && style.src === "./Dashboard.css"));
|
|
assert.ok(descriptor.styles.some(style => style.scoped && style.src === "./SSHKeyModal.css"));
|
|
assert.doesNotMatch(source, /<HelpTip\s+class=/);
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
for (const platform of ["windows", "linux"]) {
|
|
const app = Vue.createSSRApp({
|
|
render,
|
|
setup: () => ({
|
|
showSSHKeyForm: true,
|
|
closeSSHKeyForm: () => {},
|
|
saveSSHKey: () => {},
|
|
sshKeyPlatform: platform,
|
|
sshKeyFileName: "test-key",
|
|
sshKeyPrivatePath: "/test/private",
|
|
sshKeyPublicPath: "/test/public",
|
|
sshKeyCommandUsername: "deploy",
|
|
sshKeyCommandHost: "example.test",
|
|
copySSHKeyCommand: () => {},
|
|
sshKeyCommands: { windows: "generate-windows", linux: "generate-linux" },
|
|
sshPublicKeyCommands: { windows: "install-windows", linux: "install-linux" },
|
|
sshKeyForm: { name: "", private_key: "", passphrase: "" },
|
|
importSSHKeyFile: () => {},
|
|
sshKeyPassphraseVisible: false,
|
|
sshKeyFormError: "test-validation-error",
|
|
sshKeySaving: false,
|
|
}),
|
|
});
|
|
app.component("HelpTip", {
|
|
setup: (_, { slots }) => () => Vue.h("span", { class: "test-help-tip" }, slots.default?.()),
|
|
});
|
|
const html = await renderToString(app);
|
|
assert.match(html, /class="modal-card ssh-key-modal"/);
|
|
assert.match(html, /type="submit"/);
|
|
assert.match(html, /type="file"/);
|
|
assert.match(html, /type="password"/);
|
|
assert.match(html, /rows="5"/);
|
|
assert.match(html, /test-validation-error/);
|
|
assert.equal((html.match(/ required/g) || []).length, 2);
|
|
assert.ok(html.includes(`generate-${platform}`));
|
|
assert.ok(html.includes(`install-${platform}`));
|
|
assert.ok(html.includes("deploy@example.test"));
|
|
}
|
|
const css = await readFile(new URL("./SSHKeyModal.css", import.meta.url), "utf8");
|
|
assert.match(css, /\.ssh-key-modal\s*\{[^}]*overflow:\s*auto;/);
|
|
});test("domainAction.refreshesPersistedFailureWithoutLosingError", async (t) => {
|
|
let issued = false;
|
|
const { state } = await mountComposable(t, useDashboard, async (path) => {
|
|
if (path.endsWith("/issue")) {
|
|
issued = true;
|
|
return Response.json({ error: "test-issue-failure" }, { status: 502 });
|
|
}
|
|
if (path.startsWith("/api/v1/tasks?")) {
|
|
return Response.json({ items: issued ? [{ id: "task-1", status: "failed" }] : [] });
|
|
}
|
|
return Response.json({ items: [] });
|
|
});
|
|
await state.issueDomain({ id: "domain-1", name: "example.test" });
|
|
assert.equal(state.error.value, "test-issue-failure");
|
|
assert.equal(state.notice.value, "");
|
|
assert.deepEqual(state.tasks.value, [{ id: "task-1", status: "failed" }]);
|
|
assert.equal(state.displayLabel(state.taskStatusLabels, "error"), state.taskStatusLabels.failed);
|
|
});
|
|
|
|
test("domainAction.preservesOriginalErrorWhenRefreshAlsoFails", async (t) => {
|
|
let issued = false;
|
|
const { state } = await mountComposable(t, useDashboard, async (path) => {
|
|
if (path.endsWith("/issue")) {
|
|
issued = true;
|
|
return Response.json({ error: "test-original-failure" }, { status: 502 });
|
|
}
|
|
if (issued) return Response.json({ error: "test-refresh-failure" }, { status: 503 });
|
|
return Response.json({ items: [] });
|
|
});
|
|
await state.issueDomain({ id: "domain-1", name: "example.test" });
|
|
assert.equal(state.error.value, "test-original-failure");
|
|
assert.equal(state.loading.value, false);
|
|
});
|
|
|
|
test("domainAction.refreshesSuccessfulResultAndRetainsNotice", async (t) => {
|
|
let completed = false;
|
|
const { state } = await mountComposable(t, useDashboard, async (path) => {
|
|
if (path.endsWith("/certificate/validate")) {
|
|
completed = true;
|
|
return Response.json({ valid: true });
|
|
}
|
|
if (path.startsWith("/api/v1/tasks?")) {
|
|
return Response.json({ items: completed ? [{ id: "task-2", status: "success" }] : [] });
|
|
}
|
|
return Response.json({ items: [] });
|
|
});
|
|
await state.validateDomain({ id: "domain-1", name: "example.test" });
|
|
assert.equal(state.error.value, "");
|
|
assert.match(state.notice.value, /example\.test/);
|
|
assert.deepEqual(state.tasks.value, [{ id: "task-2", status: "success" }]);
|
|
});
|
|
|
|
test("dashboardLayout.keepsActivityListsBoundedAndKeyboardAccessible", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./RuntimeOverview.vue", import.meta.url), "utf8");
|
|
const stylesheet = await readFile(new URL("./RuntimeOverview.css", import.meta.url), "utf8");
|
|
assert.match(template, /class="runtime-table-scroll" tabindex="0"/);
|
|
assert.match(template, /class="runtime-audit-list" tabindex="0"/);
|
|
assert.match(stylesheet, /\.runtime-audit-list\s*\{[^}]*max-height:[^;]+;[^}]*overflow:\s*auto;/);
|
|
assert.match(stylesheet, /\.runtime-table-scroll:focus-visible/);
|
|
assert.match(stylesheet, /\.runtime-audit-list:focus-visible/);
|
|
});
|
|
|
|
test("runtimeOverview.summarizesCertificateBoundariesAndConfiguration", () => {
|
|
const now = Date.parse("2026-09-25T12:00:00Z");
|
|
const day = 86400000;
|
|
const domains = ["valid", "near", "expired", "missing", "invalid", "future"].map((id) => ({ id, name: `${id}.test`, auto_renew: id === "valid" }));
|
|
const certificate = (id, end, start = now - day) => ({ domain: { id }, certificate: { saved: { not_after: end, not_before: new Date(start).toISOString() } } });
|
|
const result = summarizeRuntime({
|
|
domains,
|
|
certificates: [
|
|
certificate("valid", new Date(now + 11 * day).toISOString()),
|
|
certificate("near", new Date(now + 10 * day).toISOString()),
|
|
certificate("expired", new Date(now).toISOString()),
|
|
certificate("invalid", "invalid"),
|
|
certificate("future", new Date(now + 30 * day).toISOString(), now + day),
|
|
],
|
|
settings: { acme: { renewal_near_expiry_days: 10 } },
|
|
servers: [{ id: "server" }],
|
|
domainServers: { valid: [{ id: "server" }], near: [] },
|
|
}, now);
|
|
assert.equal(result.total, 6);
|
|
assert.equal(result.valid, 2);
|
|
assert.equal(result.expiring, 1);
|
|
assert.equal(result.expired, 1);
|
|
assert.equal(result.missing, 3);
|
|
assert.equal(result.alerts.length, 5);
|
|
assert.equal(result.alerts[0].id, "expired");
|
|
assert.equal(result.autoRenew, 1);
|
|
assert.equal(result.configuredServers, 1);
|
|
assert.equal(result.boundDomains, 1);
|
|
});
|
|
|
|
test("runtimeOverview.handlesEmptyDataThresholdsAndTaskOrdering", () => {
|
|
const empty = summarizeRuntime({});
|
|
for (const key of ["total", "valid", "expiring", "expired", "missing", "autoRenew", "configuredServers", "boundDomains", "activeTasks", "failedTasks"]) assert.equal(empty[key], 0);
|
|
for (const value of [0, -1, "invalid"]) assert.equal(summarizeRuntime({ settings: { acme: { renewal_near_expiry_days: value } } }).threshold, 10);
|
|
assert.equal(summarizeRuntime({ settings: { acme: { renewal_near_expiry_days: 30 } } }).threshold, 30);
|
|
const tasks = ["queued", "running", "failed", "error", "success", "cancelled"].map((status, index) => ({ id: index, status, created_at: `2026-09-25T12:0${index}:00Z` }));
|
|
const original = structuredClone(tasks);
|
|
const result = summarizeRuntime({ tasks });
|
|
assert.equal(result.activeTasks, 2);
|
|
assert.equal(result.failedTasks, 2);
|
|
assert.deepEqual(result.tasks.map((item) => item.id), [5, 4, 3, 2, 1, 0]);
|
|
assert.deepEqual(tasks, original);
|
|
assert.equal(runtimeTime(null), runtimeTime("invalid"));
|
|
assert.doesNotMatch(runtimeTime("2026-09-25T12:00:00Z"), /Invalid/);
|
|
});
|
|
|
|
test("runtimeOverview.defaultsToSummaryAndLimitsRecentTasks", async (t) => {
|
|
const data = {
|
|
domains: ref([{ id: "domain", name: "example.test" }]), certificates: ref([]),
|
|
servers: ref([]), domainServers: ref({}), settings: ref({}),
|
|
tasks: ref(Array.from({ length: 12 }, (_, id) => ({ id, status: "success" }))),
|
|
};
|
|
const { state } = await mountComposable(t, () => useRuntimeOverview(data), async () => Response.json({}));
|
|
assert.equal(state.detailView.value, "");
|
|
assert.equal(state.visibleTasks.value.length, 5);
|
|
state.detailView.value = "tasks";
|
|
assert.equal(state.visibleTasks.value.length, 12);
|
|
state.detailView.value = "";
|
|
assert.equal(state.visibleTasks.value.length, 5);
|
|
assert.equal(state.taskDomain({ domain_id: "domain" }), "example.test");
|
|
assert.notEqual(state.taskDomain({ task_type: "management_renewal" }), state.taskDomain({}));
|
|
});
|
|
|
|
test("runtimeOverview.compilesAndKeepsAuditOutOfDefaultView", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const { parse, compileScript, compileTemplate } = await import("@vue/compiler-sfc");
|
|
const { renderToString } = await import("@vue/server-renderer");
|
|
const Vue = await import("vue");
|
|
const source = await readFile(new URL("./RuntimeOverview.vue", import.meta.url), "utf8");
|
|
const { descriptor, errors } = parse(source);
|
|
assert.deepEqual(errors, []);
|
|
assert.ok(compileScript(descriptor, { id: "runtime-overview" }));
|
|
const compiled = compileTemplate({ source: descriptor.template.content, filename: "RuntimeOverview.vue", id: "runtime-overview", compilerOptions: { mode: "function" } });
|
|
assert.deepEqual(compiled.errors, []);
|
|
const render = new Function("Vue", compiled.code)(Vue);
|
|
for (const detailView of ["", "tasks", "audit"]) {
|
|
const app = Vue.createSSRApp({ render, setup: () => ({
|
|
loading: false, error: "", detailView, summary: summarizeRuntime({}),
|
|
visibleTasks: [], auditLogs: [{ id: "audit", action: "login", status: "success", message: "audit-only-marker" }],
|
|
auditActionLabel: (value) => value, statusClass: () => "success",
|
|
}) });
|
|
app.component("HelpTip", { render: () => null });
|
|
const warnings = [];
|
|
app.config.warnHandler = (message) => warnings.push(message);
|
|
const html = await renderToString(app);
|
|
assert.equal(html.includes('class="runtime-metrics"'), detailView === "");
|
|
assert.equal(html.includes("audit-only-marker"), detailView === "audit");
|
|
assert.deepEqual(warnings, []);
|
|
}
|
|
});
|
|
|
|
test("dashboardLayout.replacesHeroWithBasicInformationSummary", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./Dashboard.vue", import.meta.url), "utf8");
|
|
const stylesheet = await readFile(new URL("./Dashboard.css", import.meta.url), "utf8");
|
|
assert.doesNotMatch(template, /class="hero-card"/);
|
|
assert.match(template, /class="panel overview-panel"/);
|
|
assert.match(template, /当前用户/);
|
|
assert.match(template, /到期时间/);
|
|
assert.match(template, /部署服务器/);
|
|
assert.match(stylesheet, /\.overview-summary-grid\s*\{[^}]*grid-template-columns: repeat\(3/);
|
|
assert.match(stylesheet, /\.overview-domain-row\s*\{[^}]*grid-template-columns:/);
|
|
});
|
|
|
|
test("dashboardLayout.paginatesHostedDomainsWithConfiguredPageSizes", async (t) => {
|
|
const { state } = await mountComposable(t, useDashboard, async () => Response.json({ items: [] }));
|
|
state.domains.value = Array.from({ length: 16 }, (_, index) => ({
|
|
id: `domain-${index + 1}`,
|
|
name: `domain-${index + 1}.example.test`,
|
|
}));
|
|
await nextTick();
|
|
|
|
assert.deepEqual(state.domainPageSizeOptions, [5, 10, 15, 30]);
|
|
assert.equal(state.domainPageCount.value, 4);
|
|
assert.equal(state.paginatedDomains.value.length, 5);
|
|
assert.equal(state.domainPageStart.value, 1);
|
|
assert.equal(state.domainPageEnd.value, 5);
|
|
|
|
state.nextDomainPage();
|
|
assert.equal(state.domainPage.value, 2);
|
|
assert.equal(state.paginatedDomains.value[0].id, "domain-6");
|
|
|
|
state.domainPageSize.value = 10;
|
|
await nextTick();
|
|
assert.equal(state.domainPageCount.value, 2);
|
|
assert.equal(state.paginatedDomains.value.length, 10);
|
|
|
|
state.domainPage.value = 2;
|
|
state.domainPageSize.value = 5;
|
|
await nextTick();
|
|
assert.equal(state.domainPage.value, 1);
|
|
state.domainPage.value = 2;
|
|
state.nextDomainPage();
|
|
state.nextDomainPage();
|
|
assert.equal(state.domainPage.value, 4);
|
|
state.nextDomainPage();
|
|
assert.equal(state.domainPage.value, 4);
|
|
state.previousDomainPage();
|
|
assert.equal(state.domainPage.value, 3);
|
|
assert.equal(state.statusClass("valid"), "success");
|
|
assert.equal(state.displayLabel(state.domainStatusLabels, "valid"), "正常");
|
|
});
|
|
|
|
test("dashboardLayout.movesOverviewDetailsAboveHostedDomainList", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("./Dashboard.vue", import.meta.url), "utf8");
|
|
const detailsIndex = template.indexOf('class="overview-details-grid"');
|
|
const listHeadingIndex = template.indexOf('class="overview-domain-heading"');
|
|
assert.ok(detailsIndex >= 0);
|
|
assert.ok(listHeadingIndex >= 0);
|
|
assert.ok(detailsIndex < listHeadingIndex);
|
|
assert.match(template, /v-model\.number="domainPageSize"/);
|
|
assert.match(template, /上一页/);
|
|
assert.match(template, /下一页/);
|
|
});
|
|
|
|
test("dashboardLayout.usesSharedTooltipForUserManagementDescription", async () => {
|
|
const { readFile } = await import("node:fs/promises");
|
|
const template = await readFile(new URL("../UserManagement/UserManagement.vue", import.meta.url), "utf8");
|
|
assert.match(template, /import HelpTip from "\.\.\/components\/HelpTip\/HelpTip.vue";/);
|
|
assert.match(template, /<HelpTip>[\s\S]*?<\/HelpTip>/);
|
|
assert.doesNotMatch(template, /<p class="user-management-description">/);
|
|
});
|