test: normalize Windows junction semantics

Author: PuppetWen

electron/analyzer.ts

@@ -87,7 +87,17 @@ export async function summarizeDirectory(
       }
 
       const entryPath = path.join(current, entry.name);
-      if (entry.isSymbolicLink()) {
+      let stats;
+      try {
+        stats = await lstat(entryPath);
+      } catch (error) {
+        if (scanErrors.length < 20) {
+          scanErrors.push(`${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        continue;
+      }
+
+      if (entry.isSymbolicLink() || stats.isSymbolicLink()) {
         reparsePointCount += 1;
         if (options.includeReparsePoints) {
           try {
@@ -104,16 +114,6 @@ export async function summarizeDirectory(
         continue;
       }
 
-      let stats;
-      try {
-        stats = await lstat(entryPath);
-      } catch (error) {
-        if (scanErrors.length < 20) {
-          scanErrors.push(`${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        continue;
-      }
-
       newestMtime = Math.max(newestMtime, stats.mtimeMs);
       const childPath = firstChild(root, entryPath);
       const aggregate = childMap.get(childPath) ?? {

electron/migration.ts

@@ -89,12 +89,22 @@ export function runRobocopy(source: string, destination: string): Promise<void>
   });
 }
 
+export function normalizeReparseTarget(target: string): string {
+  let normalized = target.replaceAll("/", "\\");
+  if (/^\\\\\?\\[a-z]:\\/iu.test(normalized)) normalized = normalized.slice(4);
+  if (/^\\\?\?\\[a-z]:\\/iu.test(normalized)) normalized = normalized.slice(4);
+  normalized = path.win32.normalize(normalized);
+  const root = path.win32.parse(normalized).root;
+  while (normalized.length > root.length && normalized.endsWith("\\")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized.toLocaleLowerCase();
+}
+
 function normalizedReparsePoints(summary: DirectorySummary): string[] {
   return (summary.reparsePoints ?? [])
     .map(({ relativePath, target }) =>
-      `${relativePath.replaceAll("/", "\\").toLocaleLowerCase()}\u0000${target
-        .replaceAll("/", "\\")
-        .toLocaleLowerCase()}`
+      `${path.win32.normalize(relativePath).toLocaleLowerCase()}\u0000${normalizeReparseTarget(target)}`
     )
     .sort();
 }

tests/analyzer.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from "vitest";
 import { portableCandidateScores, summarizeDirectory } from "../electron/analyzer";
 import { inferKnownDirectory } from "../electron/directory-knowledge";
 import { hasSignificantAnalysisChange } from "../electron/analysis-freshness";
+import { normalizeReparseTarget } from "../electron/migration";
 
 describe("directory ownership evidence", () => {
   it("uses portable executables from another drive as first-party ownership evidence", () => {
@@ -39,9 +40,10 @@ describe("directory ownership evidence", () => {
       expect(summary.scanErrors).toEqual([]);
       expect(summary.fileCount).toBe(1);
       expect(summary.reparsePointCount).toBe(1);
-      expect(summary.reparsePoints).toEqual([
-        { relativePath: "latest", target: versionedDirectory }
-      ]);
+      expect(summary.reparsePoints?.[0]?.relativePath).toBe("latest");
+      expect(normalizeReparseTarget(summary.reparsePoints?.[0]?.target ?? "")).toBe(
+        normalizeReparseTarget(versionedDirectory)
+      );
     } finally {
       await rm(temporaryRoot, { recursive: true, force: true });
     }

tests/migration.test.ts

@@ -2,7 +2,11 @@ import { lstat, mkdir, mkdtemp, readlink, rm, symlink, writeFile } from "node:fs
 import os from "node:os";
 import path from "node:path";
 import { describe, expect, it } from "vitest";
-import { migrationRobocopyArguments, runRobocopy } from "../electron/migration";
+import {
+  migrationRobocopyArguments,
+  normalizeReparseTarget,
+  runRobocopy
+} from "../electron/migration";
 
 describe("migration copy options", () => {
   it("copies junctions and symbolic links as links instead of expanding or excluding them", () => {
@@ -28,7 +32,9 @@ describe("migration copy options", () => {
 
       const copiedLink = path.join(destination, "latest");
       expect((await lstat(copiedLink)).isSymbolicLink()).toBe(true);
-      expect(await readlink(copiedLink)).toBe(target);
+      expect(normalizeReparseTarget(await readlink(copiedLink))).toBe(
+        normalizeReparseTarget(target)
+      );
     } finally {
       await rm(temporaryRoot, { recursive: true, force: true });
     }