@opensip-tools/fitness 1.0.4

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

@@ -0,0 +1,243 @@
+import { NotFoundError } from '@opensip-tools/core';
+import { describe, it, expect } from 'vitest';
+
+import { CheckRegistry } from '../../framework/registry.js';
+
+import type { Check } from '../../framework/check-types.js';
+
+/** Create a minimal Check stub for testing the registry. */
+function makeCheck(overrides: {
+  slug: string;
+  tags?: string[];
+  disabled?: boolean;
+  id?: string;
+}): Check {
+  return {
+    config: {
+      id: overrides.id ?? `id-${overrides.slug}`,
+      slug: overrides.slug,
+      tags: overrides.tags ?? ['quality'],
+      description: `Check: ${overrides.slug}`,
+      analysisMode: 'analyze',
+      scope: { include: [], exclude: [] },
+      itemType: 'file' as any,
+      disabled: overrides.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: [] }),
+    getMatcher: () => ({ matches: () => true }),
+  } as unknown as Check;
+}
+
+describe('CheckRegistry', () => {
+  describe('register and get', () => {
+    it('registers and retrieves a check by slug', () => {
+      const registry = new CheckRegistry();
+      const check = makeCheck({ slug: 'my-check' });
+      registry.register(check);
+      expect(registry.get('my-check')).toBe(check);
+    });
+
+    it('throws NotFoundError for missing slug', () => {
+      const registry = new CheckRegistry();
+      expect(() => registry.get('nonexistent')).toThrowError(NotFoundError);
+      expect(() => registry.get('nonexistent')).toThrowError('Check not found: nonexistent');
+    });
+  });
+
+  describe('has', () => {
+    it('returns true for registered check', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'exists' }));
+      expect(registry.has('exists')).toBe(true);
+    });
+
+    it('returns false for unregistered check', () => {
+      const registry = new CheckRegistry();
+      expect(registry.has('nope')).toBe(false);
+    });
+  });
+
+  describe('duplicate handling', () => {
+    it('silently skips duplicate registration', () => {
+      const registry = new CheckRegistry();
+      const check1 = makeCheck({ slug: 'dup', id: 'first' });
+      const check2 = makeCheck({ slug: 'dup', id: 'second' });
+      registry.register(check1);
+      registry.register(check2);
+      // First registration wins
+      expect(registry.get('dup').config.id).toBe('first');
+      expect(registry.size).toBe(1);
+    });
+  });
+
+  describe('list', () => {
+    it('returns all registered checks', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'a' }));
+      registry.register(makeCheck({ slug: 'b' }));
+      registry.register(makeCheck({ slug: 'c' }));
+      expect(registry.list()).toHaveLength(3);
+    });
+
+    it('returns empty array when no checks registered', () => {
+      const registry = new CheckRegistry();
+      expect(registry.list()).toEqual([]);
+    });
+  });
+
+  describe('listEnabled', () => {
+    it('excludes disabled checks', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'active' }));
+      registry.register(makeCheck({ slug: 'off', disabled: true }));
+      registry.register(makeCheck({ slug: 'also-active' }));
+
+      const enabled = registry.listEnabled();
+      expect(enabled).toHaveLength(2);
+      expect(enabled.map(c => c.config.slug)).toEqual(['active', 'also-active']);
+    });
+
+    it('returns all checks when none are disabled', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'x' }));
+      registry.register(makeCheck({ slug: 'y' }));
+      expect(registry.listEnabled()).toHaveLength(2);
+    });
+  });
+
+  describe('byTag', () => {
+    it('filters enabled checks by tag', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'sec1', tags: ['security'] }));
+      registry.register(makeCheck({ slug: 'qual1', tags: ['quality'] }));
+      registry.register(makeCheck({ slug: 'sec2', tags: ['security'] }));
+      registry.register(makeCheck({ slug: 'sec-off', tags: ['security'], disabled: true }));
+
+      const securityChecks = registry.byTag('security');
+      expect(securityChecks).toHaveLength(2);
+      expect(securityChecks.map(c => c.config.slug)).toEqual(['sec1', 'sec2']);
+    });
+
+    it('returns empty array for unknown tag', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'a', tags: ['quality'] }));
+      expect(registry.byTag('nonexistent')).toEqual([]);
+    });
+  });
+
+  describe('getBySlug', () => {
+    it('returns the check when found', () => {
+      const registry = new CheckRegistry();
+      const check = makeCheck({ slug: 'findme' });
+      registry.register(check);
+      expect(registry.getBySlug('findme')).toBe(check);
+    });
+
+    it('returns undefined when not found (no throw)', () => {
+      const registry = new CheckRegistry();
+      expect(registry.getBySlug('missing')).toBeUndefined();
+    });
+  });
+
+  describe('listSlugs', () => {
+    it('returns all registered slugs', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'alpha' }));
+      registry.register(makeCheck({ slug: 'beta' }));
+      registry.register(makeCheck({ slug: 'gamma' }));
+
+      const slugs = registry.listSlugs();
+      expect(slugs).toEqual(['alpha', 'beta', 'gamma']);
+    });
+
+    it('returns empty array when empty', () => {
+      const registry = new CheckRegistry();
+      expect(registry.listSlugs()).toEqual([]);
+    });
+  });
+
+  describe('size', () => {
+    it('reflects current count', () => {
+      const registry = new CheckRegistry();
+      expect(registry.size).toBe(0);
+      registry.register(makeCheck({ slug: 'one' }));
+      expect(registry.size).toBe(1);
+      registry.register(makeCheck({ slug: 'two' }));
+      expect(registry.size).toBe(2);
+    });
+  });
+
+  describe('namespace support', () => {
+    it('registers with namespace as namespace:slug key', () => {
+      const registry = new CheckRegistry();
+      const check = makeCheck({ slug: 'my-check' });
+      registry.register(check, 'my-plugin');
+      expect(registry.get('my-plugin:my-check')).toBe(check);
+    });
+
+    it('resolves bare slug to namespaced check when unambiguous', () => {
+      const registry = new CheckRegistry();
+      const check = makeCheck({ slug: 'my-check' });
+      registry.register(check, 'my-plugin');
+      expect(registry.get('my-check')).toBe(check);
+      expect(registry.getBySlug('my-check')).toBe(check);
+      expect(registry.has('my-check')).toBe(true);
+    });
+
+    it('allows same slug in different namespaces', () => {
+      const registry = new CheckRegistry();
+      const check1 = makeCheck({ slug: 'check', id: 'first' });
+      const check2 = makeCheck({ slug: 'check', id: 'second' });
+      registry.register(check1, 'plugin-a');
+      registry.register(check2, 'plugin-b');
+      expect(registry.size).toBe(2);
+      expect(registry.get('plugin-a:check').config.id).toBe('first');
+      expect(registry.get('plugin-b:check').config.id).toBe('second');
+    });
+
+    it('returns first registered for ambiguous bare slug', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'dup', id: 'first' }), 'ns-a');
+      registry.register(makeCheck({ slug: 'dup', id: 'second' }), 'ns-b');
+      // Resolves to first registered
+      expect(registry.get('dup').config.id).toBe('first');
+    });
+
+    it('silently skips duplicate namespace:slug registration', () => {
+      const registry = new CheckRegistry();
+      const check1 = makeCheck({ slug: 'x', id: 'first' });
+      const check2 = makeCheck({ slug: 'x', id: 'second' });
+      registry.register(check1, 'ns');
+      registry.register(check2, 'ns');
+      expect(registry.size).toBe(1);
+      expect(registry.get('ns:x').config.id).toBe('first');
+    });
+
+    it('listSlugs returns namespaced keys', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'a' }), 'pkg');
+      registry.register(makeCheck({ slug: 'b' }));
+      expect(registry.listSlugs()).toEqual(['pkg:a', 'b']);
+    });
+
+    it('listByBareSlug returns all checks with that slug', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'check', id: '1' }), 'ns-a');
+      registry.register(makeCheck({ slug: 'check', id: '2' }), 'ns-b');
+      registry.register(makeCheck({ slug: 'other' }), 'ns-a');
+      const results = registry.listByBareSlug('check');
+      expect(results).toHaveLength(2);
+      expect(results.map(c => c.config.id)).toEqual(['1', '2']);
+    });
+
+    it('returns undefined for unknown namespaced slug', () => {
+      const registry = new CheckRegistry();
+      registry.register(makeCheck({ slug: 'a' }), 'pkg');
+      expect(registry.getBySlug('other:a')).toBeUndefined();
+    });
+  });
+});

package/src/framework/__tests__/result-builder.test.ts

@@ -0,0 +1,178 @@
+import { createSignal } from '@opensip-tools/core';
+import { describe, expect, it } from 'vitest';
+
+import { ResultBuilder, extractSnippet, getLineNumber, isAPIFile } from '../result-builder.js';
+
+import type { Signal } from '@opensip-tools/core';
+
+const sig = (overrides: Partial<Parameters<typeof createSignal>[0]> = {}): Signal =>
+  createSignal({
+    source: 'fitness',
+    provider: 'opensip',
+    severity: 'high',
+    category: 'warning',
+    ruleId: 'fit:test',
+    message: 'something',
+    code: { file: 'src/x.ts', line: 1 },
+    ...overrides,
+  });
+
+describe('ResultBuilder', () => {
+  it('builds an empty result with totalItems', () => {
+    const result = ResultBuilder.create({ checkId: 'c1', itemType: 'files' })
+      .totalItems(10)
+      .build();
+    expect(result.signals.length).toBe(0);
+    expect(result.metadata.totalItems).toBe(10);
+  });
+
+  it('chains addSignal and addSignals', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    builder.addSignal(sig({ severity: 'high' }));
+    builder.addSignals([sig({ severity: 'medium' }), sig({ severity: 'medium' })]);
+    expect(builder.signalCount).toBe(3);
+  });
+
+  it('addSignals with empty array is a no-op', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    builder.addSignals([]);
+    expect(builder.signalCount).toBe(0);
+  });
+
+  it('separates errors from warnings via signal severity', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    builder.addSignal(sig({ severity: 'high' }));
+    builder.addSignal(sig({ severity: 'medium' }));
+    expect(builder.errorCount).toBe(1);
+    expect(builder.warningCount).toBe(1);
+  });
+
+  it('hasSignals reflects the signal collection', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    expect(builder.hasSignals).toBe(false);
+    builder.addSignal(sig());
+    expect(builder.hasSignals).toBe(true);
+  });
+
+  it('willPass is true when there are no errors', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    expect(builder.willPass).toBe(true);
+    builder.addSignal(sig({ severity: 'medium' }));
+    expect(builder.willPass).toBe(true); // warnings don't fail
+    builder.addSignal(sig({ severity: 'high' }));
+    expect(builder.willPass).toBe(false);
+  });
+
+  it('ignoredCount and incrementIgnored both update internal state', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    builder.ignoredCount(5);
+    builder.incrementIgnored();
+    builder.incrementIgnored(2);
+    builder.totalItems(1);
+    const built = builder.build();
+    expect(built.ignoredCount).toBe(8);
+  });
+
+  it('duration is included on the built result', () => {
+    const result = ResultBuilder.create({ checkId: 'c1', itemType: 'files' })
+      .totalItems(1)
+      .duration(123)
+      .build();
+    expect(result.metadata.durationMs).toBe(123);
+  });
+
+  it('filesScanned is included on the built result', () => {
+    const result = ResultBuilder.create({ checkId: 'c1', itemType: 'files' })
+      .totalItems(5)
+      .filesScanned(3)
+      .build();
+    expect(result.metadata.filesScanned).toBe(3);
+  });
+
+  it('extra payload merges into the built result', () => {
+    const result = ResultBuilder.create({ checkId: 'c1', itemType: 'files' })
+      .totalItems(1)
+      .extra({ foo: 'bar' })
+      .extra({ baz: 1 })
+      .build();
+    expect(result.metadata.extra).toEqual({ foo: 'bar', baz: 1 });
+  });
+
+  it('buildError returns an error result with the given message', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    const out = builder.buildError('something exploded', new Error('boom'));
+    expect(out.signals.length).toBe(0);
+    expect(out.info.label).toMatch(/error|exploded/i);
+  });
+
+  it('clamps compliance to 0 when violations span more files than scanned', () => {
+    const builder = ResultBuilder.create({ checkId: 'c1', itemType: 'files' });
+    builder.totalItems(2);
+    builder.addSignal(sig({ code: { file: 'a' } }));
+    builder.addSignal(sig({ code: { file: 'b' } }));
+    builder.addSignal(sig({ code: { file: 'c' } }));
+    const result = builder.build();
+    expect(result.metadata.totalItems).toBe(2);
+    // No negative value should appear in info label
+    expect(result.info.label).not.toContain('-');
+  });
+
+  it('builds violations-mode info when totalItems is 0', () => {
+    const result = ResultBuilder.create({ checkId: 'c1', itemType: 'files' })
+      .addSignal(sig({ severity: 'high' }))
+      .build();
+    expect(result.metadata.totalItems).toBe(0);
+    expect(result.signals.length).toBe(1);
+  });
+});
+
+describe('extractSnippet', () => {
+  const content = ['line1', 'line2', 'line3', 'line4', 'line5'].join('\n');
+
+  it('extracts default 2 context lines around the target', () => {
+    const out = extractSnippet(content, 3);
+    expect(out.snippet).toContain('1 | line1');
+    expect(out.snippet).toContain('5 | line5');
+  });
+
+  it('clamps to start of file', () => {
+    const out = extractSnippet(content, 1);
+    expect(out.snippet.split('\n')[0]).toBe('1 | line1');
+  });
+
+  it('clamps to end of file', () => {
+    const out = extractSnippet(content, 5);
+    expect(out.snippet).toContain('5 | line5');
+  });
+
+  it('honors a custom contextLines value', () => {
+    const out = extractSnippet(content, 3, 0);
+    expect(out.snippet).toBe('3 | line3');
+  });
+});
+
+describe('getLineNumber', () => {
+  it('returns the line number for a character index', () => {
+    const text = 'line1\nline2\nline3';
+    expect(getLineNumber(text, 0)).toBe(1);
+    expect(getLineNumber(text, 6)).toBe(2);
+    expect(getLineNumber(text, 12)).toBe(3);
+  });
+
+  it('returns 1 for negative indices', () => {
+    expect(getLineNumber('abc', -5)).toBe(1);
+  });
+});
+
+describe('isAPIFile', () => {
+  it.each([
+    ['src/api/users.ts', true],
+    ['src/routes/foo.ts', true],
+    ['src/users-handler.ts', true],
+    ['src/users.handler.ts', true],
+    ['src/lib/util.ts', false],
+    ['src/components/Button.tsx', false],
+  ])('isAPIFile(%s) === %s', (path, expected) => {
+    expect(isAPIFile(path)).toBe(expected);
+  });
+});

package/src/framework/__tests__/scope-resolver.test.ts

@@ -0,0 +1,208 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { TargetRegistry } from '../../targets/target-registry.js';
+import { buildScopeBasedFileMap } from '../scope-resolver.js';
+
+import type { Target, TargetsConfig } from '../../targets/types.js';
+
+let testDir: string;
+
+function fixture(rel: string, content = ''): string {
+  const abs = join(testDir, rel);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, content);
+  return abs;
+}
+
+function makeRegistry(targets: Target[]): TargetRegistry {
+  const reg = new TargetRegistry();
+  for (const t of targets) reg.register(t);
+  return reg;
+}
+
+function makeTarget(name: string, opts: Partial<Target['config']>): Target {
+  return {
+    config: {
+      name,
+      description: name,
+      include: opts.include ?? [],
+      exclude: opts.exclude ?? [],
+      ...(opts.languages && { languages: opts.languages }),
+      ...(opts.concerns && { concerns: opts.concerns }),
+    },
+  };
+}
+
+function makeConfig(overrides: Partial<TargetsConfig> = {}): TargetsConfig {
+  return {
+    globalExcludes: overrides.globalExcludes ?? [],
+    checkOverrides: overrides.checkOverrides ?? {},
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+   
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-scope-resolver-'));
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe('buildScopeBasedFileMap', () => {
+  it('returns an empty map when no checks have scopes or overrides', () => {
+    const registry = makeRegistry([
+      makeTarget('src', { include: ['src/**/*.ts'], languages: ['typescript'], concerns: ['backend'] }),
+    ]);
+    const out = buildScopeBasedFileMap([], registry, makeConfig(), testDir);
+    expect(out.size).toBe(0);
+  });
+
+  it('matches checks to targets by scope.languages + concerns', () => {
+    fixture('src/a.ts');
+    fixture('src/b.ts');
+    fixture('lib/c.rs');
+
+    const registry = makeRegistry([
+      makeTarget('ts-src', {
+        include: ['src/**/*.ts'],
+        languages: ['typescript'],
+        concerns: ['backend'],
+      }),
+      makeTarget('rs-lib', {
+        include: ['lib/**/*.rs'],
+        languages: ['rust'],
+        concerns: ['backend'],
+      }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'ts-check', scope: { languages: ['typescript'], concerns: ['backend'] } }],
+      registry,
+      makeConfig(),
+      testDir,
+    );
+
+    const tsFiles = out.get('ts-check');
+    expect(tsFiles).toBeDefined();
+    expect(tsFiles?.length).toBe(2);
+    expect(tsFiles?.every((f) => f.endsWith('.ts'))).toBe(true);
+  });
+
+  it('returns empty when scope matches no targets', () => {
+    fixture('src/a.ts');
+    const registry = makeRegistry([
+      makeTarget('ts-src', { include: ['src/**/*.ts'], languages: ['typescript'], concerns: ['backend'] }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'cobol-check', scope: { languages: ['cobol'], concerns: ['mainframe'] } }],
+      registry,
+      makeConfig(),
+      testDir,
+    );
+
+    expect(out.get('cobol-check')).toEqual([]);
+  });
+
+  it('uses checkOverrides when present', () => {
+    fixture('src/a.ts');
+    fixture('test/b.ts');
+    const registry = makeRegistry([
+      makeTarget('src', { include: ['src/**/*.ts'] }),
+      makeTarget('test', { include: ['test/**/*.ts'] }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'narrow-check', scope: { languages: [], concerns: [] } }],
+      registry,
+      makeConfig({ checkOverrides: { 'narrow-check': 'test' } }),
+      testDir,
+    );
+
+    const files = out.get('narrow-check');
+    expect(files?.length).toBe(1);
+    expect(files?.[0]?.endsWith('test/b.ts')).toBe(true);
+  });
+
+  it('honors checkOverrides that point to multiple targets', () => {
+    fixture('src/a.ts');
+    fixture('test/b.ts');
+    const registry = makeRegistry([
+      makeTarget('src', { include: ['src/**/*.ts'] }),
+      makeTarget('test', { include: ['test/**/*.ts'] }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'broad-check', scope: { languages: [], concerns: [] } }],
+      registry,
+      makeConfig({ checkOverrides: { 'broad-check': ['src', 'test'] } }),
+      testDir,
+    );
+
+    expect(out.get('broad-check')?.length).toBe(2);
+  });
+
+  it('applies globalExcludes during pre-resolution', () => {
+    fixture('src/a.ts');
+    fixture('src/ignore-me/b.ts');
+    const registry = makeRegistry([
+      makeTarget('src', { include: ['src/**/*.ts'], languages: ['typescript'], concerns: ['backend'] }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'check', scope: { languages: ['typescript'], concerns: ['backend'] } }],
+      registry,
+      makeConfig({ globalExcludes: ['**/ignore-me/**'] }),
+      testDir,
+    );
+
+    const files = out.get('check') ?? [];
+    expect(files.some((f) => f.includes('ignore-me'))).toBe(false);
+    expect(files.length).toBe(1);
+  });
+
+  it('applies per-target excludes', () => {
+    fixture('src/a.ts');
+    fixture('src/skip.ts');
+    const registry = makeRegistry([
+      makeTarget('src', {
+        include: ['src/**/*.ts'],
+        exclude: ['**/skip.ts'],
+        languages: ['typescript'],
+        concerns: ['backend'],
+      }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'check', scope: { languages: ['typescript'], concerns: ['backend'] } }],
+      registry,
+      makeConfig(),
+      testDir,
+    );
+
+    const files = out.get('check') ?? [];
+    expect(files.some((f) => f.endsWith('skip.ts'))).toBe(false);
+  });
+
+  it('skips checks without a scope and without an override', () => {
+    fixture('src/a.ts');
+    const registry = makeRegistry([
+      makeTarget('src', { include: ['src/**/*.ts'] }),
+    ]);
+
+    const out = buildScopeBasedFileMap(
+      [{ slug: 'unscoped' }],
+      registry,
+      makeConfig(),
+      testDir,
+    );
+
+    expect(out.has('unscoped')).toBe(false);
+  });
+});

package/src/framework/__tests__/severity-mapping.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { mapFindingSeverity, mapTagsToSignalCategory } from '../severity-mapping.js';
+
+describe('mapFindingSeverity', () => {
+  it('maps "error" to "high"', () => {
+    expect(mapFindingSeverity('error')).toBe('high');
+  });
+
+  it('maps "warning" to "medium"', () => {
+    expect(mapFindingSeverity('warning')).toBe('medium');
+  });
+
+  it('falls back to "medium" for unknown severities', () => {
+    // @ts-expect-error — exercising the runtime default
+    expect(mapFindingSeverity('whatever')).toBe('medium');
+  });
+});
+
+describe('mapTagsToSignalCategory', () => {
+  it.each([
+    ['security', 'security'],
+    ['performance', 'performance'],
+    ['architecture', 'architecture'],
+    ['resilience', 'resilience'],
+    ['testing', 'testing'],
+    ['documentation', 'documentation'],
+  ])('maps %s tag to %s category', (tag, category) => {
+    expect(mapTagsToSignalCategory([tag])).toBe(category);
+  });
+
+  it('maps "quality" tag to "warning" category', () => {
+    expect(mapTagsToSignalCategory(['quality'])).toBe('warning');
+  });
+
+  it('falls back to "warning" when no recognized tag matches', () => {
+    expect(mapTagsToSignalCategory(['custom-tag'])).toBe('warning');
+  });
+
+  it('returns "warning" for an empty tag list', () => {
+    expect(mapTagsToSignalCategory([])).toBe('warning');
+  });
+
+  it('uses the first matching tag (priority order)', () => {
+    // 'quality' comes after 'security' lexically but the function iterates the
+    // input array in order, so 'security' wins here.
+    expect(mapTagsToSignalCategory(['quality', 'security'])).toBe('warning');
+    expect(mapTagsToSignalCategory(['security', 'quality'])).toBe('security');
+  });
+});