chore: add a bunch of CLI tests

src/cli/arguments.test.ts

@@ -0,0 +1,121 @@
+import { test, expect } from '@playwright/test'
+import { parse_arguments, validate_arguments } from './arguments'
+
+test.describe('--coverage-dir', () => {
+	let cov = '--min-line-coverage=1'
+
+	test('missing --coverage-dir', () => {
+		expect(() => validate_arguments(parse_arguments([cov]))).toThrowError()
+	})
+
+	test('empty --coverage-dir', () => {
+		expect(() => validate_arguments(parse_arguments([cov, '--coverage-dir']))).toThrowError()
+	})
+
+	test('valid --coverage-dir=path/to/coverage', () => {
+		let result = validate_arguments(parse_arguments([cov, '--coverage-dir=/path/to/coverage']))
+		expect(result['coverage-dir']).toEqual('/path/to/coverage')
+	})
+})
+
+test.describe('--min-line-coverage', () => {
+	let dir = '--coverage-dir=coverage'
+
+	test('missing --min-line-coverage', () => {
+		expect(() => validate_arguments(parse_arguments([dir]))).toThrowError()
+	})
+
+	test('empty --min-line-coverage', () => {
+		expect(() => validate_arguments(parse_arguments([dir, '--min-line-coverage']))).toThrowError()
+	})
+
+	test('invalid --min-line-coverage=-1', () => {
+		expect(() => validate_arguments(parse_arguments([dir, '--min-line-coverage=-1']))).toThrowError()
+	})
+
+	test('valid --min-line-coverage=.8', () => {
+		let result = validate_arguments(parse_arguments([dir, '--min-line-coverage=.8']))
+		expect(result['min-line-coverage']).toEqual(0.8)
+	})
+})
+
+test.describe('--min-file-line-coverage', () => {
+	let args = ['--coverage-dir=coverage', '--min-line-coverage=1']
+
+	test('missing --min-file-line-coverage', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args]))).not.toThrowError()
+		expect.soft(validate_arguments(parse_arguments([...args]))['min-file-line-coverage']).toEqual(0)
+	})
+
+	test('empty --min-file-line-coverage', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args, '--min-file-line-coverage']))).toThrowError()
+	})
+
+	test('invalid --min-file-line-coverage=-1', () => {
+		expect(() => validate_arguments(parse_arguments([...args, '--min-file-line-coverage=-1']))).toThrowError()
+	})
+
+	test('valid --min-file-line-coverage=.8', () => {
+		let result = validate_arguments(parse_arguments([...args, '--min-file-line-coverage=.8']))
+		expect(result['min-file-line-coverage']).toEqual(0.8)
+	})
+})
+
+test.describe('--reporter', () => {
+	let args = ['--coverage-dir=coverage', '--min-line-coverage=1']
+
+	test('missing --reporter', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args]))).not.toThrowError()
+		expect.soft(validate_arguments(parse_arguments([...args]))['reporter']).toEqual('pretty')
+	})
+
+	test('empty --reporter', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args, '--reporter']))).toThrowError()
+	})
+
+	test('invalid --reporter=test', () => {
+		expect(() => validate_arguments(parse_arguments([...args, '--reporter=test']))).toThrowError()
+	})
+
+	test('valid --reporter=pretty', () => {
+		let result = validate_arguments(parse_arguments([...args, '--reporter=pretty']))
+		expect(result['reporter']).toEqual('pretty')
+	})
+
+	test('valid --reporter=tap', () => {
+		let result = validate_arguments(parse_arguments([...args, '--reporter=tap']))
+		expect(result['reporter']).toEqual('tap')
+	})
+})
+
+test.describe('--show-uncovered', () => {
+	let args = ['--coverage-dir=coverage', '--min-line-coverage=1']
+
+	test('missing --show-uncovered', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args]))).not.toThrowError()
+		expect.soft(validate_arguments(parse_arguments([...args]))['show-uncovered']).toEqual('violations')
+	})
+
+	test('empty --show-uncovered', () => {
+		expect.soft(() => validate_arguments(parse_arguments([...args, '--show-uncovered']))).toThrowError()
+	})
+
+	test('invalid --show-uncovered=test', () => {
+		expect(() => validate_arguments(parse_arguments([...args, '--show-uncovered=test']))).toThrowError()
+	})
+
+	test('valid --show-uncovered=none', () => {
+		let result = validate_arguments(parse_arguments([...args, '--show-uncovered=none']))
+		expect(result['show-uncovered']).toEqual('none')
+	})
+
+	test('valid --show-uncovered=violations', () => {
+		let result = validate_arguments(parse_arguments([...args, '--show-uncovered=violations']))
+		expect(result['show-uncovered']).toEqual('violations')
+	})
+
+	test('valid --show-uncovered=all', () => {
+		let result = validate_arguments(parse_arguments([...args, '--show-uncovered=all']))
+		expect(result['show-uncovered']).toEqual('all')
+	})
+})

src/cli/cli.ts

@@ -7,10 +7,11 @@ import { print as pretty } from './reporters/pretty.js'
 import { print as tap } from './reporters/tap.js'
 
 async function cli(cli_args: string[]) {
-	const args = parse_arguments(cli_args)
-	let params = validate_arguments(args)
+	console.log(cli_args)
+	let params = validate_arguments(parse_arguments(cli_args))
+	console.log(params)
 	let coverage_data = await read(params['coverage-dir'])
-	let report = await program(
+	let report = program(
 		{
 			min_file_coverage: params['min-line-coverage'],
 			min_file_line_coverage: params['min-file-line-coverage'],

src/cli/program.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from '@playwright/test'
+import { program } from './program'
+import { Coverage } from '../lib'
+
+// Line coverage: 4 covered, 3 uncovered
+let coverage = [
+	{
+		url: 'example.com',
+		text: 'abcdefg { color: red; } abcdefg { color: green; }',
+		ranges: [{ start: 0, end: 23 }],
+	},
+] satisfies Coverage[]
+
+test('returns context', () => {
+	let result = program({ min_file_coverage: 0.5 }, coverage)
+	expect.soft(result.context.coverage.covered_lines).toEqual(4)
+	expect.soft(result.context.coverage.total_files_found).toEqual(1)
+})
+
+test.describe('--min-file-coverage', () => {
+	test('Success: --min-file-coverage=0.5', () => {
+		let result = program({ min_file_coverage: 0.5 }, coverage)
+		expect(result.report.ok).toBeTruthy()
+	})
+
+	test('Failure: --min-file-coverage=1', () => {
+		let result = program({ min_file_coverage: 1 }, coverage)
+		expect(result.report.ok).toBeFalsy()
+	})
+})
+
+test.describe('--min-file-line-coverage', () => {
+	test('Success: --min-file-line-coverage=0.5', () => {
+		let result = program({ min_file_coverage: 0, min_file_line_coverage: 0.5 }, coverage)
+		expect(result.report.ok).toBeTruthy()
+	})
+
+	test('Failure: --min-file-line-coverage=1', () => {
+		let result = program({ min_file_coverage: 0, min_file_line_coverage: 1 }, coverage)
+		expect(result.report.ok).toBeFalsy()
+	})
+})

src/cli/program.ts

@@ -49,7 +49,7 @@ function validate_min_file_line_coverage(actual: number, expected: number | unde
 	}
 }
 
-export async function program(
+export function program(
 	{
 		min_file_coverage,
 		min_file_line_coverage,
@@ -62,7 +62,7 @@ export async function program(
 	if (coverage_data.length === 0) {
 		throw new MissingDataError()
 	}
-	let coverage = await calculate_coverage(coverage_data)
+	let coverage = calculate_coverage(coverage_data)
 	let min_line_coverage_result = validate_min_line_coverage(coverage.line_coverage_ratio, min_file_coverage)
 	let min_file_line_coverage_result = validate_min_file_line_coverage(
 		Math.min(...coverage.coverage_per_stylesheet.map((sheet) => sheet.line_coverage_ratio)),