// Tests for the campaign's notes reaching the Foundry world as journal pages // (Syndria98/dragonroll#98): every Dragonroll note stands as a page of the one // journal the world calls "Dragonroll", written by the module and kept in step with // the campaign. The copy runs one way — notes are written in Dragonroll — so the // backend answers with the notes and remembers each note's page; the module reads // them, renders the markdown, and prunes the page of a note the campaign deleted. // // Both sides are loaded the way the other Foundry tests do it: the sync route runs // against a stubbed `require` (models answer with plain objects and a small filter // matcher), and the Foundry module is loaded into a `node:vm` context holding // stubbed Foundry globals (`game.journals` and `JournalEntry` included) with fake // timers, like tests/item-folder-sync.test.js. // // Run with `npm test` from the repository root, or `node --test tests/`. const { test } = require("node:test"); const assert = require("node:assert/strict"); const fs = require("node:fs"); const path = require("node:path"); const vm = require("node:vm"); const MODULE_ID = "dragonroll-foundry"; const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8"); const repoRequire = (relative) => require(path.join(__dirname, "..", relative)); // --- The sync route against stubbed models ------------------------------------- // A mongoose query answers whatever `await query` and `query.lean()` answer with, and // lets `select()`, `sort()` and `limit()` sit in between. function mongooseQuery(value) { const result = { select: () => result, sort: () => result, limit: (count) => mongooseQuery(value.slice(0, count)), lean: () => Promise.resolve(value), then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected), }; return result; } // Enough of the query language the note routes use: equality, $or, $in, $nin, // $exists, $ne. Anything else is a filter this test did not expect and says so. function matches(document, filter = {}) { return Object.entries(filter).every(([key, expected]) => { if (key === "$or") return expected.some((part) => matches(document, part)); const value = document?.[key]; if (expected && typeof expected === "object" && !Array.isArray(expected)) { return Object.entries(expected).every(([operator, wanted]) => { if (operator === "$exists") return (value !== undefined && value !== null) === wanted; if (operator === "$in") return wanted.some((entry) => String(value) === String(entry)); if (operator === "$nin") return !wanted.some((entry) => String(value) === String(entry)); if (operator === "$ne") return String(value ?? "") !== String(wanted ?? ""); throw new Error(`filter operator "${key}.${operator}" is not stubbed`); }); } return String(value ?? "") === String(expected ?? ""); }); } function fakeModel(table, seed = [], campaignId) { const rows = []; let counter = 0; function Document(data = {}) { counter += 1; this._id = `${table}-${counter}`; this.isNew = true; this.foundryNames = []; Object.assign(this, data); } Document.prototype.save = async function save() { if (this.isNew) rows.push(this); this.isNew = false; return this; }; Object.defineProperty(Document.prototype, "id", { get() { return this._id; } }); for (const data of seed) { // A seeded row belongs to the campaign the requests are made against unless the // seed says otherwise: the routes scope every lookup by campaign. const row = new Document({ campaign: campaignId, ...data }); row.isNew = false; rows.push(row); } const model = function Model(data) { return new Document(data); }; model.rows = rows; model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null; model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter))); model.deleteOne = async (filter) => { const hit = rows.filter((row) => matches(row, filter)); for (const row of hit) rows.splice(rows.indexOf(row), 1); return { deletedCount: hit.length }; }; model.deleteMany = async (filter) => { const hit = rows.filter((row) => matches(row, filter)); for (const row of hit) rows.splice(rows.indexOf(row), 1); return { deletedCount: hit.length }; }; model.updateMany = async (filter, update) => { const hit = rows.filter((row) => matches(row, filter)); for (const row of hit) Object.assign(row, update.$set ?? {}); return { modifiedCount: hit.length }; }; return model; } // The Foundry sync route with every model it requires stubbed. `seed` pre-fills the // tables with documents the campaign already holds. function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) { const routes = new Map(); const router = { get: (route, ...handlers) => routes.set(`GET ${route}`, handlers), post: (route, ...handlers) => routes.set(`POST ${route}`, handlers), }; const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId }; const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row })); const models = { "../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Item": fakeModel("item", seeded(seed.items)), "../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Note": fakeModel("note", seeded(seed.notes)), "../models/Map": fakeModel("map", seeded(seed.maps)), }; const requireStub = (id) => { if (id === "express") return { Router: () => router }; if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 }; if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) }; if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js")); if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js")); if (models[id]) return models[id]; throw new Error(`require("${id}") is not stubbed`); }; const moduleStub = { exports: {} }; vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])( requireStub, moduleStub, moduleStub.exports ); async function call(route, body = {}) { const handlers = routes.get(route); assert.ok(handlers, `${route} is not mounted`); const res = { payload: null, json(payload) { this.payload = payload; }, set: () => {} }; const req = { body, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token" : "") }; await handlers[handlers.length - 1](req, res); return res.payload; } return { call, models, campaign }; } // --- The sync route: the notes it answers and the page ids it keeps --------------- test("the world reads the campaign's notes with their content and page mapping", async () => { const sync = loadSyncRoute({ seed: { notes: [ { _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: "page-9" }, { _id: "note-2", title: "Tavern Brawl", content: "- rope" }, ], }, }); const response = await sync.call("GET /sync/notes"); assert.equal(response.status, "ok"); assert.deepEqual(response.notes.map((note) => note.title), ["Session 1", "Tavern Brawl"]); assert.equal(response.notes[0].content, "**The start**", "the markdown source travels: the module renders it"); assert.equal(response.notes[0].foundryPageId, "page-9", "and the note says which page it already stands as"); }); test("mapping a note to the page the module made keeps them paired", async () => { const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } }); const response = await sync.call("POST /sync/map-note", { worldId: "world-1", noteId: "note-1", foundryPageId: "page-9", }); assert.equal(response.status, "ok"); assert.equal(sync.models["../models/Note"].rows[0].foundryPageId, "page-9"); // Mapping the same pair again is the module checking, not a conflict. const again = await sync.call("POST /sync/map-note", { worldId: "world-1", noteId: "note-1", foundryPageId: "page-9", }); assert.equal(again.status, "ok"); }); test("a page already mapped to another note is refused", async () => { const sync = loadSyncRoute({ seed: { notes: [ { _id: "note-1", title: "Session 1", content: "hi", foundryPageId: "page-9" }, { _id: "note-2", title: "Tavern Brawl", content: "ho" }, ], }, }); const response = await sync.call("POST /sync/map-note", { worldId: "world-1", noteId: "note-2", foundryPageId: "page-9", }); assert.equal(response.status, "error"); assert.equal(response.msg, "foundry.errors.note-already-synced"); assert.equal(sync.models["../models/Note"].rows.find((row) => row._id === "note-2").foundryPageId, undefined, "the first note keeps its page"); }); test("map-note wants this world's note and a page for it", async () => { const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } }); assert.equal((await sync.call("POST /sync/map-note", { worldId: "world-1" })).msg, "errors.missing-data"); assert.equal((await sync.call("POST /sync/map-note", { noteId: "note-1", foundryPageId: "page-9" })).msg, "errors.missing-data", "another world cannot map this campaign's note"); const gone = await sync.call("POST /sync/map-note", { worldId: "world-1", noteId: "note-gone", foundryPageId: "page-9", }); assert.equal(gone.msg, "errors.notfound"); }); // --- The Foundry module writes the journal --------------------------------------- // Foundry's `update` takes dotted paths ("flags.dragonroll-foundry.noteId"); an // embedded document's own id is not a path to set. function writeFoundryPaths(target, data) { for (const [key, value] of Object.entries(data)) { if (key === "_id") continue; const parts = key.split("."); const last = parts.pop(); let node = target; for (const part of parts) node = node[part] ??= {}; node[last] = value; } return target; } function makeWorld({ markdown = true, keepCreateFlags = true, failMapNote = false } = {}) { const state = { hooks: new Map(), registered: new Map(), requests: [], timers: new Map(), intervals: new Map(), keepCreateFlags, failMapNote, // What Dragonroll answers the notes reconcile with. Mapping a page answers // like the real backend: the note keeps the page id, so later reads carry it. remoteNotes: [], nextId: 1, }; const journals = []; const makePage = (journal, data = {}) => { const page = { id: `page-${state.nextId++}`, documentName: "JournalEntryPage", name: data.name, text: { content: data.text?.content ?? "" }, flags: data.flags ?? {}, writes: 0, getFlag(module, key) { return this.flags?.[module]?.[key]; }, async update(update) { page.writes += 1; writeFoundryPaths(page, update); return page; }, async delete() { const index = journal.pages.contents.indexOf(page); if (index >= 0) journal.pages.contents.splice(index, 1); }, }; return page; }; const makeJournal = (data = {}) => { const pages = []; return { id: `journal-${state.nextId++}`, name: data.name, documentName: "JournalEntry", flags: data.flags ?? {}, getFlag(module, key) { return this.flags?.[module]?.[key]; }, pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) }, async update(update) { return writeFoundryPaths(this, update); }, async createEmbeddedDocuments(documentName, docs) { assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages"); // Foundry's own page validation refuses a page without a name. for (const doc of docs) assert.ok(doc.name, "a journal page needs a non-empty name"); // A world that does not keep the flags a create was handed: the page // exists but carries no mark, which is what a lost pairing looks like. const created = docs.map((doc) => makePage(this, keepCreateFlags ? doc : { ...doc, flags: {} })); pages.push(...created); return created; }, }; }; const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" }; const sandbox = { console: { log() {}, info() {}, warn() {}, error() {} }, URL, CONFIG: {}, window: { location: { origin: "http://vtt.test" } }, ui: { notifications: { info() {}, warn() {}, error() {} } }, Hooks: { once(name, fn) { state.hooks.set(name, [fn]); }, on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); }, }, setTimeout: (fn, delay = 0) => { const id = state.nextId++; state.timers.set(id, { fn, delay }); return id; }, clearTimeout: (id) => state.timers.delete(id), setInterval: (fn, delay = 0) => { // Recorded, never run by itself: tests ask for a periodic reconcile with // `runIntervals`, so the ones watching single pushes stay on their own. const id = state.nextId++; state.intervals.set(id, { fn, delay }); return id; }, clearInterval: (id) => state.intervals.delete(id), fetch: async (url, options = {}) => { const href = String(url); const body = options.body ? JSON.parse(options.body) : null; state.requests.push({ href, method: options.method, body }); if (href.includes("foundry/sync/map-note")) { if (state.failMapNote) return { ok: false, status: 500, json: async () => ({ status: "error", msg: "errors.internal" }) }; const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId)); if (note) note.foundryPageId = body.foundryPageId; return { ok: true, status: 200, json: async () => ({ status: "ok", note }) }; } if (href.includes("foundry/sync/notes")) { return { ok: true, status: 200, json: async () => ({ status: "ok", notes: state.remoteNotes }) }; } return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) }; }, Actor: { async create() { return null; } }, Item: { async create() { return null; } }, JournalEntry: { async create(data) { const journal = makeJournal(data); journals.push(journal); return [journal]; }, }, }; if (markdown) sandbox.TextEditor = { _getMarkdown: (md) => `${md}` }; sandbox.game = { user: { isGM: true }, world: { id: "world-1", title: "Test World" }, system: { id: "dnd5e" }, modules: { get: () => ({}) }, actors: { contents: [], get: () => null }, items: { contents: [], get: () => null }, folders: { contents: [], get: () => null }, journals: { contents: journals, get: (id) => journals.find((journal) => journal.id === id) }, settings: { register(module, key, definition) { state.registered.set(key, definition); if (!(key in settingsStore)) settingsStore[key] = definition.default; }, get(module, key) { return settingsStore[key]; }, async set(module, key, value) { settingsStore[key] = value; await state.registered.get(key)?.onChange?.(value); }, }, }; vm.createContext(sandbox); vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox); state.game = sandbox.game; state.journals = () => journals; state.addJournal = (name, flags = {}) => { const journal = makeJournal({ name, flags }); journals.push(journal); return journal; }; state.addPage = (journal, data) => { const page = makePage(journal, data); journal.pages.contents.push(page); return page; }; state.mapNoteRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-note")); state.notesReads = () => state.requests.filter((request) => request.href.includes("foundry/sync/notes")); const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); }; state.fire = async (name, ...args) => { for (const handler of state.hooks.get(name) || []) await handler(...args); await drain(); }; state.runTimers = async () => { for (let round = 0; round < 6; round += 1) { if (!state.timers.size && round > 2) break; const due = [...state.timers.values()]; state.timers.clear(); for (const timer of due) await timer.fn(); await drain(); } }; // The reconciles `setInterval` registered: what runs every few seconds on a // linked world, and so what carries each note into its journal page. state.runIntervals = async () => { for (const interval of [...state.intervals.values()]) await interval.fn(); await drain(); }; state.linkedSetup = async () => { await state.fire("init"); await state.fire("ready"); await state.runTimers(); state.requests.length = 0; return state; }; return state; } // The fetch stub updates a note with the page it maps, like the real backend // does, so every test works on notes of its own. const sessionNote = (over = {}) => ({ _id: "note-1", title: "Session 1", content: "**The start**", ...over }); const tavernNote = (over = {}) => ({ _id: "note-2", title: "Tavern Brawl", content: "A rope, a chandelier.", ...over }); test("the campaign's notes become pages of one Dragonroll journal", async () => { const world = await makeWorld().linkedSetup(); world.remoteNotes = [sessionNote(), tavernNote()]; await world.runIntervals(); assert.equal(world.journals().length, 1, "one journal carries the campaign's notes"); const journal = world.journals()[0]; assert.equal(journal.name, "Dragonroll"); assert.deepEqual(journal.pages.contents.map((page) => [page.name, page.text.content]), [ ["Session 1", "**The start**"], ["Tavern Brawl", "A rope, a chandelier."], ], "each note is a page, its markdown rendered by Foundry's own renderer"); assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"], "each page keeps the note it stands for"); assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [ ["note-1", journal.pages.contents[0].id], ["note-2", journal.pages.contents[1].id], ], "and the campaign remembers each note's page"); }); test("reconciling again does not double the journal or its pages", async () => { const world = await makeWorld().linkedSetup(); world.remoteNotes = [sessionNote(), tavernNote()]; await world.runIntervals(); await world.runIntervals(); await world.runIntervals(); assert.equal(world.journals().length, 1, "the journal is made once, not per reconcile"); assert.equal(world.journals()[0].pages.contents.length, 2, "and each note stands as the one page it was given"); assert.equal(world.mapNoteRequests().length, 2, "an already-mapped note is not mapped again"); }); test("an existing journal named Dragonroll is used, not doubled", async () => { const world = await makeWorld().linkedSetup(); const gmsOwn = world.addJournal("Dragonroll"); world.remoteNotes = [sessionNote()]; await world.runIntervals(); assert.equal(world.journals().length, 1, "the journal the world already had is the notes' one"); assert.deepEqual(gmsOwn.pages.contents.map((page) => page.name), ["Session 1"]); assert.equal(gmsOwn.getFlag(MODULE_ID, "notesJournal"), true, "and it is marked, so renaming it keeps the notes' home findable"); }); test("a note edited in Dragonroll rewrites its page", async () => { const world = await makeWorld().linkedSetup(); world.remoteNotes = [sessionNote()]; await world.runIntervals(); const first = world.remoteNotes[0]; world.remoteNotes = [{ ...first, title: "Session 1 — revisited", content: "**A different start**" }]; await world.runIntervals(); const journal = world.journals()[0]; assert.equal(journal.pages.contents.length, 1, "the note still stands as the same single page"); assert.deepEqual(journal.pages.contents[0].name, "Session 1 — revisited"); assert.equal(journal.pages.contents[0].text.content, "**A different start**"); assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping"); }); test("a note deleted in Dragonroll takes its page with it", async () => { const world = await makeWorld().linkedSetup(); world.remoteNotes = [sessionNote(), tavernNote()]; await world.runIntervals(); const journal = world.journals()[0]; const gmsPage = world.addPage(journal, { name: "My own notes", text: { content: "not from Dragonroll" } }); world.remoteNotes = world.remoteNotes.filter((note) => note._id !== "note-2"); await world.runIntervals(); assert.deepEqual(journal.pages.contents.map((page) => page.name), ["Session 1", "My own notes"], "the deleted note's page goes; the GM's own page stays"); assert.ok(journal.pages.contents.includes(gmsPage)); }); test("pages already in step with the campaign are not rewritten", async () => { const world = await makeWorld().linkedSetup(); world.remoteNotes = [sessionNote()]; await world.runIntervals(); const [page] = world.journals()[0].pages.contents; assert.equal(page.writes, 0, "the page was created whole, not patched"); await world.runIntervals(); assert.equal(page.writes, 0, "a reconcile that changes nothing leaves the page alone"); }); test("the campaign's page mapping claims a page whose flag was lost", async () => { const world = await makeWorld().linkedSetup(); const journal = world.addJournal("Dragonroll"); const orphan = world.addPage(journal, { name: "Old name", text: { content: "old" } }); world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: orphan.id }]; await world.runIntervals(); assert.equal(journal.pages.contents.length, 1, "no second page under the same title"); assert.equal(orphan.name, "Session 1"); assert.equal(orphan.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked again"); }); test("a page under the note's title with no mark is claimed, not doubled", async () => { const world = await makeWorld().linkedSetup(); const journal = world.addJournal("Dragonroll"); const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } }); // The campaign has no page id for the note, and the page carries no flag: this // is a page the module made before the pairing was kept, or one whose flag was // lost. It is claimed instead of a second page being made under the same title. world.remoteNotes = [sessionNote()]; await world.runIntervals(); assert.equal(journal.pages.contents.length, 1, "no second page under the note's title"); assert.equal(existing.text.content, "**The start**", "the note's text lands on the page the world already had"); assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked as the note's"); assert.deepEqual(world.mapNoteRequests().map((request) => request.body.foundryPageId), [existing.id], "the campaign is told which page the note now stands as"); await world.runIntervals(); assert.equal(journal.pages.contents.length, 1, "reconciling again does not add another"); }); test("two notes of one title do not share a single page", async () => { const world = await makeWorld().linkedSetup(); const journal = world.addJournal("Dragonroll"); const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } }); world.remoteNotes = [sessionNote(), { _id: "note-9", title: "Session 1", content: "second" }]; await world.runIntervals(); assert.equal(journal.pages.contents.length, 2, "the second note gets a page of its own"); assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "the world's page is claimed by the first note"); assert.equal(journal.pages.contents[1].getFlag(MODULE_ID, "noteId"), "note-9"); }); test("a page whose mark and mapping were both lost is claimed again, not doubled", async () => { // Both ways of recognising the pairing are gone: the create's flag did not stick, // and the campaign never got to keep the page id. Without claiming the page it // already made, every reconcile would write another one. const world = await makeWorld({ keepCreateFlags: false, failMapNote: true }).linkedSetup(); world.remoteNotes = [sessionNote()]; await world.runIntervals(); await world.runIntervals(); await world.runIntervals(); const journal = world.journals()[0]; assert.equal(journal.pages.contents.length, 1, "one note stands as the one page it was given"); assert.equal(journal.pages.contents[0].getFlag(MODULE_ID, "noteId"), "note-1", "and the page keeps the note it stands for even though the create did not mark it"); }); test("without Foundry's markdown renderer the fallback keeps the text legible", async () => { const world = await makeWorld({ markdown: false }).linkedSetup(); world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }]; await world.runIntervals(); assert.equal( world.journals()[0].pages.contents[0].text.content, "

a & b < c
line two

\n

second para

", "escaped paragraphs instead of nothing, until this Foundry offers a renderer", ); }); test("autosync off: the campaign's notes are not written into the world", async () => { const world = await makeWorld().linkedSetup(); await world.game.settings.set(MODULE_ID, "autoSync", false); world.remoteNotes = [sessionNote()]; await world.runIntervals(); assert.deepEqual(world.journals(), [], "no journal is made"); assert.deepEqual(world.notesReads(), [], "and the campaign is not even asked"); });