fix(core): use env vars instead of cli args for runner config

Author: matejchalk

packages/core/src/lib/implementation/runner.ts

@@ -15,9 +15,9 @@ import {
   executeProcess,
   fileExists,
   isVerbose,
-  objectToCliArgs,
   readJsonFile,
   removeDirectoryIfExists,
+  runnerArgsToEnv,
   ui,
 } from '@code-pushup/utils';
 import { normalizeAuditOutputs } from '../normalize.js';
@@ -40,7 +40,7 @@ export async function executeRunnerConfig(
 
   const { duration, date } = await executeProcess({
     command: config.command,
-    args: [...(config.args ?? []), ...objectToCliArgs(args)],
+    args: config.args,
     observer: {
       onStdout: stdout => {
         if (isVerbose()) {
@@ -49,6 +49,7 @@ export async function executeRunnerConfig(
       },
       onStderr: stderr => ui().logger.error(stderr),
     },
+    env: { ...process.env, ...runnerArgsToEnv(args) },
   });
 
   // read process output from the file system and parse it

packages/core/src/lib/implementation/runner.unit.test.ts

@@ -1,5 +1,13 @@
 import { vol } from 'memfs';
-import { type AuditOutputs, auditOutputsSchema } from '@code-pushup/models';
+import {
+  type AuditOutputs,
+  DEFAULT_PERSIST_CONFIG,
+  DEFAULT_PERSIST_FILENAME,
+  DEFAULT_PERSIST_FORMAT,
+  DEFAULT_PERSIST_OUTPUT_DIR,
+  DEFAULT_PERSIST_SKIP_REPORT,
+  auditOutputsSchema,
+} from '@code-pushup/models';
 import {
   ISO_STRING_REGEXP,
   MEMFS_VOLUME,
@@ -8,6 +16,7 @@ import {
   MINIMAL_RUNNER_FUNCTION_MOCK,
   osAgnosticPath,
 } from '@code-pushup/test-utils';
+import * as utils from '@code-pushup/utils';
 import {
   type RunnerResult,
   executePluginRunner,
@@ -38,10 +47,14 @@ describe('executeRunnerConfig', () => {
       },
       MEMFS_VOLUME,
     );
+
+    vi.spyOn(utils, 'executeProcess');
   });
 
   it('should execute valid runner config', async () => {
-    const runnerResult = await executeRunnerConfig(MINIMAL_RUNNER_CONFIG_MOCK);
+    const runnerResult = await executeRunnerConfig(MINIMAL_RUNNER_CONFIG_MOCK, {
+      persist: DEFAULT_PERSIST_CONFIG,
+    });
 
     // data sanity
     expect((runnerResult.audits as AuditOutputs)[0]?.slug).toBe('node-version');
@@ -50,23 +63,42 @@ describe('executeRunnerConfig', () => {
 
     // schema validation
     expect(() => auditOutputsSchema.parse(runnerResult.audits)).not.toThrow();
-  });
 
-  it('should use outputTransform when provided', async () => {
-    const runnerResult = await executeRunnerConfig({
+    // executed process configuration
+    expect(utils.executeProcess).toHaveBeenCalledWith<[utils.ProcessConfig]>({
       command: 'node',
       args: ['-v'],
-      outputFile: 'output.json',
-      outputTransform: (outputs: unknown): Promise<AuditOutputs> =>
-        Promise.resolve([
-          {
-            slug: (outputs as AuditOutputs)[0]!.slug,
-            score: 0.3,
-            value: 16,
-            displayValue: '16.0.0',
-          },
-        ]),
+      env: expect.objectContaining({
+        CP_PERSIST_OUTPUT_DIR: DEFAULT_PERSIST_OUTPUT_DIR,
+        CP_PERSIST_FILENAME: DEFAULT_PERSIST_FILENAME,
+        CP_PERSIST_FORMAT: DEFAULT_PERSIST_FORMAT.join(','),
+        CP_PERSIST_SKIP_REPORTS: `${DEFAULT_PERSIST_SKIP_REPORT}`,
+      }),
+      observer: {
+        onStdout: expect.any(Function),
+        onStderr: expect.any(Function),
+      },
     });
+  });
+
+  it('should use outputTransform when provided', async () => {
+    const runnerResult = await executeRunnerConfig(
+      {
+        command: 'node',
+        args: ['-v'],
+        outputFile: 'output.json',
+        outputTransform: (outputs: unknown): Promise<AuditOutputs> =>
+          Promise.resolve([
+            {
+              slug: (outputs as AuditOutputs)[0]!.slug,
+              score: 0.3,
+              value: 16,
+              displayValue: '16.0.0',
+            },
+          ]),
+      },
+      { persist: DEFAULT_PERSIST_CONFIG },
+    );
     const auditOutputs = runnerResult.audits as AuditOutputs;
 
     expect(auditOutputs[0]?.slug).toBe('node-version');
@@ -75,13 +107,16 @@ describe('executeRunnerConfig', () => {
 
   it('should throw if outputTransform throws', async () => {
     await expect(
-      executeRunnerConfig({
-        command: 'node',
-        args: ['-v'],
-        outputFile: 'output.json',
-        outputTransform: () =>
-          Promise.reject(new Error('Error: outputTransform has failed.')),
-      }),
+      executeRunnerConfig(
+        {
+          command: 'node',
+          args: ['-v'],
+          outputFile: 'output.json',
+          outputTransform: () =>
+            Promise.reject(new Error('Error: outputTransform has failed.')),
+        },
+        { persist: DEFAULT_PERSIST_CONFIG },
+      ),
     ).rejects.toThrow('Error: outputTransform has failed.');
   });
 });
@@ -90,6 +125,7 @@ describe('executeRunnerFunction', () => {
   it('should execute a valid runner function', async () => {
     const runnerResult: RunnerResult = await executeRunnerFunction(
       MINIMAL_RUNNER_FUNCTION_MOCK,
+      { persist: DEFAULT_PERSIST_CONFIG },
     );
     const auditOutputs = runnerResult.audits as AuditOutputs;
 
@@ -102,14 +138,12 @@ describe('executeRunnerFunction', () => {
   });
 
   it('should throw if the runner function throws', async () => {
-    const nextSpy = vi.fn();
     await expect(
       executeRunnerFunction(
         () => Promise.reject(new Error('Error: Runner has failed.')),
-        nextSpy,
+        { persist: DEFAULT_PERSIST_CONFIG },
       ),
     ).rejects.toThrow('Error: Runner has failed.');
-    expect(nextSpy).not.toHaveBeenCalled();
   });
 
   it('should throw with an invalid runner type', async () => {
@@ -122,7 +156,9 @@ describe('executeRunnerFunction', () => {
 
 describe('executePluginRunner', () => {
   it('should execute a valid plugin config', async () => {
-    const pluginResult = await executePluginRunner(MINIMAL_PLUGIN_CONFIG_MOCK);
+    const pluginResult = await executePluginRunner(MINIMAL_PLUGIN_CONFIG_MOCK, {
+      persist: DEFAULT_PERSIST_CONFIG,
+    });
     expect(pluginResult.audits[0]?.slug).toBe('node-version');
   });
 
@@ -141,14 +177,17 @@ describe('executePluginRunner', () => {
     );
 
     await expect(
-      executePluginRunner({
-        ...MINIMAL_PLUGIN_CONFIG_MOCK,
-        runner: {
-          command: 'node',
-          args: ['-v'],
-          outputFile: 'output.json',
+      executePluginRunner(
+        {
+          ...MINIMAL_PLUGIN_CONFIG_MOCK,
+          runner: {
+            command: 'node',
+            args: ['-v'],
+            outputFile: 'output.json',
+          },
         },
-      }),
+        { persist: DEFAULT_PERSIST_CONFIG },
+      ),
     ).resolves.toStrictEqual({
       duration: expect.any(Number),
       date: expect.any(String),
@@ -164,16 +203,19 @@ describe('executePluginRunner', () => {
 
   it('should yield audit outputs for a valid runner function', async () => {
     await expect(
-      executePluginRunner({
-        ...MINIMAL_PLUGIN_CONFIG_MOCK,
-        runner: () => [
-          {
-            slug: 'node-version',
-            score: 0.3,
-            value: 16,
-          },
-        ],
-      }),
+      executePluginRunner(
+        {
+          ...MINIMAL_PLUGIN_CONFIG_MOCK,
+          runner: () => [
+            {
+              slug: 'node-version',
+              score: 0.3,
+              value: 16,
+            },
+          ],
+        },
+        { persist: DEFAULT_PERSIST_CONFIG },
+      ),
     ).resolves.toStrictEqual({
       duration: expect.any(Number),
       date: expect.any(String),