test: split and expand suites for parser/builder/snapshots/exporter

Replaces the single parser.test.ts with five focused files and grows the
suite from 4 tests to 52:

- parser-sql.test.ts: existing SQL cases plus coverage for non-CREATE
  statements, composite PKs, CREATE TEMPORARY, Chinese identifiers,
  blank input, and UNIQUE/KEY/INDEX clause skipping
- parser-dbml.test.ts: existing DBML case plus comments-inside-strings,
  multi-line attributes, note-as-comment, nested Note/indexes blocks,
  Ref { ... } blocks, schema-qualified targets, Chinese identifiers,
  Project/Enum/TableGroup ignores, recovery from stray top-level lines,
  and a regression test for the in-app sample DBML
- builder.test.ts: covers generateChenModelData (entities, attributes,
  diamonds + N/1 edges, dashed placeholders for missing tables,
  self-loop edge type, hideFields, isColored, labelMode), getTextWidth
  and estimateAttributeHalfSize
- snapshots.test.ts: hashInput stability/uniqueness/unicode plus
  captureGraphSnapshot happy-path and destroyed-graph short-circuit
- exporter-xml.test.ts: escapeXml escaping rules and buildDrawioXML
  output structure (mxfile shell, vertex / edge counts, label escaping,
  per-node-type style strings, missing-endpoint skipping, dashed style)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ystemsrx

src/test/builder.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import {
+  generateChenModelData,
+  estimateAttributeHalfSize,
+  getTextWidth,
+} from "../builder";
+import type { ParsedRelationship, ParsedTable } from "../types";
+
+const usersTable: ParsedTable = {
+  name: "users",
+  columns: [
+    { name: "id", type: "int", isPrimaryKey: true, comment: "user id" },
+    { name: "name", type: "varchar(50)", isPrimaryKey: false },
+  ],
+  primaryKeys: ["id"],
+  foreignKeys: [],
+};
+
+const ordersTable: ParsedTable = {
+  name: "orders",
+  columns: [
+    { name: "id", type: "int", isPrimaryKey: true },
+    { name: "user_id", type: "int", isPrimaryKey: false },
+  ],
+  primaryKeys: ["id"],
+  foreignKeys: [
+    { column: "user_id", referencedTable: "users", referencedColumn: "id" },
+  ],
+};
+
+describe("generateChenModelData", () => {
+  it("creates an entity node per table and an attribute node per column", () => {
+    const data = generateChenModelData([usersTable], []);
+    const entities = data.nodes.filter((n) => n.nodeType === "entity");
+    const attrs = data.nodes.filter((n) => n.nodeType === "attribute");
+    expect(entities).toHaveLength(1);
+    expect(entities[0].label).toBe("users");
+    expect(attrs.map((a) => a.label)).toEqual(["id", "name"]);
+    // Primary key attribute is bolder/highlighted
+    expect(attrs[0].keyType).toBe("pk");
+    expect(attrs[1].keyType).toBe("normal");
+  });
+
+  it("connects every attribute back to its parent entity", () => {
+    const data = generateChenModelData([usersTable], []);
+    const entityId = data.nodes.find((n) => n.nodeType === "entity")!.id;
+    const attrEdges = data.edges.filter(
+      (e) => e.edgeType === "entity-attribute",
+    );
+    expect(attrEdges).toHaveLength(2);
+    expect(attrEdges.every((e) => e.source === entityId)).toBe(true);
+  });
+
+  it("renders one diamond + two edges (N / 1) for each relationship", () => {
+    const rels: ParsedRelationship[] = [
+      { from: "orders", to: "users", label: "user_id" },
+    ];
+    const data = generateChenModelData([usersTable, ordersTable], rels);
+    const diamonds = data.nodes.filter((n) => n.nodeType === "relationship");
+    expect(diamonds).toHaveLength(1);
+    expect(diamonds[0].label).toBe("user_id");
+
+    const erEdges = data.edges.filter(
+      (e) =>
+        e.edgeType === "entity-relationship" ||
+        e.edgeType === "relationship-entity",
+    );
+    expect(erEdges).toHaveLength(2);
+    const labels = erEdges.map((e) => e.label).sort();
+    expect(labels).toEqual(["1", "N"]);
+  });
+
+  it("creates a dashed placeholder entity for refs to unknown tables", () => {
+    const rels: ParsedRelationship[] = [
+      { from: "orders", to: "missing", label: "x_id" },
+    ];
+    const data = generateChenModelData([ordersTable], rels);
+    const placeholder = data.nodes.find(
+      (n) => n.nodeType === "entity" && n.isPlaceholder,
+    );
+    expect(placeholder).toBeDefined();
+    expect(placeholder!.label).toBe("missing");
+    expect(placeholder!.style?.lineDash).toEqual([4, 4]);
+  });
+
+  it("marks self-loop relationships with self-loop-arc edge type", () => {
+    const selfRel: ParsedRelationship[] = [
+      { from: "users", to: "users", label: "manager_id" },
+    ];
+    const data = generateChenModelData([usersTable], selfRel);
+    const erEdges = data.edges.filter(
+      (e) =>
+        e.edgeType === "entity-relationship" ||
+        e.edgeType === "relationship-entity",
+    );
+    expect(erEdges).toHaveLength(2);
+    expect(erEdges.every((e) => e.type === "self-loop-arc")).toBe(true);
+    expect(erEdges.every((e) => e.curveOffset === 22)).toBe(true);
+  });
+
+  it("hideFields=true skips attribute nodes & their edges", () => {
+    const data = generateChenModelData([usersTable], [], true, "name", true);
+    expect(data.nodes.filter((n) => n.nodeType === "attribute")).toHaveLength(
+      0,
+    );
+    expect(
+      data.edges.filter((e) => e.edgeType === "entity-attribute"),
+    ).toHaveLength(0);
+  });
+
+  it("isColored=false uses black/white styling", () => {
+    const data = generateChenModelData([usersTable], [], false);
+    const entity = data.nodes.find((n) => n.nodeType === "entity")!;
+    const attr = data.nodes.find((n) => n.nodeType === "attribute")!;
+    expect(entity.style?.stroke).toBe("#000000");
+    expect(attr.style?.stroke).toBe("#000000");
+  });
+
+  it("labelMode='comment' shows column comment instead of name (falls back to name)", () => {
+    const data = generateChenModelData([usersTable], [], true, "comment");
+    const attrs = data.nodes.filter((n) => n.nodeType === "attribute");
+    // id has comment "user id"
+    expect(attrs[0].label).toBe("user id");
+    // name has no comment → falls back to name
+    expect(attrs[1].label).toBe("name");
+  });
+
+  it("labelMode='any' prefers comment when present, name otherwise", () => {
+    const data = generateChenModelData([usersTable], [], true, "any");
+    const attrs = data.nodes.filter((n) => n.nodeType === "attribute");
+    expect(attrs[0].label).toBe("user id");
+    expect(attrs[1].label).toBe("name");
+  });
+});
+
+describe("getTextWidth", () => {
+  it("counts CJK characters at full font width and ASCII at ~0.6 width", () => {
+    const fontSize = 10;
+    expect(getTextWidth("ab", fontSize)).toBeCloseTo(12, 5); // 0.6 * 2 * 10
+    expect(getTextWidth("中", fontSize)).toBeCloseTo(10, 5);
+    expect(getTextWidth("a中", fontSize)).toBeCloseTo(16, 5);
+    expect(getTextWidth("", fontSize)).toBe(0);
+  });
+});
+
+describe("estimateAttributeHalfSize", () => {
+  it("never goes below the configured minimum (60 wide / 40 tall halved)", () => {
+    const { halfW, halfH } = estimateAttributeHalfSize("");
+    expect(halfW).toBeGreaterThanOrEqual(30);
+    expect(halfH).toBeGreaterThanOrEqual(20);
+  });
+
+  it("grows for longer labels", () => {
+    const small = estimateAttributeHalfSize("a");
+    const large = estimateAttributeHalfSize(
+      "a_very_long_attribute_label_indeed",
+    );
+    expect(large.halfW).toBeGreaterThan(small.halfW);
+  });
+});

src/test/exporter-xml.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from "vitest";
+import { buildDrawioXML, escapeXml } from "../exporter";
+import type {
+  EREdgeModel,
+  ERNodeModel,
+  GraphEdgeLike,
+  GraphLike,
+  GraphNodeLike,
+} from "../types";
+
+describe("escapeXml", () => {
+  it("escapes the five canonical XML entities", () => {
+    expect(escapeXml(`<a href="x">x & y</a>`)).toBe(
+      "&lt;a href=&quot;x&quot;&gt;x &amp; y&lt;/a&gt;",
+    );
+    expect(escapeXml("It's")).toBe("It&apos;s");
+  });
+
+  it("treats null/undefined as empty string", () => {
+    expect(escapeXml(null)).toBe("");
+    expect(escapeXml(undefined)).toBe("");
+  });
+
+  it("stringifies non-string inputs", () => {
+    expect(escapeXml(42)).toBe("42");
+    expect(escapeXml(true)).toBe("true");
+  });
+});
+
+// 构造仅 buildDrawioXML 需要的 GraphLike 子集。
+const buildNode = (
+  model: ERNodeModel,
+  bbox: { minX: number; minY: number; width: number; height: number },
+): GraphNodeLike =>
+  ({
+    getModel: () => model,
+    getBBox: () => ({
+      ...bbox,
+      maxX: bbox.minX + bbox.width,
+      maxY: bbox.minY + bbox.height,
+      centerX: bbox.minX + bbox.width / 2,
+      centerY: bbox.minY + bbox.height / 2,
+    }),
+  }) as unknown as GraphNodeLike;
+
+const buildEdge = (model: EREdgeModel): GraphEdgeLike =>
+  ({ getModel: () => model }) as unknown as GraphEdgeLike;
+
+const buildGraph = (
+  nodes: GraphNodeLike[],
+  edges: GraphEdgeLike[],
+): GraphLike =>
+  ({
+    destroyed: false,
+    getNodes: () => nodes,
+    getEdges: () => edges,
+    findById: () => null,
+    updateItem: () => {},
+    setAutoPaint: () => {},
+    paint: () => {},
+    refreshPositions: () => {},
+    get: () => null,
+    getZoom: () => 1,
+  }) as unknown as GraphLike;
+
+describe("buildDrawioXML", () => {
+  it("emits a well-formed mxfile root with one mxCell per node + edge", () => {
+    const nodes = [
+      buildNode(
+        {
+          id: "entity-users-0",
+          label: "users",
+          nodeType: "entity",
+          style: { fill: "#ffffff", stroke: "#000000", lineWidth: 2 },
+        },
+        { minX: 100, minY: 80, width: 120, height: 60 },
+      ),
+      buildNode(
+        {
+          id: "attr-users-id-0-0",
+          label: "id",
+          nodeType: "attribute",
+          keyType: "pk",
+          style: { fill: "#fffbe6", stroke: "#52c41a", lineWidth: 2 },
+        },
+        { minX: 200, minY: 200, width: 60, height: 40 },
+      ),
+    ];
+    const edges = [
+      buildEdge({
+        source: "entity-users-0",
+        target: "attr-users-id-0-0",
+        edgeType: "entity-attribute",
+        style: { stroke: "#000000", lineWidth: 1 },
+      }),
+    ];
+
+    const xml = buildDrawioXML(buildGraph(nodes, edges));
+
+    // Header / shell
+    expect(xml.startsWith('<?xml version="1.0" encoding="UTF-8"?>')).toBe(true);
+    expect(xml).toContain("<mxfile");
+    expect(xml).toContain("</mxfile>");
+    expect(xml).toMatch(/<diagram id="sql2er-[a-z0-9-]+" name="ER">/);
+
+    // Two vertex cells (renumbered to v0, v1) + one edge cell
+    expect((xml.match(/vertex="1"/g) || []).length).toBe(2);
+    expect((xml.match(/edge="1"/g) || []).length).toBe(1);
+    // Edge endpoints should reference the renumbered vertex ids
+    expect(xml).toContain('source="v0"');
+    expect(xml).toContain('target="v1"');
+
+    // Geometry uses rounded ints
+    expect(xml).toContain('<mxGeometry x="100" y="80" width="120" height="60"');
+  });
+
+  it("XML-escapes node and edge labels", () => {
+    const xml = buildDrawioXML(
+      buildGraph(
+        [
+          buildNode(
+            {
+              id: "n",
+              label: `<bad & "quoted">`,
+              nodeType: "entity",
+            },
+            { minX: 0, minY: 0, width: 10, height: 10 },
+          ),
+        ],
+        [],
+      ),
+    );
+    expect(xml).toContain(
+      'value="&lt;bad &amp; &quot;quoted&quot;&gt;"',
+    );
+    expect(xml).not.toContain('value="<bad');
+  });
+
+  it("uses different style strings for entity / attribute / relationship nodes", () => {
+    const xml = buildDrawioXML(
+      buildGraph(
+        [
+          buildNode(
+            { id: "e", label: "E", nodeType: "entity" },
+            { minX: 0, minY: 0, width: 10, height: 10 },
+          ),
+          buildNode(
+            { id: "a", label: "A", nodeType: "attribute", keyType: "pk" },
+            { minX: 0, minY: 0, width: 10, height: 10 },
+          ),
+          buildNode(
+            { id: "r", label: "R", nodeType: "relationship" },
+            { minX: 0, minY: 0, width: 10, height: 10 },
+          ),
+        ],
+        [],
+      ),
+    );
+    // Entity: rectangle (no shape prefix), attribute: ellipse, relationship: rhombus
+    expect(xml).toMatch(/value="E"[^/]*style="rounded=0/);
+    expect(xml).toMatch(/value="A"[^/]*style="ellipse/);
+    expect(xml).toMatch(/value="R"[^/]*style="rhombus/);
+  });
+
+  it("skips edges whose source or target id is unknown", () => {
+    const nodes = [
+      buildNode(
+        { id: "e1", label: "e1", nodeType: "entity" },
+        { minX: 0, minY: 0, width: 10, height: 10 },
+      ),
+    ];
+    const edges = [
+      buildEdge({ source: "e1", target: "ghost" }),
+      buildEdge({ source: "ghost", target: "e1" }),
+    ];
+    const xml = buildDrawioXML(buildGraph(nodes, edges));
+    expect((xml.match(/edge="1"/g) || []).length).toBe(0);
+  });
+
+  it("marks dashed-style nodes with dashed=1", () => {
+    const xml = buildDrawioXML(
+      buildGraph(
+        [
+          buildNode(
+            {
+              id: "p",
+              label: "missing",
+              nodeType: "entity",
+              style: { lineDash: [4, 4] },
+            },
+            { minX: 0, minY: 0, width: 10, height: 10 },
+          ),
+        ],
+        [],
+      ),
+    );
+    expect(xml).toContain("dashed=1");
+  });
+});