refactor(chore): improvements testing

packages/cli/src/lib/collect/command-object.spec.ts

@@ -61,7 +61,6 @@ function mockPlugin(): PluginConfig {
         slug: 'command-object-audit-slug',
         title: 'audit title',
         description: 'audit description',
-        label: 'mock audit label',
         docsUrl: 'http://www.my-docs.dev',
       },
     ],

packages/models/src/lib/category-config.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { categoryConfigSchema } from './category-config';
-import { mockCategory } from './implementation/helpers.mock';
+import { mockCategory } from '../../test';
 
 describe('categoryConfigSchema', () => {
   it('should parse if configuration with audit refs is valid', () => {

packages/models/src/lib/core-config.spec.ts

@@ -1,10 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { coreConfigSchema } from './core-config';
-import {
-  mockCategory,
-  mockConfig,
-  mockPluginConfig,
-} from './implementation/helpers.mock';
+import { mockCategory, mockConfig, mockPluginConfig } from '../../test';
 
 /*
  - plugin slug: es-lint

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

@@ -81,6 +81,7 @@ export function weightSchema(
 export function positiveIntSchema(description: string) {
   return z.number({ description }).int().nonnegative();
 }
+
 /**
  * Schema for a unixFilePath
  * @param description
@@ -89,6 +90,24 @@ export function unixFilePathSchema(description: string) {
   return z.string({ description }).regex(unixFilePathRegex);
 }
 
+export function packageVersionSchema(options?: {
+  versionDescription?: string;
+  optional?: boolean;
+}) {
+  let { versionDescription, optional } = options || {};
+  versionDescription = versionDescription || 'NPM version of the package';
+  optional = !!optional;
+  const packageSchema = z.string({ description: 'NPM package name' });
+  const versionSchema = z.string({ description: versionDescription });
+  return z.object(
+    {
+      package: optional ? packageSchema.optional() : packageSchema,
+      version: optional ? versionSchema.optional() : versionSchema,
+    },
+    { description: 'NPM package name and version of a published package' },
+  );
+}
+
 export function weightedRefSchema(
   description: string,
   slugDescription: string,

packages/models/src/lib/persist-config.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { mockPersistConfig } from './implementation/helpers.mock';
+import { mockPersistConfig } from '../../test';
 import { persistConfigSchema } from './persist-config';
 
 describe('persistConfigSchema', () => {

packages/models/src/lib/plugin-config.spec.ts

@@ -3,7 +3,7 @@ import {
   mockGroupConfig,
   mockPluginConfig,
   mockRunnerOutput,
-} from './implementation/helpers.mock';
+} from '../../test';
 import {
   auditGroupSchema,
   pluginConfigSchema,

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

@@ -3,6 +3,7 @@ import {
   descriptionSchema,
   docsUrlSchema,
   generalFilePathSchema,
+  packageVersionSchema,
   positiveIntSchema,
   scorableSchema,
   slugSchema,
@@ -18,22 +19,26 @@ import {
 } from './implementation/utils';
 
 // Define Zod schema for the PluginMetadata type
-export const pluginMetadataSchema = z.object(
-  {
-    slug: slugSchema(),
-    name: z
-      .string({
-        description: 'Display name',
-      })
-      .max(128),
-    icon: z.union([z.unknown(), z.string()], {
-      description: 'Icon from VSCode Material Icons extension',
-    }),
-    docsUrl: docsUrlSchema('Plugin documentation site'),
-  },
-  {
-    description: 'Plugin metadata',
-  },
+export const pluginMetadataSchema = packageVersionSchema({
+  optional: true,
+}).merge(
+  z.object(
+    {
+      slug: slugSchema(),
+      name: z
+        .string({
+          description: 'Display name',
+        })
+        .max(128),
+      icon: z.union([z.unknown(), z.string()], {
+        description: 'Icon from VSCode Material Icons extension',
+      }),
+      docsUrl: docsUrlSchema('Plugin documentation site'),
+    },
+    {
+      description: 'Plugin metadata',
+    },
+  ),
 );
 
 // Define Zod schema for the RunnerConfig type
@@ -54,11 +59,6 @@ const runnerConfigSchema = z.object(
 export const auditMetadataSchema = z.object(
   {
     slug: slugSchema('ID (unique within plugin)'),
-    label: z
-      .string({
-        description: 'Abbreviated name',
-      })
-      .max(128),
     title: titleSchema('Descriptive name'),
     description: descriptionSchema('Description (Markdown)'),
     docsUrl: docsUrlSchema('Link to documentation (rationale)'),
@@ -138,27 +138,6 @@ export const pluginConfigSchema = z
 
 export type PluginConfig = z.infer<typeof pluginConfigSchema>;
 
-/**
- * Define Zod schema for the SourceFileLocation type.
- *
- * @example
- *
- * // Example data for the RunnerOutput type
- * const runnerOutputData = {
- *   audits: [
- *     // ... populate with example audit data ...
- *   ],
- * };
- *
- * // Validate the data against the schema
- * const validationResult = runnerOutputSchema.safeParse(runnerOutputData);
- *
- * if (validationResult.success) {
- *   console.log('Valid runner output:', validationResult.data);
- * } else {
- *   console.error('Invalid runner output:', validationResult.error);
- * }
- */
 const sourceFileLocationSchema = z.object(
   {
     file: unixFilePathSchema('Relative path to source file in Git repo'),

packages/models/src/lib/report.spec.ts

@@ -1,8 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import {
-  mockPluginConfig,
-  mockRunnerOutput,
-} from './implementation/helpers.mock';
+import { mockPluginConfig, mockRunnerOutput } from '../../test';
 import { runnerOutputAuditRefsPresentInPluginConfigs } from './report';
 
 describe('RunnerOutput', () => {

packages/models/src/lib/report.ts

@@ -7,6 +7,7 @@ import {
   auditResultSchema,
   pluginMetadataSchema,
 } from './plugin-config';
+import { packageVersionSchema } from './implementation/schemas';
 
 export type PluginOutput = RunnerOutput & {
   slug: string;
@@ -25,15 +26,17 @@ export const pluginReportSchema = z.object({
 });
 export type PluginReport = z.infer<typeof pluginReportSchema>;
 
-export const reportSchema = z.object(
-  {
-    package: z.string({ description: 'NPM package name' }),
-    version: z.string({ description: 'NPM version of the CLI' }),
-    date: z.string({ description: 'Start date and time of the collect run' }),
-    duration: z.number({ description: 'Duration of the collect run in ms' }),
-    plugins: z.array(pluginReportSchema),
-  },
-  { description: 'Collect output data.' },
+export const reportSchema = packageVersionSchema({
+  versionDescription: 'NPM version of the CLI',
+}).merge(
+  z.object(
+    {
+      date: z.string({ description: 'Start date and time of the collect run' }),
+      duration: z.number({ description: 'Duration of the collect run in ms' }),
+      plugins: z.array(pluginReportSchema),
+    },
+    { description: 'Collect output data.' },
+  ),
 );
 
 export type Report = z.infer<typeof reportSchema>;

packages/models/src/lib/upload-config.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { mockUploadConfig } from './implementation/helpers.mock';
+import { mockUploadConfig } from '../../test';
 import { uploadConfigSchema } from './upload-config';
 
 describe('uploadConfigSchema', () => {

packages/models/src/lib/implementation/helpers.mock.ts → packages/models/test/helpers.mock.ts

@@ -1,13 +1,13 @@
-import { CategoryConfig } from '../category-config';
-import { CoreConfig } from '../core-config';
-import { PersistConfig } from '../persist-config';
+import { CategoryConfig } from '../src/lib/category-config';
+import { CoreConfig } from '../src/lib/core-config';
+import { PersistConfig } from '../src/lib/persist-config';
 import {
   AuditGroup,
   AuditMetadata,
   PluginConfig,
   RunnerOutput,
-} from '../plugin-config';
-import { UploadConfig } from '../upload-config';
+} from '../src/lib/plugin-config';
+import { UploadConfig } from '../src/lib/upload-config';
 
 export function mockConfig(opt?: {
   pluginSlug?: string | string[];
@@ -31,13 +31,14 @@ export function mockPluginConfig(opt?: {
   pluginSlug?: string;
   auditSlug?: string | string[];
   groupSlug?: string | string[];
+  outputPath?: string;
 }): PluginConfig {
   const { groupSlug } = opt || {};
-  let { pluginSlug, auditSlug } = opt || {};
+  let { pluginSlug, auditSlug, outputPath } = opt || {};
   pluginSlug = pluginSlug || 'mock-plugin-slug';
   auditSlug = auditSlug || 'mock-audit-slug';
   const addGroups = groupSlug !== undefined;
-  const outputPath = 'out-execute-plugin.json';
+  outputPath = outputPath || 'out-execute-plugin.json';
 
   const audits = Array.isArray(auditSlug)
     ? auditSlug.map(slug => mockAuditConfig({ auditSlug: slug }))
@@ -59,7 +60,7 @@ export function mockPluginConfig(opt?: {
         '-c',
         `echo '${JSON.stringify({
           audits: audits.map(({ slug }, idx) => ({
-            slug: `${pluginSlug}#${slug}`,
+            slug: `${slug}`,
             value: parseFloat('0.' + idx),
           })),
         } satisfies RunnerOutput)}' > ${outputPath}`,
@@ -81,7 +82,6 @@ export function mockAuditConfig(opt?: { auditSlug?: string }): AuditMetadata {
     slug: auditSlug,
     title: 'audit title',
     description: 'audit description',
-    label: 'mock audit label',
     docsUrl: 'http://www.my-docs.dev',
   };
 }

packages/models/test/index.ts

@@ -0,0 +1 @@
+export * from './helpers.mock';

packages/models/tsconfig.lib.json

@@ -10,6 +10,7 @@
     "vite.config.ts",
     "src/**/*.spec.ts",
     "src/**/*.test.ts",
-    "src/**/*.mock.ts"
+    "src/**/*.mock.ts",
+    "test/**/*.ts"
   ]
 }

packages/utils/src/lib/collect/implementation/execute-plugin.spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { executePlugin, executePlugins } from './execute-plugin';
-import { mockPluginConfig } from './mock/schema-helper.mock';
+import { mockPluginConfig } from '@quality-metrics/models/testing';
 import {
   pluginConfigSchema,
   runnerOutputSchema,
@@ -9,16 +9,10 @@ import {
 describe('executePlugin', () => {
   it('should work with valid plugin', async () => {
     const cfg = pluginConfigSchema.parse(mockPluginConfig());
-    const expectedResult = [
-      {
-        slug: 'mock-audit-slug',
-        value: 0,
-      },
-    ];
     const errorSpy = vi.fn();
     const pluginResult = await executePlugin(cfg).catch(errorSpy);
-    expect(pluginResult.audits).toEqual(expectedResult);
     expect(errorSpy).toHaveBeenCalledTimes(0);
+    expect(pluginResult.audits[0].slug).toBe('mock-audit-slug');
     expect(() => runnerOutputSchema.parse(pluginResult)).not.toThrow();
   });