@photostructure/fs-metadata 0.6.0 → 0.7.0

package/src/test-utils/memory-test-runner.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env tsx
+
+/**
+ * Standalone memory test runner for use in CI environments
+ *
+ * This script runs memory tests without Jest to avoid worker process issues
+ * particularly on Windows CI. It uses the same test logic as the Jest tests
+ * but with a simpler execution model.
+ */
+
+import { MemoryTestResult, runAllMemoryTests } from "./memory-test-core";
+
+// ANSI color codes for output (disable on Windows for better compatibility)
+const isWindows = process.platform === "win32";
+const colors = {
+  RED: isWindows ? "" : "\x1b[31m",
+  GREEN: isWindows ? "" : "\x1b[32m",
+  YELLOW: isWindows ? "" : "\x1b[33m",
+  BLUE: isWindows ? "" : "\x1b[34m",
+  RESET: isWindows ? "" : "\x1b[0m",
+};
+
+function formatMemory(bytes: number): string {
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+
+function printResult(result: MemoryTestResult): void {
+  const statusSymbol = result.passed ? "✓" : "✗";
+  const statusColor = result.passed ? colors.GREEN : colors.RED;
+
+  console.log(
+    `\n${statusColor}${statusSymbol} ${result.testName}${colors.RESET}`,
+  );
+  console.log(`  Initial memory: ${formatMemory(result.initialMemory)}`);
+  console.log(`  Final memory: ${formatMemory(result.finalMemory)}`);
+  console.log(`  Memory increase: ${formatMemory(result.memoryIncrease)}`);
+  console.log(`  Memory slope: ${result.slope.toFixed(6)}`);
+
+  if (result.errorMessage) {
+    console.log(`  ${colors.RED}Error: ${result.errorMessage}${colors.RESET}`);
+  }
+}
+
+async function main(): Promise<void> {
+  console.log(
+    `${colors.BLUE}=== Standalone Memory Test Runner ===${colors.RESET}`,
+  );
+  console.log(`Platform: ${process.platform}`);
+  console.log(`Node version: ${process.version}`);
+  console.log(`Process architecture: ${process.arch}`);
+
+  // Check if garbage collection is exposed
+  if (!global.gc) {
+    console.error(
+      `${colors.RED}Error: Garbage collection is not exposed.${colors.RESET}`,
+    );
+    console.error(
+      "Please run with: NODE_OPTIONS='--expose-gc' tsx scripts/memory-test-runner.ts",
+    );
+    process.exit(1);
+  }
+
+  console.log("\nRunning memory tests...");
+
+  try {
+    const startTime = Date.now();
+    const results = await runAllMemoryTests();
+    const duration = Date.now() - startTime;
+
+    // Print individual results
+    for (const result of results) {
+      printResult(result);
+    }
+
+    // Summary
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.filter((r) => !r.passed).length;
+    const total = results.length;
+
+    console.log(`\n${colors.BLUE}=== Test Summary ===${colors.RESET}`);
+    console.log(`Total tests: ${total}`);
+    console.log(`${colors.GREEN}Passed: ${passed}${colors.RESET}`);
+    if (failed > 0) {
+      console.log(`${colors.RED}Failed: ${failed}${colors.RESET}`);
+    }
+    console.log(`Duration: ${(duration / 1000).toFixed(2)}s`);
+
+    if (failed > 0) {
+      console.log(`\n${colors.RED}Memory tests failed!${colors.RESET}`);
+      process.exit(1);
+    } else {
+      console.log(`\n${colors.GREEN}All memory tests passed!${colors.RESET}`);
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(
+      `\n${colors.RED}Fatal error running memory tests:${colors.RESET}`,
+    );
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+main().catch((error) => {
+  console.error(`${colors.RED}Unhandled error:${colors.RESET}`, error);
+  process.exit(1);
+});

package/src/test-utils/platform.ts

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { env, platform } from "node:process";
 import { normalizePath } from "../path";
-import { isMacOS, isWindows } from "../platform";
+import { isAlpine, isARM64, isMacOS, isWindows } from "../platform";
 import { toNotBlank } from "../string";
 
 /**
@@ -45,3 +45,48 @@ export function tmpDirNotHidden() {
   mkdirSync(dir, { recursive: true });
   return dir;
 }
+
+/**
+ * Skip timing-sensitive tests on Alpine ARM64 due to emulation timing issues
+ */
+export const itSkipAlpineARM64 = isAlpine() && isARM64 ? it.skip : it;
+
+/**
+ * Skip timing-sensitive describe blocks on Alpine ARM64 due to emulation timing issues
+ */
+export const describeSkipAlpineARM64 =
+  isAlpine() && isARM64 ? describe.skip : describe;
+
+/**
+ * Skip tests on ARM64 CI environments due to various issues:
+ * - Alpine ARM64: emulation timing issues
+ * - Windows ARM64: Jest worker process failures
+ */
+export const describeSkipARM64CI =
+  isARM64 && env["CI"] ? describe.skip : describe;
+
+export const itSkipARM64CI = isARM64 && env["CI"] ? it.skip : it;
+
+/**
+ * Skip tests on Windows CI environments due to Jest worker process failures
+ * These tests pass locally but fail in GitHub Actions with:
+ * "Jest worker encountered 4 child process exceptions, exceeding retry limit"
+ */
+export const describeSkipWindowsCI =
+  isWindows && env["CI"] ? describe.skip : describe;
+
+export const itSkipWindowsCI = isWindows && env["CI"] ? it.skip : it;
+
+/**
+ * Platform-specific tests that are stable in CI environments
+ * (skips on Windows CI due to Jest worker process issues)
+ * @param supported The platforms to run tests on
+ * @returns jest.Describe function that runs on specified platforms but skips on Windows CI
+ */
+export function describePlatformStable(...supported: NodeJS.Platform[]) {
+  // Skip on Windows CI due to Jest worker process failures
+  if (isWindows && env["CI"]) {
+    return describe.skip;
+  }
+  return describePlatform(...supported);
+}

package/src/test-utils/worker-thread-helper.cjs

@@ -3,18 +3,101 @@
 /* eslint-disable @typescript-eslint/no-require-imports */
 /* eslint-disable no-undef */
 
-const { parentPort, workerData } = require('node:worker_threads');
-const path = require('node:path');
+const { parentPort, workerData } = require("node:worker_threads");
+const path = require("node:path");
+
+// Windows ARM64 Jest worker workaround
+if (
+  process.platform === "win32" &&
+  process.arch === "arm64" &&
+  process.env.CI
+) {
+  console.error("[Worker] Windows ARM64 detected in CI, applying workarounds");
+  // Ensure we're using the correct module paths
+  if (!global.__dirname && typeof __dirname === "undefined") {
+    console.error("[Worker] __dirname is undefined, using workaround");
+  }
+}
 
 // Use eval with the worker data to create the module functions
 const createModule = () => {
-  const nodeGypBuild = require('node-gyp-build');
-  const binding = nodeGypBuild(path.join(__dirname, '../..'));
-  
+  const nodeGypBuild = require("node-gyp-build");
+
+  // Debug logging for CI
+  if (process.env.CI || process.env.DEBUG_WORKER) {
+    console.error("[Worker] Environment:");
+    console.error("  - Platform:", process.platform);
+    console.error("  - Architecture:", process.arch);
+    console.error("  - Node version:", process.version);
+    console.error("  - Current directory:", process.cwd());
+    console.error("  - __dirname:", __dirname);
+    console.error("  - Worker ID:", require("node:worker_threads").threadId);
+    console.error(
+      "  - Is main thread:",
+      require("node:worker_threads").isMainThread,
+    );
+  }
+
+  // Try multiple paths to find the native module
+  let binding;
+  const possiblePaths = [
+    path.join(__dirname, "../.."), // Original path
+    process.cwd(), // Current working directory
+    path.resolve(__dirname, "../.."), // Absolute resolved path
+    path.join(process.cwd(), "prebuilds"), // Direct prebuilds path
+  ];
+
+  // Add Windows-specific paths if on Windows
+  if (process.platform === "win32") {
+    // Try normalized Windows paths
+    possiblePaths.push(
+      path.win32.resolve(__dirname, "../.."),
+      path.win32.join(process.cwd()),
+    );
+  }
+
+  let lastError;
+  for (const tryPath of possiblePaths) {
+    try {
+      if (process.env.CI || process.env.DEBUG_WORKER) {
+        console.error("[Worker] Trying path:", tryPath);
+        // Also check if prebuilds directory exists
+        const fs = require("fs");
+        const prebuildsPath = path.join(tryPath, "prebuilds");
+        if (fs.existsSync(prebuildsPath)) {
+          console.error("[Worker] Prebuilds found at:", prebuildsPath);
+          const files = fs.readdirSync(prebuildsPath);
+          console.error("[Worker] Prebuild directories:", files);
+        }
+      }
+      binding = nodeGypBuild(tryPath);
+      if (process.env.CI || process.env.DEBUG_WORKER) {
+        console.error("[Worker] Success! Loaded from:", tryPath);
+        console.error("[Worker] Binding functions:", Object.keys(binding));
+      }
+      break;
+    } catch (err) {
+      lastError = err;
+      if (process.env.CI || process.env.DEBUG_WORKER) {
+        console.error("[Worker] Failed to load from", tryPath);
+        console.error("[Worker] Error:", err.message);
+        if (err.stack && process.env.DEBUG_WORKER) {
+          console.error("[Worker] Stack:", err.stack);
+        }
+      }
+    }
+  }
+
+  if (!binding) {
+    const errorMsg = `Failed to load native module from any path. Tried: ${possiblePaths.join(", ")}. Last error: ${lastError?.message || "unknown"}`;
+    console.error("[Worker] FATAL:", errorMsg);
+    throw new Error(errorMsg);
+  }
+
   // Platform detection
   const platform = process.platform;
-  const isLinux = platform === 'linux';
-  
+  const isLinux = platform === "linux";
+
   // For Linux, we need a simplified implementation since the main one is complex
   if (isLinux) {
     return {
@@ -22,10 +105,10 @@ const createModule = () => {
         // Return the same mount points as the main thread would
         // This is a simplified version for testing
         return [
-          { mountPoint: '/', fstype: 'ext4', isSystemVolume: true },
-          { mountPoint: '/boot', fstype: 'ext4', isSystemVolume: true },
-          { mountPoint: '/boot/efi', fstype: 'vfat', isSystemVolume: true },
-          { mountPoint: '/home', fstype: 'ext4', isSystemVolume: false }
+          { mountPoint: "/", fstype: "ext4", isSystemVolume: true },
+          { mountPoint: "/boot", fstype: "ext4", isSystemVolume: true },
+          { mountPoint: "/boot/efi", fstype: "vfat", isSystemVolume: true },
+          { mountPoint: "/home", fstype: "ext4", isSystemVolume: false },
         ];
       },
       getVolumeMetadata: async (mountPoint, options) => {
@@ -33,15 +116,15 @@ const createModule = () => {
       },
       isHidden: async (filePath) => {
         const basename = path.basename(filePath);
-        return basename.startsWith('.');
+        return basename.startsWith(".");
       },
       setHidden: async (/* filePath, hidden */) => {
         // Linux doesn't support hidden attribute
         return;
-      }
+      },
     };
   }
-  
+
   // For Windows and macOS, use the native binding directly
   return {
     getVolumeMountPoints: async () => {
@@ -51,38 +134,86 @@ const createModule = () => {
       return binding.getVolumeMetadata({ mountPoint, ...options });
     },
     isHidden: binding.isHidden,
-    setHidden: binding.setHidden
+    setHidden: binding.setHidden,
   };
 };
 
-const fsMetadata = createModule();
+let fsMetadata;
+try {
+  fsMetadata = createModule();
+} catch (error) {
+  console.error("[Worker] Failed to create module:", error.message);
+  console.error("[Worker] Stack:", error.stack);
+  // Send error back to parent
+  parentPort.postMessage({
+    success: false,
+    error: `Module initialization failed: ${error.message}`,
+    stack: error.stack,
+    platform: process.platform,
+    arch: process.arch,
+    task: "module_init",
+  });
+  parentPort.close();
+  process.exit(1);
+}
 
 async function runWorkerTask() {
   try {
     const { task, ...params } = workerData;
+
+    if (process.env.CI || process.env.DEBUG_WORKER) {
+      console.error("[Worker] Running task:", task, "with params:", params);
+    }
+
     let result;
-    
+
     switch (task) {
-      case 'getVolumeMountPoints':
+      case "getVolumeMountPoints":
         result = await fsMetadata.getVolumeMountPoints();
         break;
-      case 'getVolumeMetadata':
-        result = await fsMetadata.getVolumeMetadata(params.mountPoint, params.options);
+      case "getVolumeMetadata":
+        result = await fsMetadata.getVolumeMetadata(
+          params.mountPoint,
+          params.options,
+        );
         break;
-      case 'isHidden':
+      case "isHidden":
         result = await fsMetadata.isHidden(params.path);
         break;
-      case 'setHidden':
+      case "setHidden":
         result = await fsMetadata.setHidden(params.path, params.hidden);
         break;
       default:
-        throw new Error('Unknown task: ' + task);
+        throw new Error("Unknown task: " + task);
     }
-    
+
+    if (process.env.CI || process.env.DEBUG_WORKER) {
+      console.error("[Worker] Task completed successfully");
+    }
+
     parentPort.postMessage({ success: true, result });
   } catch (error) {
-    parentPort.postMessage({ success: false, error: error.message });
+    if (process.env.CI || process.env.DEBUG_WORKER) {
+      console.error("[Worker] Task failed:", error.message);
+      console.error("[Worker] Error stack:", error.stack);
+    }
+
+    // Include more error details
+    const errorInfo = {
+      success: false,
+      error: error.message,
+      stack: process.env.CI ? error.stack : undefined,
+      platform: process.platform,
+      arch: process.arch,
+      task: workerData.task,
+    };
+
+    parentPort.postMessage(errorInfo);
   }
+
+  // Close the parent port to signal we're done
+  // This allows the worker to exit naturally
+  parentPort.close();
 }
 
-runWorkerTask();
+runWorkerTask();

package/src/types/native_bindings.ts

@@ -59,6 +59,6 @@ export interface NativeBindings {
 export type GetVolumeMetadataOptions = {
   mountPoint: string;
   device?: string;
-} & Partial<Pick<Options, "timeoutMs">>;
+} & Partial<Pick<Options, "timeoutMs" | "skipNetworkVolumes">>;
 
 export type NativeBindingsFn = () => NativeBindings | Promise<NativeBindings>;

package/src/types/options.ts

@@ -51,4 +51,10 @@ export interface Options {
    * Windows and false elsewhere.
    */
   includeSystemVolumes: boolean;
+
+  /**
+   * Skip detailed info for network volumes to avoid blocking.
+   * Defaults to false.
+   */
+  skipNetworkVolumes: boolean;
 }