@sasjs/cli 6.6.0 → 6.8.0

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

@@ -70,10 +70,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@sasjs/adapter": "^5.1.1",
+    "@sasjs/adapter": "^5.1.3",
     "@sasjs/core": "^6.1.1",
     "@sasjs/lint": "4.9.0",
-    "@sasjs/utils": "^4.1.2",
+    "@sasjs/utils": "^4.3.2",
     "axios": "1.20.0",
     "chalk": "4.1.2",
     "dotenv": "18.0.8",
@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.6.0"
+  "version": "6.8.0"
 }