test(plugin-doc-coverage): finish remaining tests, add format to coverage

Author: aramirezj

packages/plugin-doc-coverage/src/lib/config.unit.test.ts

@@ -5,23 +5,80 @@ import {
 } from './config.js';
 
 describe('docCoveragePluginConfigSchema', () => {
-  it('accepts a valid source glob pattern', () => {
-    expect(() =>
-      docCoveragePluginConfigSchema.parse({
-        sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'],
-      } satisfies DocCoveragePluginConfig),
-    ).not.toThrow();
+  describe('sourceGlob', () => {
+    it('accepts a valid source glob pattern', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          sourceGlob: ['src/**/*.{ts,tsx}', '!**/*.spec.ts', '!**/*.test.ts'],
+        } satisfies DocCoveragePluginConfig),
+      ).not.toThrow();
+    });
+
+    it('uses default value for missing sourceGlob', () => {
+      const result = docCoveragePluginConfigSchema.parse({});
+      expect(result.sourceGlob).toEqual([
+        'src/**/*.{ts,tsx}',
+        '!**/*.spec.ts',
+        '!**/*.test.ts',
+      ]);
+    });
+
+    it('throws for invalid sourceGlob type', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          sourceGlob: 123,
+        }),
+      ).toThrow('Expected array');
+    });
   });
 
-  it('not throws for missing sourceGlob', () => {
-    expect(() => docCoveragePluginConfigSchema.parse({})).not.toThrow();
+  describe('onlyAudits', () => {
+    it('accepts valid audit slugs array', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          onlyAudits: ['functions-coverage', 'classes-coverage'],
+          sourceGlob: ['src/**/*.ts'],
+        }),
+      ).not.toThrow();
+    });
+
+    it('accepts empty array for onlyAudits', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          onlyAudits: [],
+          sourceGlob: ['src/**/*.ts'],
+        }),
+      ).not.toThrow();
+    });
+
+    it('allows onlyAudits to be undefined', () => {
+      const result = docCoveragePluginConfigSchema.parse({});
+      expect(result.onlyAudits).toBeUndefined();
+    });
+
+    it('throws for invalid onlyAudits type', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          onlyAudits: 'functions-coverage',
+        }),
+      ).toThrow('Expected array');
+    });
+
+    it('throws for array with non-string elements', () => {
+      expect(() =>
+        docCoveragePluginConfigSchema.parse({
+          onlyAudits: [123, true],
+        }),
+      ).toThrow('Expected string');
+    });
   });
 
-  it('throws for invalid sourceGlob type', () => {
+  it('accepts a complete valid configuration', () => {
     expect(() =>
       docCoveragePluginConfigSchema.parse({
-        sourceGlob: 123,
-      }),
-    ).toThrow('Expected string');
+        sourceGlob: ['src/**/*.ts'],
+        onlyAudits: ['functions-coverage'],
+      } satisfies DocCoveragePluginConfig),
+    ).not.toThrow();
   });
 });

packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.ts

@@ -10,12 +10,12 @@ import {
   filterGroupsByOnlyAudits,
 } from './utils.js';
 
-const PLUGIN_TITLE = 'Documentation coverage';
+export const PLUGIN_TITLE = 'Documentation coverage';
 
-const PLUGIN_DESCRIPTION =
+export const PLUGIN_DESCRIPTION =
   'Official Code PushUp documentation coverage plugin.';
 
-const PLUGIN_DOCS_URL =
+export const PLUGIN_DOCS_URL =
   'https://www.npmjs.com/package/@code-pushup/doc-coverage-plugin/';
 
 /**

packages/plugin-doc-coverage/src/lib/doc-coverage-plugin.unit.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import type { RunnerConfig } from '@code-pushup/models';
-import { docCoveragePlugin } from './doc-coverage-plugin.js';
+import { PLUGIN_SLUG } from './constants.js';
+import {
+  PLUGIN_DESCRIPTION,
+  PLUGIN_DOCS_URL,
+  PLUGIN_TITLE,
+  docCoveragePlugin,
+} from './doc-coverage-plugin.js';
 
 vi.mock('./runner/index.ts', () => ({
   createRunnerConfig: vi.fn().mockReturnValue({
@@ -17,46 +23,14 @@ describe('docCoveragePlugin', () => {
       }),
     ).resolves.toStrictEqual(
       expect.objectContaining({
-        slug: 'doc-coverage',
-        title: 'Documentation coverage',
-        audits: expect.any(Array),
-        runner: expect.any(Object),
-      }),
-    );
-  });
-
-  it('should generate percentage coverage audit', async () => {
-    await expect(
-      docCoveragePlugin({
-        sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],
-      }),
-    ).resolves.toStrictEqual(
-      expect.objectContaining({
-        audits: [
-          {
-            slug: 'percentage-coverage',
-            title: 'Percentage of codebase with documentation',
-            description: expect.stringContaining(
-              'how many % of the codebase have documentation',
-            ),
-          },
-        ],
-      }),
-    );
-  });
-
-  it('should include package metadata', async () => {
-    await expect(
-      docCoveragePlugin({
-        sourceGlob: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],
-      }),
-    ).resolves.toStrictEqual(
-      expect.objectContaining({
+        slug: PLUGIN_SLUG,
+        title: PLUGIN_TITLE,
         icon: 'folder-src',
-        description: expect.stringContaining('documentation coverage plugin'),
-        docsUrl: expect.stringContaining('npmjs.com'),
-        packageName: expect.any(String),
-        version: expect.any(String),
+        description: PLUGIN_DESCRIPTION,
+        docsUrl: PLUGIN_DOCS_URL,
+        groups: expect.any(Array),
+        audits: expect.any(Array),
+        runner: expect.any(Function),
       }),
     );
   });

packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.integration.test.ts.snap

@@ -13,7 +13,7 @@ exports[`processDocCoverage > should succesfully get the right number of ts file
     "nodesCount": 0,
   },
   "functions": {
-    "coverage": 33.333333333333336,
+    "coverage": 33.33,
     "issues": [
       {
         "file": "/home/alejandro/dev/code-pushup-cli/packages/plugin-doc-coverage/mocks/fixtures/angular/app.component.spec.ts",

packages/plugin-doc-coverage/src/lib/runner/__snapshots__/doc-processer.unit.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`getUnprocessedCoverageReport > should produce a full report 1`] = `
 {
   "classes": {
-    "coverage": 33.333333333333336,
+    "coverage": 33.33,
     "issues": [
       {
         "file": "test.ts",
@@ -21,7 +21,7 @@ exports[`getUnprocessedCoverageReport > should produce a full report 1`] = `
     "nodesCount": 3,
   },
   "enums": {
-    "coverage": 33.333333333333336,
+    "coverage": 33.33,
     "issues": [
       {
         "file": "test.ts",
@@ -44,7 +44,7 @@ exports[`getUnprocessedCoverageReport > should produce a full report 1`] = `
     "nodesCount": 3,
   },
   "interfaces": {
-    "coverage": 66.66666666666667,
+    "coverage": 66.67,
     "issues": [
       {
         "file": "test.ts",

packages/plugin-doc-coverage/src/lib/runner/utils.ts

@@ -28,7 +28,11 @@ export function calculateCoverage(result: UnprocessedCoverageResult) {
           coverage:
             value.nodesCount === 0
               ? 100
-              : (1 - value.issues.length / value.nodesCount) * 100,
+              : Number(
+                  ((1 - value.issues.length / value.nodesCount) * 100).toFixed(
+                    2,
+                  ),
+                ),
           issues: value.issues,
           nodesCount: value.nodesCount,
         },

packages/plugin-doc-coverage/src/lib/runner/utils.unit.test.ts

@@ -0,0 +1,85 @@
+import { SyntaxKind } from 'ts-morph';
+import type { UnprocessedCoverageResult } from './models';
+import {
+  calculateCoverage,
+  createEmptyUnprocessedCoverageReport,
+  getCoverageTypeFromKind,
+} from './utils';
+
+describe('createEmptyUnprocessedCoverageReport', () => {
+  it('should create an empty report with all categories initialized', () => {
+    const result = createEmptyUnprocessedCoverageReport();
+
+    expect(result).toStrictEqual({
+      enums: { nodesCount: 0, issues: [] },
+      interfaces: { nodesCount: 0, issues: [] },
+      types: { nodesCount: 0, issues: [] },
+      functions: { nodesCount: 0, issues: [] },
+      variables: { nodesCount: 0, issues: [] },
+      classes: { nodesCount: 0, issues: [] },
+      methods: { nodesCount: 0, issues: [] },
+      properties: { nodesCount: 0, issues: [] },
+    });
+  });
+});
+
+describe('calculateCoverage', () => {
+  it('should calculate 100% coverage when there are no nodes', () => {
+    const input: UnprocessedCoverageResult =
+      createEmptyUnprocessedCoverageReport();
+    const result = calculateCoverage(input);
+
+    Object.values(result).forEach(category => {
+      expect(category.coverage).toBe(100);
+      expect(category.nodesCount).toBe(0);
+      expect(category.issues).toEqual([]);
+    });
+  });
+
+  it('should calculate correct coverage percentage with issues', () => {
+    const input: UnprocessedCoverageResult = {
+      ...createEmptyUnprocessedCoverageReport(),
+      functions: {
+        nodesCount: 4,
+        issues: [
+          { type: 'functions', line: 1, file: 'test.ts', name: 'fn1' },
+          { type: 'functions', line: 2, file: 'test.ts', name: 'fn2' },
+        ],
+      },
+      classes: {
+        nodesCount: 4,
+        issues: [
+          { type: 'classes', line: 1, file: 'test.ts', name: 'Class1' },
+          { type: 'classes', line: 2, file: 'test.ts', name: 'Class2' },
+          { type: 'classes', line: 3, file: 'test.ts', name: 'Class3' },
+        ],
+      },
+    };
+
+    const result = calculateCoverage(input);
+
+    expect(result.functions.coverage).toBe(50);
+    expect(result.classes.coverage).toBe(25);
+  });
+});
+
+describe('getCoverageTypeFromKind', () => {
+  it.each([
+    [SyntaxKind.ClassDeclaration, 'classes'],
+    [SyntaxKind.MethodDeclaration, 'methods'],
+    [SyntaxKind.FunctionDeclaration, 'functions'],
+    [SyntaxKind.InterfaceDeclaration, 'interfaces'],
+    [SyntaxKind.EnumDeclaration, 'enums'],
+    [SyntaxKind.VariableDeclaration, 'variables'],
+    [SyntaxKind.PropertyDeclaration, 'properties'],
+    [SyntaxKind.TypeAliasDeclaration, 'types'],
+  ])('should return %s for SyntaxKind.%s', (kind, expectedType) => {
+    expect(getCoverageTypeFromKind(kind)).toBe(expectedType);
+  });
+
+  it('should throw error for unsupported syntax kind', () => {
+    expect(() => getCoverageTypeFromKind(SyntaxKind.Unknown)).toThrow(
+      'Unsupported syntax kind',
+    );
+  });
+});

packages/plugin-doc-coverage/src/lib/utils.unit.test.ts

@@ -0,0 +1,79 @@
+import type { Group } from '@code-pushup/models';
+import { AUDITS_MAP } from './constants';
+import { filterAuditsByPluginConfig, filterGroupsByOnlyAudits } from './utils';
+
+describe('filterAuditsByPluginConfig', () => {
+  it('should return all audits when onlyAudits is not provided', () => {
+    const result = filterAuditsByPluginConfig({});
+    expect(result).toStrictEqual(Object.values(AUDITS_MAP));
+  });
+
+  it('should return all audits when onlyAudits is empty array', () => {
+    const result = filterAuditsByPluginConfig({ onlyAudits: [] });
+    expect(result).toStrictEqual(Object.values(AUDITS_MAP));
+  });
+
+  it('should return only specified audits when onlyAudits is provided', () => {
+    const onlyAudits = ['functions-coverage', 'classes-coverage'];
+    const result = filterAuditsByPluginConfig({ onlyAudits });
+
+    expect(result).toStrictEqual(
+      Object.values(AUDITS_MAP).filter(audit =>
+        onlyAudits.includes(audit.slug),
+      ),
+    );
+  });
+});
+
+describe('filterGroupsByOnlyAudits', () => {
+  const mockGroups: Group[] = [
+    {
+      title: 'Group 1',
+      slug: 'group-1',
+      refs: [
+        { slug: 'functions-coverage', weight: 1 },
+        { slug: 'classes-coverage', weight: 1 },
+      ],
+    },
+    {
+      title: 'Group 2',
+      slug: 'group-2',
+      refs: [
+        { slug: 'types-coverage', weight: 1 },
+        { slug: 'interfaces-coverage', weight: 1 },
+      ],
+    },
+  ];
+
+  it('should return all groups when onlyAudits is not provided', () => {
+    const result = filterGroupsByOnlyAudits(mockGroups, {});
+    expect(result).toStrictEqual(mockGroups);
+  });
+
+  it('should return all groups when onlyAudits is empty array', () => {
+    const result = filterGroupsByOnlyAudits(mockGroups, { onlyAudits: [] });
+    expect(result).toStrictEqual(mockGroups);
+  });
+
+  it('should filter groups based on specified audits', () => {
+    const result = filterGroupsByOnlyAudits(mockGroups, {
+      onlyAudits: ['functions-coverage'],
+    });
+
+    expect(result).toStrictEqual([
+      {
+        title: 'Group 1',
+        slug: 'group-1',
+        refs: [{ slug: 'functions-coverage', weight: 1 }],
+      },
+    ]);
+  });
+
+  it('should remove groups with no matching refs', () => {
+    const result = filterGroupsByOnlyAudits(mockGroups, {
+      onlyAudits: ['enums-coverage'],
+    });
+
+    expect(result).toStrictEqual([]);
+  });
+});