@opensip-tools/fitness 1.0.4

package/src/plugins/__tests__/check-package-discovery.test.ts

@@ -0,0 +1,204 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  discoverCheckPackages,
+  readCheckPackageMetadata,
+  readCheckPackagePreferences,
+} from '../check-package-discovery.js'
+
+let testDir: string
+
+function makeNodeModulesPackage(testDir: string, scopedName: string, fields: Record<string, unknown> = {}): string {
+  const [scope, name] = scopedName.startsWith('@')
+    ? [scopedName.split('/')[0], scopedName.split('/').slice(1).join('/')]
+    : ['', scopedName]
+  const dir = scope ? join(testDir, 'node_modules', scope, name) : join(testDir, 'node_modules', name)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(
+    join(dir, 'package.json'),
+    JSON.stringify({ name: scopedName, version: '0.0.0', main: './index.js', ...fields }),
+  )
+  writeFileSync(join(dir, 'index.js'), 'export const checks = []')
+  return dir
+}
+
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-check-pkg-disc-'))
+})
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true })
+})
+
+describe('discoverCheckPackages — auto-discovery (default)', () => {
+  it('finds @opensip-tools/checks-* packages in node_modules', () => {
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-go')
+    const result = discoverCheckPackages({ projectDir: testDir })
+    const names = result.map((p) => p.name).sort()
+    expect(names).toEqual([
+      '@opensip-tools/checks-go',
+      '@opensip-tools/checks-python',
+    ])
+  })
+
+  it('returns every @opensip-tools/checks-* package without privileging any one', () => {
+    // No package is hardcoded into the CLI any more; the discovery layer
+    // treats them all the same. The only reason a check package would be
+    // excluded is if the package.json is missing or unreadable.
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-typescript')
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    const result = discoverCheckPackages({ projectDir: testDir })
+    expect(result.map((p) => p.name).sort()).toEqual([
+      '@opensip-tools/checks-python',
+      '@opensip-tools/checks-typescript',
+    ])
+  })
+
+  it('ignores @opensip-tools packages that are not check packs', () => {
+    makeNodeModulesPackage(testDir, '@opensip-tools/lang-python')
+    makeNodeModulesPackage(testDir, '@opensip-tools/core')
+    const result = discoverCheckPackages({ projectDir: testDir })
+    expect(result).toHaveLength(0)
+  })
+
+  it('walks ancestor node_modules to handle pnpm hoisted layouts', () => {
+    // Place check package in workspace-root node_modules, run discovery
+    // from a nested project dir.
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    const nestedDir = join(testDir, 'apps', 'web')
+    mkdirSync(nestedDir, { recursive: true })
+    const result = discoverCheckPackages({ projectDir: nestedDir })
+    expect(result.map((p) => p.name)).toEqual(['@opensip-tools/checks-python'])
+  })
+
+  it('returns empty array when there is no @opensip-tools scope dir', () => {
+    const result = discoverCheckPackages({ projectDir: testDir })
+    expect(result).toEqual([])
+  })
+})
+
+describe('discoverCheckPackages — opt-out', () => {
+  it('returns empty array when autoDiscover is false', () => {
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    const result = discoverCheckPackages({ projectDir: testDir, autoDiscover: false })
+    expect(result).toEqual([])
+  })
+})
+
+describe('discoverCheckPackages — explicit packages', () => {
+  it('loads only the configured list', () => {
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-go')
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-java')
+    const result = discoverCheckPackages({
+      projectDir: testDir,
+      explicitPackages: ['@opensip-tools/checks-python'],
+    })
+    expect(result.map((p) => p.name)).toEqual(['@opensip-tools/checks-python'])
+  })
+
+  it('warns and skips packages that are configured but not installed', () => {
+    const result = discoverCheckPackages({
+      projectDir: testDir,
+      explicitPackages: ['@opensip-tools/checks-missing'],
+    })
+    expect(result).toEqual([])
+  })
+
+  it('explicit empty list disables loading entirely', () => {
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    const result = discoverCheckPackages({ projectDir: testDir, explicitPackages: [] })
+    expect(result).toEqual([])
+  })
+
+  it('honors every entry in the explicit list — no package is privileged', () => {
+    // After the decoupling there is no hardcoded "builtin" package; the
+    // explicit list passes through verbatim. This guards against
+    // re-introducing a magic name skip.
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-typescript')
+    makeNodeModulesPackage(testDir, '@opensip-tools/checks-python')
+    const result = discoverCheckPackages({
+      projectDir: testDir,
+      explicitPackages: ['@opensip-tools/checks-typescript', '@opensip-tools/checks-python'],
+    })
+    expect(result.map((p) => p.name).sort()).toEqual([
+      '@opensip-tools/checks-python',
+      '@opensip-tools/checks-typescript',
+    ])
+  })
+})
+
+describe('readCheckPackageMetadata', () => {
+  it('reads name and main from package.json', () => {
+    const dir = makeNodeModulesPackage(testDir, '@opensip-tools/checks-python', {
+      main: './dist/index.js',
+    })
+    const meta = readCheckPackageMetadata(dir)
+    expect(meta?.name).toBe('@opensip-tools/checks-python')
+    expect(meta?.mainEntry.endsWith('/dist/index.js')).toBe(true)
+  })
+
+  it('honors exports["."] over main', () => {
+    const dir = makeNodeModulesPackage(testDir, '@opensip-tools/checks-go', {
+      main: './main-fallback.js',
+      exports: { '.': './dist/preferred.js' },
+    })
+    const meta = readCheckPackageMetadata(dir)
+    expect(meta?.mainEntry.endsWith('/dist/preferred.js')).toBe(true)
+  })
+
+  it('returns undefined when no package.json exists', () => {
+    expect(readCheckPackageMetadata('/nonexistent/path')).toBeUndefined()
+  })
+})
+
+describe('readCheckPackagePreferences', () => {
+  it('reads checkPackages and autoDiscoverChecks from project config', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: x
+    languages: [typescript]
+    concerns: []
+    include: ["**/*.ts"]
+plugins:
+  checkPackages:
+    - "@opensip-tools/checks-python"
+  autoDiscoverChecks: false
+fitness:
+  failOnErrors: 1
+  failOnWarnings: 0
+  disabledChecks: []
+`,
+    )
+    const prefs = readCheckPackagePreferences(testDir)
+    expect(prefs.checkPackages).toEqual(['@opensip-tools/checks-python'])
+    expect(prefs.autoDiscoverChecks).toBe(false)
+  })
+
+  it('returns empty object when config has no plugins section', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: x
+    languages: []
+    concerns: []
+    include: ["**/*.ts"]
+fitness: { failOnErrors: 0, failOnWarnings: 0, disabledChecks: [] }
+`,
+    )
+    const prefs = readCheckPackagePreferences(testDir)
+    expect(prefs).toEqual({})
+  })
+
+  it('returns empty object when no config file exists', () => {
+    expect(readCheckPackagePreferences(testDir)).toEqual({})
+  })
+})

package/src/plugins/__tests__/lang-domain.test.ts

@@ -0,0 +1,198 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { defaultLanguageRegistry } from '@opensip-tools/core'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { loadAllPlugins, loadPlugin } from '../loader.js'
+
+import type { DiscoveredPlugin } from '@opensip-tools/core'
+
+let testDir: string
+
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-lang-domain-'))
+  defaultLanguageRegistry.clear()
+})
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true })
+  defaultLanguageRegistry.clear()
+})
+
+describe('lang plugin domain', () => {
+  it('registers adapters from a lang plugin', async () => {
+    const pluginFile = join(testDir, 'lang-fake.mjs')
+    writeFileSync(pluginFile, `
+      export const adapters = [{
+        id: 'fake-rust',
+        fileExtensions: ['.fakers'],
+        parse: () => ({ marker: 'fake-tree' }),
+        stripStrings: (s) => s,
+        stripComments: (s) => s,
+      }];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'lang-fake',
+      source: 'lang-fake.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.error).toBeUndefined()
+    expect(result.adaptersRegistered).toBe(1)
+    expect(defaultLanguageRegistry.get('fake-rust')).toBeDefined()
+    expect(defaultLanguageRegistry.forFile('demo.fakers')?.id).toBe('fake-rust')
+  })
+
+  it('does not register checks when loading in lang domain', async () => {
+    const pluginFile = join(testDir, 'lang-with-checks.mjs')
+    // A plugin in the lang domain that exports checks should NOT register them.
+    writeFileSync(pluginFile, `
+      export const checks = [{ config: { id: 'wrong', slug: 'wrong' }, run: () => {} }];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'wrong-shape',
+      source: 'lang-with-checks.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.checksRegistered).toBe(0)
+    expect(result.adaptersRegistered).toBe(0)
+  })
+
+  it('warns when a lang plugin exports no adapters', async () => {
+    const pluginFile = join(testDir, 'lang-empty.mjs')
+    writeFileSync(pluginFile, '// no exports at all')
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'empty',
+      source: 'lang-empty.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.adaptersRegistered).toBe(0)
+    expect(result.error).toBeUndefined()
+  })
+
+  it('skips invalid adapter entries', async () => {
+    const pluginFile = join(testDir, 'lang-bad-item.mjs')
+    writeFileSync(pluginFile, `
+      export const adapters = [
+        { id: 'good', fileExtensions: ['.g'], parse: () => null, stripStrings: (s) => s, stripComments: (s) => s },
+        { wrong: 'shape' },
+        null,
+      ];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'bad-items',
+      source: 'lang-bad-item.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.adaptersRegistered).toBe(1)
+    expect(defaultLanguageRegistry.get('good')).toBeDefined()
+  })
+
+  it('registers adapters exported as named exports (no array wrapper)', async () => {
+    const pluginFile = join(testDir, 'lang-named-export.mjs')
+    writeFileSync(pluginFile, `
+      export const myLang = {
+        id: 'fake-lang-named',
+        fileExtensions: ['.fln'],
+        parse: () => ({ ok: true }),
+        stripStrings: (s) => s,
+        stripComments: (s) => s,
+      };
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'lang-named-export',
+      source: 'lang-named-export.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.error).toBeUndefined()
+    expect(result.adaptersRegistered).toBe(1)
+    expect(defaultLanguageRegistry.get('fake-lang-named')).toBeDefined()
+  })
+
+  it('registers an adapter from default export', async () => {
+    const pluginFile = join(testDir, 'lang-default.mjs')
+    writeFileSync(pluginFile, `
+      export default {
+        id: 'fake-lang-default',
+        fileExtensions: ['.fld'],
+        parse: () => ({ ok: true }),
+        stripStrings: (s) => s,
+        stripComments: (s) => s,
+      };
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'lang-default',
+      source: 'lang-default.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.error).toBeUndefined()
+    expect(result.adaptersRegistered).toBe(1)
+    expect(defaultLanguageRegistry.get('fake-lang-default')).toBeDefined()
+  })
+
+  it('deduplicates adapters appearing in both array and named export', async () => {
+    const pluginFile = join(testDir, 'lang-dedup.mjs')
+    writeFileSync(pluginFile, `
+      export const myLang = {
+        id: 'fake-lang-dedup',
+        fileExtensions: ['.fdd'],
+        parse: () => ({ ok: true }),
+        stripStrings: (s) => s,
+        stripComments: (s) => s,
+      };
+      export const adapters = [myLang];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'lang-dedup',
+      source: 'lang-dedup.mjs',
+    }
+
+    const result = await loadPlugin(plugin, 'lang')
+    expect(result.error).toBeUndefined()
+    expect(result.adaptersRegistered).toBe(1)
+  })
+
+  it('loadAllPlugins for the lang domain returns empty', async () => {
+    // There is no project-local lang plugin discovery path —
+    // language adapters ship as direct deps of @opensip-tools/cli
+    // and are registered by the CLI bootstrap, not by walking a
+    // user-source dir. Verify that loadAllPlugins('lang', ...)
+    // discovers nothing rather than reading from a stray directory.
+    const baseDir = mkdtempSync(join(tmpdir(), 'opensip-lang-base-'))
+    try {
+      const result = await loadAllPlugins('lang', baseDir)
+      expect(result.totalAdapters).toBe(0)
+      expect(result.plugins).toHaveLength(0)
+    } finally {
+      rmSync(baseDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/plugins/__tests__/loader.test.ts

@@ -0,0 +1,226 @@
+import { mkdirSync, writeFileSync, rmSync , mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+import { loadPlugin, loadAllPlugins } from '../loader.js'
+
+import type { DiscoveredPlugin } from '@opensip-tools/core'
+
+let testDir: string
+
+beforeEach(() => {
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-loader-test-'))
+})
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true })
+})
+
+describe('loadPlugin', () => {
+  it('loads a plugin that exports an empty checks array', async () => {
+    const pluginFile = join(testDir, 'empty-plugin.mjs')
+    writeFileSync(pluginFile, `
+      export const checks = [];
+      export const metadata = { name: 'empty', version: '1.0.0' };
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'empty-plugin',
+      source: 'empty-plugin.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.checksRegistered).toBe(0)
+    expect(result.error).toBeUndefined()
+    expect(result.namespace).toBe('empty-plugin')
+  })
+
+  it('handles plugin that throws on import', async () => {
+    const pluginFile = join(testDir, 'broken-plugin.mjs')
+    writeFileSync(pluginFile, 'throw new Error("plugin init failed")')
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'broken',
+      source: 'broken-plugin.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.checksRegistered).toBe(0)
+    expect(result.error).toContain('plugin init failed')
+  })
+
+  it('handles plugin with no exports gracefully', async () => {
+    const pluginFile = join(testDir, 'no-exports.mjs')
+    writeFileSync(pluginFile, '// nothing exported')
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'no-exports',
+      source: 'no-exports.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.checksRegistered).toBe(0)
+    expect(result.recipesRegistered).toBe(0)
+    expect(result.error).toBeUndefined()
+  })
+
+  it('skips non-Check objects in checks array', async () => {
+    const pluginFile = join(testDir, 'bad-checks.mjs')
+    writeFileSync(pluginFile, `
+      export const checks = [
+        { notACheck: true },
+        "string",
+        42,
+        null,
+      ];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'bad-checks',
+      source: 'bad-checks.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.checksRegistered).toBe(0)
+    expect(result.error).toBeUndefined()
+  })
+
+  it('registers Check instances exported as named exports (no array wrapper)', async () => {
+    const pluginFile = join(testDir, 'named-export-checks.mjs')
+    writeFileSync(pluginFile, `
+      import { defineCheck } from '@opensip-tools/fitness';
+
+      export const myFirstCheck = defineCheck({
+        id: '11111111-1111-1111-1111-111111111111',
+        slug: 'my-first',
+        description: 'First check via named export',
+        scope: { languages: ['rust'], concerns: [] },
+        tags: ['quality'],
+        analyze: () => [],
+      });
+
+      export const mySecondCheck = defineCheck({
+        id: '22222222-2222-2222-2222-222222222222',
+        slug: 'my-second',
+        description: 'Second check via named export',
+        scope: { languages: ['rust'], concerns: [] },
+        tags: ['quality'],
+        analyze: () => [],
+      });
+
+      // Non-check named exports are ignored
+      export const helper = (s) => s;
+      export const VERSION = '1.0.0';
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'named-export-checks',
+      source: 'named-export-checks.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.error).toBeUndefined()
+    expect(result.checksRegistered).toBe(2)
+  })
+
+  it('registers a Check from default export', async () => {
+    const pluginFile = join(testDir, 'default-export-check.mjs')
+    writeFileSync(pluginFile, `
+      import { defineCheck } from '@opensip-tools/fitness';
+
+      export default defineCheck({
+        id: '33333333-3333-3333-3333-333333333333',
+        slug: 'default-check',
+        description: 'Single check via default export',
+        scope: { languages: ['rust'], concerns: [] },
+        tags: ['quality'],
+        analyze: () => [],
+      });
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'default-export-check',
+      source: 'default-export-check.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.error).toBeUndefined()
+    expect(result.checksRegistered).toBe(1)
+  })
+
+  it('deduplicates checks appearing in both array and named exports', async () => {
+    const pluginFile = join(testDir, 'dedup-checks.mjs')
+    writeFileSync(pluginFile, `
+      import { defineCheck } from '@opensip-tools/fitness';
+
+      export const sameCheck = defineCheck({
+        id: '44444444-4444-4444-4444-444444444444',
+        slug: 'same',
+        description: 'Same check exported two ways',
+        scope: { languages: ['rust'], concerns: [] },
+        tags: ['quality'],
+        analyze: () => [],
+      });
+
+      export const checks = [sameCheck];
+    `)
+
+    const plugin: DiscoveredPlugin = {
+      type: 'file',
+      entryPoint: pluginFile,
+      namespace: 'dedup-checks',
+      source: 'dedup-checks.mjs',
+    }
+
+    const result = await loadPlugin(plugin)
+    expect(result.error).toBeUndefined()
+    expect(result.checksRegistered).toBe(1)
+  })
+})
+
+describe('loadAllPlugins', () => {
+  it('returns empty result when no plugins found', async () => {
+    const result = await loadAllPlugins('fit', join(testDir, 'nonexistent'))
+    expect(result.plugins).toEqual([])
+    expect(result.totalChecks).toBe(0)
+    expect(result.totalRecipes).toBe(0)
+    expect(result.errors).toEqual([])
+  })
+
+  it('aggregates results from multiple plugins', async () => {
+    // Project layout: opensip-tools/fit/checks/<file>.mjs
+    const checksDir = join(testDir, 'opensip-tools', 'fit', 'checks')
+    mkdirSync(checksDir, { recursive: true })
+    writeFileSync(join(checksDir, 'a.mjs'), 'export const checks = []')
+    writeFileSync(join(checksDir, 'b.mjs'), 'export const checks = []')
+
+    const result = await loadAllPlugins('fit', testDir)
+    expect(result.plugins).toHaveLength(2)
+  })
+
+  it('collects errors from failed plugins', async () => {
+    const checksDir = join(testDir, 'opensip-tools', 'fit', 'checks')
+    mkdirSync(checksDir, { recursive: true })
+    writeFileSync(join(checksDir, 'ok.mjs'), 'export const checks = []')
+    writeFileSync(join(checksDir, 'bad.mjs'), 'throw new Error("boom")')
+
+    const result = await loadAllPlugins('fit', testDir)
+    expect(result.plugins).toHaveLength(2)
+    expect(result.errors).toHaveLength(1)
+    expect(result.errors[0]).toContain('boom')
+  })
+})