@sasjs/cli 6.7.0 → 6.8.1

package/build/commands/run/spec/runCommand.spec.js

@@ -100,6 +100,7 @@ var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var command_1 = require("../../../types/command");
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs', 'run'];
 var target = new utils_1.Target({
     name: 'test',
@@ -114,6 +115,55 @@ describe('RunCommand', function () {
     beforeEach(function () {
         setupMocks();
     });
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('should return the logcheck code when the log check failed the run', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    jest
+                        .spyOn(runModule, 'runSasCode')
+                        .mockImplementation(function () { return Promise.reject(new logcheck_1.LogCheckFailure('2 errors')); });
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.LogCheckError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        sasFilePath,
+                        '--no-logcheck'
+                    ], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check on for --logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath, '--logcheck'], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('on');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should parse sasjs run command', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {

package/build/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './config';
 export * from './displayResult';
 export * from './file';
 export * from './loadEnvVariables';
+export * from './logcheck';
 export * from './saveLog';
 export * from './setConstants';
 export * from './setProjectDir';

package/build/utils/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./displayResult"), exports);
 __exportStar(require("./file"), exports);
 __exportStar(require("./loadEnvVariables"), exports);
+__exportStar(require("./logcheck"), exports);
 __exportStar(require("./saveLog"), exports);
 __exportStar(require("./setConstants"), exports);
 __exportStar(require("./setProjectDir"), exports);

package/build/utils/logcheck.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How the log a command just received is treated.
+ *
+ * `auto` decides from `logCheck.autoCheck` in the project config, which is off
+ * by default; `on` and `off` are the `--logcheck` / `--no-logcheck` flags. The
+ * distinction matters because the two halves of the behaviour are separate:
+ * reporting what SAS printed is always worth doing, while changing the exit
+ * code of a command whose status a pipeline already trusts is not something to
+ * do behind a project's back.
+ */
+export type LogCheckMode = 'auto' | 'on' | 'off';
+export declare const setLogCheckMode: (value: LogCheckMode) => void;
+export declare const getLogCheckMode: () => LogCheckMode;
+/** Reads a tri-state yargs boolean: absent is `undefined`, not `false`. */
+export declare const logCheckModeOf: (flag: unknown) => LogCheckMode;
+/**
+ * A run whose log broke the policy, once `autoCheck` or `--logcheck` asked for
+ * the verdict to count.
+ *
+ * It is an error rather than a return value because it is raised several
+ * frames below the command, from whichever executor received the log, and the
+ * command is the only place that can turn it into an exit code.
+ */
+export declare class LogCheckFailure extends Error {
+    /**
+     * Marker rather than `instanceof`: the CLI is compiled to a target where a
+     * subclass of a built-in loses its prototype chain, so `instanceof` answers
+     * false in the built artefact while answering true under the test transform.
+     * The flag is read by {@link isLogCheckFailure} and cannot be faked by an
+     * unrelated error.
+     */
+    readonly logCheckFailure = true;
+    constructor(message: string);
+}
+export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFailure;
+/**
+ * Reports the issues in a log a command just received, and throws when the
+ * policy says the run should fail.
+ *
+ * Nothing is printed for a clean log: the commands this runs inside already
+ * have their own success output, and a check that announces itself on every
+ * green run is noise that gets switched off.
+ */
+export declare const checkLog: (logText: string | undefined | null, label: string) => Promise<void>;

package/build/utils/logcheck.js

@@ -0,0 +1,224 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLog = exports.isLogCheckFailure = exports.LogCheckFailure = exports.logCheckModeOf = exports.getLogCheckMode = exports.setLogCheckMode = void 0;
+var logs_1 = require("@sasjs/utils/logs");
+var chalk_1 = __importDefault(require("chalk"));
+var collectLogs_1 = require("../commands/logcheck/collectLogs");
+var logCheckConfig_1 = require("../commands/logcheck/logCheckConfig");
+var processLogCheck_1 = require("../commands/logcheck/processLogCheck");
+var renderLogCheck_1 = require("../commands/logcheck/renderLogCheck");
+var mode = 'auto';
+var setLogCheckMode = function (value) {
+    mode = value;
+};
+exports.setLogCheckMode = setLogCheckMode;
+var getLogCheckMode = function () { return mode; };
+exports.getLogCheckMode = getLogCheckMode;
+/** Reads a tri-state yargs boolean: absent is `undefined`, not `false`. */
+var logCheckModeOf = function (flag) {
+    return flag === true ? 'on' : flag === false ? 'off' : 'auto';
+};
+exports.logCheckModeOf = logCheckModeOf;
+/**
+ * A run whose log broke the policy, once `autoCheck` or `--logcheck` asked for
+ * the verdict to count.
+ *
+ * It is an error rather than a return value because it is raised several
+ * frames below the command, from whichever executor received the log, and the
+ * command is the only place that can turn it into an exit code.
+ */
+var LogCheckFailure = /** @class */ (function (_super) {
+    __extends(LogCheckFailure, _super);
+    function LogCheckFailure(message) {
+        var _this = _super.call(this, message) || this;
+        /**
+         * Marker rather than `instanceof`: the CLI is compiled to a target where a
+         * subclass of a built-in loses its prototype chain, so `instanceof` answers
+         * false in the built artefact while answering true under the test transform.
+         * The flag is read by {@link isLogCheckFailure} and cannot be faked by an
+         * unrelated error.
+         */
+        _this.logCheckFailure = true;
+        _this.name = 'LogCheckFailure';
+        return _this;
+    }
+    return LogCheckFailure;
+}(Error));
+exports.LogCheckFailure = LogCheckFailure;
+var isLogCheckFailure = function (error) {
+    return (error === null || error === void 0 ? void 0 : error.logCheckFailure) === true;
+};
+exports.isLogCheckFailure = isLogCheckFailure;
+/**
+ * Reports the issues in a log a command just received, and throws when the
+ * policy says the run should fail.
+ *
+ * Nothing is printed for a clean log: the commands this runs inside already
+ * have their own success output, and a check that announces itself on every
+ * green run is noise that gets switched off.
+ */
+var checkLog = function (logText, label) { return __awaiter(void 0, void 0, void 0, function () {
+    var config, error_1, _a, issues, suppressed, counts, failing, totals, failure;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (mode === 'off' || !logText)
+                    return [2 /*return*/];
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+            case 2:
+                config = _c.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_1 = _c.sent();
+                // An automatic check must never break the command it is riding on: a
+                // config it cannot read is worth a warning, not a failed run.
+                (_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn("Skipping the SAS log check: ".concat(error_1.message));
+                return [2 /*return*/];
+            case 4:
+                _a = (0, collectLogs_1.partitionIssues)((0, logs_1.parseLog)(logText), config.ignoreCodes), issues = _a.issues, suppressed = _a.suppressed;
+                if (!issues.length)
+                    return [2 /*return*/];
+                counts = (0, collectLogs_1.countIssues)(issues);
+                failing = mode === 'on' || config.autoCheck === true;
+                totals = __assign(__assign({}, counts), { suppressed: suppressed.length, logs: 1, skipped: 0 });
+                failure = failing ? (0, processLogCheck_1.describeFailure)(totals, config) : undefined;
+                renderInline(label, issues, counts, suppressed.length, config, failure);
+                if (failure) {
+                    throw new LogCheckFailure("SAS log check failed for ".concat(label, ": ").concat(failure));
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
+exports.checkLog = checkLog;
+/**
+ * The inline report: the heading, the issues, and the verdict when there is
+ * one. Deliberately narrower than the `logcheck` report - there is one log
+ * here and its name is already on screen, so there is no file table.
+ */
+var renderInline = function (label, issues, counts, suppressedCount, config, failure) {
+    var _a;
+    var lines = [
+        "".concat(chalk_1.default.bold('SAS log check'), " ").concat(chalk_1.default.dim(label), " - ").concat(describe(counts))
+    ];
+    lines.push.apply(lines, __spreadArray([], __read((0, renderLogCheck_1.columns)(issues.map(function (issue) { return [
+        (0, renderLogCheck_1.lineLabel)(issue),
+        (0, renderLogCheck_1.severityLabel)(issue.severity),
+        issue.code || chalk_1.default.dim('-'),
+        (0, renderLogCheck_1.truncate)(issue.message)
+    ]; }), ['LINE:COL', 'SEVERITY', 'CODE', 'MESSAGE'], '  ', '  ')), false));
+    if (suppressedCount) {
+        lines.push(chalk_1.default.dim("  ".concat(suppressedCount, " issue").concat(suppressedCount === 1 ? '' : 's', " suppressed by message code").concat(config.ignoreCodes.length ? " (".concat(config.ignoreCodes.join(', '), ")") : '')));
+    }
+    if (failure) {
+        lines.push("".concat(chalk_1.default.red.bold('  Logcheck failed: ')).concat(chalk_1.default.red(failure)));
+    }
+    (_a = process.logger) === null || _a === void 0 ? void 0 : _a.log(lines.join('\n'));
+};
+var describe = function (counts) {
+    var parts = [];
+    if (counts.errors)
+        parts.push(plural(counts.errors, 'error'));
+    if (counts.warnings)
+        parts.push(plural(counts.warnings, 'warning'));
+    if (counts.notes)
+        parts.push(plural(counts.notes, 'note'));
+    return parts.join(', ');
+};
+var plural = function (count, noun) {
+    return "".concat(count, " ").concat(noun).concat(count === 1 ? '' : 's');
+};

package/build/utils/spec/logcheck.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/spec/logcheck.spec.js

@@ -0,0 +1,297 @@
+"use strict";
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = require("fs");
+var utils_1 = require("@sasjs/utils");
+var logcheck_1 = require("../logcheck");
+var sasLog = function (extra) {
+    if (extra === void 0) { extra = ''; }
+    return "NOTE: Copyright (c) 2016 by SAS Institute Inc., Cary, NC, USA.\n\n1    data work.x;\n2      set work.y;\n3    run;\n".concat(extra);
+};
+var logWithError = sasLog('ERROR 22-322: Syntax error.\n');
+var logWithNote = sasLog('NOTE: Variable flag is uninitialized.\n');
+var cleanLog = sasLog();
+var tempFolder = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'sasjs-logcheck-inline-'))];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+describe('logCheckModeOf', function () {
+    it('reads the tri-state a yargs boolean gives', function () {
+        expect((0, logcheck_1.logCheckModeOf)(true)).toEqual('on');
+        expect((0, logcheck_1.logCheckModeOf)(false)).toEqual('off');
+        expect((0, logcheck_1.logCheckModeOf)(undefined)).toEqual('auto');
+    });
+});
+describe('checkLog', function () {
+    var originalProjectDir = process.projectDir;
+    var logged;
+    var withProject = function (logCheck) { return __awaiter(void 0, void 0, void 0, function () {
+        var folder;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _a.sent();
+                    process.projectDir = folder;
+                    if (!(logCheck !== undefined)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), JSON.stringify({ logCheck: logCheck }))];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, folder];
+            }
+        });
+    }); };
+    beforeEach(function () {
+        logged = [];
+        process.logger = {
+            log: function (message) { return logged.push(message); }
+        };
+        process.logger.logLevel = utils_1.LogLevel.Off;
+    });
+    afterEach(function () {
+        process.projectDir = originalProjectDir;
+        process.logger = undefined;
+        (0, logcheck_1.setLogCheckMode)('auto');
+    });
+    it('says nothing for a clean log', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(cleanLog, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    expect(logged).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('says nothing when it is given no log at all', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(undefined, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    expect(logged).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports the issues without failing by default', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var output;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(logWithError, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    output = logged.join('\n');
+                    expect(output).toContain('SAS log check run-job.sas');
+                    expect(output).toContain('1 error');
+                    expect(output).toContain('Syntax error.');
+                    expect(output).not.toContain('Logcheck failed');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('skips the check, with a warning, when the config cannot be read', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var folder, warn;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _a.sent();
+                    process.projectDir = folder;
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), '{ "logCheck": ')];
+                case 2:
+                    _a.sent();
+                    warn = jest.fn();
+                    process.logger.warn = warn;
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(logWithError, 'run-job.sas')];
+                case 3:
+                    _a.sent();
+                    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Skipping the SAS log check'));
+                    expect(logged).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('says nothing at all under --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true })];
+                case 1:
+                    _a.sent();
+                    (0, logcheck_1.setLogCheckMode)('off');
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(logWithError, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    expect(logged).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails the run when the project asked for it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, logcheck_1.checkLog)(logWithError, 'run-job.sas')).rejects.toThrow('SAS log check failed for run-job.sas: 1 error')];
+                case 2:
+                    _a.sent();
+                    expect(logged.join('\n')).toContain('Logcheck failed: 1 error');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails the run when the flag asked for it, without the config', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    (0, logcheck_1.setLogCheckMode)('on');
+                    return [4 /*yield*/, expect((0, logcheck_1.checkLog)(logWithError, 'run-job.sas')).rejects.toBeInstanceOf(logcheck_1.LogCheckFailure)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('does not fail on a note under the default policy', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(logWithNote, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    expect(logged.join('\n')).toContain('1 note');
+                    expect(logged.join('\n')).not.toContain('Logcheck failed');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails on a note when the policy says note', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true, failOn: 'note' })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, logcheck_1.checkLog)(logWithNote, 'run-job.sas')).rejects.toThrow('1 note')];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('suppresses an issue by message code', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ ignoreCodes: ['22-322'] })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(logWithError, 'run-job.sas')];
+                case 2:
+                    _a.sent();
+                    expect(logged).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports a suppressed issue alongside the ones that remain', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var output;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject({ ignoreCodes: ['22-322'], autoCheck: true })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logcheck_1.checkLog)(sasLog('ERROR 22-322: Syntax error.\nNOTE: Variable flag is uninitialized.\n'), 'run-job.sas').catch(function () { return undefined; })];
+                case 2:
+                    _a.sent();
+                    output = logged.join('\n');
+                    expect(output).toContain('1 note');
+                    expect(output).toContain('1 issue suppressed by message code (22-322)');
+                    expect(output).not.toContain('Logcheck failed');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('isLogCheckFailure', function () {
+    it('recognises only its own error', function () {
+        expect((0, logcheck_1.isLogCheckFailure)(new logcheck_1.LogCheckFailure('x'))).toBe(true);
+        expect((0, logcheck_1.isLogCheckFailure)(new Error('x'))).toBe(false);
+        expect((0, logcheck_1.isLogCheckFailure)('x')).toBe(false);
+        expect((0, logcheck_1.isLogCheckFailure)(undefined)).toBe(false);
+    });
+    it('is not fooled by an error that only borrows the name', function () {
+        // The marker is what the built CLI relies on: the compiled target loses the
+        // prototype chain of an Error subclass, so `instanceof` is not available
+        // there and the name alone would be a weak claim.
+        var impostor = new Error('x');
+        impostor.name = 'LogCheckFailure';
+        expect((0, logcheck_1.isLogCheckFailure)(impostor)).toBe(false);
+    });
+});
+describe('getLogCheckMode', function () {
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('starts on auto and follows what it is set to', function () {
+        expect((0, logcheck_1.getLogCheckMode)()).toEqual('auto');
+        (0, logcheck_1.setLogCheckMode)('on');
+        expect((0, logcheck_1.getLogCheckMode)()).toEqual('on');
+        (0, logcheck_1.setLogCheckMode)('off');
+        expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+    });
+});

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.7.0"
+  "version": "6.8.1"
 }