adilallo
390 lines
12 KiB
TypeScript
390 lines
12 KiB
TypeScript
import { describe, it, expect } from "vitest";
|
|
import {
|
|
buildPublishPayload,
|
|
parseDocumentSectionsForDisplay,
|
|
parseSectionsFromCreateFlowState,
|
|
} from "../../lib/create/buildPublishPayload";
|
|
import { mergeCoreValueDetailWithPresets } from "../../lib/create/finalReviewChipPresets";
|
|
import type { CreateFlowState } from "../../app/(app)/create/types";
|
|
|
|
describe("buildPublishPayload", () => {
|
|
it("returns error when title missing", () => {
|
|
expect(buildPublishPayload({})).toEqual({
|
|
ok: false,
|
|
error: "missingCommunityName",
|
|
});
|
|
});
|
|
|
|
it("returns error when title is whitespace only", () => {
|
|
expect(buildPublishPayload({ title: " \n\t " })).toEqual({
|
|
ok: false,
|
|
error: "missingCommunityName",
|
|
});
|
|
});
|
|
|
|
it("returns title and fallback Overview section when no sections", () => {
|
|
const r = buildPublishPayload({ title: "Oak Park Commons" });
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.title).toBe("Oak Park Commons");
|
|
expect(r.summary).toBeUndefined();
|
|
expect(r.document).toEqual({
|
|
sections: [
|
|
{
|
|
categoryName: "Overview",
|
|
entries: [
|
|
{
|
|
title: "Community",
|
|
body: "This CommunityRule was created in the create flow. Add more detail in a future edit.",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
coreValues: [],
|
|
});
|
|
});
|
|
|
|
it("includes trimmed summary in payload and uses it as fallback section body", () => {
|
|
const r = buildPublishPayload({
|
|
title: " My Group ",
|
|
summary: " We organize locally. ",
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.title).toBe("My Group");
|
|
expect(r.summary).toBe("We organize locally.");
|
|
expect(r.document).toEqual({
|
|
sections: [
|
|
{
|
|
categoryName: "Overview",
|
|
entries: [{ title: "Community", body: "We organize locally." }],
|
|
},
|
|
],
|
|
coreValues: [],
|
|
});
|
|
});
|
|
|
|
it("prefers communityContext over summary for the published summary field", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
summary: "One-liner or leftover",
|
|
communityContext: " Full community context. ",
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.summary).toBe("Full community context.");
|
|
});
|
|
|
|
it("uses valid state.sections when present", () => {
|
|
const sections: CreateFlowState["sections"] = [
|
|
{
|
|
categoryName: "Values",
|
|
entries: [{ title: "A", body: "B" }],
|
|
},
|
|
];
|
|
const r = buildPublishPayload({ title: "T", sections });
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.document).toEqual({ sections, coreValues: [] });
|
|
});
|
|
|
|
it("filters invalid section entries from state.sections", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
sections: [
|
|
{ categoryName: "Values", entries: [{ title: "A", body: "B" }] },
|
|
{ bad: true } as unknown as Record<string, unknown>,
|
|
],
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.document).toEqual({
|
|
sections: [{ categoryName: "Values", entries: [{ title: "A", body: "B" }] }],
|
|
coreValues: [],
|
|
});
|
|
});
|
|
|
|
it("includes coreValues from selected chips and detail text", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCoreValueIds: ["1", "2"],
|
|
coreValuesChipsSnapshot: [
|
|
{ id: "1", label: "Alpha", state: "selected" },
|
|
{ id: "2", label: "Beta", state: "selected" },
|
|
],
|
|
coreValueDetailsByChipId: {
|
|
"1": { meaning: "m1", signals: "s1" },
|
|
},
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const preset2 = mergeCoreValueDetailWithPresets("2", "Beta", undefined);
|
|
expect(r.document.coreValues).toEqual([
|
|
{ chipId: "1", label: "Alpha", meaning: "m1", signals: "s1" },
|
|
{
|
|
chipId: "2",
|
|
label: "Beta",
|
|
meaning: preset2.meaning,
|
|
signals: preset2.signals,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("buildPublishPayload — methodSelections", () => {
|
|
it("omits document.methodSelections when no method group is selected", () => {
|
|
const r = buildPublishPayload({ title: "T" });
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
expect(r.document.methodSelections).toBeUndefined();
|
|
});
|
|
|
|
it("derives methodSelections from template sections when selected ids are empty", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
sections: [
|
|
{
|
|
categoryName: "Communication",
|
|
entries: [{ title: "Slack", body: "" }],
|
|
},
|
|
],
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const ms = r.document.methodSelections as
|
|
| {
|
|
communication?: Array<{
|
|
id: string;
|
|
sections: { corePrinciple: string };
|
|
}>;
|
|
}
|
|
| undefined;
|
|
expect(ms?.communication?.length).toBe(1);
|
|
expect(ms?.communication?.[0]?.id).toBe("slack");
|
|
const first = ms?.communication?.[0];
|
|
expect(first?.sections.corePrinciple.length).toBeGreaterThan(10);
|
|
const entries =
|
|
(r.document.sections as Array<{ entries: Array<{ blocks?: unknown[] }> }>)[0]
|
|
?.entries;
|
|
expect(entries?.[0]?.blocks?.length).toBeGreaterThanOrEqual(1);
|
|
});
|
|
|
|
it("uses customMethodCardMetaById label when preset id is unknown", () => {
|
|
const customId = "00000000-0000-4000-8000-000000000002";
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCommunicationMethodIds: [customId],
|
|
customMethodCardMetaById: {
|
|
[customId]: { label: "Custom Comm", supportText: "More" },
|
|
},
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const ms = r.document.methodSelections as
|
|
| { communication?: Array<{ id: string; label: string }> }
|
|
| undefined;
|
|
expect(ms?.communication?.length).toBe(1);
|
|
expect(ms?.communication?.[0]?.id).toBe(customId);
|
|
expect(ms?.communication?.[0]?.label).toBe("Custom Comm");
|
|
});
|
|
|
|
it("embeds wizard field blocks in published Communication sections for custom UUID ids", () => {
|
|
const customId = "00000000-0000-4000-8000-000000000099";
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCommunicationMethodIds: [customId],
|
|
sections: [
|
|
{
|
|
categoryName: "Communication",
|
|
entries: [{ title: "Template row", body: "placeholder" }],
|
|
},
|
|
],
|
|
customMethodCardMetaById: {
|
|
[customId]: { label: "Wizard title", supportText: "" },
|
|
},
|
|
customMethodCardFieldBlocksById: {
|
|
[customId]: [
|
|
{
|
|
kind: "text",
|
|
id: "b1",
|
|
blockTitle: "Field A",
|
|
placeholderText: "User-authored body",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const secs = r.document.sections as Array<{
|
|
categoryName: string;
|
|
entries: Array<{ blocks?: Array<{ label: string; body: string }> }>;
|
|
}>;
|
|
const comm = secs.find((s) => s.categoryName === "Communication");
|
|
expect(comm?.entries[0]?.blocks).toEqual([
|
|
{ label: "Field A", body: "User-authored body" },
|
|
]);
|
|
});
|
|
|
|
it("emits preset-only sections when a method is selected without an override", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCommunicationMethodIds: ["signal"],
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const ms = r.document.methodSelections as
|
|
| Record<string, Array<Record<string, unknown>>>
|
|
| undefined;
|
|
expect(ms).toBeDefined();
|
|
expect(ms?.communication?.length).toBe(1);
|
|
const entry = ms?.communication?.[0] as {
|
|
id: string;
|
|
label: string;
|
|
sections: { corePrinciple: string };
|
|
};
|
|
expect(entry.id).toBe("signal");
|
|
expect(entry.label).toBe("Signal");
|
|
// Preset corePrinciple is non-empty for `signal` in the shipped messages
|
|
// file — proves we read presets when no override is present.
|
|
expect(entry.sections.corePrinciple.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("merges override on top of preset for the selected method", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCommunicationMethodIds: ["signal"],
|
|
communicationMethodDetailsById: {
|
|
signal: {
|
|
corePrinciple: "OVERRIDE PRINCIPLE",
|
|
logisticsAdmin: "OVERRIDE LOGISTICS",
|
|
codeOfConduct: "OVERRIDE COC",
|
|
},
|
|
},
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const ms = r.document.methodSelections as
|
|
| Record<string, Array<Record<string, unknown>>>
|
|
| undefined;
|
|
const entry = ms?.communication?.[0] as {
|
|
sections: {
|
|
corePrinciple: string;
|
|
logisticsAdmin: string;
|
|
codeOfConduct: string;
|
|
};
|
|
};
|
|
expect(entry.sections.corePrinciple).toBe("OVERRIDE PRINCIPLE");
|
|
expect(entry.sections.logisticsAdmin).toBe("OVERRIDE LOGISTICS");
|
|
expect(entry.sections.codeOfConduct).toBe("OVERRIDE COC");
|
|
});
|
|
|
|
it("emits a methodSelections entry per selected group", () => {
|
|
const r = buildPublishPayload({
|
|
title: "T",
|
|
selectedCommunicationMethodIds: ["signal"],
|
|
selectedMembershipMethodIds: ["open-access"],
|
|
selectedDecisionApproachIds: ["lazy-consensus"],
|
|
selectedConflictManagementIds: ["peer-mediation"],
|
|
});
|
|
expect(r.ok).toBe(true);
|
|
if (!r.ok) return;
|
|
const ms = r.document.methodSelections as
|
|
| Record<string, Array<unknown>>
|
|
| undefined;
|
|
expect(Object.keys(ms ?? {}).sort()).toEqual([
|
|
"communication",
|
|
"conflictManagement",
|
|
"decisionApproaches",
|
|
"membership",
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("parseDocumentSectionsForDisplay", () => {
|
|
it("returns empty for non-object", () => {
|
|
expect(parseDocumentSectionsForDisplay(null)).toEqual([]);
|
|
});
|
|
|
|
it("parses valid sections array", () => {
|
|
const doc = {
|
|
sections: [
|
|
{ categoryName: "X", entries: [{ title: "t", body: "b" }] },
|
|
],
|
|
};
|
|
expect(parseDocumentSectionsForDisplay(doc)).toEqual(doc.sections);
|
|
});
|
|
|
|
it("accepts entries with labeled blocks and omits body in JSON (normalized to \"\")", () => {
|
|
const doc = {
|
|
sections: [
|
|
{
|
|
categoryName: "Membership",
|
|
entries: [
|
|
{
|
|
title: "Open membership",
|
|
blocks: [
|
|
{ label: "Eligibility", body: "Anyone may join." },
|
|
{ label: "Process", body: "Sign the sheet." },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
expect(parseDocumentSectionsForDisplay(doc)).toEqual([
|
|
{
|
|
categoryName: "Membership",
|
|
entries: [
|
|
{
|
|
title: "Open membership",
|
|
body: "",
|
|
blocks: [
|
|
{ label: "Eligibility", body: "Anyone may join." },
|
|
{ label: "Process", body: "Sign the sheet." },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("accepts entries with labeled blocks and empty body", () => {
|
|
const doc = {
|
|
sections: [
|
|
{
|
|
categoryName: "Membership",
|
|
entries: [
|
|
{
|
|
title: "Open membership",
|
|
body: "",
|
|
blocks: [
|
|
{ label: "Eligibility", body: "Anyone may join." },
|
|
{ label: "Process", body: "Sign the sheet." },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
expect(parseDocumentSectionsForDisplay(doc)).toEqual(doc.sections);
|
|
});
|
|
|
|
it("still parses entries with empty body and no blocks", () => {
|
|
const doc = {
|
|
sections: [
|
|
{
|
|
categoryName: "Values",
|
|
entries: [{ title: "Consensus", body: "" }],
|
|
},
|
|
],
|
|
};
|
|
expect(parseDocumentSectionsForDisplay(doc)).toEqual(doc.sections);
|
|
});
|
|
});
|
|
|
|
describe("parseSectionsFromCreateFlowState", () => {
|
|
it("returns empty when sections missing", () => {
|
|
expect(parseSectionsFromCreateFlowState({})).toEqual([]);
|
|
});
|
|
});
|