fix: resolve incomplete linting across projects

eslint.config.js

@@ -28,6 +28,7 @@ export default tseslint.config(
             String.raw`^.*/eslint(\.base)?\.config\.[cm]?js$`,
             String.raw`^.*/code-pushup\.(config|preset)(\.m?[jt]s)?$`,
             '^[./]+/tools/.*$',
+            String.raw`^[./]+/(testing/)?test-setup-config/src/index\.js$`,
           ],
           depConstraints: [
             {
@@ -115,6 +116,7 @@ export default tseslint.config(
     files: ['**/*.ts', '**/*.js'],
     rules: {
       'n/file-extension-in-import': ['error', 'always'],
+      'unicorn/number-literal-case': 'off',
     },
   },
   {
@@ -127,7 +129,7 @@ export default tseslint.config(
   {
     // tests need only be compatible with local Node version
     // publishable packages should pick up version range from "engines" in their package.json
-    files: ['e2e/**/*.ts', 'testing/**/*.ts'],
+    files: ['e2e/**/*.ts', 'testing/**/*.ts', '**/*.test.ts'],
     settings: {
       node: {
         version: fs.readFileSync('.node-version', 'utf8'),

nx.json

@@ -72,7 +72,7 @@
       "options": {
         "command": "eslint",
         "args": [
-          "{projectRoot}/**/*.ts",
+          "'{projectRoot}/**/*.ts'",
           "{projectRoot}/package.json",
           "--config={projectRoot}/eslint.config.js",
           "--max-warnings=0",

packages/ci/vitest.int.config.ts

@@ -1,16 +1,3 @@
 import { createIntTestConfig } from '../../testing/test-setup-config/src/index.js';
 
-let config = createIntTestConfig('ci');
-
-config = {
-  ...config,
-  test: {
-    ...config.test,
-    setupFiles: [
-      ...(config.test!.setupFiles || []),
-      '../../testing/test-setup/src/lib/logger.mock.ts',
-    ],
-  },
-};
-
-export default config;
+export default createIntTestConfig('ci');

packages/ci/vitest.unit.config.ts

@@ -1,16 +1,3 @@
 import { createUnitTestConfig } from '../../testing/test-setup-config/src/index.js';
 
-let config = createUnitTestConfig('ci');
-
-config = {
-  ...config,
-  test: {
-    ...config.test,
-    setupFiles: [
-      ...(config.test!.setupFiles || []),
-      '../../testing/test-setup/src/lib/logger.mock.ts',
-    ],
-  },
-};
-
-export default config;
+export default createUnitTestConfig('ci');

packages/core/src/lib/implementation/execute-plugin.unit.test.ts

@@ -24,7 +24,7 @@ describe('executePlugin', () => {
     ReturnType<(typeof runnerModule)['executePluginRunner']>
   >;
 
-  beforeAll(() => {
+  beforeEach(() => {
     readRunnerResultsSpy = vi.spyOn(runnerModule, 'readRunnerResults');
     executePluginRunnerSpy = vi.spyOn(runnerModule, 'executePluginRunner');
   });
@@ -35,11 +35,6 @@ describe('executePlugin', () => {
   });
 
   it('should execute a valid plugin config and pass runner params', async () => {
-    const executePluginRunnerSpy = vi.spyOn(
-      runnerModule,
-      'executePluginRunner',
-    );
-
     await expect(
       executePlugin(MINIMAL_PLUGIN_CONFIG_MOCK, {
         persist: {},
@@ -68,8 +63,6 @@ describe('executePlugin', () => {
   });
 
   it('should try to read cache if cache.read is true', async () => {
-    const readRunnerResultsSpy = vi.spyOn(runnerModule, 'readRunnerResults');
-
     const validRunnerResult = {
       duration: 0, // readRunnerResults now automatically sets this to 0 for cache hits
       date: new Date().toISOString(), // readRunnerResults sets this to current time
@@ -106,12 +99,6 @@ describe('executePlugin', () => {
   });
 
   it('should try to execute runner if cache.read is true and file not present', async () => {
-    const readRunnerResultsSpy = vi.spyOn(runnerModule, 'readRunnerResults');
-    const executePluginRunnerSpy = vi.spyOn(
-      runnerModule,
-      'executePluginRunner',
-    );
-
     readRunnerResultsSpy.mockResolvedValue(null);
     const runnerResult = {
       duration: 1000,

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

@@ -45,18 +45,15 @@ export async function executeRunnerConfig(
   await removeDirectoryIfExists(path.dirname(outputFile));
 
   // transform unknownAuditOutputs to auditOutputs
-  const audits = outputTransform ? await outputTransform(outputs) : outputs;
-
-  return audits;
+  return outputTransform ? await outputTransform(outputs) : outputs;
 }
 
 export async function executeRunnerFunction(
   runner: RunnerFunction,
   args: RunnerArgs,
 ): Promise<unknown> {
   // execute plugin runner
-  const audits = await runner(args);
-  return audits;
+  return runner(args);
 }
 
 /**

packages/models/src/lib/implementation/validate.ts

@@ -11,6 +11,7 @@ type SchemaValidationContext = {
  */
 type ZodInputLooseAutocomplete<T extends ZodType> =
   | z.input<T>
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   | {}
   | null
   | undefined;

packages/models/src/lib/implementation/validate.unit.test.ts

@@ -15,7 +15,7 @@ describe('validate', () => {
   afterEach(async () => {
     // Allow any lingering async operations from transforms to complete
     // This prevents unhandled rejections in subsequent tests
-    await new Promise(resolve => setImmediate(resolve));
+    await new Promise(setImmediate);
   });
 
   it('should return parsed data if valid', () => {

packages/models/src/lib/plugin-config.unit.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { ZodError } from 'zod';
 import {
   type PluginConfig,
   pluginConfigSchema,
@@ -164,28 +165,28 @@ describe('pluginUrlsSchema', () => {
   });
 
   it('should throw for invalid URL', () => {
-    expect(() => pluginUrlsSchema.parse('invalid')).toThrow();
+    expect(() => pluginUrlsSchema.parse('invalid')).toThrow(ZodError);
   });
 
   it('should throw for array with invalid URL', () => {
     expect(() =>
       pluginUrlsSchema.parse(['https://example.com', 'invalid']),
-    ).toThrow();
+    ).toThrow(ZodError);
   });
 
   it('should throw for object with invalid URL', () => {
-    expect(() => pluginUrlsSchema.parse({ invalid: 1 })).toThrow();
+    expect(() => pluginUrlsSchema.parse({ invalid: 1 })).toThrow(ZodError);
   });
 
   it('should throw for invalid negative weight', () => {
-    expect(() =>
-      pluginUrlsSchema.parse({ 'https://example.com': -1 }),
-    ).toThrow();
+    expect(() => pluginUrlsSchema.parse({ 'https://example.com': -1 })).toThrow(
+      ZodError,
+    );
   });
 
   it('should throw for invalid string weight', () => {
     expect(() =>
       pluginUrlsSchema.parse({ 'https://example.com': '1' }),
-    ).toThrow();
+    ).toThrow(ZodError);
   });
 });

packages/nx-plugin/src/executors/cli/executor.unit.test.ts

@@ -16,11 +16,13 @@ describe('runAutorunExecutor', () => {
   beforeAll(() => {
     Object.entries(process.env)
       .filter(([k]) => k.startsWith('CP_'))
-      .forEach(([k]) => delete process.env[k]);
+      .forEach(([k]) => Reflect.deleteProperty(process.env, k));
   });
 
   afterAll(() => {
-    Object.entries(processEnvCP).forEach(([k, v]) => (process.env[k] = v));
+    Object.entries(processEnvCP).forEach(([k, v]) =>
+      Reflect.set(process.env, k, v),
+    );
   });
 
   beforeEach(() => {

packages/nx-plugin/src/executors/internal/cli.ts

@@ -1,5 +1,3 @@
-import { logger } from '@nx/devkit';
-
 export function createCliCommandString(options?: {
   args?: Record<string, unknown>;
   command?: string;

packages/nx-plugin/src/generators/configuration/generator.int.test.ts

@@ -7,7 +7,6 @@ import {
 import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
 import * as path from 'node:path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { DEFAULT_TARGET_NAME, PACKAGE_NAME } from '../../internal/constants.js';
 import { configurationGenerator } from './generator.js';
 
 describe('configurationGenerator', () => {

packages/nx-plugin/src/internal/execute-process.ts

@@ -6,6 +6,8 @@
 export async function executeProcess(
   cfg: import('@code-pushup/utils').ProcessConfig,
 ): Promise<import('@code-pushup/utils').ProcessResult> {
-  const { executeProcess } = await import('@code-pushup/utils');
-  return executeProcess(cfg);
+  const { executeProcess: executeProcessFromUtils } = await import(
+    '@code-pushup/utils'
+  );
+  return executeProcessFromUtils(cfg);
 }

packages/nx-plugin/src/plugin/target/configuration-target.ts

@@ -11,7 +11,9 @@ export function createConfigurationTarget(options?: {
   const args = objectToCliArgs({
     ...(projectName ? { project: projectName } : {}),
   });
+  const argsString = args.length > 0 ? args.join(' ') : '';
+  const baseCommand = `nx g ${bin}:configuration`;
   return {
-    command: `nx g ${bin}:configuration${args.length > 0 ? ` ${args.join(' ')}` : ''}`,
+    command: argsString ? `${baseCommand} ${argsString}` : baseCommand,
   };
 }

packages/plugin-axe/src/lib/config.ts

@@ -5,14 +5,16 @@ import {
 } from '@code-pushup/models';
 import { AXE_DEFAULT_PRESET, AXE_PRESETS } from './constants.js';
 
+const DEFAULT_TIMEOUT_MS = 30_000;
+
 export const axePluginOptionsSchema = z
   .object({
     preset: z.enum(AXE_PRESETS).default(AXE_DEFAULT_PRESET).meta({
       description:
         'Accessibility ruleset preset (default: wcag21aa for WCAG 2.1 Level AA compliance)',
     }),
     scoreTargets: pluginScoreTargetsSchema.optional(),
-    timeout: positiveIntSchema.default(30_000).meta({
+    timeout: positiveIntSchema.default(DEFAULT_TIMEOUT_MS).meta({
       description:
         'Page navigation timeout in milliseconds (default: 30000ms / 30s)',
     }),

packages/plugin-axe/src/lib/config.unit.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { ZodError } from 'zod';
 import { axePluginOptionsSchema } from './config.js';
 
 describe('axePluginOptionsSchema', () => {
@@ -31,17 +32,21 @@ describe('axePluginOptionsSchema', () => {
   });
 
   it('should reject invalid preset values', () => {
-    expect(() => axePluginOptionsSchema.parse({ preset: 'wcag3aa' })).toThrow();
+    expect(() => axePluginOptionsSchema.parse({ preset: 'wcag3aa' })).toThrow(
+      ZodError,
+    );
   });
 
   it('should reject scoreTargets values greater than 1', () => {
-    expect(() => axePluginOptionsSchema.parse({ scoreTargets: 1.5 })).toThrow();
+    expect(() => axePluginOptionsSchema.parse({ scoreTargets: 1.5 })).toThrow(
+      ZodError,
+    );
   });
 
   it('should reject negative scoreTargets', () => {
-    expect(() =>
-      axePluginOptionsSchema.parse({ scoreTargets: -0.1 }),
-    ).toThrow();
+    expect(() => axePluginOptionsSchema.parse({ scoreTargets: -0.1 })).toThrow(
+      ZodError,
+    );
   });
 
   it('should accept custom timeout value', () => {
@@ -51,11 +56,17 @@ describe('axePluginOptionsSchema', () => {
   });
 
   it('should reject non-positive timeout values', () => {
-    expect(() => axePluginOptionsSchema.parse({ timeout: 0 })).toThrow();
-    expect(() => axePluginOptionsSchema.parse({ timeout: -1000 })).toThrow();
+    expect(() => axePluginOptionsSchema.parse({ timeout: 0 })).toThrow(
+      ZodError,
+    );
+    expect(() => axePluginOptionsSchema.parse({ timeout: -1000 })).toThrow(
+      ZodError,
+    );
   });
 
   it('should reject non-integer timeout values', () => {
-    expect(() => axePluginOptionsSchema.parse({ timeout: 1000.5 })).toThrow();
+    expect(() => axePluginOptionsSchema.parse({ timeout: 1000.5 })).toThrow(
+      ZodError,
+    );
   });
 });

packages/plugin-axe/src/lib/meta/groups.unit.test.ts

@@ -77,7 +77,7 @@ describe('transformRulesToGroups', () => {
       'best-practice',
     );
 
-    expect(groups).toSatisfyAll<Group>(({ slug }) => !slug.match(/^cat\./));
+    expect(groups).toSatisfyAll<Group>(({ slug }) => !/^cat\./.test(slug));
   });
 
   it('should include both WCAG 2.2 and category groups for "all" preset', () => {

packages/plugin-axe/src/lib/meta/transform.ts

@@ -47,6 +47,7 @@ export function transformRulesToGroups(
         return createWcagGroups(rules, '2.1');
       case 'wcag22aa':
         return createWcagGroups(rules, '2.2');
+      // eslint-disable-next-line sonarjs/no-duplicate-string
       case 'best-practice':
         return createCategoryGroups(rules);
       case 'all':
@@ -128,7 +129,7 @@ function createCategoryGroups(rules: axe.RuleMetadata[]): Group[] {
     rules.flatMap(({ tags }) => tags.filter(tag => tag.startsWith('cat.'))),
   );
 
-  return Array.from(categoryTags).map(tag => {
+  return [...categoryTags].map(tag => {
     const slug = tag.replace('cat.', '');
     const title = formatCategoryTitle(tag, slug);
     const categoryRules = rules.filter(({ tags }) => tags.includes(tag));

packages/plugin-axe/src/lib/processing.unit.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { processAuditsAndGroups } from './processing';
+import { processAuditsAndGroups } from './processing.js';
 
 describe('processAuditsAndGroups', () => {
   it('should return audits and groups without expansion when analyzing single URL', () => {