tests/import.test.ts
Rama main · réplica de lectura del repositorio original.
// The import wizard (docs/import.md): the pure half (shared/importPlan.ts),
// each converter against a hand-written export of its kind under
// tests/fixtures/import, and the whole preview → commit → undo loop over a
// throwaway vault — collisions resolved out loud, attachments moved into the
// vault's attachments folder with the links that named them rewritten, and no
// imported note public.
import assert from "node:assert/strict";
import { after, before, describe, it } from "node:test";
import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { cleanName, frontmatterBlock, linksToWikilinks, normaliseFields, notionDate, notionProperties, renameEmbeds, resolveTargets, stripNotionId } from "../shared/importPlan.ts";
import { zipSync } from "../shared/zip.ts";
import { dropCommonRoot, unzipExport, type ExportFile } from "../server/import/common.ts";
import { convertEvernote } from "../server/import/evernote.ts";
import { convertNotion } from "../server/import/notion.ts";
import { convertObsidian } from "../server/import/obsidian.ts";
import { commitImport, planImport, undoImport } from "../server/import/plan.ts";
import { initIndexer, isNotePublished, noteTitle } from "../server/indexer.ts";
import { initSite } from "../server/site.ts";
import { initVault } from "../server/vault.ts";
import { makeDir, makeVault, removeVault } from "./helpers/vault.ts";
const FIX = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "import");
/** Every file under a fixture folder, as the export's own paths. */
function readTree(root: string, prefix = ""): ExportFile[] {
const out: ExportFile[] = [];
for (const name of readdirSync(path.join(root, prefix))) {
const rel = prefix === "" ? name : `${prefix}/${name}`;
if (statSync(path.join(root, rel)).isDirectory()) out.push(...readTree(root, rel));
else out.push({ path: rel, bytes: new Uint8Array(readFileSync(path.join(root, rel))) });
}
return out;
}
/** The fixture folder as the zip its app would have written. */
function zipOf(dir: string): Uint8Array {
return zipSync(readTree(dir).map((f) => ({ name: f.path, data: f.bytes })));
}
const notionFiles = (): ExportFile[] => unzipExport(zipOf(path.join(FIX, "notion")));
const enexFiles = (): ExportFile[] => [{ path: "Reading notes.enex", bytes: new Uint8Array(readFileSync(path.join(FIX, "evernote", "Reading notes.enex"))) }];
const obsidianFiles = (): ExportFile[] => dropCommonRoot(readTree(path.join(FIX, "obsidian")));
describe("the pure half (shared/importPlan.ts)", () => {
it("strips Notion's ids and cleans names", () => {
assert.equal(stripNotionId("Reading list 0f8e2b7c4d1a4e6b9c3d2e1f0a9b8c7d.md"), "Reading list.md");
assert.equal(stripNotionId("Books 3a4b5c6d7e8f40a1b2c3d4e5f6a7b8c9"), "Books");
assert.equal(stripNotionId("Plain name"), "Plain name");
assert.equal(cleanName(" a/b: [c] #d? "), "a b c d");
assert.equal(cleanName("..."), "Untitled");
});
it("resolves collisions against the vault and within the export, never overwriting", () => {
const { targets, collisions } = resolveTargets(
[
{ source: "a", path: "In/Notes.md" },
{ source: "b", path: "In/notes.md" },
{ source: "c", path: "In/Welcome.md" },
],
(p) => p === "In/Welcome.md",
);
assert.deepEqual([...targets.values()], ["In/Notes.md", "In/notes 2.md", "In/Welcome 2.md"]);
assert.deepEqual(collisions.map((c) => [c.source, c.reason]), [["b", "duplicate"], ["c", "exists"]]);
});
it("reads Notion's property lines, and leaves a sentence with a colon in the body", () => {
const p = notionProperties("# Book\n\nAuthor: Someone\nTags: a, b c\nStarted: September 10, 2026\n\nBody: prose.\n");
assert.equal(p.title, "Book");
assert.deepEqual(p.fields, [["Author", "Someone"], ["Tags", ["a", "b-c"]], ["Started", "2026-09-10"]]);
assert.equal(p.body, "Body: prose.\n");
const q = notionProperties("# Page\n\nNote: this is a sentence\nand it goes on.\n");
assert.deepEqual(q.fields, []);
assert.match(q.body, /^Note: this is a sentence/);
assert.equal(notionDate("September 9, 2026 7:15 PM"), "2026-09-09");
});
it("normalises keys, drops publish, and writes frontmatter YAML reads back", () => {
const f = normaliseFields([["Tags", "x, y"], ["Created", "2026-01-02"], ["publish", true], ["Status", "Reading: now"], ["Alias", "Z"]]);
assert.deepEqual(f, [["tags", ["x", "y"]], ["created", "2026-01-02"], ["Status", "Reading: now"], ["aliases", "Z"]]);
assert.equal(frontmatterBlock(f), '---\ntags: [x, y]\ncreated: 2026-01-02\nStatus: "Reading: now"\naliases: Z\n---\n');
});
it("rewrites links between imported notes into wikilinks, and renames embeds", () => {
const { text, count } = linksToWikilinks("See [the list](../Reading%20list%20abc.md#Top) and [web](https://x.org) and .", "Sub", (p) => (p === "Reading list abc.md" ? "In/Reading list.md" : null));
assert.equal(text, "See [[Reading list#Top|the list]] and [web](https://x.org) and .");
assert.equal(count, 1);
const r = renameEmbeds("![[a.png]] ![[Attachments/b.png|200]] [[Note]]", new Map([["a.png", "a 2.png"], ["Attachments/b.png", "b.png"]]));
assert.equal(r.text, "![[a 2.png]] ![[b.png|200]] [[Note]]");
assert.equal(r.count, 2);
});
});
describe("the converters, each against a real-shaped export", () => {
it("Notion: ids gone, properties to frontmatter, the database a table, rows given the CSV's cells", () => {
const c = convertNotion(notionFiles());
const by = new Map(c.notes.map((n) => [n.want, n]));
assert.deepEqual(c.notes.map((n) => n.want).sort(), [
"Books.md",
"Books/Invisible Cities.md",
"Books/The Muqaddimah.md",
"Colophon.md",
"Notes.md",
"Notes.md",
"Reading list.md",
"Reading list/Why read slowly.md",
].sort());
const muq = by.get("Books/The Muqaddimah.md")!;
assert.deepEqual(muq.fields, [["Author", "Ibn Khaldun"], ["Status", "Reading"], ["tags", ["history", "sociology"]], ["Started", "2026-09-10"], ["created", "2026-09-09"]]);
assert.match(muq.body, /^Asabiyya: the group feeling/);
// A row page with no property lines borrows them from the database.
assert.deepEqual(by.get("Books/Invisible Cities.md")!.fields, [["Author", "Italo Calvino"], ["Status", "Done"], ["tags", ["fiction"]], ["Started", "2026-08-02"]]);
assert.match(by.get("Books.md")!.body, /^\| Name \| Author \| Status \| Tags \| Started \|\n\| --- /);
// The HTML page: its property table, its body only.
const col = by.get("Colophon.md")!;
assert.deepEqual(col.fields, [["tags", ["meta", "site"]], ["created", "2026-09-01"]]);
assert.match(col.body, /^Set in \*\*Lora\*\*\. Built from \[the reading list\]\(\/Reading%20list/);
assert.deepEqual(c.attachments.map((a) => a.name), ["cover.svg"]);
});
it("Evernote: title, tags, created and source to frontmatter; resources to attachments where they stood; to-dos to tasks", () => {
const c = convertEvernote(enexFiles());
assert.deepEqual(c.notes.map((n) => n.want), ["Muqaddimah — chapter one.md", "Welcome.md", "ملاحظة عربية.md"]);
const [first, , ar] = c.notes;
assert.deepEqual(first.fields, [["tags", ["history", "ibn-khaldun"]], ["created", "2026-09-10"], ["updated", "2026-09-12"], ["source", "https://example.org/muqaddimah/1"]]);
assert.match(first.body, /Asabiyya is the \*\*group feeling\*\* that founds a dynasty\./);
assert.match(first.body, /- \[x\] Read the prolegomena/);
assert.match(first.body, /- \[ \] Compare with Machiavelli/);
assert.match(first.body, /!\[\[map\.png\]\]/);
assert.match(first.body, /The scan: !\[\[e4a37a595b9d\.pdf\]\]/);
assert.deepEqual(c.attachments.map((a) => [a.name, a.bytes.length > 0]), [["map.png", true], ["e4a37a595b9d.pdf", true]]);
assert.deepEqual(ar.fields, [["tags", ["عربي"]], ["created", "2026-09-15"]]);
});
it("Obsidian: notes as they are, publish taken out, .obsidian and the unknown left behind", () => {
const c = convertObsidian(obsidianFiles());
assert.deepEqual(c.notes.map((n) => n.want).sort(), ["Index.md", "Projects/Plan.md", "Seedlings.md"]);
const index = c.notes.find((n) => n.want === "Index.md")!;
assert.match(index.body, /^---\naliases: \[Home, Start here\]\ntags: \[garden, index\]\n---\n/);
assert.doesNotMatch(index.body, /publish/);
assert.equal(c.stats.publishCleared, 1);
assert.equal(c.stats.aliases, 1);
assert.deepEqual(c.attachments.map((a) => a.source), ["Attachments/diagram.svg"]);
assert.deepEqual(c.skipped.map((s) => [s.path, s.reason]).sort(), [[".obsidian/app.json", "system"], ["Attachments/Welcome.png.txt", "unsupported"]]);
});
});
describe("preview → commit → undo, over a vault", () => {
const data = makeDir();
let root = "";
before(async () => {
root = makeVault({
"Welcome.md": "# Welcome\n",
"Attachments/diagram.svg": "<svg xmlns='http://www.w3.org/2000/svg'><!-- the vault's own, different --></svg>\n",
"Garden/Seedlings.md": "# Already here\n",
});
initSite({ ASTROLABE_DATA: data });
initVault(root);
await initIndexer();
});
after(() => {
removeVault(root);
removeVault(data);
});
it("Notion: the preview counts and writes nothing; the commit writes the plan; links become wikilinks", async () => {
const preview = planImport("notion", notionFiles(), "Imported");
assert.equal(preview.notes, 8);
assert.equal(preview.attachments, 1);
assert.equal(preview.attachmentsFolder, "Attachments");
assert.deepEqual(preview.collisions.map((c) => [c.wanted, c.target, c.reason]), [["Imported/Notes.md", "Imported/Notes 2.md", "duplicate"]]);
assert.ok(preview.links >= 6, `links rewritten: ${preview.links}`);
assert.ok(preview.frontmatter.properties >= 9);
assert.ok(!existsSync(path.join(root, "Imported")), "the preview wrote nothing");
const lines: string[] = [];
const done = await commitImport(preview.planId, (p) => lines.push(p.type));
assert.equal(done.notes.length, 8);
assert.equal(lines.filter((l) => l === "progress").length, 9);
assert.equal(lines.at(-1), "done");
const read = (p: string): string => readFileSync(path.join(root, p), "utf8");
const list = read("Imported/Reading list.md");
assert.match(list, /^# Reading list\n\nWhat I am reading, and why\.\n/);
assert.match(list, /- \[\[Why read slowly\]\]/);
assert.match(list, /The shelf: \[\[Books\]\]/);
assert.match(list, /\[a web page\]\(https:\/\/example\.org\/reading\)/);
// The image re-resolved from the note's folder to the attachments folder.
assert.match(list, /!\[cover\.svg\]\(\.\.\/Attachments\/cover\.svg\)/);
assert.match(read("Imported/Reading list/Why read slowly.md"), /See \[\[Reading list\|the list\]\] and \[\[The Muqaddimah\]\]\./);
assert.match(read("Imported/Books/The Muqaddimah.md"), /^---\nAuthor: Ibn Khaldun\nStatus: Reading\ntags: \[history, sociology\]\nStarted: 2026-09-10\ncreated: 2026-09-09\n---\n\n# The Muqaddimah\n/);
assert.match(read("Imported/Books.md"), /\| \[\[The Muqaddimah\]\] \| Ibn Khaldun \|/);
assert.match(read("Imported/Colophon.md"), /Built from \[\[Reading list\|the reading list\]\]/);
assert.ok(existsSync(path.join(root, "Attachments/cover.svg")));
assert.equal(noteTitle("Imported/Notes 2.md"), "Notes 2");
for (const p of done.notes) assert.equal(isNotePublished(p), false, `${p} must not be public`);
const undone = await undoImport(done.undoId);
assert.equal(undone.removed.length, 9);
assert.deepEqual(undone.kept, []);
assert.ok(!existsSync(path.join(root, "Imported")), "the folders the import made are gone");
assert.ok(!existsSync(path.join(root, "Attachments/cover.svg")));
assert.ok(existsSync(path.join(root, "Attachments/diagram.svg")), "the vault's own file is untouched");
await assert.rejects(undoImport(done.undoId), /can no longer be taken back/);
});
it("Evernote at the vault root: a note the vault has becomes Welcome 2, and nothing is public", async () => {
const preview = planImport("evernote", enexFiles(), "");
assert.deepEqual(preview.collisions.map((c) => [c.wanted, c.target, c.reason]), [["Welcome.md", "Welcome 2.md", "exists"]]);
const done = await commitImport(preview.planId);
assert.equal(readFileSync(path.join(root, "Welcome.md"), "utf8"), "# Welcome\n", "never overwritten");
const first = readFileSync(path.join(root, "Muqaddimah — chapter one.md"), "utf8");
assert.match(first, /^---\ntags: \[history, ibn-khaldun\]\ncreated: 2026-09-10\nupdated: 2026-09-12\nsource: "https:\/\/example\.org\/muqaddimah\/1"\n---\n\n# Muqaddimah — chapter one\n/);
assert.ok(existsSync(path.join(root, "Attachments/map.png")));
for (const p of done.notes) assert.equal(isNotePublished(p), false);
// An edit after the import survives the undo, and is reported.
writeFileSync(path.join(root, "Welcome 2.md"), "# Mine now\n");
const undone = await undoImport(done.undoId);
assert.deepEqual(undone.kept, ["Welcome 2.md"]);
assert.equal(readFileSync(path.join(root, "Welcome 2.md"), "utf8"), "# Mine now\n");
assert.ok(!existsSync(path.join(root, "Attachments/map.png")));
});
it("Obsidian: attachments into the attachments folder, renamed on a clash, embeds and paths rewritten; publish never lands", async () => {
const preview = planImport("obsidian", obsidianFiles(), "Garden");
assert.deepEqual(
preview.collisions.map((c) => [c.wanted, c.target, c.reason]),
[
["Garden/Seedlings.md", "Garden/Seedlings 2.md", "exists"],
["Attachments/diagram.svg", "Attachments/diagram 2.svg", "exists"],
],
);
assert.equal(preview.frontmatter.publishCleared, 1);
const done = await commitImport(preview.planId);
const index = readFileSync(path.join(root, "Garden/Index.md"), "utf8");
assert.match(index, /^---\naliases: \[Home, Start here\]\ntags: \[garden, index\]\n---\n/);
assert.match(index, /Projects: \[\[Garden\/Projects\/Plan\]\] and \[\[Seedlings 2\]\]\./);
assert.match(index, /\n!\[\[diagram 2\.svg\]\]\n/);
assert.match(index, /A path-form embed: !\[\[diagram 2\.svg\|200\]\]/);
assert.match(index, /A Markdown image: !\[the diagram\]\(\.\.\/Attachments\/diagram%202\.svg\)/);
assert.match(readFileSync(path.join(root, "Garden/Projects/Plan.md"), "utf8"), /See \[\[Index#The garden\]\] and \[\[Seedlings 2\|the seedlings\]\]\./);
assert.match(readFileSync(path.join(root, "Garden/Seedlings 2.md"), "utf8"), /Back to \[\[Index\|the index\]\]\./);
assert.equal(readFileSync(path.join(root, "Garden/Seedlings.md"), "utf8"), "# Already here\n");
for (const p of done.notes) assert.equal(isNotePublished(p), false, `${p} must not be public`);
const undone = await undoImport(done.undoId);
assert.equal(undone.kept.length, 0);
assert.ok(existsSync(path.join(root, "Garden/Seedlings.md")), "the folder that was there stays, with its note");
assert.ok(!existsSync(path.join(root, "Garden/Projects")));
});
it("an expired or unknown plan is refused, and an export with no notes is refused at preview", async () => {
await assert.rejects(commitImport("nope"), /expired/);
assert.throws(() => planImport("obsidian", [{ path: "a.bin", bytes: new Uint8Array([1]) }], "X"), /no notes/);
});
});