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 } }); 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.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, ), ); 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 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 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(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, 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("/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"); }); 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); });