@sasjs/cli 6.3.0 → 6.4.0

package/README.md

@@ -17,6 +17,7 @@
 - Scaffold a new SAS App in seconds (`sasjs create myApp -t jobs`)
 - Compile / Build SAS Jobs, Services & Macros _locally_ and deploy / execute _remotely_, in isolation from other developers (`sasjs cbd`)
 - Compile a single Job, Service or Test without touching the rest of the build (`sasjs compile identify --source sasjs/jobs/daily/load.sas`)
+- Write the test coverage report to `sasjsbuild/coverage.json` on every compile, ready for a CI job to publish
 - No dependency on the server filesystem
 - Optionally synchronise a local folder onto the server filesystem using `sasjs fs`
 - Trigger Viya Jobs & Flows (`sasjs job execute` / `sasjs flow execute`)

package/build/commands/compile/internal/compileTestFile.d.ts

@@ -1,5 +1,7 @@
 import { CompileTree, Target } from '@sasjs/utils';
 import { TestFlow } from '../../../types';
+/** The coverage report `sasjs compile` writes to the build folder. */
+export declare const coverageFileName = "coverage.json";
 /**
  * Resolves the relative destination fragment for a compiled test file inside
  * `sasjsbuild/tests` - either just the file's basename (saveToRoot, used for

package/build/commands/compile/internal/compileTestFile.js

@@ -64,7 +64,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileTestFlow = exports.getTestFileDestinationFragment = void 0;
+exports.compileTestFlow = exports.getTestFileDestinationFragment = exports.coverageFileName = void 0;
 exports.compileTestFile = compileTestFile;
 exports.copyTestMacroFiles = copyTestMacroFiles;
 var utils_1 = require("@sasjs/utils");
@@ -75,6 +75,8 @@ var config_1 = require("../../../utils/config");
 var file_1 = require("../../../utils/file");
 var _1 = require("./");
 var getFileName = function (filePath) { return path_1.default.parse(filePath).base; };
+/** The coverage report `sasjs compile` writes to the build folder. */
+exports.coverageFileName = 'coverage.json';
 /**
  * Resolves the relative destination fragment for a compiled test file inside
  * `sasjsbuild/tests` - either just the file's basename (saveToRoot, used for
@@ -232,7 +234,7 @@ var compileTestFlow = function (target) { return __awaiter(void 0, void 0, void
 }); };
 exports.compileTestFlow = compileTestFlow;
 var printTestCoverage = function (testFlow, buildDestinationFolder, target) { return __awaiter(void 0, void 0, void 0, function () {
-    var toCover, covered, extraTests, serviceFolder, collectCoverage, jobFolder, macroFolders, filter, coverage, notCovered, coveredServices, servicesToCover, notCoveredServices, coveredJobs, jobsToCover, notCoveredJobs, coveredMacros, macrosToCover, notCoveredMacros, calculateCoverage, formatCoverage;
+    var toCover, covered, extraTests, serviceFolder, collectCoverage, jobFolder, macroFolders, filter, coveredServices, servicesToCover, coveredJobs, jobsToCover, coveredMacros, macrosToCover, coverage, markCoverage, summarize, formatCoverage, summary, report;
     var _a, _b, _c;
     return __generator(this, function (_d) {
         switch (_d.label) {
@@ -315,74 +317,52 @@ var printTestCoverage = function (testFlow, buildDestinationFolder, target) { re
                 filter = function (files, type) {
                     return files.filter(function (file) { return new RegExp("^".concat(type)).test(file); });
                 };
-                coverage = {};
-                notCovered = toCover.filter(function (tc) { return !covered.includes(tc); });
                 coveredServices = filter(covered, types_1.CoverageType.service);
                 servicesToCover = filter(toCover, types_1.CoverageType.service);
-                notCoveredServices = filter(notCovered, types_1.CoverageType.service);
-                notCoveredServices.forEach(function (file, i) {
-                    coverage[file] = {
-                        Type: types_1.CoverageType.service,
-                        Coverage: types_1.CoverageState.notCovered
-                    };
-                });
                 coveredJobs = filter(covered, types_1.CoverageType.job);
                 jobsToCover = filter(toCover, types_1.CoverageType.job);
-                notCoveredJobs = filter(notCovered, types_1.CoverageType.job);
-                notCoveredJobs.forEach(function (file, i) {
-                    coverage[file] = {
-                        Type: types_1.CoverageType.job,
-                        Coverage: types_1.CoverageState.notCovered
-                    };
-                });
                 coveredMacros = filter(covered, types_1.CoverageType.macro);
                 macrosToCover = filter(toCover, types_1.CoverageType.macro);
-                notCoveredMacros = filter(notCovered, types_1.CoverageType.macro);
-                if (!notCoveredMacros.length) return [3 /*break*/, 6];
-                return [4 /*yield*/, (0, utils_1.asyncForEach)(macroFolders, function (macroFolder) { return __awaiter(void 0, void 0, void 0, function () {
-                        var macros, macroTypeRegExp;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, (0, utils_1.listFilesAndSubFoldersInFolder)(macroFolder)];
-                                case 1: return [4 /*yield*/, (_a.sent()).filter(function (file) { return !(0, utils_1.isTestFile)(file); })];
-                                case 2:
-                                    macros = _a.sent();
-                                    macroTypeRegExp = new RegExp("^macros".concat(utils_1.pathSepEscaped));
-                                    notCoveredMacros = notCoveredMacros.map(function (macro) {
-                                        return macros.includes(macro.replace(macroTypeRegExp, ''))
-                                            ? macro.replace(macroTypeRegExp, macroFolder + path_1.default.sep)
-                                            : macro;
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })];
-            case 5:
-                _d.sent();
-                _d.label = 6;
-            case 6:
-                notCoveredMacros.forEach(function (file, i) {
-                    coverage[file] = {
-                        Type: types_1.CoverageType.macro,
-                        Coverage: types_1.CoverageState.notCovered
-                    };
-                });
+                coverage = {};
+                markCoverage = function (type, filesToCover, coveredFiles) {
+                    return filesToCover.forEach(function (file) {
+                        coverage[file] = {
+                            Type: type,
+                            Coverage: coveredFiles.includes(file)
+                                ? types_1.CoverageState.covered
+                                : types_1.CoverageState.notCovered
+                        };
+                    });
+                };
+                markCoverage(types_1.CoverageType.service, servicesToCover, coveredServices);
+                markCoverage(types_1.CoverageType.job, jobsToCover, coveredJobs);
+                markCoverage(types_1.CoverageType.macro, macrosToCover, coveredMacros);
                 extraTests.forEach(function (file) {
                     coverage[file] = {
                         Type: types_1.CoverageType.test,
                         Coverage: types_1.CoverageState.standalone
                     };
                 });
-                calculateCoverage = function (covered, from) {
-                    return (Math.round((covered / from) * 100) || 0) + '%';
-                };
-                formatCoverage = function (type, covered, toCover) {
+                summarize = function (cov, toCov) { return ({
+                    covered: cov.length,
+                    total: toCov.length,
+                    percentage: toCov.length ? Math.round((cov.length / toCov.length) * 100) : 0
+                }); };
+                formatCoverage = function (type, summary) {
                     var _a;
-                    return toCover.length
-                        ? (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info("".concat(type, " coverage: ").concat(covered.length, "/").concat(toCover.length, " (").concat(chalk_1.default.greenBright(calculateCoverage(covered.length, toCover.length)), ")"))
+                    return summary.total
+                        ? (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info("".concat(type, " coverage: ").concat(summary.covered, "/").concat(summary.total, " (").concat(chalk_1.default.greenBright("".concat(summary.percentage, "%")), ")"))
                         : null;
                 };
+                summary = {
+                    services: summarize(coveredServices, servicesToCover),
+                    jobs: summarize(coveredJobs, jobsToCover),
+                    macros: summarize(coveredMacros, macrosToCover),
+                    overall: summarize(covered, toCover)
+                };
                 (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info('Test coverage:');
+                // The table renders the same map coverage.json serialises, so a reader sees
+                // every file - covered rows included - under the key the report uses.
                 (_b = process.logger) === null || _b === void 0 ? void 0 : _b.table(Object.keys(coverage).map(function (key) { return [
                     key,
                     coverage[key].Type,
@@ -390,13 +370,21 @@ var printTestCoverage = function (testFlow, buildDestinationFolder, target) { re
                 ]; }), {
                     head: ['File', 'Type', 'Coverage']
                 });
-                formatCoverage('Services', coveredServices, servicesToCover);
-                formatCoverage('Jobs', coveredJobs, jobsToCover);
-                formatCoverage('Macros', coveredMacros, macrosToCover);
-                formatCoverage('Overall', covered, toCover);
+                formatCoverage('Services', summary.services);
+                formatCoverage('Jobs', summary.jobs);
+                formatCoverage('Macros', summary.macros);
+                formatCoverage('Overall', summary.overall);
                 (_c = process.logger) === null || _c === void 0 ? void 0 : _c.log('');
-                return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(buildDestinationFolder, 'testFlow.json'), JSON.stringify(testFlow, null, 2))];
-            case 7:
+                return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(buildDestinationFolder, 'testFlow.json'), JSON.stringify(testFlow, null, 2))
+                    // The numbers are already computed and rendered above, so the report costs
+                    // one small file - which lets a CI job publish the figures instead of
+                    // scraping the log.
+                ];
+            case 5:
+                _d.sent();
+                report = { summary: summary, files: coverage };
+                return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(buildDestinationFolder, exports.coverageFileName), JSON.stringify(report, null, 2))];
+            case 6:
                 _d.sent();
                 return [2 /*return*/];
         }

package/build/commands/compile/internal/spec/compileTestFile.spec.js

@@ -51,6 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var __1 = require("../");
+var compileTestFile_1 = require("../compileTestFile");
 var utils_1 = require("@sasjs/utils");
 var test_1 = require("../../../../utils/test");
 var path_1 = __importDefault(require("path"));
@@ -391,6 +392,163 @@ describe('compileTestFile', function () {
                 }
             });
         }); });
+        it('should write the coverage report to the build folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var report, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 2:
+                        report = _b.apply(_a, [_c.sent()]);
+                        expect(report.summary).toEqual({
+                            services: { covered: 0, total: 4, percentage: 0 },
+                            jobs: { covered: 0, total: 0, percentage: 0 },
+                            macros: { covered: 0, total: 0, percentage: 0 },
+                            overall: { covered: 0, total: 4, percentage: 0 }
+                        });
+                        // the same rows the console table lists, standalone tests included
+                        expect(report.files[['services', 'common', 'appinit.sas'].join('/')]).toEqual({ Type: 'service', Coverage: 'not covered' });
+                        expect(report.files[['tests', 'jobs', 'jobs', 'testJob.test.sas'].join('/')]).toEqual({ Type: 'test', Coverage: 'standalone' });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should key the report by project-relative paths, never build machine paths', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var macroPath, tableSpy, report, _a, _b, tableRows;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        macroPath = path_1.default.join(sasjsPath, 'macros', 'uncoveredmacro.sas');
+                        tableSpy = jest
+                            .spyOn(process.logger, 'table')
+                            .mockImplementation(function () { return ''; });
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroPath, '%macro uncoveredmacro(); %mend uncoveredmacro;')];
+                    case 1:
+                        _c.sent();
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, , 5, 7]);
+                        return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 3:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 4:
+                        report = _b.apply(_a, [_c.sent()]);
+                        // macros are keyed like services and jobs, in the report and in the
+                        // console table alike - a build machine path in either would make the
+                        // same project produce different output elsewhere.
+                        expect(report.files['macros/uncoveredmacro.sas']).toEqual({
+                            Type: 'macro',
+                            Coverage: 'not covered'
+                        });
+                        expect(Object.keys(report.files).filter(function (key) { return path_1.default.isAbsolute(key); })).toEqual([]);
+                        expect(report.summary.macros).toEqual({
+                            covered: 0,
+                            total: 1,
+                            percentage: 0
+                        });
+                        tableRows = tableSpy.mock.calls[0][0];
+                        expect(tableRows).toContainEqual([
+                            'macros/uncoveredmacro.sas',
+                            'macro',
+                            'not covered'
+                        ]);
+                        expect(tableRows.flat().filter(function (cell) { return path_1.default.isAbsolute(cell); })).toEqual([]);
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, (0, utils_1.deleteFile)(macroPath)];
+                    case 6:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should mark covered files in the report, not just the gaps', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var macroPath, macroTestPath, tableSpy, report, _a, _b, tableRows;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        macroPath = path_1.default.join(sasjsPath, 'macros', 'coveredmacro.sas');
+                        macroTestPath = path_1.default.join(sasjsPath, 'macros', 'coveredmacro.test.sas');
+                        tableSpy = jest
+                            .spyOn(process.logger, 'table')
+                            .mockImplementation(function () { return ''; });
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroPath, '%macro coveredmacro(); %mend coveredmacro;')];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, (0, utils_1.createFile)(macroTestPath, '%put testing coveredmacro;')];
+                    case 2:
+                        _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, , 6, 9]);
+                        return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 4:
+                        _c.sent();
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(buildPath, compileTestFile_1.coverageFileName))];
+                    case 5:
+                        report = _b.apply(_a, [_c.sent()]);
+                        expect(report.files['macros/coveredmacro.sas']).toEqual({
+                            Type: 'macro',
+                            Coverage: 'covered'
+                        });
+                        expect(report.summary.macros).toEqual({
+                            covered: 1,
+                            total: 1,
+                            percentage: 100
+                        });
+                        tableRows = tableSpy.mock.calls[0][0];
+                        expect(tableRows).toContainEqual([
+                            'macros/coveredmacro.sas',
+                            'macro',
+                            'covered'
+                        ]);
+                        return [3 /*break*/, 9];
+                    case 6: return [4 /*yield*/, (0, utils_1.deleteFile)(macroPath)];
+                    case 7:
+                        _c.sent();
+                        return [4 /*yield*/, (0, utils_1.deleteFile)(macroTestPath)];
+                    case 8:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should not write a coverage report when no tests were compiled', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var coveragePath, testFlow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        coveragePath = path_1.default.join(buildPath, compileTestFile_1.coverageFileName);
+                        // remove the report the compile wrote, so the assertion below is about
+                        // the no-tests path and not about a file left over from it
+                        return [4 /*yield*/, (0, utils_1.deleteFile)(coveragePath)];
+                    case 2:
+                        // remove the report the compile wrote, so the assertion below is about
+                        // the no-tests path and not about a file left over from it
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_1.deleteFolder)(path_1.default.join(buildPath, 'tests'))];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, (0, __1.compileTestFlow)(target)];
+                    case 4:
+                        testFlow = _a.sent();
+                        expect(testFlow).toBeUndefined();
+                        return [4 /*yield*/, expect((0, utils_1.fileExists)(coveragePath)).resolves.toEqual(false)];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('should log a warning is testFolders was used in root or target configuration', function () { return __awaiter(void 0, void 0, void 0, function () {
             var testTarget, testConfig, expectedWarn;
             return __generator(this, function (_a) {

package/build/commands/help/help.js

@@ -97,6 +97,7 @@ function printHelpText() {
                         "compiles the services specified in the ".concat(chalk_1.default.cyanBright('serviceFolders'), " property of the 'serviceConfig' in your target and common configuration."),
                         "A single file is compiled by naming its type as a sub command - ".concat(chalk_1.default.cyanBright('job'), ", ").concat(chalk_1.default.cyanBright('service'), ", ").concat(chalk_1.default.cyanBright('test'), " or ").concat(chalk_1.default.cyanBright('identify'), ", which works the type out from the file itself - together with ").concat(chalk_1.default.cyanBright('--source'), " (or ").concat(chalk_1.default.cyanBright('-s'), ")."),
                         "The compiled file is written to the ".concat(chalk_1.default.cyanBright('jobs'), " or ").concat(chalk_1.default.cyanBright('services'), " folder of sasjsbuild for its type, or below ").concat(chalk_1.default.cyanBright('--output'), " (or ").concat(chalk_1.default.cyanBright('-o'), ") when given."),
+                        "The test coverage report is written to ".concat(chalk_1.default.cyanBright('coverage.json'), " in the build folder alongside ").concat(chalk_1.default.cyanBright('testFlow.json'), "."),
                         "command example: sasjs compile identify --source sasjs/jobs/daily/load.sas --target myTarget"
                     ]
                 },

package/build/types/index.d.ts

@@ -2,6 +2,6 @@ export { CommandBase } from './command/commandBase';
 export { File, FilePath } from './file';
 export { Folder } from './folder';
 export { TargetScope } from './targetScope';
-export { TestFlow, Coverage, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
+export { TestFlow, Coverage, CoverageReport, CoverageSummary, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
 export { Flow, FlowWave, FlowWaveJob } from './flow';
 export * from './log';

package/build/types/testing.d.ts

@@ -12,6 +12,7 @@ export declare enum CoverageType {
 }
 export declare enum CoverageState {
     notCovered = "not covered",
+    covered = "covered",
     standalone = "standalone"
 }
 export interface Coverage {
@@ -20,6 +21,38 @@ export interface Coverage {
         Coverage: CoverageState;
     };
 }
+/**
+ * Totals for one group of files (services, jobs, macros or all of them).
+ * `percentage` is rounded to a whole number, matching the figure printed in
+ * the console summary.
+ */
+export interface CoverageSummary {
+    covered: number;
+    total: number;
+    percentage: number;
+}
+/**
+ * The content of the coverage report `sasjs compile` writes to
+ * `coverage.json` in the build folder.
+ *
+ * `summary` carries the same totals as the console output. `files` is a
+ * complete per-file map - every service, job and macro the compile found,
+ * each marked `covered` or `not covered`, plus standalone tests - keyed by
+ * project-relative path (`services/common/appinit.sas`,
+ * `macros/mymacro.sas`), never by a path from the machine that compiled it.
+ *
+ * The console table renders this same map, so the rows a reader sees and the
+ * keys a consumer reads are the same, covered rows included.
+ */
+export interface CoverageReport {
+    summary: {
+        services: CoverageSummary;
+        jobs: CoverageSummary;
+        macros: CoverageSummary;
+        overall: CoverageSummary;
+    };
+    files: Coverage;
+}
 export interface TestResultDescription {
     TEST_DESCRIPTION: string;
     TEST_RESULT: TestResultStatus.pass | TestResultStatus.fail;

package/build/types/testing.js

@@ -11,6 +11,7 @@ var CoverageType;
 var CoverageState;
 (function (CoverageState) {
     CoverageState["notCovered"] = "not covered";
+    CoverageState["covered"] = "covered";
     CoverageState["standalone"] = "standalone";
 })(CoverageState || (exports.CoverageState = CoverageState = {}));
 var TestResultStatus;

package/package.json

@@ -126,5 +126,5 @@
   "peerDependencies": {
     "@sasjs/lint": "^4.4.0"
   },
-  "version": "6.3.0"
+  "version": "6.4.0"
 }