@sasjs/cli 6.4.1 → 6.4.3

package/build/utils/spec/config.folders.spec.js

@@ -0,0 +1,394 @@
+"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 __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 });
+var path_1 = __importDefault(require("path"));
+var config_1 = require("../config");
+/**
+ * The folder and stream accessors in config.ts read the global configuration
+ * `setConstants` writes to `process`, merge the target's own entries over it and
+ * resolve everything against the build source folder. None of that was covered:
+ * the functions returned whatever the caller's target happened to contain, so a
+ * regression in the merge (a dropped target folder, a duplicated path, a
+ * relative path that never got resolved) had nothing to fail against.
+ */
+var buildSourceFolder = '/project/sasjsbuild';
+// `getAbsolutePath` joins with the platform separator, so an expectation has to
+// be built the same way: a hardcoded '/project/sasjsbuild/sas' is only right on
+// a POSIX runner, and the Windows job runs this suite too.
+var inBuild = function () {
+    var parts = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        parts[_i] = arguments[_i];
+    }
+    return path_1.default.join.apply(path_1.default, __spreadArray([buildSourceFolder], __read(parts), false));
+};
+var sas9CredentialsError = 'SAS9 credentials are required.';
+var targetWith = function (properties) { return properties; };
+describe('config folder accessors', function () {
+    var originalConfig = process.sasjsConfig;
+    var originalConstants = process.sasjsConstants;
+    beforeEach(function () {
+        ;
+        process.sasjsConfig = {};
+        process.sasjsConstants = {
+            buildSourceFolder: buildSourceFolder,
+            sas9CredentialsError: sas9CredentialsError
+        };
+    });
+    afterAll(function () {
+        ;
+        process.sasjsConfig = originalConfig;
+        process.sasjsConstants = originalConstants;
+    });
+    describe('getProgramFolders', function () {
+        it('returns an empty list when neither the config nor the target names a folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getProgramFolders)(targetWith({}))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('resolves the configuration folders against the build source folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { programFolders: ['sas'] };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getProgramFolders)(targetWith({}))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([inBuild('sas')]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("appends the target's own folders after the configuration ones", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { programFolders: ['sas'] };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getProgramFolders)(targetWith({ programFolders: ['extra'] }))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([inBuild('sas'), inBuild('extra')]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('collapses a folder named in both places', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { programFolders: ['sas'] };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getProgramFolders)(targetWith({ programFolders: ['sas'] }))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([inBuild('sas')]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('leaves an absolute folder path alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { programFolders: ['/somewhere/else'] };
+                        // kept absolute rather than joined onto the build folder, but
+                        // `getAbsolutePath` normalises it, which on Windows means backslashes
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getProgramFolders)(targetWith({}))];
+                    case 1:
+                        // kept absolute rather than joined onto the build folder, but
+                        // `getAbsolutePath` normalises it, which on Windows means backslashes
+                        _a.apply(void 0, [_b.sent()]).toEqual([
+                            path_1.default.normalize('/somewhere/else')
+                        ]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getBinaryFolders', function () {
+        it('returns an empty list with nothing configured', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getBinaryFolders)(targetWith({}))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('merges the configuration and target binary folders', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { binaryFolders: ['bin'] };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getBinaryFolders)(targetWith({ binaryFolders: ['macros/bin', 'bin'] }))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([inBuild('bin'), inBuild('macros', 'bin')]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getMacroFolders', function () {
+        it('returns an empty list when no target is given and nothing is configured', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getMacroFolders)()];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('merges the configuration and target macro folders', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = { macroFolders: ['macros'] };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getMacroFolders)(targetWith({ macroFolders: ['moremacros'] }))];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual([inBuild('macros'), inBuild('moremacros')]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getStreamConfig', function () {
+        it('defaults the service name when nothing is configured', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getStreamConfig)()];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual({ streamServiceName: 'clickme' });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('takes the configuration stream settings', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = {
+                            streamConfig: {
+                                streamServiceName: 'from_config',
+                                streamWebFolder: 'web'
+                            }
+                        };
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getStreamConfig)()];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual({
+                            streamServiceName: 'from_config',
+                            streamWebFolder: 'web'
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('lets the target override the configuration', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var target, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        ;
+                        process.sasjsConfig = {
+                            streamConfig: { streamServiceName: 'from_config' }
+                        };
+                        target = targetWith({
+                            streamConfig: { streamServiceName: 'from_target' }
+                        });
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getStreamConfig)(target)];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual({
+                            streamServiceName: 'from_target'
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getAuthConfigSAS9', function () {
+        var originalUsername = process.env.SAS_USERNAME;
+        var originalPassword = process.env.SAS_PASSWORD;
+        // Assigning `undefined` to process.env stores the string "undefined", so an
+        // absent variable has to be put back with a delete. The suite runs with
+        // --runInBand, so a leaked "undefined" would be visible to every spec file
+        // that follows and to anything asserting there are no SAS9 credentials.
+        var restore = function (name, value) {
+            if (value === undefined)
+                delete process.env[name];
+            else
+                process.env[name] = value;
+        };
+        afterEach(function () {
+            restore('SAS_USERNAME', originalUsername);
+            restore('SAS_PASSWORD', originalPassword);
+        });
+        it("takes the credentials from the target's authConfigSas9", function () {
+            delete process.env.SAS_USERNAME;
+            delete process.env.SAS_PASSWORD;
+            var target = targetWith({
+                authConfigSas9: { userName: 'target-user', password: 'target-pass' }
+            });
+            expect((0, config_1.getAuthConfigSAS9)(target)).toEqual({
+                userName: 'target-user',
+                password: 'target-pass'
+            });
+        });
+        it('falls back to the SAS_USERNAME and SAS_PASSWORD environment variables', function () {
+            process.env.SAS_USERNAME = 'env-user';
+            process.env.SAS_PASSWORD = 'env-pass';
+            expect((0, config_1.getAuthConfigSAS9)(targetWith({}))).toEqual({
+                userName: 'env-user',
+                password: 'env-pass'
+            });
+        });
+        it('prefers the target credentials over the environment', function () {
+            process.env.SAS_USERNAME = 'env-user';
+            process.env.SAS_PASSWORD = 'env-pass';
+            var target = targetWith({
+                authConfigSas9: { userName: 'target-user', password: 'target-pass' }
+            });
+            expect((0, config_1.getAuthConfigSAS9)(target).userName).toEqual('target-user');
+        });
+        it('throws the configured error when no credentials exist at all', function () {
+            delete process.env.SAS_USERNAME;
+            delete process.env.SAS_PASSWORD;
+            expect(function () { return (0, config_1.getAuthConfigSAS9)(targetWith({})); }).toThrow(sas9CredentialsError);
+        });
+        it('throws when only the user name is present', function () {
+            process.env.SAS_USERNAME = 'env-user';
+            delete process.env.SAS_PASSWORD;
+            expect(function () { return (0, config_1.getAuthConfigSAS9)(targetWith({})); }).toThrow(sas9CredentialsError);
+        });
+    });
+    describe('test hooks', function () {
+        it("returns the target's testSetUp without looking at the local config", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var target, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        target = targetWith({ testConfig: { testSetUp: 'setup.sas' } });
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getTestSetUp)(target)];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual('setup.sas');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("returns the target's testTearDown without looking at the local config", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var target, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        target = targetWith({
+                            testConfig: { testTearDown: 'teardown.sas' }
+                        });
+                        _a = expect;
+                        return [4 /*yield*/, (0, config_1.getTestTearDown)(target)];
+                    case 1:
+                        _a.apply(void 0, [_b.sent()]).toEqual('teardown.sas');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.4.1"
+  "version": "6.4.3"
 }