test(cover): add coverage for cover/formatters and cover/type

cover/formatters.test.mts: 17 tests covering every emoji threshold,
default/json/simple format paths, NaN handling, type-coverage in
overall average.

cover/type.test.mts: 10 tests covering successful parse, unparseable
output, spawn-failure null/throw paths, cwd validation, default
process.cwd(). spawn is mocked at the package specifier.

Author: jdalton

test/unit/cover/formatters.test.mts

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Unit tests for coverage output formatters.
+ *
+ * Covers `formatCoverage` (default/simple/json formats) and
+ * `getCoverageEmoji` (every threshold band).
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import {
+  formatCoverage,
+  getCoverageEmoji,
+} from '@socketsecurity/lib/cover/formatters'
+
+const sampleCode = {
+  statements: { covered: 85, total: 100, percent: '85.00' },
+  branches: { covered: 80, total: 100, percent: '80.00' },
+  functions: { covered: 90, total: 100, percent: '90.00' },
+  lines: { covered: 88, total: 100, percent: '88.00' },
+}
+
+describe('cover/formatters', () => {
+  describe('getCoverageEmoji', () => {
+    it('returns rocket for >= 99%', () => {
+      expect(getCoverageEmoji(99)).toBe(' 🚀')
+      expect(getCoverageEmoji(100)).toBe(' 🚀')
+    })
+
+    it('returns target for >= 95%', () => {
+      expect(getCoverageEmoji(95)).toBe(' 🎯')
+      expect(getCoverageEmoji(98.99)).toBe(' 🎯')
+    })
+
+    it('returns sparkles for >= 90%', () => {
+      expect(getCoverageEmoji(90)).toBe(' ✨')
+      expect(getCoverageEmoji(94.99)).toBe(' ✨')
+    })
+
+    it('returns heart for >= 85%', () => {
+      expect(getCoverageEmoji(85)).toBe(' 💚')
+      expect(getCoverageEmoji(89.99)).toBe(' 💚')
+    })
+
+    it('returns check for >= 80%', () => {
+      expect(getCoverageEmoji(80)).toBe(' ✅')
+    })
+
+    it('returns green-circle for >= 70%', () => {
+      expect(getCoverageEmoji(70)).toBe(' 🟢')
+    })
+
+    it('returns yellow-circle for >= 60%', () => {
+      expect(getCoverageEmoji(60)).toBe(' 🟡')
+    })
+
+    it('returns hammer for >= 50%', () => {
+      expect(getCoverageEmoji(50)).toBe(' 🔨')
+    })
+
+    it('returns warning for < 50%', () => {
+      expect(getCoverageEmoji(49)).toBe(' ⚠️')
+      expect(getCoverageEmoji(0)).toBe(' ⚠️')
+    })
+
+    it('handles negative percentages by returning empty string', () => {
+      // No threshold matches; .find returns undefined → '' fallback.
+      expect(getCoverageEmoji(-1)).toBe('')
+    })
+  })
+
+  describe('formatCoverage', () => {
+    it('produces a default human-readable report', () => {
+      const out = formatCoverage({ code: sampleCode })
+      expect(out).toContain('Code Coverage:')
+      expect(out).toContain('Statements: 85.00%')
+      expect(out).toContain('Branches: 80.00%')
+      expect(out).toContain('Functions: 90.00%')
+      expect(out).toContain('Lines: 88.00%')
+      expect(out).toContain('Overall: 85.75%')
+    })
+
+    it('returns JSON when format=json', () => {
+      const out = formatCoverage({ code: sampleCode, format: 'json' })
+      const parsed = JSON.parse(out)
+      expect(parsed.code).toEqual(sampleCode)
+    })
+
+    it('returns just the overall percent when format=simple', () => {
+      const out = formatCoverage({ code: sampleCode, format: 'simple' })
+      expect(out).toBe('85.75')
+    })
+
+    it('includes type coverage section when present', () => {
+      const out = formatCoverage({
+        code: sampleCode,
+        type: { covered: 1500, total: 2000, percent: '75.00' },
+      })
+      expect(out).toContain('Type Coverage:')
+      expect(out).toContain('75.00% (1500/2000)')
+    })
+
+    it('includes type in overall average when present', () => {
+      const out = formatCoverage({
+        code: sampleCode,
+        type: { covered: 5, total: 10, percent: '50.00' },
+        format: 'simple',
+      })
+      // average of (85, 80, 90, 88, 50) = 78.6
+      expect(out).toBe('78.60')
+    })
+
+    it('handles NaN percent values as 0', () => {
+      const broken = {
+        statements: { covered: 0, total: 0, percent: 'NaN' },
+        branches: { covered: 0, total: 0, percent: 'NaN' },
+        functions: { covered: 0, total: 0, percent: 'NaN' },
+        lines: { covered: 0, total: 0, percent: 'NaN' },
+      }
+      const out = formatCoverage({ code: broken, format: 'simple' })
+      expect(out).toBe('0.00')
+    })
+
+    it('appends an emoji to the overall line in default format', () => {
+      const out = formatCoverage({ code: sampleCode })
+      // 85.75% overall → 💚 band.
+      expect(out).toContain('💚')
+    })
+  })
+})

test/unit/cover/type.test.mts

@@ -0,0 +1,128 @@
+/**
+ * @fileoverview Unit tests for TypeScript type-coverage helper.
+ *
+ * Mocks `spawn` from `../../src/spawn` so tests don't need the
+ * `type-coverage` binary installed. Covers:
+ *   - Successful parse of "covered / total percent%" output
+ *   - null on unparseable output (no match, partial match)
+ *   - null on spawn failure when generateIfMissing=false (default)
+ *   - Throws when generateIfMissing=true and spawn fails
+ *   - Throws when cwd is empty string (validation guard)
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Mock spawn at the package specifier — src resolution is enabled in
+// vitest.config.mts via the 'source' export condition.
+vi.mock('@socketsecurity/lib/spawn')
+
+import { spawn } from '@socketsecurity/lib/spawn'
+import { getTypeCoverage } from '@socketsecurity/lib/cover/type'
+
+describe('cover/type', () => {
+  beforeEach(() => {
+    vi.mocked(spawn).mockReset()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('getTypeCoverage', () => {
+    it('parses successful spawn output', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: Buffer.from('1234 / 5678 21.74%'),
+        stderr: Buffer.from(''),
+      } as any)
+      const result = await getTypeCoverage({ cwd: '/some/path' })
+      expect(result).toEqual({ covered: 1234, total: 5678, percent: '21.74' })
+    })
+
+    it('parses output with leading whitespace and other text', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: Buffer.from('some files\n  500 / 1000 50.00%\nsome more text'),
+        stderr: Buffer.from(''),
+      } as any)
+      const result = await getTypeCoverage({ cwd: '/some/path' })
+      expect(result).toEqual({ covered: 500, total: 1000, percent: '50.00' })
+    })
+
+    it('returns null when output is unparseable', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: Buffer.from('no metrics here'),
+        stderr: Buffer.from(''),
+      } as any)
+      const result = await getTypeCoverage({ cwd: '/some/path' })
+      expect(result).toBeNull()
+    })
+
+    it('returns null when spawn output is empty', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: undefined,
+        stderr: Buffer.from(''),
+      } as any)
+      const result = await getTypeCoverage({ cwd: '/some/path' })
+      expect(result).toBeNull()
+    })
+
+    it('returns null when spawn rejects and generateIfMissing=false', async () => {
+      vi.mocked(spawn).mockRejectedValueOnce(new Error('command not found'))
+      const result = await getTypeCoverage({
+        cwd: '/some/path',
+        generateIfMissing: false,
+      })
+      expect(result).toBeNull()
+    })
+
+    it('returns null when spawn rejects and generateIfMissing is omitted (default false)', async () => {
+      vi.mocked(spawn).mockRejectedValueOnce(new Error('not installed'))
+      const result = await getTypeCoverage({ cwd: '/some/path' })
+      expect(result).toBeNull()
+    })
+
+    it('throws when spawn rejects and generateIfMissing=true', async () => {
+      vi.mocked(spawn).mockRejectedValueOnce(new Error('not installed'))
+      await expect(
+        getTypeCoverage({ cwd: '/some/path', generateIfMissing: true }),
+      ).rejects.toThrow(/Unable to generate type coverage/)
+    })
+
+    it('throws when cwd is empty string', async () => {
+      await expect(getTypeCoverage({ cwd: '' })).rejects.toThrow(
+        /Working directory is required/,
+      )
+    })
+
+    it('uses process.cwd() when no cwd provided', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: Buffer.from('1 / 1 100.00%'),
+        stderr: Buffer.from(''),
+      } as any)
+      // Should resolve cleanly without throwing the cwd-required guard.
+      const result = await getTypeCoverage()
+      expect(result).toEqual({ covered: 1, total: 1, percent: '100.00' })
+    })
+
+    it('passes --detail to type-coverage', async () => {
+      vi.mocked(spawn).mockResolvedValueOnce({
+        code: 0,
+        signal: null,
+        stdout: Buffer.from('100 / 200 50.00%'),
+        stderr: Buffer.from(''),
+      } as any)
+      await getTypeCoverage({ cwd: '/x' })
+      expect(vi.mocked(spawn).mock.calls[0]?.[0]).toBe('type-coverage')
+      expect(vi.mocked(spawn).mock.calls[0]?.[1]).toEqual(['--detail'])
+    })
+  })
+})