refactor: wip

Author: BioPhoton

packages/utils/src/lib/create-runner-files.ts

@@ -1,8 +1,8 @@
 import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { threadId } from 'node:worker_threads';
 import type { RunnerFilesPaths } from '@code-pushup/models';
 import { ensureDirectoryExists, pluginWorkDir } from './file-system.js';
-import { getUniqueProcessThreadId } from './process-id.js';
 
 /**
  * Function to create timestamp nested plugin runner files for config and output.
@@ -14,7 +14,9 @@ export async function createRunnerFiles(
   pluginSlug: string,
   configJSON: string,
 ): Promise<RunnerFilesPaths> {
-  const uniqueId = getUniqueProcessThreadId();
+  // Use timestamp + process ID + threadId
+  // This prevents race conditions when running the same plugin for multiple projects in parallel
+  const uniqueId = `${(performance.timeOrigin + performance.now()) * 10}-${process.pid}-${threadId}`;
   const runnerWorkDir = path.join(pluginWorkDir(pluginSlug), uniqueId);
   const runnerConfigPath = path.join(runnerWorkDir, 'plugin-config.json');
   const runnerOutputPath = path.join(runnerWorkDir, 'runner-output.json');

packages/utils/src/lib/execute-process.int.test.ts

@@ -129,7 +129,7 @@ process:complete
           throwError: true,
         }),
       ),
-    ).rejects.toThrowError('Process failed with exit code 1');
+    ).rejects.toThrow('Process failed with exit code 1');
     expect(logger.debug).toHaveBeenCalledWith(
       expect.stringMatching(/process:start.*Error: dummy-error/s),
       { force: true },

packages/utils/src/lib/exit-process.int.test.ts

@@ -25,7 +25,7 @@ describe('subscribeProcessExit', () => {
   });
 
   it('should install event listeners for all expected events', () => {
-    expect(() => subscribeProcessExit({ onError, onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onError, onExit })).not.toThrow();
 
     expect(processOnSpy).toHaveBeenCalledWith(
       'uncaughtException',
@@ -42,91 +42,86 @@ describe('subscribeProcessExit', () => {
   });
 
   it('should call onError with error and kind for uncaughtException', () => {
-    expect(() => subscribeProcessExit({ onError })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onError })).not.toThrow();
 
     const testError = new Error('Test uncaught exception');
 
     (process as any).emit('uncaughtException', testError);
 
-    expect(onError).toHaveBeenCalledExactlyOnceWith(
-      testError,
-      'uncaughtException',
-    );
+    expect(onError).toHaveBeenCalledWith(testError, 'uncaughtException');
+    expect(onError).toHaveBeenCalledOnce();
     expect(onExit).not.toHaveBeenCalled();
   });
 
   it('should call onError with reason and kind for unhandledRejection', () => {
-    expect(() => subscribeProcessExit({ onError })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onError })).not.toThrow();
 
     const testReason = 'Test unhandled rejection';
 
     (process as any).emit('unhandledRejection', testReason);
 
-    expect(onError).toHaveBeenCalledExactlyOnceWith(
-      testReason,
-      'unhandledRejection',
-    );
+    expect(onError).toHaveBeenCalledWith(testReason, 'unhandledRejection');
+    expect(onError).toHaveBeenCalledOnce();
     expect(onExit).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGINT', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
 
     (process as any).emit('SIGINT');
 
-    expect(onExit).toHaveBeenCalledExactlyOnceWith(SIGNAL_EXIT_CODES().SIGINT, {
+    expect(onExit).toHaveBeenCalledOnce();
+    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGINT, {
       kind: 'signal',
       signal: 'SIGINT',
     });
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGTERM', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
 
     (process as any).emit('SIGTERM');
 
-    expect(onExit).toHaveBeenCalledExactlyOnceWith(
-      SIGNAL_EXIT_CODES().SIGTERM,
-      {
-        kind: 'signal',
-        signal: 'SIGTERM',
-      },
-    );
+    expect(onExit).toHaveBeenCalledOnce();
+    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGTERM, {
+      kind: 'signal',
+      signal: 'SIGTERM',
+    });
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit and exit with code 0 for SIGQUIT', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
 
     (process as any).emit('SIGQUIT');
 
-    expect(onExit).toHaveBeenCalledExactlyOnceWith(
-      SIGNAL_EXIT_CODES().SIGQUIT,
-      {
-        kind: 'signal',
-        signal: 'SIGQUIT',
-      },
-    );
+    expect(onExit).toHaveBeenCalledOnce();
+    expect(onExit).toHaveBeenCalledWith(SIGNAL_EXIT_CODES().SIGQUIT, {
+      kind: 'signal',
+      signal: 'SIGQUIT',
+    });
     expect(onError).not.toHaveBeenCalled();
   });
 
   it('should call onExit for successful process termination with exit code 0', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
 
     (process as any).emit('exit', 0);
 
-    expect(onExit).toHaveBeenCalledExactlyOnceWith(0, { kind: 'exit' });
+    expect(onExit).toHaveBeenCalledOnce();
+    expect(onExit).toHaveBeenCalledWith(0, { kind: 'exit' });
     expect(onError).not.toHaveBeenCalled();
     expect(processExitSpy).not.toHaveBeenCalled();
   });
 
   it('should call onExit for failed process termination with exit code 1', () => {
-    expect(() => subscribeProcessExit({ onExit })).not.toThrowError();
+    expect(() => subscribeProcessExit({ onExit })).not.toThrow();
 
     (process as any).emit('exit', 1);
 
-    expect(onExit).toHaveBeenCalledExactlyOnceWith(1, { kind: 'exit' });
+    expect(onExit).toHaveBeenCalledOnce();
+    expect(onExit).toHaveBeenCalledWith(1, { kind: 'exit' });
     expect(onError).not.toHaveBeenCalled();
     expect(processExitSpy).not.toHaveBeenCalled();
   });