@xenonbyte/da-vinci-workflow 0.1.21 → 0.1.22

package/scripts/test-icon-sync.js

@@ -0,0 +1,178 @@
+const assert = require("assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const {
+  MATERIAL_METADATA_URL,
+  LUCIDE_TREE_URL,
+  FEATHER_TREE_URL,
+  PHOSPHOR_TREE_URL,
+  getDefaultCatalogPath,
+  resolveCatalogPath,
+  loadIconCatalog,
+  syncIconCatalog,
+  formatIconSyncReport,
+  parseGoogleMaterialMetadata,
+  parseGitHubTreeIcons,
+  dedupeIconRecords,
+  summarizeSourceResults
+} = require("../lib/icon-sync");
+
+async function runTest(name, fn) {
+  try {
+    await fn();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    throw error;
+  }
+}
+
+function createMockFetch({ failLucide = false } = {}) {
+  return async (url) => {
+    if (url === MATERIAL_METADATA_URL) {
+      return `)]}'\n{"icons":[{"name":"settings","unsupported_families":[]}]}`;
+    }
+    if (url === LUCIDE_TREE_URL) {
+      if (failLucide) {
+        throw new Error("mock lucide outage");
+      }
+      return JSON.stringify({
+        tree: [{ path: "icons/settings.json" }]
+      });
+    }
+    if (url === FEATHER_TREE_URL) {
+      return JSON.stringify({
+        tree: [{ path: "icons/lock.svg" }]
+      });
+    }
+    if (url === PHOSPHOR_TREE_URL) {
+      return JSON.stringify({
+        tree: [{ path: "assets/regular/vault.svg" }]
+      });
+    }
+    throw new Error(`Unexpected URL: ${url}`);
+  };
+}
+
+(async () => {
+  await runTest("google metadata parser extracts material variants", () => {
+    const raw = `)]}'\n{"icons":[{"name":"settings","unsupported_families":[]},{"name":"lock_open","unsupported_families":["Material Icons Sharp"]}]}`;
+    const records = parseGoogleMaterialMetadata(raw);
+    const keys = new Set(records.map((record) => `${record.family}/${record.name}`));
+    assert.ok(keys.has("Material Symbols Rounded/settings"));
+    assert.ok(keys.has("Material Symbols Outlined/settings"));
+    assert.ok(keys.has("Material Symbols Sharp/settings"));
+    assert.ok(keys.has("Material Symbols Rounded/lock_open"));
+    assert.equal(keys.has("Material Symbols Sharp/lock_open"), false);
+  });
+
+  await runTest("github tree parser extracts icon names from paths", () => {
+    const raw = JSON.stringify({
+      tree: [
+        { path: "icons/settings.json" },
+        { path: "icons/lock-open.json" },
+        { path: "icons/nested/skip.json" },
+        { path: "readme.md" }
+      ]
+    });
+    const records = parseGitHubTreeIcons(raw, {
+      family: "lucide",
+      prefix: "icons/",
+      suffix: ".json"
+    });
+    const names = records.map((record) => record.name);
+    assert.deepEqual(names, ["settings", "lock-open"]);
+  });
+
+  await runTest("dedupe keeps first unique family/name pair", () => {
+    const deduped = dedupeIconRecords([
+      { family: "lucide", name: "settings" },
+      { family: "lucide", name: "settings" },
+      { family: "feather", name: "settings" }
+    ]);
+    assert.equal(deduped.length, 2);
+  });
+
+  await runTest("catalog path resolves to home .da-vinci directory by default", () => {
+    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-home-"));
+    const resolved = getDefaultCatalogPath(tempHome);
+    assert.match(resolved, /\.da-vinci[\/\\]icon-catalog\.json$/);
+  });
+
+  await runTest("load icon catalog reads valid schema", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-catalog-"));
+    const catalogPath = path.join(tempDir, "icon-catalog.json");
+    fs.writeFileSync(
+      catalogPath,
+      JSON.stringify(
+        {
+          schema: 1,
+          generatedAt: "2026-03-29T00:00:00.000Z",
+          iconCount: 1,
+          icons: [{ family: "lucide", name: "settings", semantic: "settings", tags: [] }]
+        },
+        null,
+        2
+      )
+    );
+
+    const loaded = loadIconCatalog({
+      catalogPath
+    });
+    assert.ok(loaded.catalog);
+    assert.equal(loaded.catalog.icons.length, 1);
+    assert.equal(resolveCatalogPath({ catalogPath }), path.resolve(catalogPath));
+  });
+
+  await runTest("source summary marks degraded when at least one source errors", () => {
+    const summary = summarizeSourceResults({
+      material: { status: "ok" },
+      lucide: { status: "error" },
+      feather: { status: "ok" }
+    });
+    assert.deepEqual(summary, {
+      total: 3,
+      okCount: 2,
+      errorCount: 1,
+      degraded: true
+    });
+  });
+
+  await runTest("icon sync keeps flow non-blocking by default on partial source failure", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-sync-"));
+    const outputPath = path.join(tempDir, "catalog.json");
+    const result = await syncIconCatalog({
+      outputPath,
+      fetchText: createMockFetch({ failLucide: true })
+    });
+
+    assert.equal(result.catalog.syncStatus, "degraded");
+    assert.equal(result.catalog.sourceResults.lucide.status, "error");
+    assert.ok(result.catalog.iconCount > 0);
+    assert.equal(fs.existsSync(outputPath), true);
+    assert.match(formatIconSyncReport(result), /Status: DEGRADED/i);
+  });
+
+  await runTest("icon sync strict mode fails on partial source failure and does not write partial catalog", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-sync-strict-"));
+    const outputPath = path.join(tempDir, "catalog.json");
+
+    await assert.rejects(
+      () =>
+        syncIconCatalog({
+          outputPath,
+          strict: true,
+          fetchText: createMockFetch({ failLucide: true })
+        }),
+      /strict mode failed/i
+    );
+
+    assert.equal(fs.existsSync(outputPath), false);
+  });
+
+  console.log("All icon-sync tests passed.");
+})().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/scripts/test-pen-persistence.js

@@ -17,6 +17,7 @@ const {
 } = require("../lib/pencil-lock");
 
 const fixturePath = path.join(__dirname, "fixtures", "complex-sample.pen");
+const mockPencilPath = path.join(__dirname, "fixtures", "mock-pencil.js");
 
 function runTest(name, fn) {
   try {
@@ -65,7 +66,8 @@ runTest("writePenFromPayloadFiles writes and reopens a complex sample", () => {
     nodesFile,
     variablesFile,
     version: fixture.version,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
@@ -82,7 +84,8 @@ runTest("snapshotPenFile round-trips a complex sample", () => {
   const result = snapshotPenFile({
     inputPath: fixturePath,
     outputPath,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
@@ -97,7 +100,8 @@ runTest("ensurePenFile seeds a missing project-local .pen and state", () => {
 
   const result = ensurePenFile({
     outputPath,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));