jsdocs-plugin.unit.test.ts

import { describe, expect, it, vi } from 'vitest';
import { pluginConfigSchema } from '@code-pushup/models';
import {
  GROUPS,
  PLUGIN_DESCRIPTION,
  PLUGIN_DOCS_URL,
  PLUGIN_SLUG,
  PLUGIN_TITLE,
} from './constants.js';
import { jsDocsPlugin } from './jsdocs-plugin.js';
import { createRunnerFunction } from './runner/runner.js';
import {
  filterAuditsByPluginConfig,
  filterGroupsByOnlyAudits,
} from './utils.js';

vi.mock('./utils.js', async () => ({
  ...(await vi.importActual('./utils.js')),
  filterAuditsByPluginConfig: vi.fn().mockReturnValue([
    {
      slug: 'mock-audit',
      title: 'Mock Audit',
    },
  ]),
  filterGroupsByOnlyAudits: vi.fn().mockReturnValue([
    {
      slug: 'mock-group',
      title: 'Mock Group',
      refs: [
        {
          slug: 'mock-audit',
          weight: 1,
        },
      ],
    },
  ]),
}));

vi.mock('./runner/runner.js', () => ({
  createRunnerFunction: vi.fn().mockReturnValue(() => Promise.resolve([])),
}));

describe('jsDocsPlugin', () => {
  it('should create a valid plugin config', () => {
    expect(
      jsDocsPlugin({
        patterns: ['src/**/*.ts', '!**/*.spec.ts', '!**/*.test.ts'],
      }),
    ).toStrictEqual(
      expect.objectContaining({
        slug: PLUGIN_SLUG,
        title: PLUGIN_TITLE,
        icon: 'folder-docs',
        description: PLUGIN_DESCRIPTION,
        docsUrl: PLUGIN_DOCS_URL,
        groups: expect.any(Array),
        audits: expect.any(Array),
        runner: expect.any(Function),
      }),
    );
  });

  it('should throw for invalid plugin options', () => {
    expect(() =>
      // @ts-expect-error testing invalid config
      jsDocsPlugin({ patterns: 123 }),
    ).toThrow('Invalid input');
  });

  it('should filter groups', () => {
    const config = { patterns: ['src/**/*.ts'] };
    jsDocsPlugin(config);

    expect(filterGroupsByOnlyAudits).toHaveBeenCalledWith(GROUPS, config);
  });

  it('should filter audits', async () => {
    const config = { patterns: ['src/**/*.ts'] };
    jsDocsPlugin(config);

    expect(filterAuditsByPluginConfig).toHaveBeenCalledWith(config);
  });

  it('should forward options to runner function', async () => {
    const config = { patterns: ['src/**/*.ts'] };
    jsDocsPlugin(config);

    expect(createRunnerFunction).toHaveBeenCalledWith(config);
  });

  it('should pass scoreTargets to PluginConfig when provided', () => {
    const scoreTargets = { 'functions-coverage': 0.9 };
    const pluginConfig = jsDocsPlugin({
      patterns: ['src/**/*.ts'],
      scoreTargets,
    });

    expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
    expect(pluginConfig.scoreTargets).toStrictEqual(scoreTargets);
  });
});