lcov-badge2 1.0.3 → 1.1.0

package/src/cli.spec.ts

@@ -0,0 +1,111 @@
+import path from 'path';
+
+import { Arguments, processArguments } from './cli';
+
+describe('CLI', () => {
+    beforeEach(() => {
+        jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        jest.spyOn(process, 'exit').mockImplementation();
+    });
+
+    afterEach(() => {
+        (console.log as jest.Mock).mockReset();
+    });
+
+    describe('When the help argument is passed', () => {
+        describe.each(['-h', '--help'])('When %s is passed', (arg) => {
+            beforeEach(() => {
+                process.argv = ['node', path.join('some', 'path', 'whatever', 'foo.ts'), arg];
+                processArguments();
+            });
+
+            test('it prints the help message', () => {
+                expect(console.log).toHaveBeenCalledTimes(1);
+                expect((console.log as jest.MockedFunction<typeof console.log>).mock.calls[0][0])
+                    .toContain('Usage: foo.ts [-h] [-o OUTPUT] [-l LABEL] input');
+            });
+
+            test('it exits without an error', () => {
+                expect(process.exit).toHaveBeenCalledWith(0);
+            });
+        });
+    });
+
+    describe('When no positional arguments are passed', () => {
+        beforeEach(() => {
+            process.argv = ['node', 'foo.ts', '-l', 'foo'];
+            processArguments();
+        });
+
+        test('it prints an error message', () => {
+            expect(console.error).toHaveBeenCalledWith('Input must be provided');
+        });
+
+        test('it exits with an error', () => {
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('When multiple positional arguments are passed', () => {
+        beforeEach(() => {
+            process.argv = ['node', 'foo.ts', '-l', 'foo', 'bar', 'baz'];
+            processArguments();
+        });
+
+        test('it prints an error message', () => {
+            expect(console.error).toHaveBeenCalledWith('Only one input can be provided');
+        });
+
+        test('it exits with an error', () => {
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('When only an input is provided', () => {
+        let args: Arguments;
+
+        beforeEach(() => {
+            process.argv = ['node', 'foo.ts', 'foo'];
+            args = processArguments();
+        });
+
+        test('it sets the input', () => {
+            expect(args.input).toBe('foo');
+        });
+
+        test('it uses the default label value', () => {
+            expect(args.label).toBe('coverage');
+        });
+
+        test('it uses the default output value', () => {
+            expect(args.output).toBe('badge.svg');
+        });
+    });
+
+    describe('When providing a value for label', () => {
+        let args: Arguments;
+
+        beforeEach(() => {
+            process.argv = ['node', 'foo.ts', '-l', 'my-coverage', 'foo'];
+            args = processArguments();
+        });
+
+        test('it sets the value for label', () => {
+            expect(args.label).toBe('my-coverage');
+        });
+    });
+
+    describe('When providing a value for output', () => {
+        let args: Arguments;
+
+        beforeEach(() => {
+            process.argv = ['node', 'foo.ts', '-o', 'my-badge.svg', 'foo'];
+            args = processArguments();
+        });
+
+        test('it sets the value for label', () => {
+            expect(args.output).toBe('my-badge.svg');
+        });
+    });
+});

package/src/cli.ts

@@ -0,0 +1,80 @@
+import minimist, { ParsedArgs } from 'minimist';
+import buildOptions from 'minimist-options';
+import { basename } from 'path';
+
+export interface Arguments {
+    input: string;
+    label: string;
+    output: string;
+}
+
+const defaultOutputPath = 'badge.svg';
+const defaultLabel = 'coverage';
+
+function exitWithError(message: string): never {
+    console.error(message);
+    process.exit(1);
+}
+
+function printHelp(): never {
+    const message = `Usage: ${basename(process.argv[1])} [-h] [-o OUTPUT] [-l LABEL] input
+
+Positional Arguments:
+  input                 Path to LCOV file to parse
+
+Optional Arguments:
+  -h, --help            Show this help message and exit
+  -o OUTPUT, --output OUTPUT
+                        Output file path (default: ${defaultOutputPath})
+  -l LABEL, --label LABEL
+                        Badge label (default: ${defaultLabel})
+    `;
+    console.log(message);
+    process.exit(0);
+}
+
+function validateArguments(args: ParsedArgs): void {
+    if (!args._.length) {
+        exitWithError('Input must be provided');
+    }
+
+    if (args._.length !== 1) {
+        exitWithError('Only one input can be provided');
+    }
+}
+
+export function processArguments(): Arguments {
+    const options = buildOptions({
+        help: {
+            type: 'boolean',
+            alias: 'h',
+            default: false,
+        },
+        label: {
+            type: 'string',
+            alias: 'l',
+            default: defaultLabel,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            default: defaultOutputPath,
+        },
+        // Special option for positional arguments (`_` in minimist)
+        arguments: 'string',
+    });
+
+    const args = minimist(process.argv.slice(2), options);
+
+    if (args.help) {
+        printHelp();
+    }
+
+    validateArguments(args);
+
+    return {
+        input: args._[0],
+        label: args.label,
+        output: args.output,
+    };
+}

package/src/coverage.spec.ts

@@ -0,0 +1,88 @@
+import parse from 'parse-lcov';
+
+import { getCoverageLevel } from './coverage';
+
+jest.mock('parse-lcov');
+
+describe('Coverage', () => {
+    beforeEach(() => {
+        (parse as jest.MockedFunction<typeof parse>).mockReturnValue([]);
+    });
+
+    test('it reads the file', () => {
+        getCoverageLevel('foo.lcov');
+        expect(parse).toHaveBeenCalledWith('foo.lcov');
+    });
+
+    describe('When there are no lines of code', () => {
+        beforeEach(() => {
+            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
+                {
+                    title: '',
+                    file: '',
+                    functions: { found: 0, hit: 0, details: [] },
+                    branches: { found: 0, hit: 0, details: [] },
+                    lines: { found: 0, hit: 0, details: [] },
+                },
+            ]);
+        });
+
+        test('it returns 100', () => {
+            expect(getCoverageLevel('foo')).toBe(100);
+        });
+    });
+
+    describe('When there are lines of code and none are hit', () => {
+        beforeEach(() => {
+            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
+                {
+                    title: '',
+                    file: '',
+                    functions: { found: 1, hit: 0, details: [] },
+                    branches: { found: 2, hit: 0, details: [] },
+                    lines: { found: 3, hit: 0, details: [] },
+                },
+            ]);
+        });
+
+        test('it returns 0', () => {
+            expect(getCoverageLevel('foo')).toBe(0);
+        });
+    });
+
+    describe('When there are lines of code and all are hit', () => {
+        beforeEach(() => {
+            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
+                {
+                    title: '',
+                    file: '',
+                    functions: { found: 1, hit: 1, details: [] },
+                    branches: { found: 2, hit: 2, details: [] },
+                    lines: { found: 3, hit: 3, details: [] },
+                },
+            ]);
+        });
+
+        test('it returns 0', () => {
+            expect(getCoverageLevel('foo')).toBe(100);
+        });
+    });
+
+    describe('When there are lines of code and some are hit', () => {
+        beforeEach(() => {
+            (parse as jest.MockedFunction<typeof parse>).mockReturnValue([
+                {
+                    title: '',
+                    file: '',
+                    functions: { found: 100, hit: 66, details: [] },
+                    branches: { found: 200, hit: 157, details: [] },
+                    lines: { found: 1234, hit: 963, details: [] },
+                },
+            ]);
+        });
+
+        test('it calculates the coverage', () => {
+            expect(getCoverageLevel('foo')).toBe(74.18);
+        });
+    });
+});

package/src/coverage.ts

@@ -0,0 +1,24 @@
+import parse from 'parse-lcov';
+
+export function getCoverageLevel(lcov: string): number {
+    const coverage = parse(lcov);
+
+    const summary = {
+        lines: { found: 0, hit: 0 },
+        branches: { found: 0, hit: 0 },
+        functions: { found: 0, hit: 0 },
+    };
+    const keys = Object.keys(summary) as (keyof typeof summary)[];
+
+    coverage.forEach((arg) => {
+        keys.forEach((key) => {
+            summary[key].found += arg[key].found;
+            summary[key].hit += arg[key].hit;
+        });
+    });
+
+    return Math.round(keys.reduce((avg, key) => {
+        const found = summary[key].found;
+        return avg + (found > 0 ? summary[key].hit / found * 100 : 100);
+    }, 0) / keys.length * 100) / 100;
+}

package/src/main.spec.ts

@@ -0,0 +1,78 @@
+import { spawnSync, SpawnSyncReturns } from 'child_process';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+import { createBadge } from './badge';
+import { getCoverageLevel } from './coverage';
+import { generateBadge } from './main';
+
+jest.mock('./badge');
+jest.mock('./coverage');
+
+describe('Main', () => {
+    let badgeContents: string;
+
+    beforeEach(async () => {
+        jest.spyOn(fs, 'readFile').mockResolvedValue('some lcov content');
+        (getCoverageLevel as jest.MockedFunction<typeof getCoverageLevel>).mockReturnValue(99.5);
+        (createBadge as jest.MockedFunction<typeof createBadge>).mockResolvedValue('totally an svg');
+
+        badgeContents = await generateBadge('foo.lcov', 'something');
+    });
+
+    test('the main function generates the badge from the input', () => {
+        expect(fs.readFile).toHaveBeenCalledWith('foo.lcov');
+        expect(getCoverageLevel).toHaveBeenCalledWith('some lcov content');
+        expect(createBadge).toHaveBeenCalledWith('something', 99.5);
+    });
+
+    test('it returns the SVG as a string', () => {
+        expect(badgeContents).toBe('totally an svg');
+    });
+
+    describe('Running as a script', () => {
+        const report = `
+            TN:
+            SF:src/badge.ts
+            FN:3,getColor
+            FN:19,createBadge
+            FNF:2
+            FNH:2
+            FNDA:13,getColor
+            FNDA:13,createBadge
+            DA:1,2
+            LF:15
+            LH:15
+            BRDA:4,0,0,2
+            BRF:10
+            BRH:10
+            end_of_record`;
+        let inputFilePath: string;
+        let filePath: string;
+        let result: SpawnSyncReturns<string | Buffer>;
+
+        beforeEach(async () => {
+            const dir = os.tmpdir();
+            filePath = path.join(dir, `badge-${new Date().valueOf()}.svg`);
+            inputFilePath = path.join(dir, `lcov-${new Date().valueOf()}.info`);
+
+            await fs.writeFile(inputFilePath, report);
+
+            result = spawnSync('ts-node', [path.join(__dirname, 'main.ts'), '-o', filePath, inputFilePath]);
+        });
+
+        afterEach(async () => {
+            await fs.rm(filePath);
+            await fs.rm(inputFilePath);
+        });
+
+        test('it exited successfully', () => {
+            expect(result.status).toBe(0);
+        });
+
+        test('it writes the badge file', async () => {
+            await expect(fs.stat(filePath)).resolves.not.toThrow();
+        });
+    });
+});

package/src/main.ts

@@ -0,0 +1,21 @@
+import * as fs from 'fs/promises';
+
+import { createBadge } from './badge';
+import { processArguments } from './cli';
+import { getCoverageLevel } from './coverage';
+
+export async function generateBadge(filename: string, label = 'coverage'): Promise<string> {
+    const input = (await fs.readFile(filename)).toString();
+    const coverage = getCoverageLevel(input);
+    return createBadge(label, coverage);
+}
+
+if (require.main === module) {
+    const args = processArguments();
+    generateBadge(args.input, args.label)
+        .then(async (badge) => fs.writeFile(args.output, badge))
+        .catch((e) => {
+            console.error(e);
+            process.exit(1);
+        });
+}

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "sourceMap": false
+  },
+  "exclude": [
+    "src/**/*.spec.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "target": "ES5",
+    "lib": [
+      "es2020"
+    ],
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "resolveJsonModule": true,
+    "strict": true,
+    "typeRoots": [
+      "node_modules/@types",
+      "types"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/types/badge-up2/index.d.ts

@@ -0,0 +1,19 @@
+declare module 'badge-up2' {
+    export enum colors {
+        brightgreen = '#4C1',
+        green = '#97CA00',
+        yellow = '#DFB317',
+        yellowgreen = '#A4A61D',
+        orange = '#FE7D37',
+        red = '#E05D44',
+        blue = '#007EC6',
+        grey = '#555',
+        gray = '#555',
+        lightgrey = '#9F9F9F',
+        lightgray = '#9F9F9F',
+        purple = '#400090'
+    }
+
+    function badge(field1: string, field2: string, color: colors): Promise<string>;
+    export default badge;
+}

package/badge.d.ts

@@ -1 +0,0 @@
-export declare function createBadge(label: string, coverage: number): Promise<string>;

package/badge.js

@@ -1,89 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBadge = void 0;
-var badge_up_1 = __importStar(require("badge-up"));
-function getColor(coverage) {
-    if (coverage > 97) {
-        return badge_up_1.colors.brightgreen;
-    }
-    else if (coverage > 93) {
-        return badge_up_1.colors.green;
-    }
-    else if (coverage > 90) {
-        return badge_up_1.colors.yellowgreen;
-    }
-    else if (coverage > 85) {
-        return badge_up_1.colors.yellow;
-    }
-    else if (coverage > 75) {
-        return badge_up_1.colors.orange;
-    }
-    else {
-        return badge_up_1.colors.red;
-    }
-}
-function createBadge(label, coverage) {
-    return __awaiter(this, void 0, void 0, function () {
-        var color;
-        return __generator(this, function (_a) {
-            color = getColor(coverage);
-            return [2, badge_up_1.default(label, coverage + "%", color)];
-        });
-    });
-}
-exports.createBadge = createBadge;

package/cli.d.ts

@@ -1,6 +0,0 @@
-export interface Arguments {
-    input: string;
-    label: string;
-    output: string;
-}
-export declare function processArguments(): Arguments;

package/cli.js

@@ -1,59 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processArguments = void 0;
-var minimist_1 = __importDefault(require("minimist"));
-var minimist_options_1 = __importDefault(require("minimist-options"));
-var path_1 = require("path");
-var defaultOutputPath = 'badge.svg';
-var defaultLabel = 'coverage';
-function exitWithError(message) {
-    console.error(message);
-    process.exit(1);
-}
-function printHelp() {
-    var message = "Usage: " + path_1.basename(process.argv[1]) + " [-h] [-o OUTPUT] [-l LABEL] input\n\nPositional Arguments:\n  input                 Path to LCOV file to parse\n\nOptional Arguments:\n  -h, --help            Show this help message and exit\n  -o OUTPUT, --output OUTPUT\n                        Output file path (default: " + defaultOutputPath + ")\n  -l LABEL, --label LABEL\n                        Badge label (default: " + defaultLabel + ")\n    ";
-    console.log(message);
-    process.exit(0);
-}
-function validateArguments(args) {
-    if (!args._.length) {
-        exitWithError('Input must be provided');
-    }
-    if (args._.length !== 1) {
-        exitWithError('Only one input can be provided');
-    }
-}
-function processArguments() {
-    var options = minimist_options_1.default({
-        help: {
-            type: 'boolean',
-            alias: 'h',
-            default: false,
-        },
-        label: {
-            type: 'string',
-            alias: 'l',
-            default: defaultLabel,
-        },
-        output: {
-            type: 'string',
-            alias: 'o',
-            default: defaultOutputPath,
-        },
-        arguments: 'string',
-    });
-    var args = minimist_1.default(process.argv.slice(2), options);
-    if (args.help) {
-        printHelp();
-    }
-    validateArguments(args);
-    return {
-        input: args._[0],
-        label: args.label,
-        output: args.output,
-    };
-}
-exports.processArguments = processArguments;

package/coverage.d.ts

@@ -1 +0,0 @@
-export declare function getCoverageLevel(lcov: string): number;

package/coverage.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCoverageLevel = void 0;
-var parse_lcov_1 = __importDefault(require("parse-lcov"));
-function getCoverageLevel(lcov) {
-    var coverage = parse_lcov_1.default(lcov);
-    var summary = {
-        lines: { found: 0, hit: 0 },
-        branches: { found: 0, hit: 0 },
-        functions: { found: 0, hit: 0 },
-    };
-    var keys = Object.keys(summary);
-    coverage.forEach(function (arg) {
-        keys.forEach(function (key) {
-            summary[key].found += arg[key].found;
-            summary[key].hit += arg[key].hit;
-        });
-    });
-    return Math.round(keys.reduce(function (avg, key) {
-        var found = summary[key].found;
-        return avg + (found > 0 ? summary[key].hit / found * 100 : 100);
-    }, 0) / keys.length * 100) / 100;
-}
-exports.getCoverageLevel = getCoverageLevel;

package/main.d.ts

@@ -1 +0,0 @@
-export declare function generateBadge(filename: string, label?: string): Promise<string>;