eyeling 1.26.3 → 1.26.5

package/test/examples.test.js

@@ -52,20 +52,53 @@ function normalizeMarkdownForCompare(text) {
 // Normalize N3 output for comparison.
 // Eyeling (and other N3 tools) may emit the same closure with different
 // triple ordering. Examples tests should verify content, not presentation.
-function normalizeN3ForCompare(n3Text) {
-  return stripTrailingWhitespace(n3Text)
+function normalizeN3ForCompare(n3Text, sourceText = '', expectedPath = '') {
+  let value = stripTrailingWhitespace(n3Text);
+
+  // get-uuid.n3 intentionally uses log:skolem and relative IRIs, so its
+  // output depends on the checkout path and generated skolem seed. Compare the
+  // shape of the generated triples rather than those environment-specific bits.
+  if (/\blog:skolem\b/.test(sourceText) || path.basename(expectedPath) === 'get-uuid.n3') {
+    value = value
+      .replace(/<urn:uuid:[^>]+>/g, '<urn:uuid:__UUID__>')
+      .replace(/<file:\/\/[^>\s]*\/examples\/([^/>]+)>/g, '<file://__EXAMPLES__/$1>');
+  }
+
+  return value
     .split('\n')
     .filter((l) => l.length > 0)
     .sort((a, b) => a.localeCompare(b))
     .join('\n');
 }
 
-function normalizeForCompare(text, expectedPath) {
+function normalizeForCompare(text, expectedPath, sourceText = '') {
   const ext = path.extname(expectedPath);
   const value = text;
   if (ext === '.md') return normalizeMarkdownForCompare(value);
   if (ext === '.txt') return normalizeTextForCompare(value);
-  return normalizeN3ForCompare(value);
+  return normalizeN3ForCompare(value, sourceText, expectedPath);
+}
+
+function normalizeProofForCompare(text, expectedPath, sourceText) {
+  let value = normalizeForCompare(text, expectedPath, sourceText);
+
+  // Some proof goldens intentionally cover volatile builtins such as
+  // time:localTime. Keep those examples useful by comparing proof structure
+  // while masking only the volatile literal values.
+  if (/\btime:localTime\b/.test(sourceText)) {
+    value = value
+      .replace(/"[^"\n]*"\^\^xsd:dateTime/g, '"__DATETIME__"^^xsd:dateTime')
+      .replace(/"PT[0-9]+(?:\.[0-9]+)?S"\^\^xsd:duration/g, '"__DURATION__"^^xsd:duration');
+  }
+
+  return value;
+}
+
+function compareGeneratedOutput({ expectedPath, generatedPath, sourceText, proof }) {
+  const expectedText = fs.readFileSync(expectedPath, 'utf8');
+  const generatedText = fs.readFileSync(generatedPath, 'utf8');
+  const normalize = proof ? normalizeProofForCompare : normalizeForCompare;
+  return normalize(expectedText, expectedPath, sourceText) === normalize(generatedText, expectedPath, sourceText);
 }
 
 // Expectation logic (robust, long-term):
@@ -141,6 +174,42 @@ function resolveExampleBuiltinPath(root, inputFile) {
   return { abs, rel };
 }
 
+function runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath, proof = false }) {
+  const builtin = resolveExampleBuiltinPath(root, file);
+  const trigInput = resolveExampleTrigInput(root, file);
+  const rdfMode = !!trigInput;
+  const modeFlag = proof ? '-p' : '-d';
+  const outFd = fs.openSync(generatedPath, 'w');
+
+  try {
+    if (builtin) {
+      const args = [eyelingJsPath, modeFlag];
+      if (rdfMode) args.push('-r');
+      args.push('--builtin', builtin.rel, path.join('examples', file));
+      if (trigInput) args.push(path.join('examples', trigInput.rel));
+      return cp.spawnSync(nodePath, args, {
+        cwd: root,
+        stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
+        maxBuffer: 200 * 1024 * 1024,
+        encoding: 'utf8',
+      });
+    }
+
+    const args = [eyelingJsPath, modeFlag];
+    if (rdfMode) args.push('-r');
+    args.push(file);
+    if (trigInput) args.push(trigInput.rel);
+    return cp.spawnSync(nodePath, args, {
+      cwd: examplesDir,
+      stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
+      maxBuffer: 200 * 1024 * 1024,
+      encoding: 'utf8',
+    });
+  } finally {
+    fs.closeSync(outFd);
+  }
+}
+
 function main() {
   const suiteStart = Date.now();
 
@@ -148,6 +217,7 @@ function main() {
   const root = path.resolve(__dirname, '..');
   const examplesDir = path.join(root, 'examples');
   const outputDir = path.join(examplesDir, 'output');
+  const proofDir = path.join(examplesDir, 'proof');
   const eyelingJsPath = path.join(root, 'eyeling.js');
   const nodePath = process.execPath;
 
@@ -164,8 +234,15 @@ function main() {
     .readdirSync(examplesDir)
     .filter((f) => f.endsWith('.n3'))
     .sort((a, b) => a.localeCompare(b));
-
-  info(`Running ${files.length} examples tests`);
+  const proofFiles = fs.existsSync(proofDir)
+    ? fs
+        .readdirSync(proofDir)
+        .filter((f) => f.endsWith('.n3') && fs.existsSync(path.join(examplesDir, f)))
+        .sort((a, b) => a.localeCompare(b))
+    : [];
+  const totalTests = files.length + proofFiles.length;
+
+  info(`Running ${files.length} examples tests and ${proofFiles.length} proof golden tests`);
   console.log(`${C.dim}${getEyelingVersion(nodePath, eyelingJsPath, root)}; node ${process.version}${C.n}`);
 
   if (files.length === 0) {
@@ -178,6 +255,7 @@ function main() {
 
   // Pretty, stable numbering (e.g., 001..100 when running 100 tests)
   const idxWidth = String(files.length).length;
+  const proofIdxWidth = String(Math.max(proofFiles.length, 1)).length;
 
   for (let i = 0; i < files.length; i++) {
     const idx = String(i + 1).padStart(idxWidth, '0');
@@ -221,38 +299,7 @@ function main() {
     //   node eyeling.js --builtin examples/builtin/foo.js examples/foo.n3
     // A matching examples/input/<stem>.trig sidecar is external RDF/TriG
     // evidence for this example, so include it and run in -r mode automatically.
-    const builtin = resolveExampleBuiltinPath(root, file);
-    const trigInput = resolveExampleTrigInput(root, file);
-    const rdfMode = !!trigInput;
-    const outFd = fs.openSync(generatedPath, 'w');
-    let r;
-    try {
-      if (builtin) {
-        const args = [eyelingJsPath, '-d'];
-        if (rdfMode) args.push('-r');
-        args.push('--builtin', builtin.rel, path.join('examples', file));
-        if (trigInput) args.push(path.join('examples', trigInput.rel));
-        r = cp.spawnSync(nodePath, args, {
-          cwd: root,
-          stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
-          maxBuffer: 200 * 1024 * 1024,
-          encoding: 'utf8',
-        });
-      } else {
-        const args = [eyelingJsPath, '-d'];
-        if (rdfMode) args.push('-r');
-        args.push(file);
-        if (trigInput) args.push(trigInput.rel);
-        r = cp.spawnSync(nodePath, args, {
-          cwd: examplesDir,
-          stdio: ['ignore', outFd, 'pipe'], // stdout -> file, stderr captured
-          maxBuffer: 200 * 1024 * 1024,
-          encoding: 'utf8',
-        });
-      }
-    } finally {
-      fs.closeSync(outFd);
-    }
+    const r = runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath });
 
     const rc = r.status == null ? 1 : r.status;
 
@@ -261,12 +308,7 @@ function main() {
     // Compare output. N3 outputs are order-insensitive; Markdown outputs are order-sensitive.
     let diffOk = false;
     try {
-      const expectedText = fs.readFileSync(expectedPath, 'utf8');
-      const generatedText = fs.readFileSync(generatedPath, 'utf8');
-      if (expectedText == null) throw new Error('missing expected output');
-      diffOk =
-        normalizeForCompare(expectedText, expectedPath) ===
-        normalizeForCompare(generatedText, expectedPath);
+      diffOk = compareGeneratedOutput({ expectedPath, generatedPath, sourceText: n3Text, proof: false });
     } catch {
       diffOk = false;
     }
@@ -302,15 +344,76 @@ function main() {
     if (tmpDir) rmrf(tmpDir);
   }
 
+
+  for (let i = 0; i < proofFiles.length; i++) {
+    const idx = String(i + 1).padStart(proofIdxWidth, '0');
+    const file = proofFiles[i];
+    const start = Date.now();
+    const filePath = path.join(examplesDir, file);
+    const expectedPath = path.join(proofDir, file);
+
+    let n3Text;
+    try {
+      n3Text = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      const ms = Date.now() - start;
+      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      fail(`Cannot read proof input: ${e.message}`);
+      failed++;
+      continue;
+    }
+
+    const expectedRc = expectedExitCode(n3Text);
+    const tmpDir = mkTmpDir();
+    const generatedPath = path.join(tmpDir, 'generated.n3');
+    const r = runExampleToFile({ root, examplesDir, eyelingJsPath, nodePath, file, generatedPath, proof: true });
+    const rc = r.status == null ? 1 : r.status;
+    const ms = Date.now() - start;
+
+    let diffOk = false;
+    try {
+      diffOk = compareGeneratedOutput({ expectedPath, generatedPath, sourceText: n3Text, proof: true });
+    } catch {
+      diffOk = false;
+    }
+
+    const rcOk = rc === expectedRc;
+
+    if (diffOk && rcOk) {
+      if (expectedRc === 0) {
+        ok(`proof ${idx} ${file} ${msTag(ms)}`);
+      } else {
+        ok(`proof ${idx} ${file} (expected exit ${expectedRc}) ${msTag(ms)}`);
+      }
+      passed++;
+    } else {
+      fail(`proof ${idx} ${file} ${msTag(ms)}`);
+      if (!rcOk) {
+        fail(`Exit code ${rc}, expected ${expectedRc}`);
+      }
+      if (!diffOk) {
+        fail('Proof output differs');
+      }
+      showDiff({
+        examplesDir,
+        expectedPath,
+        generatedPath,
+      });
+      failed++;
+    }
+
+    if (tmpDir) rmrf(tmpDir);
+  }
+
   console.log('');
   const suiteMs = Date.now() - suiteStart;
   info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
 
   if (failed === 0) {
-    ok(`All examples tests passed (${passed}/${files.length})`);
+    ok(`All examples tests passed (${passed}/${totalTests})`);
     process.exit(0);
   } else {
-    fail(`Some examples tests failed (${passed}/${files.length})`);
+    fail(`Some examples tests failed (${passed}/${totalTests})`);
     // keep exit code 2 (matches historical behavior of examples/test)
     process.exit(2);
   }