next-ai-draw-io/packages/mcp-server/tests/history.test.ts

/**
 * Tests for the diagram history: the versions restore_version can go to.
 */

import { beforeAll, describe, expect, it } from "vitest"
import { installDomPolyfill } from "../src/dom.ts"
import {
    addHistory,
    clearHistory,
    currentEntryId,
    firstCopyIds,
    getHistory,
    isInHistory,
    otherVersions,
} from "../src/history.ts"

beforeAll(() => {
    // XML parsing for the content fingerprints
    installDomPolyfill()
})

const page = (cellId: string) =>
    `<mxfile><diagram id="p" name="P"><mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/><mxCell id="${cellId}" vertex="1" parent="1"/></root></mxGraphModel></diagram></mxfile>`

const A = page("a")
const B = page("b")
const C = page("c")

// draw.io's copy of B: other attribute order, whitespace and viewport
// attributes, same diagram
const B_COPY = `<mxfile host="app.diagrams.net">
  <diagram name="P" id="p">
    <mxGraphModel dx="100" dy="200" pageWidth="850">
      <root>
        <mxCell id="0" />
        <mxCell id="1" parent="0" />
        <mxCell id="b" parent="1" vertex="1" />
      </root>
    </mxGraphModel>
  </diagram>
</mxfile>`

const fill = (id: string, versions: string[]) => {
    clearHistory(id)
    for (const xml of versions) addHistory(id, xml)
}

describe("otherVersions", () => {
    it("lists the versions before the canvas, newest first", () => {
        const id = "history-abc"
        fill(id, [A, B, C])
        expect(otherVersions(id, C).map((e) => e.xml)).toEqual([B, A])
    })

    it("lists each version once after an undo, the left one first", () => {
        const id = "history-abcb"
        fill(id, [A, B, C, B])
        expect(otherVersions(id, B).map((e) => e.xml)).toEqual([C, A])
    })

    it("lists every version when the canvas is in none of them", () => {
        const id = "history-manual"
        fill(id, [A, B, C])
        expect(otherVersions(id, page("manual")).map((e) => e.xml)).toEqual([
            C,
            B,
            A,
        ])
    })

    it("counts a re-serialised copy as the same version", () => {
        const id = "history-copy"
        fill(id, [A, B, B_COPY])
        expect(otherVersions(id, B).map((e) => e.xml)).toEqual([A])
        expect(otherVersions(id, B_COPY).map((e) => e.xml)).toEqual([A])
    })

    it("keeps the newest copy of a repeated version", () => {
        const id = "history-newest"
        fill(id, [A, B, A])
        const [newestA] = otherVersions(id, B)
        expect(newestA.id).toBe(getHistory(id)[2].id)
        expect(otherVersions(id, B)).toHaveLength(1)
    })

    it("matches a bare model from the browser with its named page", () => {
        const id = "history-bare"
        const named = (xml: string) => xml.replace('name="P"', 'name="Arch"')
        fill(id, [named(A), named(B)])
        // The browser's sync sent page B without its <mxfile> wrapper
        const bareB = B.replace(/^.*?(<mxGraphModel>)/, "$1").replace(
            "</diagram></mxfile>",
            "",
        )
        expect(otherVersions(id, bareB).map((e) => e.xml)).toEqual([named(A)])
        expect(isInHistory(id, bareB)).toBe(true)
        expect(isInHistory(id, C)).toBe(false)
    })

    it("still counts a rename when an unrelated bare model is in History", () => {
        const id = "history-mixed"
        const bareX = page("x")
            .replace(/^.*?(<mxGraphModel>)/, "$1")
            .replace("</diagram></mxfile>", "")
        const arch = B.replace('name="P"', 'name="Arch"')
        const overview = B.replace('name="P"', 'name="Overview"')
        fill(id, [bareX, arch])
        expect(otherVersions(id, overview).map((e) => e.xml)).toEqual([
            arch,
            bareX,
        ])
        expect(isInHistory(id, overview)).toBe(false)
    })

    it("returns nothing for an empty history", () => {
        const id = "history-empty"
        clearHistory(id)
        expect(otherVersions(id, A)).toEqual([])
    })
})

describe("entries", () => {
    it("record who made them, when, and their page count", () => {
        const id = "history-fields"
        clearHistory(id)
        const before = Date.now()
        addHistory(id, A)
        addHistory(id, B, "<svg/>", "user")
        addHistory(
            id,
            `<mxfile><diagram id="p" name="P"><mxGraphModel><root><mxCell id="0"/></root></mxGraphModel></diagram><diagram id="q" name="Q"><mxGraphModel><root><mxCell id="0"/></root></mxGraphModel></diagram></mxfile>`,
            "",
            "restore",
        )
        const [first, second, third] = getHistory(id)
        expect(first.source).toBeUndefined()
        expect(first.time).toBeGreaterThanOrEqual(before)
        expect(first.pages).toBe(1)
        expect(second.source).toBe("user")
        expect(second.svg).toBe("<svg/>")
        expect(third.source).toBe("restore")
        expect(third.pages).toBe(2)
        // A bare model is one page; text that is no diagram has none
        addHistory(id, "<mxGraphModel><root/></mxGraphModel>")
        addHistory(id, "not a diagram")
        expect(
            getHistory(id)
                .slice(-2)
                .map((e) => e.pages),
        ).toEqual([1, 0])
    })
})

// The shell's version cards: which entry the canvas shows, and which
// entries are copies of an earlier one (a restore adds one)
describe("currentEntryId and firstCopyIds", () => {
    it("name the newest entry with the canvas's content, by the rule of otherVersions", () => {
        const id = "history-current"
        fill(id, [A, B, C, A])
        const [a, b, c, aCopy] = getHistory(id)
        expect(currentEntryId(id, A)).toBe(aCopy.id)
        expect(currentEntryId(id, B_COPY)).toBe(b.id)
        expect(currentEntryId(id, page("manual"))).toBeNull()
        // A restore's copy belongs with its first entry; the others are
        // their own
        expect([...firstCopyIds(id).entries()]).toEqual([
            [a.id, a.id],
            [b.id, b.id],
            [c.id, c.id],
            [aCopy.id, a.id],
        ])
    })

    it("agree with otherVersions on a page setting that only the canvas shows", () => {
        // The same cells with another background: one version to the MCP
        // core (the model's edits stay valid when the user changes a page
        // setting), so the canvas still shows that entry and restore_version
        // offers no other copy of it
        const id = "history-background"
        const withBackground = A.replace(
            "<mxGraphModel>",
            '<mxGraphModel background="#ffcc00" shadow="1">',
        )
        fill(id, [A, B])
        const [a] = getHistory(id)
        expect(currentEntryId(id, withBackground)).toBe(a.id)
        expect(otherVersions(id, withBackground).map((e) => e.xml)).toEqual([B])
        expect(isInHistory(id, withBackground)).toBe(true)
    })

    it("return nothing for an empty history", () => {
        const id = "history-current-empty"
        clearHistory(id)
        expect(currentEntryId(id, A)).toBeNull()
        expect(firstCopyIds(id).size).toBe(0)
    })
})