Files
persionalBrand/apps/api/test/http.integration.test.js
T

1821 lines
72 KiB
JavaScript

import assert from "node:assert/strict";
import { after, before, test } from "node:test";
import { PrismaClient } from "@prisma/client";
import { createApp } from "../dist/main.js";
import { readIdentity, signIdentity } from "../dist/auth.js";
import { WechatAuthService } from "../dist/wechat-auth.js";
let app;
const prisma = new PrismaClient();
const brandId = process.env.DEFAULT_BRAND_ID;
const openid = `integration-${Date.now()}`;
let customerToken;
const createdBookingIds = [];
before(async () => {
await prisma.customerUser.create({ data: { brandId, openid } });
customerToken = signIdentity({ subject: openid, brandId, role: "customer" });
app = await createApp();
await app.init();
});
after(async () => {
await app.close();
await prisma.brandRelease.deleteMany({ where: { brandId } });
await prisma.booking.deleteMany({ where: { id: { in: createdBookingIds } } });
await prisma.customerUser.deleteMany({ where: { openid } });
await prisma.$disconnect();
});
test("admin release lifecycle is authorized, brand-scoped, and versioned", async () => {
const missing = await request("/admin/releases");
assert.equal(missing.statusCode, 401);
assert.equal((await request("/admin/releases/readiness")).statusCode, 401);
const customer = await request("/admin/releases", {
headers: { authorization: `Bearer ${customerToken}` },
});
assert.equal(customer.statusCode, 403);
assert.equal(
(
await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${customerToken}` },
})
).statusCode,
403,
);
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
assert.equal(login.statusCode, 201);
const adminToken = JSON.parse(login.body).token;
const readiness = await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(readiness.statusCode, 200);
assert.equal(JSON.parse(readiness.body).ready, true);
const enabledForms = await prisma.inquiryForm.findMany({
where: { brandId, isEnabled: true },
select: { id: true },
});
await prisma.inquiryForm.updateMany({ where: { brandId }, data: { isEnabled: false } });
try {
const noForms = await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(JSON.parse(noForms.body).ready, false);
assert.equal(
JSON.parse(noForms.body).checks.find((check) => check.key === "forms")?.passed,
false,
);
} finally {
await prisma.inquiryForm.updateMany({
where: { id: { in: enabledForms.map((form) => form.id) } },
data: { isEnabled: true },
});
}
const originalBrand = await prisma.brandProfile.findUniqueOrThrow({ where: { id: brandId } });
const originalConfig = originalBrand.config;
const originalOffering = await prisma.offering.findFirstOrThrow({ where: { brandId } });
await prisma.brandProfile.update({
where: { id: brandId },
data: {
config: {
...(originalConfig && typeof originalConfig === "object" ? originalConfig : {}),
heroImage: "",
founder: "",
},
},
});
const missingBrandContent = JSON.parse(
(
await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${adminToken}` },
})
).body,
);
assert.equal(missingBrandContent.ready, false);
assert.equal(
missingBrandContent.checks.find((check) => check.key === "asset:brand.stallHero")?.passed,
false,
);
assert.equal(
missingBrandContent.checks.find((check) => check.key === "content:identity:founder")
?.destination,
"/admin/brand",
);
assert.match(
missingBrandContent.checks.find((check) => check.key === "asset:brand.stallHero")?.help,
/真实摊位/,
);
assert.equal(
(
await request("/admin/releases/publish", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: {},
})
).statusCode,
400,
);
await prisma.brandProfile.update({
where: { id: brandId },
data: { config: originalConfig },
});
await prisma.offering.update({ where: { id: originalOffering.id }, data: { coverUrl: null } });
const missingOfferingImage = JSON.parse(
(
await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${adminToken}` },
})
).body,
);
assert.equal(missingOfferingImage.ready, false);
assert.equal(
missingOfferingImage.checks.find((check) => check.key === "asset:offering.cover")?.passed,
false,
);
await prisma.offering.update({
where: { id: originalOffering.id },
data: { coverUrl: originalOffering.coverUrl },
});
await prisma.brandProfile.update({ where: { id: brandId }, data: { tagline: "" } });
const incomplete = await request("/admin/releases/readiness", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(JSON.parse(incomplete.body).ready, false);
assert.equal(
(
await request("/admin/releases/publish", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: {},
})
).statusCode,
400,
);
await prisma.brandProfile.update({
where: { id: brandId },
data: { tagline: "集成测试待发布标语" },
});
const beforePublish = JSON.parse((await request("/public/workspace")).body);
assert.equal(beforePublish.brand.tagline, originalBrand.tagline);
const published = await request("/admin/releases/publish", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: { note: "集成测试发布" },
});
assert.equal(published.statusCode, 201);
const first = JSON.parse(published.body);
assert.equal(first.version, 2);
assert.equal(first.status, "published");
assert.equal(
JSON.parse((await request("/public/workspace")).body).brand.tagline,
"集成测试待发布标语",
);
const draftOnlyForm = await prisma.inquiryForm.create({
data: {
brandId,
name: "未发布的草稿表单",
fieldsSnapshot: [{ key: "phone", type: "phone", label: "手机", required: true }],
},
});
const draftSubmission = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: draftOnlyForm.id, values: { phone: "13871112222" } },
});
assert.equal(draftSubmission.statusCode, 400);
const listed = await request("/admin/releases", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(listed.statusCode, 200);
assert.equal(JSON.parse(listed.body)[0].version, 2);
const concurrent = await Promise.all(
["并发发布 A", "并发发布 B"].map((note) =>
request("/admin/releases/publish", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: { note },
}),
),
);
assert.deepEqual(
concurrent.map((item) => item.statusCode),
[201, 201],
);
assert.deepEqual(
concurrent.map((item) => JSON.parse(item.body).version).sort((a, b) => a - b),
[3, 4],
);
const rolledBack = await request("/admin/releases/1/rollback", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(rolledBack.statusCode, 201);
assert.equal(JSON.parse(rolledBack.body).version, 5);
assert.equal(
JSON.parse((await request("/public/workspace")).body).brand.tagline,
originalBrand.tagline,
);
const revoked = await request("/admin/releases/revoke", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: {},
});
assert.equal(revoked.statusCode, 201);
assert.equal(JSON.parse(revoked.body).status, "revoked");
assert.equal(JSON.parse(revoked.body).revokedBy, readIdentity(adminToken).subject);
const unpublished = JSON.parse((await request("/public/workspace")).body);
assert.equal(unpublished.publication.status, "unpublished");
assert.equal(unpublished.brand, null);
assert.deepEqual(unpublished.offerings, []);
assert.deepEqual(JSON.parse((await request("/public/offerings")).body), []);
const revokedSubmission = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: draftOnlyForm.id, values: { phone: "13871112222" } },
});
assert.equal(revokedSubmission.statusCode, 400);
const revokedBooking = await request("/customer/bookings", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: {
requestType: "inquiry",
customerName: "集成测试客户",
wechatId: "integration-wechat",
contactPreference: "wechat",
},
});
assert.equal(revokedBooking.statusCode, 400);
await prisma.inquiryForm.delete({ where: { id: draftOnlyForm.id } });
await prisma.brandProfile.update({
where: { id: brandId },
data: { tagline: originalBrand.tagline },
});
assert.equal((await publishReleaseForTests("恢复集成测试基线")).statusCode, 201);
});
async function request(url, options = {}) {
return app
.getHttpAdapter()
.getInstance()
.inject({ method: "GET", url, ...options });
}
async function publishReleaseForTests(note = "集成测试发布") {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
return request("/admin/releases/publish", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { note },
});
}
test("health and public content are available without authentication", async () => {
const health = await request("/health");
assert.equal(health.statusCode, 200);
assert.deepEqual(JSON.parse(health.body), { status: "ok", service: "personal-brand-api" });
const brand = await request("/public/brand");
assert.equal(brand.statusCode, 200);
assert.equal(JSON.parse(brand.body).name, "阿成家常菜");
const services = await request("/public/offerings");
assert.equal(services.statusCode, 200);
assert.ok(JSON.parse(services.body).length >= 3);
const removedServicesRoute = await request("/public/services");
assert.equal(removedServicesRoute.statusCode, 404);
const workspace = await request("/public/workspace");
assert.equal(workspace.statusCode, 200);
const runtime = JSON.parse(workspace.body);
assert.equal(runtime.schemaVersion, "1.0.0");
assert.ok(Array.isArray(runtime.navigation.tabs));
assert.ok(Array.isArray(runtime.modules));
assert.ok(Array.isArray(runtime.offerings));
assert.ok(Array.isArray(runtime.inquiryForms));
assert.ok(Array.isArray(runtime.capabilities));
assert.ok(runtime.theme.colors.background);
assert.ok(Array.isArray(runtime.plugins));
assert.equal(runtime.brand.founder, "阿成");
assert.ok(runtime.offerings.every((item) => item.coverUrl));
assert.ok(runtime.trustContent.length > 0);
const bySlug = await request("/public/workspace?brandSlug=default-brand");
assert.equal(bySlug.statusCode, 200);
assert.equal(JSON.parse(bySlug.body).brand.id, brandId);
const missingSlug = await request("/public/workspace?brandSlug=missing-brand");
assert.equal(missingSlug.statusCode, 404);
});
test("visual template compatibility is enforced by catalog, preview, and brand switching", async () => {
const catalog = await request("/public/templates");
assert.equal(catalog.statusCode, 200);
const visuals = JSON.parse(catalog.body).visuals;
assert.deepEqual(
visuals.find((visual) => visual.key === "linjing-editorial").supportedIndustryTemplates,
["personal", "doors"],
);
const incompatiblePreview = await request(
"/public/templates/preview?industry=food&visual=linjing-editorial",
);
assert.equal(incompatiblePreview.statusCode, 400);
const compatiblePreview = await request(
"/public/templates/preview?industry=doors&visual=linjing-editorial",
);
assert.equal(compatiblePreview.statusCode, 200);
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const compatibleSwitch = await request("/admin/config/brand", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { config: { visualTemplateKey: "acheng-campus-food" } },
});
assert.equal(compatibleSwitch.statusCode, 200);
});
test("seeded public workspaces keep personal, food, and doors brands isolated", async () => {
const expected = [
{
slug: "linran-brand",
id: "00000000-0000-0000-0000-000000000003",
templateKey: "personal",
founder: "林然",
offeringKind: "service",
categoryLabel: "策略咨询",
},
{
slug: "default-brand",
id: "00000000-0000-0000-0000-000000000001",
templateKey: "food",
founder: "阿成",
offeringKind: "package",
categoryLabel: "套餐",
},
{
slug: "linjing-doors",
id: "00000000-0000-0000-0000-000000000002",
templateKey: "doors",
founder: "林叙安 (Lin XUAN)",
offeringKind: "product",
categoryLabel: "入户大门",
},
];
const workspaces = await Promise.all(
expected.map(async (item) => {
const response = await request(`/public/workspace?brandSlug=${item.slug}`);
assert.equal(response.statusCode, 200);
const workspace = JSON.parse(response.body);
assert.equal(workspace.brand.id, item.id);
assert.equal(workspace.template.key, item.templateKey);
assert.ok(workspace.visualTemplate?.key);
assert.ok(workspace.visualTemplateManifest?.pages?.length > 0);
assert.equal(workspace.navigation.tabs.length, item.templateKey === "food" ? 5 : 3);
assert.equal("templatePackageManifest" in workspace, false);
assert.equal(workspace.brand.founder, item.founder);
assert.ok(workspace.trustContent.length > 0);
assert.ok(workspace.trustPresentation);
assert.ok(workspace.inquiryForm);
assert.equal(workspace.inquiryForm.isEnabled, true);
assert.ok(workspace.offerings.length > 0);
assert.ok(workspace.offerings.every((offering) => offering.brandId === undefined));
assert.ok(
workspace.offerings.some(
(offering) =>
offering.kind === item.offeringKind &&
offering.presentation?.categoryLabel === item.categoryLabel,
),
);
if (item.templateKey === "doors") {
assert.ok(workspace.offerings.some((offering) => offering.presentation.series));
assert.ok(workspace.offerings.some((offering) => offering.presentation.hardware));
}
return workspace;
}),
);
assert.equal(new Set(workspaces.map((workspace) => workspace.brand.id)).size, 3);
});
test("public workspace uses brand-scoped capability installations and preserves status", async () => {
await prisma.capabilityInstallation.deleteMany({ where: { brandId } });
const installation = await prisma.capabilityInstallation.create({
data: {
brandId,
capabilityKey: "inquiry",
capabilityVersion: "1.0.0",
status: "disabled",
config: { source: "integration-test" },
},
});
try {
const published = await publishReleaseForTests();
assert.equal(published.statusCode, 201);
const response = await request("/public/workspace");
assert.equal(response.statusCode, 200);
const body = JSON.parse(response.body);
assert.deepEqual(body.runtimeCapabilities, [
{
key: "inquiry",
version: "1.0.0",
status: "disabled",
config: { source: "integration-test" },
},
]);
assert.notEqual(body.runtimeCapabilities[0].status, "enabled");
} finally {
await prisma.capabilityInstallation.delete({ where: { id: installation.id } });
}
});
test("admin can update declared capability status with authorization and audit", async () => {
const unauthorized = await request("/admin/workspace/capabilities/inquiry", {
method: "PATCH",
payload: { capabilityVersion: "1.0.0", status: "disabled" },
});
assert.equal(unauthorized.statusCode, 401);
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const updated = await request("/admin/workspace/capabilities/inquiry", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { capabilityVersion: "1.0.0", status: "disabled", config: { mode: "manual" } },
});
assert.equal(updated.statusCode, 200);
assert.equal(JSON.parse(updated.body).status, "disabled");
const audit = await prisma.capabilityAuditLog.findFirst({
where: { brandId, capabilityKey: "inquiry" },
orderBy: { createdAt: "desc" },
});
assert.ok(audit);
assert.equal(audit.toStatus, "disabled");
await prisma.capabilityInstallation.deleteMany({ where: { brandId } });
await prisma.capabilityAuditLog.deleteMany({ where: { brandId } });
});
test("editor membership can manage brand content but cannot change system settings", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const identity = readIdentity(token);
const membership = await prisma.brandMembership.findUnique({
where: { adminUserId_brandId: { adminUserId: identity.subject, brandId } },
});
assert.ok(membership);
await prisma.brandMembership.update({ where: { id: membership.id }, data: { role: "editor" } });
try {
const offerings = await request("/admin/workspace/offerings", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(offerings.statusCode, 200);
const capabilities = await request("/admin/workspace/capabilities", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(capabilities.statusCode, 403);
const visualHistory = await request("/admin/config/visual-template/history", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(visualHistory.statusCode, 403);
const visualUpdate = await request("/admin/config/brand", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { config: { visualTemplateKey: "unknown-visual" } },
});
assert.equal(visualUpdate.statusCode, 403);
} finally {
await prisma.brandMembership.update({
where: { id: membership.id },
data: { role: membership.role },
});
}
});
test("owner can manage brand members without removing the final owner", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const identity = readIdentity(token);
const members = await request("/admin/brands/members", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(members.statusCode, 200);
const current = JSON.parse(members.body).find((item) => item.adminUserId === identity.subject);
assert.ok(current);
const selfDisable = await request(`/admin/brands/members/${current.id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: false },
});
assert.equal(selfDisable.statusCode, 400);
const created = await request("/admin/brands/members", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
username: `editor-${Date.now()}`,
displayName: "测试编辑",
password: "test-password-123",
role: "editor",
},
});
assert.equal(created.statusCode, 201);
const guestMembership = JSON.parse(created.body);
try {
const updated = await request(`/admin/brands/members/${guestMembership.id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: false },
});
assert.equal(updated.statusCode, 200);
assert.equal(JSON.parse(updated.body).isEnabled, false);
} finally {
await prisma.brandMembership.delete({ where: { id: guestMembership.id } });
await prisma.adminUser.delete({ where: { id: guestMembership.adminUser.id } });
}
});
test("manually created member must change the initial password before normal use", async () => {
const ownerLogin = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const ownerToken = JSON.parse(ownerLogin.body).token;
const username = `first-login-${Date.now()}`;
const created = await request("/admin/brands/members", {
method: "POST",
headers: { authorization: `Bearer ${ownerToken}` },
payload: {
username,
displayName: "首次登录测试",
password: "initial-password-123",
role: "editor",
},
});
assert.equal(created.statusCode, 201);
const member = JSON.parse(created.body);
assert.equal(member.adminUser.mustChangePassword, undefined);
try {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username, password: "initial-password-123" },
});
assert.equal(login.statusCode, 201);
assert.equal(JSON.parse(login.body).mustChangePassword, true);
const changed = await request("/admin/session/change-password", {
method: "POST",
headers: { authorization: `Bearer ${JSON.parse(login.body).token}` },
payload: { currentPassword: "initial-password-123", newPassword: "updated-password-123" },
});
assert.equal(changed.statusCode, 201);
const updatedLogin = await request("/admin/session/login", {
method: "POST",
payload: { username, password: "updated-password-123" },
});
assert.equal(updatedLogin.statusCode, 201);
assert.equal(JSON.parse(updatedLogin.body).mustChangePassword, false);
} finally {
await prisma.brandMembership.delete({ where: { id: member.id } });
await prisma.adminUser.delete({ where: { id: member.adminUser.id } });
}
});
test("admin can install optional quote capability without industry-specific branching", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const response = await request("/admin/workspace/capabilities/quote-request", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { capabilityVersion: "1.0.0", status: "enabled", config: { currency: "CNY" } },
});
assert.equal(response.statusCode, 200);
assert.equal(JSON.parse(response.body).capabilityKey, "quote-request");
assert.equal((await publishReleaseForTests()).statusCode, 201);
const workspace = await request("/public/workspace");
assert.ok(JSON.parse(workspace.body).plugins.some((plugin) => plugin.key === "quote-request"));
await prisma.capabilityInstallation.deleteMany({
where: { brandId, capabilityKey: "quote-request" },
});
await prisma.capabilityAuditLog.deleteMany({
where: { brandId, capabilityKey: "quote-request" },
});
});
test("admin capability list includes template defaults and brand overrides", async () => {
await prisma.capabilityInstallation.deleteMany({ where: { brandId } });
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const defaults = await request("/admin/workspace/capabilities", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(defaults.statusCode, 200);
const defaultBody = JSON.parse(defaults.body);
assert.ok(
defaultBody.some((item) => item.capabilityKey === "inquiry" && item.source === "template"),
);
await prisma.capabilityInstallation.create({
data: {
brandId,
capabilityKey: "inquiry",
capabilityVersion: "1.0.0",
status: "disabled",
config: { mode: "manual" },
},
});
const overrides = await request("/admin/workspace/capabilities", {
headers: { authorization: `Bearer ${token}` },
});
const override = JSON.parse(overrides.body).find((item) => item.capabilityKey === "inquiry");
assert.equal(override.source, "brand");
assert.equal(override.status, "disabled");
assert.deepEqual(override.config, { mode: "manual" });
await prisma.capabilityInstallation.deleteMany({ where: { brandId } });
});
test("admin can install doors industry template through the shared runtime contract", async () => {
await prisma.inquirySubmission.deleteMany({ where: { brandId } });
await prisma.inquiryForm.deleteMany({ where: { brandId } });
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
try {
const installed = await request("/admin/workspace/install", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { templateKey: "doors" },
});
assert.equal(installed.statusCode, 201);
assert.equal(JSON.parse(installed.body).template.key, "doors");
const workspace = await request("/public/workspace");
assert.equal(workspace.statusCode, 200);
const body = JSON.parse(workspace.body);
assert.equal(body.template.key, "food");
assert.equal(body.publication.status, "published");
const samplePreview = await request("/admin/workspace/sample-content/preview", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(samplePreview.statusCode, 200);
assert.equal(JSON.parse(samplePreview.body).templateKey, "doors");
} finally {
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
}
});
test("admin can preview and import sample content idempotently", async () => {
const originalBrand = await prisma.brandProfile.findUnique({ where: { id: brandId } });
await prisma.brandProfile.update({ where: { id: brandId }, data: { templateKey: "doors" } });
await prisma.offering.deleteMany({
where: {
brandId,
name: { in: ["序章·入户门", "庭院·边界门", "室内·静谧门", "一对一门系统设计咨询"] },
},
});
await prisma.trustContent.deleteMany({
where: { brandId, content: "示例内容,待品牌主理人完善。" },
});
await prisma.brandFieldDefinition.deleteMany({ where: { brandId, source: "sample" } });
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const preview = await request("/admin/workspace/sample-content/preview", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(preview.statusCode, 200);
const imported = await request("/admin/workspace/sample-content/import", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(imported.statusCode, 201);
const duplicate = await request("/admin/workspace/sample-content/import", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(duplicate.statusCode, 400);
await prisma.offering.deleteMany({
where: {
brandId,
name: { in: ["序章·入户门", "庭院·边界门", "室内·静谧门", "一对一门系统设计咨询"] },
},
});
await prisma.trustContent.deleteMany({
where: { brandId, content: "示例内容,待品牌主理人完善。" },
});
await prisma.brandFieldDefinition.deleteMany({ where: { brandId, source: "sample" } });
await prisma.capabilityAuditLog.deleteMany({ where: { brandId, capabilityKey: "doors" } });
await prisma.brandProfile.update({
where: { id: brandId },
data: { templateKey: originalBrand?.templateKey ?? "food" },
});
});
test("admin can install a template and public workspace exposes enabled configuration", async () => {
await prisma.inquirySubmission.deleteMany({ where: { brandId } });
await prisma.inquiryForm.deleteMany({ where: { brandId } });
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const before = await request("/admin/workspace");
assert.equal(before.statusCode, 401);
const customerAccess = await request("/admin/workspace", {
headers: { authorization: `Bearer ${customerToken}` },
});
assert.equal(customerAccess.statusCode, 403);
const installed = await request("/admin/workspace/install", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { templateKey: "personal" },
});
assert.equal(installed.statusCode, 201);
assert.equal(JSON.parse(installed.body).template.key, "personal");
assert.equal(JSON.parse(installed.body).visualTemplate.key, "linjing-editorial");
assert.equal(JSON.parse(installed.body).installation.configSnapshot.schemaVersion, "1.0");
try {
const previewUnauthorized = await request("/admin/workspace/template/preview");
assert.equal(previewUnauthorized.statusCode, 401);
const preview = await request("/admin/workspace/template/preview", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(preview.statusCode, 200);
assert.equal(JSON.parse(preview.body).canUpgrade, false);
const rollbackUnauthorized = await request("/admin/workspace/template/rollback", {
method: "POST",
});
assert.equal(rollbackUnauthorized.statusCode, 401);
const installedRecord = JSON.parse(installed.body).installation;
await prisma.brandTemplateInstallation.update({
where: { id: installedRecord.id },
data: {
templateVersion: "2.0.0",
previousSnapshots: [installedRecord.configSnapshot],
},
});
const rollback = await request("/admin/workspace/template/rollback", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(rollback.statusCode, 201);
assert.equal(JSON.parse(rollback.body).installation.templateVersion, "1.0.0");
assert.equal(JSON.parse(rollback.body).installation.previousSnapshots.length, 0);
assert.match(JSON.parse(rollback.body).note, /配置基线/);
const workspace = await request("/admin/workspace", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(workspace.statusCode, 200);
assert.equal(JSON.parse(workspace.body).installations.length, 1);
assert.equal(JSON.parse(workspace.body).fields.length, 5);
const templateContent = JSON.parse(workspace.body).templateContent;
assert.equal(templateContent.displayName, "阿成校园餐");
assert.ok(templateContent.admin.sections.some((section) => section.title === "首页出摊信息"));
assert.ok(
templateContent.admin.sections
.flatMap((section) => section.fields)
.some((field) => field.binding === "brand.config.heroImage"),
);
const publicWorkspace = await request("/public/workspace");
assert.equal(publicWorkspace.statusCode, 200);
const workspaceBody = JSON.parse(publicWorkspace.body);
assert.equal(workspaceBody.contractVersion, "1.0");
assert.equal(workspaceBody.template.key, "food");
assert.ok(workspaceBody.modules.length > 0);
assert.equal(workspaceBody.modules.length, workspaceBody.runtimeModules.length);
assert.equal("templateContent" in workspaceBody, false);
assert.equal(workspaceBody.runtimeModules[0].schemaVersion, "1.0");
assert.ok(workspaceBody.inquiryForm);
const conflict = await request("/admin/workspace/install", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { templateKey: "food" },
});
assert.equal(conflict.statusCode, 400);
} finally {
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
}
});
test("admin can customize workspace modules and fields with brand isolation", async () => {
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const install = await request("/admin/workspace/install", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { templateKey: "food" },
});
assert.equal(install.statusCode, 201);
const workspace = await request("/admin/workspace", {
headers: { authorization: `Bearer ${token}` },
});
const moduleId = JSON.parse(workspace.body).modules[0].id;
const invalidField = await request("/admin/workspace/fields", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { scope: "unknown", key: "Bad-Key", label: "非法字段", type: "text" },
});
assert.equal(invalidField.statusCode, 400);
const updatedModule = await request(`/admin/workspace/modules/${moduleId}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { title: "我的品牌介绍", isEnabled: false },
});
assert.equal(updatedModule.statusCode, 200);
const createdField = await request("/admin/workspace/fields", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
scope: "profile",
key: `region_${Date.now()}`,
label: "服务区域",
type: "text",
required: false,
},
});
assert.equal(createdField.statusCode, 201);
const fieldId = JSON.parse(createdField.body).id;
try {
const updatedField = await request(`/admin/workspace/fields/${fieldId}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { label: "主要服务区域", visibleWhen: { mode: "all", rules: [] } },
});
assert.equal(updatedField.statusCode, 200);
const deletedField = await request(`/admin/workspace/fields/${fieldId}`, {
method: "DELETE",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(deletedField.statusCode, 200);
} finally {
await prisma.brandFieldDefinition.deleteMany({ where: { brandId } });
await prisma.brandModule.deleteMany({ where: { brandId } });
await prisma.brandTemplateInstallation.deleteMany({ where: { brandId } });
}
});
test("admin visual template selection is reflected in public runtime workspace", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const before = await request("/public/workspace");
assert.equal(before.statusCode, 200);
const updated = await request("/admin/config/brand", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { config: { visualTemplateKey: "acheng-campus-food" } },
});
assert.equal(updated.statusCode, 200);
try {
const runtime = await request("/public/workspace");
assert.equal(runtime.statusCode, 200);
const body = JSON.parse(runtime.body);
assert.equal(body.visualTemplate.key, "acheng-campus-food");
assert.equal(body.visualTemplate.version, "1.0.0");
assert.equal(body.theme.colors.accent, "#E87532");
assert.equal(body.visualTemplate.variants.hero, "stall-board");
assert.equal(body.visualTemplateManifest.key, "acheng-campus-food");
assert.equal(body.visualTemplateManifest.brandFirst, true);
assert.deepEqual(
body.visualTemplateManifest.pages.map((page) => page.key),
["home", "offerings", "detail", "inquiry", "success", "records", "profile"],
);
} finally {
await request("/admin/config/brand", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { config: JSON.parse(before.body).brand?.config ?? {} },
});
}
});
test("public workspace exposes declared brand and trust presentation data", async () => {
const doorsBrand = await prisma.brandProfile.findUnique({ where: { slug: "linjing-doors" } });
assert.ok(doorsBrand);
const original = doorsBrand;
await prisma.brandProfile.update({
where: { id: doorsBrand.id },
data: {
config: {
...(original?.config && typeof original.config === "object" ? original.config : {}),
homeHero: { title: "尚未发布的集成测试首页标题" },
},
},
});
try {
const runtime = await request("/public/workspace?brandSlug=linjing-doors");
assert.equal(runtime.statusCode, 200);
const body = JSON.parse(runtime.body);
assert.equal(body.brand.founder, "林叙安 (Lin XUAN)");
assert.equal(body.brand.title, "高端门系统建筑研造主理人");
assert.notEqual(body.brand.homeHero.title, "尚未发布的集成测试首页标题");
assert.equal(body.trustPresentation.stats.length, 4);
assert.equal(body.trustPresentation.pillars.length, 3);
assert.equal(body.trustPresentation.serviceFlow.length, 6);
assert.equal(body.brand.profilePresentation.coverage.length, 2);
assert.equal(body.brand.profilePresentation.warranty.length, 4);
assert.equal(body.brand.visualPresentation.home.proofTitle, "14 年,只做门与空间的关系");
assert.equal(body.brand.visualPresentation.inquiry.submitLabel, "提交量房与定制评估需求");
assert.equal(body.brand.visualPresentation.records.emptyAction, "开始咨询");
assert.equal(body.offerings.length, 4);
assert.ok(body.offerings.every((offering) => offering.presentation.heroImage));
assert.ok(
body.offerings.every((offering) => offering.presentation.details.materialsList.length),
);
const doorType = body.inquiryForms[0].fields.find((field) => field.key === "doorType");
assert.equal(doorType.options.length, 5);
assert.equal(doorType.options[0].value, "入户大门(防暴铸铜 / 实木)");
} finally {
await prisma.brandProfile.update({
where: { id: doorsBrand.id },
data: { config: original?.config ?? {} },
});
}
});
test("admin can create and version an inquiry form", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const offering = await prisma.offering.findFirst({ where: { brandId, isEnabled: true } });
assert.ok(offering);
const created = await request("/admin/workspace/forms", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
name: "品牌合作咨询",
offeringId: offering.id,
fieldsSnapshot: [{ key: "project", type: "textarea", label: "项目背景", required: true }],
},
});
assert.equal(created.statusCode, 201);
const id = JSON.parse(created.body).id;
try {
const disabledForm = await request(`/admin/workspace/forms/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: false },
});
assert.equal(disabledForm.statusCode, 200);
assert.equal(JSON.parse(disabledForm.body).isEnabled, false);
assert.equal((await request(`/public/inquiry-forms/${id}`)).statusCode, 400);
const blockedDisabledForm = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: id, values: { budget: 1000 } },
});
assert.equal(blockedDisabledForm.statusCode, 400);
const enabledForm = await request(`/admin/workspace/forms/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: true },
});
assert.equal(enabledForm.statusCode, 200);
const updated = await request(`/admin/workspace/forms/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: {
fieldsSnapshot: [
{ key: "budget", type: "number", label: "预算", required: true },
{
key: "contact_method",
type: "select",
label: "联系渠道",
options: [{ label: "微信", value: "wechat" }],
},
],
},
});
assert.equal(updated.statusCode, 200);
assert.equal(JSON.parse(updated.body).version, 2);
await prisma.offering.update({ where: { id: offering.id }, data: { isEnabled: false } });
assert.equal((await request(`/public/inquiry-forms/${id}`)).statusCode, 400);
const blockedSubmission = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: id, values: { budget: 1000 } },
});
assert.equal(blockedSubmission.statusCode, 400);
await prisma.offering.update({ where: { id: offering.id }, data: { isEnabled: true } });
const missingRequired = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: id, values: {} },
});
assert.equal(missingRequired.statusCode, 400);
const capability = await prisma.capabilityInstallation.create({
data: {
brandId,
capabilityKey: "inquiry",
capabilityVersion: "1.0.0",
status: "disabled",
},
});
const blockedCapability = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: id, values: { budget: 1000 } },
});
assert.equal(blockedCapability.statusCode, 400);
await prisma.capabilityInstallation.delete({ where: { id: capability.id } });
assert.equal((await publishReleaseForTests()).statusCode, 201);
const publicForm = await request(`/public/inquiry-forms/${id}`);
assert.equal(publicForm.statusCode, 200);
const publicOffering = await request(`/public/offerings/${offering.id}`);
assert.equal(publicOffering.statusCode, 200);
assert.equal(JSON.parse(publicOffering.body).inquiryForms[0].id, id);
const publicWorkspace = await request("/public/workspace");
assert.equal(publicWorkspace.statusCode, 200);
assert.equal(JSON.parse(publicWorkspace.body).inquiryForm.id, id);
assert.ok(
JSON.parse(publicWorkspace.body).inquiryForms.some(
(form) => form.key === id && form.targetId === offering.id,
),
);
const runtimeForm = JSON.parse(publicWorkspace.body).inquiryForms.find(
(form) => form.key === id,
);
assert.deepEqual(runtimeForm.fields[1].options, [{ label: "微信", value: "wechat" }]);
await prisma.inquiryForm.update({
where: { id },
data: {
version: 3,
fieldsSnapshot: [{ key: "draft_only", type: "text", label: "草稿字段", required: true }],
},
});
const submission = await request("/customer/inquiry-submissions", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: { formId: id, values: { budget: 1000, ignored: "not persisted" } },
});
assert.equal(submission.statusCode, 201);
assert.equal(JSON.parse(submission.body).formVersion, 2);
assert.equal(JSON.parse(submission.body).fieldsSnapshot[0].key, "budget");
assert.equal(JSON.parse(submission.body).offeringId, offering.id);
assert.deepEqual(JSON.parse(submission.body).values, { budget: 1000 });
assert.equal((await request("/customer/inquiry-submissions")).statusCode, 401);
const adminCannotListCustomerSubmissions = await request("/customer/inquiry-submissions", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(adminCannotListCustomerSubmissions.statusCode, 403);
const customerSubmissions = await request("/customer/inquiry-submissions", {
headers: { authorization: `Bearer ${customerToken}` },
});
assert.equal(customerSubmissions.statusCode, 200);
assert.ok(
JSON.parse(customerSubmissions.body).some(
(item) => item.id === JSON.parse(submission.body).id,
),
);
const customerSubmission = await request(
`/customer/inquiry-submissions/${JSON.parse(submission.body).id}`,
{ headers: { authorization: `Bearer ${customerToken}` } },
);
assert.equal(customerSubmission.statusCode, 200);
assert.equal(JSON.parse(customerSubmission.body).customerSubject, undefined);
const missingCustomerSubmission = await request(
"/customer/inquiry-submissions/00000000-0000-0000-0000-000000000000",
{ headers: { authorization: `Bearer ${customerToken}` } },
);
assert.equal(missingCustomerSubmission.statusCode, 404);
const adminSubmissionsWithoutToken = await request("/admin/workspace/submissions");
assert.equal(adminSubmissionsWithoutToken.statusCode, 401);
const adminSubmissions = await request("/admin/workspace/submissions", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(adminSubmissions.statusCode, 200);
assert.ok(
JSON.parse(adminSubmissions.body).some((item) => item.id === JSON.parse(submission.body).id),
);
const savedSubmission = JSON.parse(adminSubmissions.body).find(
(item) => item.id === JSON.parse(submission.body).id,
);
assert.equal(savedSubmission.offering.id, offering.id);
const customerUpdate = await request(`/admin/workspace/submissions/${savedSubmission.id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${customerToken}` },
payload: { status: "replied" },
});
assert.equal(customerUpdate.statusCode, 403);
const updatedSubmission = await request(`/admin/workspace/submissions/${savedSubmission.id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { status: "reviewing", adminNote: "已开始评估需求" },
});
assert.equal(updatedSubmission.statusCode, 200);
assert.equal(JSON.parse(updatedSubmission.body).status, "reviewing");
assert.equal(JSON.parse(updatedSubmission.body).adminNote, "已开始评估需求");
const customerSubmissionAfterUpdate = await request(
`/customer/inquiry-submissions/${savedSubmission.id}`,
{ headers: { authorization: `Bearer ${customerToken}` } },
);
assert.equal(customerSubmissionAfterUpdate.statusCode, 200);
const customerBody = JSON.parse(customerSubmissionAfterUpdate.body);
assert.equal(customerBody.adminNote, undefined);
assert.equal(customerBody.statusHistory[0].toStatus, "reviewing");
assert.equal(customerBody.statusHistory[0].adminNote, undefined);
const history = await prisma.inquirySubmissionStatusHistory.findMany({
where: { submissionId: savedSubmission.id },
});
assert.equal(history.length, 1);
assert.equal(history[0].toStatus, "reviewing");
} finally {
await prisma.inquirySubmission.deleteMany({ where: { inquiryFormId: id } });
await prisma.inquiryForm.delete({ where: { id } });
}
});
test("admin rejects invalid dynamic inquiry field definitions", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const invalid = await request("/admin/workspace/forms", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
name: "非法字段表单",
fieldsSnapshot: [{ key: "ContactMethod", type: "select", label: "渠道", options: [] }],
},
});
assert.equal(invalid.statusCode, 400);
});
test("admin can manage offerings and public endpoint hides disabled offerings", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const invalidConfig = await request("/admin/workspace/offerings", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
kind: "product",
name: `无效配置-${Date.now()}`,
config: { sections: "必须是数组" },
},
});
assert.equal(invalidConfig.statusCode, 400);
const created = await request("/admin/workspace/offerings", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: {
kind: "product",
name: `测试提供项-${Date.now()}`,
summary: "测试摘要",
isEnabled: true,
},
});
assert.equal(created.statusCode, 201);
const id = JSON.parse(created.body).id;
try {
const listed = await request("/admin/workspace/offerings", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(listed.statusCode, 200);
assert.ok(JSON.parse(listed.body).some((item) => item.id === id));
const publicItem = await request(`/public/offerings/${id}`);
assert.equal(publicItem.statusCode, 400);
const publicList = await request("/public/offerings");
assert.equal(publicList.statusCode, 200);
assert.ok(!JSON.parse(publicList.body).some((item) => item.id === id));
const updated = await request(`/admin/workspace/offerings/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: false },
});
assert.equal(updated.statusCode, 200);
const hidden = await request(`/public/offerings/${id}`);
assert.equal(hidden.statusCode, 400);
const reenabled = await request(`/admin/workspace/offerings/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { isEnabled: true },
});
assert.equal(reenabled.statusCode, 200);
assert.equal((await request(`/public/offerings/${id}`)).statusCode, 400);
} finally {
const deleted = await request(`/admin/workspace/offerings/${id}`, {
method: "DELETE",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(deleted.statusCode, 200);
assert.equal(await prisma.offering.findUnique({ where: { id } }), null);
}
});
test("offering with an inquiry form cannot be deleted", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const offering = await prisma.offering.create({
data: { brandId, kind: "service", name: `保护测试-${Date.now()}`, description: "测试" },
});
const form = await prisma.inquiryForm.create({
data: { brandId, offeringId: offering.id, name: "保护测试表单", fieldsSnapshot: [] },
});
try {
const response = await request(`/admin/workspace/offerings/${offering.id}`, {
method: "DELETE",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(response.statusCode, 400);
} finally {
await prisma.inquiryForm.delete({ where: { id: form.id } });
await prisma.offering.delete({ where: { id: offering.id } });
}
});
test("admin booking endpoints reject missing or customer credentials", async () => {
const missing = await request("/admin/bookings");
assert.equal(missing.statusCode, 401);
const customer = await request("/admin/bookings", {
headers: { authorization: "Bearer invalid-token" },
});
assert.equal(customer.statusCode, 401);
});
test("seeded admin can log in and read protected booking resources", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
assert.equal(login.statusCode, 201);
const token = JSON.parse(login.body).token;
assert.ok(token);
const count = await request("/admin/bookings/unread-count", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(count.statusCode, 200);
assert.equal(typeof JSON.parse(count.body).count, "number");
const tags = await request("/admin/bookings/tags", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(tags.statusCode, 200);
assert.equal(JSON.parse(tags.body).length, 6);
});
test("admin login validates credentials", async () => {
const response = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: "wrong-password" },
});
assert.equal(response.statusCode, 401);
});
test("admin can list and switch only enabled brand memberships", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const brands = await request("/admin/brands", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(brands.statusCode, 200);
const memberships = JSON.parse(brands.body);
assert.ok(memberships.some((item) => item.brand.id === brandId));
assert.ok(memberships.some((item) => item.brand.slug === "linjing-doors"));
assert.ok(memberships.length >= 2);
const denied = await request("/admin/brands/00000000-0000-0000-0000-000000000000/switch", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(denied.statusCode, 403);
});
test("brand switching isolates admin configuration, offerings, and public workspace", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
assert.equal(login.statusCode, 201);
const defaultToken = JSON.parse(login.body).token;
const memberships = JSON.parse(
(
await request("/admin/brands", {
headers: { authorization: `Bearer ${defaultToken}` },
})
).body,
);
const doorsBrand = memberships.find((item) => item.brand.slug === "linjing-doors")?.brand;
assert.ok(doorsBrand);
const switched = await request(`/admin/brands/${doorsBrand.id}/switch`, {
method: "POST",
headers: { authorization: `Bearer ${defaultToken}` },
});
assert.equal(switched.statusCode, 201);
const doorsToken = JSON.parse(switched.body).token;
const [
defaultConfig,
doorsConfig,
defaultOfferings,
doorsOfferings,
defaultAdminWorkspace,
doorsAdminWorkspace,
doorsWorkspace,
] = await Promise.all([
request("/admin/config/brand", {
headers: { authorization: `Bearer ${defaultToken}` },
}),
request("/admin/config/brand", {
headers: { authorization: `Bearer ${doorsToken}` },
}),
request("/admin/workspace/offerings", {
headers: { authorization: `Bearer ${defaultToken}` },
}),
request("/admin/workspace/offerings", {
headers: { authorization: `Bearer ${doorsToken}` },
}),
request("/admin/workspace", {
headers: { authorization: `Bearer ${defaultToken}` },
}),
request("/admin/workspace", {
headers: { authorization: `Bearer ${doorsToken}` },
}),
request("/public/workspace?brandSlug=linjing-doors"),
]);
assert.equal(defaultConfig.statusCode, 200);
assert.equal(doorsConfig.statusCode, 200);
assert.equal(JSON.parse(defaultConfig.body).id, brandId);
assert.equal(JSON.parse(doorsConfig.body).id, doorsBrand.id);
assert.equal(defaultOfferings.statusCode, 200);
assert.equal(doorsOfferings.statusCode, 200);
assert.notDeepEqual(
JSON.parse(defaultOfferings.body).map((item) => item.id),
JSON.parse(doorsOfferings.body).map((item) => item.id),
);
assert.equal(doorsWorkspace.statusCode, 200);
assert.equal(JSON.parse(doorsWorkspace.body).brand.id, doorsBrand.id);
assert.equal(JSON.parse(doorsWorkspace.body).template.key, "doors");
assert.equal(defaultAdminWorkspace.statusCode, 200);
assert.equal(doorsAdminWorkspace.statusCode, 200);
assert.equal(JSON.parse(defaultAdminWorkspace.body).templateContent.displayName, "阿成校园餐");
assert.equal(JSON.parse(doorsAdminWorkspace.body).templateContent.displayName, "林境建筑画册");
});
test("disabled brand membership blocks existing admin token", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const admin = await prisma.adminUser.findUnique({ where: { username: "admin" } });
assert.ok(admin);
const membership = await prisma.brandMembership.findUnique({
where: { adminUserId_brandId: { adminUserId: admin.id, brandId } },
});
assert.ok(membership);
await prisma.brandMembership.update({ where: { id: membership.id }, data: { isEnabled: false } });
try {
const response = await request("/admin/workspace", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(response.statusCode, 403);
} finally {
await prisma.brandMembership.update({
where: { id: membership.id },
data: { isEnabled: true },
});
}
});
test("admin can read and update brand and service configuration", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const adminToken = JSON.parse(login.body).token;
const removedAdminRoute = await request("/admin/config/services", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(removedAdminRoute.statusCode, 404);
assert.ok(adminToken);
const unauthorized = await request("/admin/config/brand");
assert.equal(unauthorized.statusCode, 401);
const brandBefore = await prisma.brandProfile.findUnique({ where: { id: brandId } });
assert.ok(brandBefore);
const serviceBefore = await prisma.offering.findFirst({ where: { brandId, isEnabled: true } });
assert.ok(serviceBefore);
let createdServiceId;
try {
const brand = await request("/admin/config/brand", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(brand.statusCode, 200);
assert.equal(JSON.parse(brand.body).id, brandId);
const updatedBrand = await request("/admin/config/brand", {
method: "PATCH",
headers: { authorization: `Bearer ${adminToken}` },
payload: {
description: "集成测试品牌简介",
contactPhone: "13800000000",
templateKey: "personal",
},
});
assert.equal(updatedBrand.statusCode, 200);
assert.equal(JSON.parse(updatedBrand.body).description, "集成测试品牌简介");
assert.equal(JSON.parse(updatedBrand.body).templateKey, "personal");
const updatedService = await request(`/admin/workspace/offerings/${serviceBefore.id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${adminToken}` },
payload: { priceText: "集成测试价格", sortOrder: 99 },
});
assert.equal(updatedService.statusCode, 200);
assert.equal(JSON.parse(updatedService.body).priceText, "集成测试价格");
assert.equal(JSON.parse(updatedService.body).sortOrder, 99);
const publicServices = await request("/public/offerings");
assert.equal(publicServices.statusCode, 200);
const projectedService = JSON.parse(publicServices.body).find(
(item) => item.id === serviceBefore.id,
);
assert.equal(projectedService.priceText, serviceBefore.priceText);
const listedServices = await request("/admin/workspace/offerings", {
headers: { authorization: `Bearer ${adminToken}` },
});
assert.equal(listedServices.statusCode, 200);
assert.ok(JSON.parse(listedServices.body).some((item) => item.id === serviceBefore.id));
const createdService = await request("/admin/workspace/offerings", {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: {
name: "集成测试通用服务",
description: "通用品牌服务",
kind: "service",
config: { duration: 60 },
},
});
assert.equal(createdService.statusCode, 201);
const createdServiceBody = JSON.parse(createdService.body);
createdServiceId = createdServiceBody.id;
assert.equal(createdServiceBody.kind, "service");
const createdOffering = await prisma.offering.findUnique({
where: { id: createdServiceBody.id },
});
assert.equal(createdOffering?.name, "集成测试通用服务");
} finally {
await prisma.brandProfile.update({
where: { id: brandId },
data: {
description: brandBefore.description,
contactPhone: brandBefore.contactPhone,
templateKey: brandBefore.templateKey,
},
});
await prisma.offering.update({
where: { id: serviceBefore.id },
data: { priceText: serviceBefore.priceText, sortOrder: serviceBefore.sortOrder },
});
if (createdServiceId) {
await prisma.offering.delete({ where: { id: createdServiceId } });
}
}
});
test("admin can update user-facing brand presentation without replacing other config", async () => {
assert.equal(
(await request("/admin/config/presentation", { method: "PATCH", payload: { home: {} } }))
.statusCode,
401,
);
assert.equal(
(
await request("/admin/config/presentation", {
method: "PATCH",
headers: { authorization: `Bearer ${customerToken}` },
payload: { home: {} },
})
).statusCode,
403,
);
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
const brand = await prisma.brandProfile.findUnique({ where: { id: brandId } });
assert.ok(brand);
const originalConfig = brand.config;
try {
const response = await request("/admin/config/presentation", {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: {
identity: { founder: "可编辑主理人", title: "品牌主理人", ignoredNumber: 123 },
home: { proofTitle: "用户可编辑的信任标题", ignoredNumber: 123 },
inquiry: { submitLabel: "开始沟通" },
},
});
assert.equal(response.statusCode, 200);
const presentation = JSON.parse(response.body).visualPresentation;
assert.equal(presentation.home.proofTitle, "用户可编辑的信任标题");
assert.equal(presentation.home.ignoredNumber, undefined);
assert.equal(presentation.inquiry.submitLabel, "开始沟通");
const runtime = await request("/public/workspace");
assert.notEqual(JSON.parse(runtime.body).brand.founder, "可编辑主理人");
assert.notEqual(JSON.parse(runtime.body).brand.title, "品牌主理人");
assert.notEqual(
JSON.parse(runtime.body).brand.visualPresentation.home.proofTitle,
"用户可编辑的信任标题",
);
} finally {
await prisma.brandProfile.update({ where: { id: brandId }, data: { config: originalConfig } });
}
});
test("admin can manage trust content", async () => {
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const token = JSON.parse(login.body).token;
assert.equal((await request("/admin/config/trust-content")).statusCode, 401);
const created = await request("/admin/config/trust-content", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { type: "profile", title: "关于我", content: "集成测试内容", summary: "测试摘要" },
});
assert.equal(created.statusCode, 201);
const id = JSON.parse(created.body).id;
const draft = await request("/admin/config/trust-content", {
method: "POST",
headers: { authorization: `Bearer ${token}` },
payload: { type: "experience", title: "草稿", content: "不应公开", isPublished: false },
});
assert.equal(draft.statusCode, 201);
const publicContent = await request("/public/trust-content");
assert.equal(publicContent.statusCode, 200);
const publicItems = JSON.parse(publicContent.body);
assert.ok(!publicItems.some((item) => item.id === id));
assert.ok(!publicItems.some((item) => item.id === JSON.parse(draft.body).id));
try {
const list = await request("/admin/config/trust-content", {
headers: { authorization: `Bearer ${token}` },
});
assert.equal(list.statusCode, 200);
const updated = await request(`/admin/config/trust-content/${id}`, {
method: "PATCH",
headers: { authorization: `Bearer ${token}` },
payload: { content: "更新后的内容" },
});
assert.equal(updated.statusCode, 200);
assert.equal(JSON.parse(updated.body).content, "更新后的内容");
} finally {
const deleted = await request(`/admin/config/trust-content/${id}`, {
method: "DELETE",
headers: { authorization: `Bearer ${token}` },
});
assert.equal(deleted.statusCode, 200);
await prisma.trustContent.delete({ where: { id: JSON.parse(draft.body).id } });
}
});
test("customer booking endpoints require a valid customer session", async () => {
const missing = await request("/customer/bookings");
assert.equal(missing.statusCode, 400);
const list = await request("/customer/bookings", {
headers: { authorization: `Bearer ${customerToken}` },
});
assert.equal(list.statusCode, 200);
assert.deepEqual(JSON.parse(list.body), []);
});
test("wechat login validates the request DTO before exchanging the code", async () => {
const response = await request("/customer/session/wechat", {
method: "POST",
payload: {},
});
assert.equal(response.statusCode, 400);
});
test("wechat login creates a customer session for the requested brand", async () => {
const doorsBrand = await prisma.brandProfile.findUnique({ where: { slug: "linjing-doors" } });
assert.ok(doorsBrand);
const sessionOpenid = `doors-login-${Date.now()}`;
const wechatAuth = app.get(WechatAuthService);
const originalExchangeCode = wechatAuth.exchangeCode;
wechatAuth.exchangeCode = async () => ({ openid: sessionOpenid });
try {
const response = await request("/customer/session/wechat?brandSlug=linjing-doors", {
method: "POST",
payload: { code: "test-code" },
});
assert.equal(response.statusCode, 201);
const identity = readIdentity(JSON.parse(response.body).token);
assert.equal(identity.brandId, doorsBrand.id);
assert.equal(identity.role, "customer");
assert.ok(
await prisma.customerUser.findUnique({
where: { brandId_openid: { brandId: doorsBrand.id, openid: sessionOpenid } },
}),
);
} finally {
wechatAuth.exchangeCode = originalExchangeCode;
await prisma.customerUser.deleteMany({ where: { openid: sessionOpenid } });
}
});
test("customer booking DTO rejects incomplete package requests", async () => {
const response = await request("/customer/bookings", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: {
requestType: "package",
customerName: "集成测试客户",
contactPreference: "wechat",
},
});
assert.equal(response.statusCode, 400);
assert.equal(JSON.parse(response.body).error.code, "HTTP_400");
});
test("customer can create a generic inquiry without food-specific fields", async () => {
const response = await request("/customer/bookings", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: {
requestType: "inquiry",
customerName: "个人品牌咨询客户",
wechatId: "inquiry-wechat",
contactPreference: "wechat",
requestedTime: "下周三 14:00",
note: "希望讨论品牌合作方案",
},
});
assert.equal(response.statusCode, 201);
const body = JSON.parse(response.body);
const booking = await prisma.booking.findUnique({ where: { bookingNo: body.bookingNo } });
assert.ok(booking);
assert.equal(booking.requestType, "inquiry");
createdBookingIds.push(booking.id);
});
test("customer can create and cancel a package booking", async () => {
const service = await prisma.offering.findFirst({
where: { brandId, isEnabled: true, priceAmount: { not: null } },
});
assert.ok(service);
const release = await prisma.brandRelease.findFirst({
where: { brandId, status: "published" },
orderBy: { version: "desc" },
});
const publishedOffering = release?.snapshot?.offerings?.find?.((item) => item.id === service.id);
assert.ok(publishedOffering);
await prisma.offering.update({
where: { id: service.id },
data: { priceAmount: service.priceAmount + 500, name: `${service.name}草稿` },
});
const created = await request("/customer/bookings", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: {
requestType: "package",
customerName: "集成测试客户",
wechatId: "integration-wechat",
contactPreference: "wechat",
items: [{ offeringId: service.id, quantity: 2 }],
},
});
await prisma.offering.update({
where: { id: service.id },
data: { priceAmount: service.priceAmount, name: service.name },
});
assert.equal(created.statusCode, 201);
const createdBody = JSON.parse(created.body);
assert.equal(createdBody.estimatedAmount, publishedOffering.priceAmount * 2);
const booking = await prisma.booking.findUnique({ where: { bookingNo: createdBody.bookingNo } });
assert.ok(booking);
assert.equal(booking.workflowKey, "booking.basic");
assert.equal(booking.currentState, "received");
assert.equal(booking.offeringId, service.id);
const bookingItem = await prisma.bookingItem.findFirst({ where: { bookingId: booking.id } });
assert.equal(bookingItem?.serviceNameSnapshot, publishedOffering.name);
const initialTransitions = await prisma.bookingStateTransition.findMany({
where: { bookingId: booking.id },
});
assert.equal(initialTransitions.length, 1);
assert.equal(initialTransitions[0].toState, "received");
createdBookingIds.push(booking.id);
const cancelled = await request(`/customer/bookings/${booking.id}/cancel`, {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
});
assert.equal(cancelled.statusCode, 201);
assert.equal(JSON.parse(cancelled.body).status, "cancelled");
const transitions = await prisma.bookingStateTransition.findMany({
where: { bookingId: booking.id },
orderBy: { createdAt: "asc" },
});
assert.deepEqual(
transitions.map((item) => item.toState),
["received", "cancelled"],
);
});
test("admin can advance booking status but cannot skip the state machine", async () => {
const service = await prisma.offering.findFirst({
where: { brandId, isEnabled: true, priceAmount: { not: null } },
});
assert.ok(service);
const created = await request("/customer/bookings", {
method: "POST",
headers: { authorization: `Bearer ${customerToken}` },
payload: {
requestType: "package",
customerName: "状态测试客户",
phone: "13800000000",
contactPreference: "phone",
items: [{ offeringId: service.id, quantity: 1 }],
},
});
const booking = await prisma.booking.findUnique({
where: { bookingNo: JSON.parse(created.body).bookingNo },
});
assert.ok(booking);
createdBookingIds.push(booking.id);
const login = await request("/admin/session/login", {
method: "POST",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const adminToken = JSON.parse(login.body).token;
const contacting = await request(`/admin/bookings/${booking.id}/status`, {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: { status: "contacting", adminNote: "已联系客户" },
});
assert.equal(contacting.statusCode, 201);
assert.equal(JSON.parse(contacting.body).status, "contacting");
const contactingState = await prisma.booking.findUnique({ where: { id: booking.id } });
assert.equal(contactingState?.currentState, "contacting");
const skipped = await request(`/admin/bookings/${booking.id}/status`, {
method: "POST",
headers: { authorization: `Bearer ${adminToken}` },
payload: { status: "completed" },
});
assert.equal(skipped.statusCode, 400);
});