90d3fab483
Add ~330 tests across server (Jest), client (Vitest), editor-ext (Vitest)
and packages/mcp (node:test) for the gitmost features added since
053a9c0d: AI chat, AI agent roles, public-share assistant, MCP per-user
auth, HTML embed, page templates/embed, realtime tree, tree
expand/collapse, and the AI-settings UI.
Test-tooling fixes (prerequisite, were silently hiding coverage):
- Repair 3 page-template specs broken by the 11-arg TransclusionService
constructor; they never compiled, so template access-control / content
-leak / unsync-strip coverage was fictitious.
- Build @docmost/editor-ext before server tests via a `pretest` hook;
the stale dist omitted the new HtmlEmbed/PageEmbed exports (TS2305).
- Let jest resolve the .tsx email templates: add `tsx` to
moduleFileExtensions and widen the ts-jest transform to (t|j)sx?.
Behaviour-preserving "extract pure core" refactors that the tests drive:
- server: resolveShareAssistantRequest + uiMessageTextLength
(public-share controller), decideBasicGate + mapAuthResultToResponse
(mcp), buildErrorAssistantRecord (ai-chat), jsonbObject export (roles).
- client: render-raw-html + shouldExecute/canEdit, decide-embed-state,
page-embed picker utils, tree-socket reducers, open/close branch maps,
isEndpointConfigured/resolveKeyField; buildTreeWithChildren now treats
a permission-trimmed orphan as a root instead of crashing.
Deferred (need a test DB or HTTP harness, documented in the specs):
repo-level Postgres integration tests and the public-share XFF E2E.
Pre-existing DI/lib0-ESM suite failures are untouched and out of scope.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
113 lines
4.0 KiB
TypeScript
113 lines
4.0 KiB
TypeScript
import { describe, it, expect, beforeEach, afterEach } from "vitest";
|
|
import { JSDOM } from "jsdom";
|
|
import { renderRawHtml, shouldExecute, canEdit } from "./render-raw-html";
|
|
|
|
// jsdom does NOT execute <script> nodes unless its instance was created with
|
|
// `runScripts: "dangerously"`. The whole point of renderRawHtml is to make
|
|
// re-created scripts run, so the execution tests drive a dedicated script-
|
|
// running JSDOM and pass it a container from THAT document (renderRawHtml uses
|
|
// `container.ownerDocument`, so it creates the fresh scripts in the running
|
|
// instance). The default vitest jsdom (no runScripts) is used for the
|
|
// structural and policy assertions.
|
|
describe("renderRawHtml (script execution against a runScripts jsdom)", () => {
|
|
let dom: JSDOM;
|
|
let container: HTMLElement;
|
|
|
|
beforeEach(() => {
|
|
dom = new JSDOM("<!doctype html><html><body></body></html>", {
|
|
runScripts: "dangerously",
|
|
});
|
|
container = dom.window.document.createElement("div");
|
|
dom.window.document.body.appendChild(container);
|
|
});
|
|
|
|
afterEach(() => {
|
|
dom.window.close();
|
|
});
|
|
|
|
it("re-creates and executes an inline <script> (observable side effect)", () => {
|
|
renderRawHtml(
|
|
container,
|
|
"<div>hello</div><script>window.__htmlEmbedFlag = true;</script>",
|
|
);
|
|
// The re-created inline script ran inside the jsdom window.
|
|
expect((dom.window as unknown as Record<string, unknown>).__htmlEmbedFlag).toBe(
|
|
true,
|
|
);
|
|
// The non-script markup is preserved.
|
|
expect(container.querySelector("div")?.textContent).toBe("hello");
|
|
});
|
|
|
|
it("copies src/async/defer onto a re-created external <script src>", () => {
|
|
renderRawHtml(
|
|
container,
|
|
'<script src="https://example.com/t.js" async defer></script>',
|
|
);
|
|
const script = container.querySelector("script");
|
|
expect(script).not.toBeNull();
|
|
expect(script?.getAttribute("src")).toBe("https://example.com/t.js");
|
|
expect(script?.hasAttribute("async")).toBe(true);
|
|
expect(script?.hasAttribute("defer")).toBe(true);
|
|
});
|
|
|
|
it("clears the container when the source is empty", () => {
|
|
container.innerHTML = "<p>stale</p>";
|
|
renderRawHtml(container, "");
|
|
expect(container.innerHTML).toBe("");
|
|
});
|
|
|
|
it("clears prior content first on a re-render with new source", () => {
|
|
const win = dom.window as unknown as Record<string, unknown>;
|
|
renderRawHtml(
|
|
container,
|
|
"<span id='first'>one</span><script>window.__htmlEmbedCount = 1;</script>",
|
|
);
|
|
expect(win.__htmlEmbedCount).toBe(1);
|
|
expect(container.querySelector("#first")).not.toBeNull();
|
|
|
|
renderRawHtml(
|
|
container,
|
|
"<span id='second'>two</span><script>window.__htmlEmbedCount = 2;</script>",
|
|
);
|
|
// Prior content is gone; only the new render remains.
|
|
expect(container.querySelector("#first")).toBeNull();
|
|
expect(container.querySelector("#second")).not.toBeNull();
|
|
expect(win.__htmlEmbedCount).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe("shouldExecute (execution policy)", () => {
|
|
it("read-only executes regardless of the workspace toggle", () => {
|
|
// isEditable=false → the server already gated the content.
|
|
expect(shouldExecute(false, false)).toBe(true);
|
|
expect(shouldExecute(false, true)).toBe(true);
|
|
});
|
|
|
|
it("editable + toggle OFF does NOT execute", () => {
|
|
expect(shouldExecute(true, false)).toBe(false);
|
|
});
|
|
|
|
it("editable + toggle ON executes", () => {
|
|
expect(shouldExecute(true, true)).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("canEdit (edit policy)", () => {
|
|
it("a member (non-admin) can never edit", () => {
|
|
expect(canEdit(true, false, true)).toBe(false);
|
|
expect(canEdit(false, false, true)).toBe(false);
|
|
});
|
|
|
|
it("an admin with the toggle OFF cannot edit", () => {
|
|
expect(canEdit(true, true, false)).toBe(false);
|
|
});
|
|
|
|
it("an admin with the toggle ON in editable mode can edit", () => {
|
|
expect(canEdit(true, true, true)).toBe(true);
|
|
});
|
|
|
|
it("an admin in read-only mode cannot edit (no edit affordance)", () => {
|
|
expect(canEdit(false, true, true)).toBe(false);
|
|
});
|
|
});
|