test(enhanced): harden treeshake fixture setup for CI flake (#4441)

Author: ScriptedAlchemy

packages/enhanced/rstest.treeshake.serial.config.ts

@@ -19,6 +19,9 @@ export default defineConfig({
     maxWorkers: 1,
     minWorkers: 1,
   },
+  // Also disable in-file test concurrency (default is 5), otherwise
+  // describe blocks can still race on fixture generation and compilation.
+  maxConcurrency: 1,
   globals: true,
   include: [
     path.resolve(__dirname, 'test/ConfigTestCases.treeshake.rstest.ts'),

packages/enhanced/test/ConfigTestCases.rstest.ts

@@ -160,6 +160,51 @@ const ensureTreeShakingFixtures = (testDirectory: string) => {
   }
 };
 
+const collectTreeShakingMissingModuleStubs = (outputDirectory: string) => {
+  const independentPackagesDir = path.join(
+    outputDirectory,
+    'independent-packages',
+  );
+  if (!fs.existsSync(independentPackagesDir)) {
+    return [] as string[];
+  }
+  const missing = new Set<string>();
+  const pending = [independentPackagesDir];
+  const pattern =
+    /Cannot find module ['"]([^'"]*tree-shaking-share[^'"]*node_modules[^'"]*)['"]/g;
+  while (pending.length) {
+    const currentDir = pending.pop() as string;
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        pending.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== 'share-entry.js') {
+        continue;
+      }
+      let content = '';
+      try {
+        content = fs.readFileSync(fullPath, 'utf-8');
+      } catch {
+        continue;
+      }
+      pattern.lastIndex = 0;
+      let match: RegExpExecArray | null = null;
+      while ((match = pattern.exec(content))) {
+        missing.add(match[1]);
+      }
+    }
+  }
+  return Array.from(missing).sort();
+};
+
 const dedupeByMessage = (items: any[]) => {
   if (!Array.isArray(items) || items.length === 0) {
     return [] as any[];
@@ -589,25 +634,28 @@ export const describeCases = (config: any) => {
               `${testName} should compile`,
               async () => {
                 ensureTreeShakingFixturesIfNeeded();
-                try {
-                  // Robust cleanup to avoid ENOTEMPTY and race conditions
-                  (fs as any).rmSync?.(outputDirectory, {
-                    recursive: true,
-                    force: true,
-                  });
-                } catch {
+                const isTreeShakingFixtureCase = testDirectory.includes(
+                  `${path.sep}tree-shaking-share${path.sep}`,
+                );
+                const cleanOutputDirectory = () => {
                   try {
-                    rimrafSync(outputDirectory);
+                    // Robust cleanup to avoid ENOTEMPTY and race conditions
+                    (fs as any).rmSync?.(outputDirectory, {
+                      recursive: true,
+                      force: true,
+                    });
                   } catch {
-                    /* ignore */
+                    try {
+                      rimrafSync(outputDirectory);
+                    } catch {
+                      /* ignore */
+                    }
                   }
-                }
-                fs.mkdirSync(outputDirectory, { recursive: true });
-                infraStructureLog.length = 0;
-
-                // 运行 webpack
-                const { stats } = await new Promise<{ stats: any }>(
-                  (resolve, reject) => {
+                };
+                const runWebpackCompile = async () => {
+                  infraStructureLog.length = 0;
+                  stderr.reset();
+                  return new Promise<{ stats: any }>((resolve, reject) => {
                     const onCompiled = (err: any, stats: any) => {
                       if (err) return reject(err);
                       resolve({ stats });
@@ -631,12 +679,58 @@ export const describeCases = (config: any) => {
                     } catch (e: any) {
                       reject(e);
                     }
-                  },
-                ).catch((e) => {
+                  });
+                };
+
+                cleanOutputDirectory();
+                fs.mkdirSync(outputDirectory, { recursive: true });
+                let { stats } = await runWebpackCompile().catch((e) => {
                   handleFatalError(e);
                   throw e; // rethrow for rstest to mark failure otherwise
                 });
 
+                // Under heavy IO/CPU contention, tree-shaking fixture packages can
+                // transiently resolve as missing. Rebuild with bounded retries
+                // after re-ensuring fixtures when share-entry stubs contain
+                // webpackMissingModule.
+                if (isTreeShakingFixtureCase) {
+                  const maxTreeShakingAttempts = 4;
+                  for (
+                    let attempt = 1;
+                    attempt < maxTreeShakingAttempts;
+                    attempt++
+                  ) {
+                    const missingModules =
+                      collectTreeShakingMissingModuleStubs(outputDirectory);
+                    if (!missingModules.length) {
+                      break;
+                    }
+                    ensureTreeShakingFixturesIfNeeded();
+                    // Give the FS a tiny settle window under extreme IO pressure.
+                    await new Promise<void>((resolve) =>
+                      setTimeout(resolve, 25 * attempt),
+                    );
+                    cleanOutputDirectory();
+                    fs.mkdirSync(outputDirectory, { recursive: true });
+                    ({ stats } = await runWebpackCompile().catch((e) => {
+                      handleFatalError(e);
+                      throw e;
+                    }));
+                    if (attempt === maxTreeShakingAttempts - 1) {
+                      const remainingMissingModules =
+                        collectTreeShakingMissingModuleStubs(outputDirectory);
+                      if (remainingMissingModules.length) {
+                        throw new Error(
+                          [
+                            `Tree-shaking fixture modules remained unresolved after ${maxTreeShakingAttempts} compilation attempts:`,
+                            ...remainingMissingModules,
+                          ].join('\n'),
+                        );
+                      }
+                    }
+                  }
+                }
+
                 // 写入 stats
                 const statOptions = { preset: 'verbose', colors: false };
                 fs.mkdirSync(outputDirectory, { recursive: true });

packages/enhanced/test/scripts/ensure-reshake-fixtures.js

@@ -132,11 +132,8 @@ const uiLibSideEffectEntry = [
 ].join('\n');
 
 for (const baseDir of fixtureRoots) {
-  try {
-    fs.rmSync(baseDir, { recursive: true, force: true });
-  } catch {
-    // ignore cleanup errors and ensure the directory exists
-  }
+  // Keep fixture generation non-destructive so concurrent test workers/processes
+  // never observe temporarily-missing files during resolution.
   fs.mkdirSync(baseDir, { recursive: true });
   const isReshake = baseDir.includes(`${path.sep}reshake-share${path.sep}`);
   if (isReshake) {

packages/enhanced/test/setupTestFramework.js

@@ -157,6 +157,24 @@ const reshakeServerUiLibSideEffect = path.join(
   'ui-lib-side-effect',
   'index.js',
 );
+const reshakeServerUiLibDynamicSpecific = path.join(
+  __dirname,
+  'configCases',
+  'tree-shaking-share',
+  'server-strategy',
+  'node_modules',
+  'ui-lib-dynamic-specific-export',
+  'index.js',
+);
+const reshakeServerUiLibDynamicDefault = path.join(
+  __dirname,
+  'configCases',
+  'tree-shaking-share',
+  'server-strategy',
+  'node_modules',
+  'ui-lib-dynamic-default-export',
+  'index.js',
+);
 const inferStrategyUiLib = path.join(
   __dirname,
   'configCases',
@@ -179,6 +197,8 @@ const reshakeDep = path.join(
 if (
   !fs.existsSync(reshakeServerUiLib) ||
   !fs.existsSync(reshakeServerUiLibSideEffect) ||
+  !fs.existsSync(reshakeServerUiLibDynamicSpecific) ||
+  !fs.existsSync(reshakeServerUiLibDynamicDefault) ||
   !fs.existsSync(inferStrategyUiLib) ||
   !fs.existsSync(reshakeDep)
 ) {