@sasjs/cli 6.27.2 → 6.28.0

package/build/commands/build/internal/mockSite/spec/sw.spec.js

@@ -486,44 +486,276 @@ describe('service worker host', function () {
         });
     }); });
     it('answers only the line the interface writes, not one further down', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var worker, response, _a;
-        var _b, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        var worker, response, body;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     // The interface puts `%let _program` first; a line further down belongs to
-                    // the program. Answered, it would hand a caller's own SAS program the session
-                    // recorded for another file - the "inventing a session" the refusal exists to
-                    // avoid, with a different file's log.
+                    // the program. Reading it would hand a caller's own SAS program the session
+                    // recorded for another file - a different file's log, which is worse than the
+                    // mocked one.
                     ;
-                    global.__sasTranscript = (_b = {},
-                        _b["".concat(appLoc, "/services/public/program.sas")] = {
+                    global.__sasTranscript = (_a = {},
+                        _a["".concat(appLoc, "/services/public/program.sas")] = {
                             webout: '{"SYSSITE":"00000000"}',
                             log: 'NOTE: recorded',
                             print: 'The SAS System'
                         },
-                        _b);
+                        _a);
                     worker = loadWorker();
-                    worker.runtime.load((_c = {},
-                        _c[drivePath('services/public/mine.sas')] = 'data work.class; run;',
-                        _c));
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('services/public/mine.sas')] = 'data work.class; run;',
+                        _b));
                     return [4 /*yield*/, worker.dispatch('/SASjsApi/code/execute', runRequest({
                             code: "data _null_;\n%let _program = ".concat(appLoc, "/services/public/program.sas;\nrun;"),
                             runTime: 'sas'
                         }))];
                 case 1:
-                    response = _d.sent();
-                    expect(response.status).toBe(400);
-                    _a = expect;
+                    response = _c.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _c.sent();
+                    expect(body).toContain('This is a mocked SAS session');
+                    expect(body).not.toContain('NOTE: recorded');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers a program it never recorded with the mocked session', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('services/public/other.sas')] = 'data work.class; run;',
+                        _a));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/other")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _b.sent();
+                    expect(body).toContain('This is a mocked SAS session');
+                    expect(body).toContain('services/public/other');
+                    expect(body).not.toContain('SAS is not available');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers an unsaved buffer with the mocked session', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/code/execute', runRequest({ code: 'data work.class; run;', runTime: 'sas' }))];
+                case 1:
+                    response = _a.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _a.sent();
+                    expect(body).toContain('This is a mocked SAS session');
+                    expect(body).toContain('the code in this buffer');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('gives the mocked session the notes, warnings and errors a log panel reads', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/code/execute', runRequest({ code: 'data work.class; run;', runTime: 'sas' }))];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _a.sent();
+                    expect(body).toMatch(/^\d+\s+\w/m); // source lines with their numbers
+                    expect(body).toContain('ERROR 22-322');
+                    expect(body).toContain('WARNING:');
+                    expect(body).toContain('NOTE:');
+                    expect(body).toContain('The SAS System');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fills a program path holding $& literally', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('services/public/$&x.sas')] = 'data work.class; run;',
+                        _a));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/$&x")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _b.sent();
+                    expect(body).toContain('services/public/$&x');
+                    expect(body).not.toContain('{{program}}');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('prefers the recording that names the program over the mocked session', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // The project's own output beats ours, which is why it recorded it.
+                    ;
+                    global.__sasTranscript = (_a = {},
+                        _a["".concat(appLoc, "/services/public/report.sas")] = {
+                            webout: '',
+                            log: 'NOTE: the recorded session',
+                            print: ''
+                        },
+                        _a);
+                    worker = loadWorker();
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('services/public/report.sas')] = 'data work.class; run;',
+                        _b));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/report")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _c.sent();
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _c.sent();
+                    expect(body).toContain('the recorded session');
+                    expect(body).not.toContain('This is a mocked SAS session');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('runs a JavaScript code run rather than answering it with the recorded session', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, body;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // The demo's app services are JavaScript. They execute here, so a project that ships a
+                    // fallback must not have its own code replaced by a recorded SAS session: the run time,
+                    // not the presence of code, is what makes a run SAS.
+                    ;
+                    global.__sasTranscript = {
+                        '*': {
+                            webout: 'RECORDED-SESSION',
+                            log: 'NOTE: the demo session',
+                            print: ''
+                        }
+                    };
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/code/execute', runRequest({ code: '_webout = "inline";', runTime: 'js', params: {} }))];
+                case 1:
+                    response = _a.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _a.sent();
+                    expect(body.split(LOGS_SEPARATOR)[0].trim()).toBe('inline');
+                    expect(body).not.toContain('RECORDED-SESSION');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('runs the run time first in RUN_TIMES when a program names no extension', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // SASjs Server gives priority to the run time that comes first in `RUN_TIMES`
+                    // (docs/pages/settings.md): with `js,sas`, `/services/public/twin` is `twin.js`. This host
+                    // declares that order, so a project shipping both files runs the JavaScript one - and the
+                    // SAS recording, which answers only a run time this host cannot execute, is not consulted.
+                    ;
+                    global.__sasTranscript = {
+                        '*': {
+                            webout: 'RECORDED-SESSION',
+                            log: 'NOTE: the demo session',
+                            print: ''
+                        }
+                    };
+                    worker = seeded();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('services/public/twin.js')] = '_webout = "from the js twin";',
+                        _a[drivePath('services/public/twin.sas')] = 'data work.class; run;',
+                        _a));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/twin")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _b.sent();
+                    expect(body).toContain('from the js twin');
+                    expect(body).not.toContain('RECORDED-SESSION');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('runs a JavaScript program rather than answering it with the recorded session', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // Same rule on the program path: a program run states no run time, so its extension
+                    // decides - `service.js` is executed, `report.sas` is not.
+                    ;
+                    global.__sasTranscript = {
+                        '*': {
+                            webout: 'RECORDED-SESSION',
+                            log: 'NOTE: the demo session',
+                            print: ''
+                        }
+                    };
+                    worker = seeded();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('services/public/service.js')] = '_webout = "from the service";',
+                        _a));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/service")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
                     return [4 /*yield*/, response.text()];
                 case 2:
-                    _a.apply(void 0, [_d.sent()]).toContain('SAS is not available');
+                    body = _b.sent();
+                    expect(body).toContain('from the service');
+                    expect(body).not.toContain('RECORDED-SESSION');
                     delete global.__sasTranscript;
                     return [2 /*return*/];
             }
         });
     }); });
-    it('refuses SAS code that names no recorded program', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('answers SAS code that names no recorded program with the mocked session', function () { return __awaiter(void 0, void 0, void 0, function () {
         var worker, _a, _b, code, response, body, e_1_1;
         var e_1, _c;
         return __generator(this, function (_d) {
@@ -544,11 +776,11 @@ describe('service worker host', function () {
                     return [4 /*yield*/, worker.dispatch('/SASjsApi/code/execute', runRequest({ code: code, runTime: 'sas' }))];
                 case 3:
                     response = _d.sent();
-                    expect(response.status).toBe(400);
+                    expect(response.status).toBe(200);
                     return [4 /*yield*/, response.text()];
                 case 4:
                     body = _d.sent();
-                    expect(body).toContain('SAS is not available');
+                    expect(body).toContain('This is a mocked SAS session');
                     expect(body).not.toContain('SyntaxError');
                     _d.label = 5;
                 case 5:
@@ -569,7 +801,7 @@ describe('service worker host', function () {
             }
         });
     }); });
-    it('refuses a .sas program no recording names, as it always did', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('answers a .sas program no recording names with the mocked session', function () { return __awaiter(void 0, void 0, void 0, function () {
         var worker, response, body;
         var _a;
         return __generator(this, function (_b) {
@@ -580,15 +812,16 @@ describe('service worker host', function () {
                         _a[drivePath('services/public/other.sas')] = 'data work.class; run;',
                         _a));
                     return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
-                            encodeURIComponent("".concat(appLoc, "/services/public/other")))];
+                            encodeURIComponent("".concat(appLoc, "/services/public/other")) +
+                            '&_debug=131')];
                 case 1:
                     response = _b.sent();
-                    expect(response.status).toBe(400);
+                    expect(response.status).toBe(200);
                     return [4 /*yield*/, response.text()];
                 case 2:
                     body = _b.sent();
-                    expect(body).toContain('SAS is not available');
-                    expect(body).toContain('recorded session');
+                    expect(body).toContain('This is a mocked SAS session');
+                    expect(body).not.toContain('SAS is not available');
                     expect(body).not.toContain('SyntaxError');
                     return [2 /*return*/];
             }
@@ -1396,41 +1629,88 @@ describe('service worker host', function () {
                 }
             });
         }); });
-        it('keeps a trigger a JSON answer, not the recorded transcript', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var worker, response, body;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+        it('answers a trigger of a SAS program with a session, not a refusal', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, body, state, _a, output, _b;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
-                        // A recording answers a run, not a trigger: the trigger route answers with
-                        // the session record a client parses as JSON, so returning the framed
-                        // webout there would break triggerProgram and the Studio.
+                        // A trigger reaches the runtime rather than the run route, so it is answered there - and
+                        // still as the session record a client parses as JSON, never the framed run. Returning the
+                        // framed webout would break triggerProgram and the Studio.
                         ;
-                        global.__sasTranscript = (_a = {},
-                            _a["".concat(appLoc, "/services/public/report.sas")] = {
+                        global.__sasTranscript = (_c = {},
+                            _c["".concat(appLoc, "/services/public/report.sas")] = {
                                 webout: '{"SYSSITE":"00000000"}',
                                 log: 'NOTE: recorded',
                                 print: 'The SAS System'
                             },
-                            _a);
+                            _c);
                         worker = loadWorker();
-                        worker.runtime.load((_b = {},
-                            _b[drivePath('services/public/report.sas')] = 'data work.class; run;',
-                            _b));
+                        worker.runtime.load((_d = {},
+                            _d[drivePath('services/public/report.sas')] = 'data work.class; run;',
+                            _d));
                         return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/trigger?_program=' +
                                 encodeURIComponent("".concat(appLoc, "/services/public/report")), runRequest({ params: {} }))];
                     case 1:
-                        response = _c.sent();
+                        response = _e.sent();
+                        expect(response.status).toBe(200);
                         expect(response.headers.get('content-type')).toContain('application/json');
                         return [4 /*yield*/, response.json()];
                     case 2:
-                        body = _c.sent();
+                        body = _e.sent();
                         expect(body).not.toHaveProperty('webout');
+                        expect(body.sessionId).toBeTruthy();
+                        return [4 /*yield*/, worker.dispatch("/SASjsApi/session/".concat(body.sessionId, "/state"))];
+                    case 3:
+                        state = _e.sent();
+                        _a = expect;
+                        return [4 /*yield*/, state.json()];
+                    case 4:
+                        _a.apply(void 0, [_e.sent()]).toEqual({ state: 'completed' });
+                        return [4 /*yield*/, worker.dispatch("/SASjsApi/session/".concat(body.sessionId, "/output"))];
+                    case 5:
+                        output = _e.sent();
+                        _b = expect;
+                        return [4 /*yield*/, output.text()];
+                    case 6:
+                        _b.apply(void 0, [_e.sent()]).toContain('SYSSITE');
                         delete global.__sasTranscript;
                         return [2 /*return*/];
                 }
             });
         }); });
+        it('answers a triggered SAS program the project never recorded', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, sessionId, output, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        worker = loadWorker();
+                        worker.runtime.load((_b = {},
+                            _b[drivePath('services/public/other.sas')] = 'data work.class; run;',
+                            _b));
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/trigger?_program=' +
+                                encodeURIComponent("".concat(appLoc, "/services/public/other")), runRequest({ params: {} }))];
+                    case 1:
+                        response = _c.sent();
+                        expect(response.status).toBe(200);
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        sessionId = (_c.sent()).sessionId;
+                        expect(sessionId).toBeTruthy();
+                        return [4 /*yield*/, worker.dispatch("/SASjsApi/session/".concat(sessionId, "/output"))];
+                    case 3:
+                        output = _c.sent();
+                        expect(output.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, output.text()];
+                    case 4:
+                        _a.apply(void 0, [_c.sent()]).toContain('SYSSITE');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('refuses a deploy upload with no archive, and one that is not a zip', function () { return __awaiter(void 0, void 0, void 0, function () {
             var dispatch, empty, _a, form, notZip, _b;
             return __generator(this, function (_c) {

package/package.json

@@ -73,7 +73,7 @@
     "@sasjs/adapter": "6.0.2",
     "@sasjs/api": "0.28.0",
     "@sasjs/core": "7.1.12",
-    "@sasjs/lint": "5.1.1",
+    "@sasjs/lint": "5.3.0",
     "@sasjs/utils": "4.11.0",
     "axios": "1.20.0",
     "chalk": "4.1.2",
@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.27.2"
+  "version": "6.28.0"
 }