@opensip-tools/fitness 1.0.4

package/src/recipes/__tests__/check-config.test.ts

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Tests for the per-check recipe-config helper.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest'
+
+import {
+  getCheckConfig,
+  setCurrentRecipeCheckConfig,
+  clearCurrentRecipeCheckConfig,
+} from '../check-config.js'
+
+interface SampleConfig extends Record<string, unknown> {
+  additionalEntries?: string[]
+}
+
+describe('getCheckConfig', () => {
+  afterEach(() => {
+    clearCurrentRecipeCheckConfig()
+  })
+
+  it('returns an empty object when no recipe config is set', () => {
+    const cfg = getCheckConfig<SampleConfig>('any-slug')
+    expect(cfg).toEqual({})
+  })
+
+  it('returns an empty object for a slug not present in the recipe config', () => {
+    setCurrentRecipeCheckConfig({
+      'other-check': { additionalEntries: ['x'] },
+    })
+    const cfg = getCheckConfig<SampleConfig>('missing')
+    expect(cfg).toEqual({})
+  })
+
+  it('returns the recipe-config slice for the matching slug', () => {
+    setCurrentRecipeCheckConfig({
+      'sample-check': { additionalEntries: ['a', 'b'] },
+    })
+    const cfg = getCheckConfig<SampleConfig>('sample-check')
+    expect(cfg.additionalEntries).toEqual(['a', 'b'])
+  })
+
+  it('returns an empty object after clearCurrentRecipeCheckConfig is called', () => {
+    setCurrentRecipeCheckConfig({
+      'sample-check': { additionalEntries: ['a', 'b'] },
+    })
+    clearCurrentRecipeCheckConfig()
+    const cfg = getCheckConfig<SampleConfig>('sample-check')
+    expect(cfg).toEqual({})
+  })
+})

package/src/recipes/__tests__/check-resolution.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from 'vitest'
+
+import { CheckRegistry } from '../../framework/registry.js'
+import { resolveChecks } from '../check-resolution.js'
+
+import type { Check } from '../../framework/check-types.js'
+import type { CheckSelector } from '../types.js'
+
+function makeCheck(slug: string, tags: string[] = ['quality'], opts?: { disabled?: boolean }): Check {
+  return {
+    config: {
+      id: `id-${slug}`,
+      slug,
+      tags,
+      description: `Check: ${slug}`,
+      analysisMode: 'analyze',
+      scope: { include: [], exclude: [], description: '' },
+      itemType: 'files',
+      disabled: opts?.disabled,
+      // eslint-disable-next-line @typescript-eslint/require-await -- mock matches expected `() => Promise<CheckResult>` shape
+      execute: async () => ({ findings: [], passed: true }),
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- mock matches expected `() => Promise<CheckResult>` shape
+    run: async () => ({ findings: [], passed: true }),
+    getScope: () => ({ include: [], exclude: [], description: '' }),
+    getMatcher: () => ({ matches: () => true }),
+  } as unknown as Check
+}
+
+function createRegistry(...checks: Check[]): CheckRegistry {
+  const reg = new CheckRegistry()
+  for (const check of checks) {
+    reg.register(check)
+  }
+  return reg
+}
+
+function createNamespacedRegistry(namespace: string, ...checks: Check[]): CheckRegistry {
+  const reg = new CheckRegistry()
+  for (const check of checks) {
+    reg.register(check, namespace)
+  }
+  return reg
+}
+
+describe('resolveChecks', () => {
+  describe('tags selector', () => {
+    it('resolves checks matching a single tag', () => {
+      const reg = createRegistry(
+        makeCheck('a', ['security']),
+        makeCheck('b', ['quality']),
+        makeCheck('c', ['security', 'quality']),
+      )
+      const selector: CheckSelector = { type: 'tags', include: ['security'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(2)
+      expect(result).toContain('a')
+      expect(result).toContain('c')
+    })
+
+    it('resolves checks matching any include tag', () => {
+      const reg = createRegistry(
+        makeCheck('a', ['security']),
+        makeCheck('b', ['performance']),
+        makeCheck('c', ['quality']),
+      )
+      const selector: CheckSelector = { type: 'tags', include: ['security', 'performance'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(2)
+      expect(result).toContain('a')
+      expect(result).toContain('b')
+    })
+
+    it('excludes checks matching exclude tags', () => {
+      const reg = createRegistry(
+        makeCheck('a', ['security', 'backend']),
+        makeCheck('b', ['security', 'frontend']),
+      )
+      const selector: CheckSelector = { type: 'tags', include: ['security'], exclude: ['frontend'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toEqual(['a'])
+    })
+
+    it('returns empty array when no tags match', () => {
+      const reg = createRegistry(makeCheck('a', ['quality']))
+      const selector: CheckSelector = { type: 'tags', include: ['nonexistent'] }
+      expect(resolveChecks(selector, reg)).toEqual([])
+    })
+  })
+
+  describe('explicit selector', () => {
+    it('resolves by bare slug', () => {
+      const reg = createRegistry(makeCheck('no-eval'), makeCheck('no-console'))
+      const selector: CheckSelector = { type: 'explicit', checkIds: ['no-eval'] }
+      expect(resolveChecks(selector, reg)).toEqual(['no-eval'])
+    })
+
+    it('resolves bare slug to namespaced check', () => {
+      const reg = createNamespacedRegistry('builtin',
+        makeCheck('no-eval'),
+        makeCheck('no-console'),
+      )
+      const selector: CheckSelector = { type: 'explicit', checkIds: ['no-eval'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(1)
+      expect(result[0]).toBe('builtin:no-eval')
+    })
+
+    it('resolves by exact namespaced slug', () => {
+      const reg = createNamespacedRegistry('builtin', makeCheck('no-eval'))
+      const selector: CheckSelector = { type: 'explicit', checkIds: ['builtin:no-eval'] }
+      expect(resolveChecks(selector, reg)).toEqual(['builtin:no-eval'])
+    })
+
+    it('filters out unknown slugs', () => {
+      const reg = createRegistry(makeCheck('exists'))
+      const selector: CheckSelector = { type: 'explicit', checkIds: ['exists', 'nope'] }
+      expect(resolveChecks(selector, reg)).toEqual(['exists'])
+    })
+  })
+
+  describe('pattern selector', () => {
+    it('matches tag/slug patterns like security/*', () => {
+      const reg = createRegistry(
+        makeCheck('no-eval', ['security']),
+        makeCheck('null-safety', ['quality']),
+        makeCheck('sql-injection', ['security']),
+      )
+      const selector: CheckSelector = { type: 'pattern', include: ['security/*'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(2)
+      expect(result).toContain('no-eval')
+      expect(result).toContain('sql-injection')
+    })
+
+    it('matches bare slug patterns', () => {
+      const reg = createRegistry(
+        makeCheck('no-eval'), makeCheck('no-console'), makeCheck('null-safety'),
+      )
+      const selector: CheckSelector = { type: 'pattern', include: ['no-*'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(2)
+    })
+
+    it('excludes patterns correctly', () => {
+      const reg = createRegistry(
+        makeCheck('no-eval', ['security']),
+        makeCheck('no-console', ['quality']),
+        makeCheck('no-any', ['quality']),
+      )
+      const selector: CheckSelector = { type: 'pattern', include: ['no-*'], exclude: ['quality/*'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toEqual(['no-eval'])
+    })
+
+    it('matches namespaced slugs via tag patterns', () => {
+      const reg = createNamespacedRegistry('builtin',
+        makeCheck('no-eval', ['security']),
+        makeCheck('null-safety', ['quality']),
+      )
+      const selector: CheckSelector = { type: 'pattern', include: ['security/*'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toHaveLength(1)
+      expect(result[0]).toBe('builtin:no-eval')
+    })
+  })
+
+  describe('all selector', () => {
+    it('returns all checks', () => {
+      const reg = createRegistry(makeCheck('a'), makeCheck('b'), makeCheck('c'))
+      const selector: CheckSelector = { type: 'all' }
+      expect(resolveChecks(selector, reg)).toHaveLength(3)
+    })
+
+    it('excludes by pattern', () => {
+      const reg = createRegistry(
+        makeCheck('no-eval', ['security']),
+        makeCheck('null-safety', ['quality']),
+      )
+      const selector: CheckSelector = { type: 'all', exclude: ['security/*'] }
+      const result = resolveChecks(selector, reg)
+      expect(result).toEqual(['null-safety'])
+    })
+  })
+})

package/src/recipes/__tests__/registry.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest';
+
+import { FitnessRecipeRegistry } from '../registry.js';
+
+import type { FitnessRecipe } from '../types.js';
+
+const stub = (id: string, name: string, tags: string[] = []): FitnessRecipe => ({
+  id,
+  name,
+  displayName: name,
+  description: name,
+  tags,
+  checks: { type: 'all', exclude: [] },
+  execution: { mode: 'parallel', stopOnFirstFailure: false, timeout: 30_000 },
+  reporting: { format: 'table', verbose: false },
+});
+
+describe('FitnessRecipeRegistry', () => {
+  it('pre-loads built-in recipes by default', () => {
+    const reg = new FitnessRecipeRegistry({ logWarnings: false });
+    expect(reg.size).toBeGreaterThan(0);
+    expect(reg.has('default')).toBe(true);
+  });
+
+  it('loadRecipe finds by name or id', () => {
+    const reg = new FitnessRecipeRegistry({ logWarnings: false });
+    expect(reg.loadRecipe('default')).toBeDefined();
+    expect(reg.loadRecipe('nope')).toBeUndefined();
+  });
+
+  it('getByName / getById work independently', () => {
+    const reg = new FitnessRecipeRegistry({ logWarnings: false });
+    const def = reg.getByName('default');
+    expect(def).toBeDefined();
+    expect(reg.getById(def?.id ?? '')).toBe(def);
+    expect(reg.getById('NOT_EXIST')).toBeUndefined();
+  });
+
+  it('register refuses to overwrite by default', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_a', 'a'));
+    expect(() => reg.register(stub('URCP_a', 'a'))).toThrow(/already registered/);
+  });
+
+  it('register allows overwrite when explicitly requested', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_a', 'a'));
+    reg.register({ ...stub('URCP_a', 'a'), description: 'updated' }, { allowOverwrite: true });
+    expect(reg.getByName('a')?.description).toBe('updated');
+  });
+
+  it('registerAll mounts every recipe in a list', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.clear();
+    reg.registerAll([stub('URCP_a', 'a'), stub('URCP_b', 'b')]);
+    expect(reg.size).toBe(2);
+  });
+
+  it('remove returns true on hit, false on miss', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_a', 'a'));
+    expect(reg.remove('URCP_a')).toBe(true);
+    expect(reg.remove('URCP_a')).toBe(false);
+  });
+
+  it('reset clears user-registered and restores built-ins', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_user', 'user'));
+    reg.reset();
+    expect(reg.has('user')).toBe(false);
+    expect(reg.has('default')).toBe(true);
+  });
+
+  it('getByTag returns matching recipes', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_t1', 't1', ['custom-tag-xyz']));
+    reg.register(stub('URCP_t2', 't2', ['other-tag']));
+    expect(reg.getByTag('custom-tag-xyz').map((r) => r.name)).toEqual(['t1']);
+  });
+
+  it('getNames returns all registered names', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    expect(reg.getNames()).toContain('default');
+  });
+
+  it('listForDisplay distinguishes built-in vs user-defined', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.register(stub('URCP_user', 'user'));
+    const display = reg.listForDisplay();
+    expect(display.find((d) => d.name === 'default')?.isBuiltIn).toBe(true);
+    expect(display.find((d) => d.name === 'user')?.isUserDefined).toBe(true);
+  });
+
+  it('isOverridden / getOverriddenBuiltIns reflect override state', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    expect(reg.isOverridden('default')).toBe(false);
+    expect(reg.getOverriddenBuiltIns()).toEqual([]);
+  });
+
+  it('getUserRecipesLoadResult is defined when loadUserRecipes runs', () => {
+    const reg = new FitnessRecipeRegistry({ logWarnings: false });
+    expect(reg.getUserRecipesLoadResult()).toBeDefined();
+  });
+
+  it('getUserRecipesLoadResult is undefined when loadUserRecipes is disabled', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    expect(reg.getUserRecipesLoadResult()).toBeUndefined();
+  });
+
+  it('clear removes everything', () => {
+    const reg = new FitnessRecipeRegistry({ loadUserRecipes: false, logWarnings: false });
+    reg.clear();
+    expect(reg.size).toBe(0);
+  });
+});

package/src/recipes/__tests__/retry.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { CheckAbortedError } from '../../framework/execution-context.js';
+import { executeWithRetry } from '../retry.js';
+
+const opts = (overrides: Partial<Parameters<typeof executeWithRetry>[1]> = {}) => ({
+  enabled: true,
+  maxRetries: 2,
+  checkId: 'check-id',
+  checkSlug: 'check-slug',
+  ...overrides,
+});
+
+describe('executeWithRetry', () => {
+  it('returns result on first success without retrying', async () => {
+    const fn = vi.fn().mockResolvedValue(42);
+    const out = await executeWithRetry(fn, opts());
+    expect(out).toEqual({ result: 42, lastError: undefined, retryCount: 0, wasRetried: false });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not retry CheckAbortedError', async () => {
+    const aborted = new CheckAbortedError('check-slug');
+    const fn = vi.fn().mockRejectedValue(aborted);
+    const out = await executeWithRetry(fn, opts());
+    expect(out.wasRetried).toBe(false);
+    expect(out.retryCount).toBe(0);
+    expect(out.lastError).toBe(aborted);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not retry when retries are disabled', async () => {
+    const err = new Error('boom');
+    const fn = vi.fn().mockRejectedValue(err);
+    const out = await executeWithRetry(fn, opts({ enabled: false }));
+    expect(out.wasRetried).toBe(false);
+    expect(out.retryCount).toBe(0);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not retry when maxRetries is 0', async () => {
+    const err = new Error('boom');
+    const fn = vi.fn().mockRejectedValue(err);
+    const out = await executeWithRetry(fn, opts({ maxRetries: 0 }));
+    expect(out.wasRetried).toBe(false);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries up to maxRetries on transient failure and succeeds', async () => {
+    vi.useFakeTimers();
+    let calls = 0;
+    const fn = vi.fn().mockImplementation(() => {
+      calls++;
+      if (calls < 3) return Promise.reject(new Error(`fail-${calls}`));
+      return Promise.resolve('ok');
+    });
+
+    const promise = executeWithRetry(fn, opts({ maxRetries: 3 }));
+    await vi.runAllTimersAsync();
+    const out = await promise;
+
+    expect(out.result).toBe('ok');
+    expect(out.wasRetried).toBe(true);
+    expect(out.retryCount).toBe(2);
+    expect(fn).toHaveBeenCalledTimes(3);
+    vi.useRealTimers();
+  });
+
+  it('returns lastError after exhausting retries', async () => {
+    vi.useFakeTimers();
+    const err = new Error('persistent');
+    const fn = vi.fn().mockRejectedValue(err);
+    const promise = executeWithRetry(fn, opts({ maxRetries: 2 }));
+    await vi.runAllTimersAsync();
+    const out = await promise;
+    expect(out.result).toBeUndefined();
+    expect(out.lastError).toBe(err);
+    expect(out.retryCount).toBe(2);
+    expect(out.wasRetried).toBe(true);
+    expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
+    vi.useRealTimers();
+  });
+});