@sasjs/cli 6.0.0 → 6.1.0

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -0,0 +1,296 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The parity claim of a browser-hosted build is that a service runs in the
+ * browser exactly as it runs as a stored program. That claim lives in
+ * runtime-core.js (parameter emission, WEBIN refs, program resolution, webout
+ * precedence, the error shape), so it is tested directly against the file the
+ * site ships.
+ */
+var appLoc = '/Public/app/test';
+var drivePath = function (relative) {
+    return "/sasjs/drive/files".concat(appLoc, "/").concat(relative);
+};
+var loadRuntime = function () {
+    ;
+    global.self = {};
+    jest.resetModules();
+    return require('../assets/runtime-core.js');
+};
+var jsonResponse = function (body) { return ({
+    ok: true,
+    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, body];
+    }); }); }
+}); };
+var seedDrive = function (runtime, files) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                ;
+                global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        if (url.includes('mock-config'))
+                            return [2 /*return*/, jsonResponse({ appLoc: appLoc })];
+                        if (url.includes('vfs-seed'))
+                            return [2 /*return*/, jsonResponse({ files: files })];
+                        return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({})];
+                                }); }); } }];
+                    });
+                }); });
+                return [4 /*yield*/, runtime.seed()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+describe('browser runtime', function () {
+    afterEach(function () {
+        delete global.self;
+        delete global.fetch;
+    });
+    it('exposes request parameters as variables, with JSON escaping', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: '_webout = typeof said + "|" + said + "|" + count;',
+            params: { said: 'he said "hi"\nback\\slash', count: '7' }
+        });
+        expect(result.error).toBeNull();
+        expect(result.webout).toBe('string|he said "hi"\nback\\slash|7');
+    });
+    it('leaves a parameter name that is not an identifier out of the prelude', function () {
+        var runtime = loadRuntime();
+        // an emitted `const not-an-identifier` would be a syntax error for every
+        // service on the drive, so such names are filtered out
+        var result = runtime.run({
+            code: '_webout = "ran";',
+            params: { 'not-an-identifier': 'x', '1leading': 'y' }
+        });
+        expect(result.error).toBeNull();
+        expect(result.webout).toBe('ran');
+    });
+    it('exposes uploaded tables as WEBIN refs', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: '_webout = [_WEBIN_FILE_COUNT, _WEBIN_NAME1, _WEBIN_FILENAME1, _WEBIN_FILEREF1].join(",");',
+            tables: [{ name: 'table1', filename: 'data.csv', csv: 'a,b\n1,2\n' }]
+        });
+        expect(result.error).toBeNull();
+        expect(result.webout).toBe('1,table1,data.csv,a,b\n1,2\n');
+        // the fileref carries the CSV verbatim, as the fileref does on the server
+        expect(result.webout).toContain('a,b\n1,2');
+    });
+    it('reads a webout the service wrote to the fileref directly', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: "require('fs').writeFileSync(weboutPath, 'from-file');"
+        });
+        expect(result.webout).toBe('from-file');
+    });
+    it('writes an assigned webout to the fileref, as the generated program does', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({ code: "_webout = 'inline';" });
+        expect(result.webout).toBe('inline');
+    });
+    it('reports a thrown error without failing the run', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({ code: 'throw new Error("boom")' });
+        expect(result.error).toContain('boom');
+        expect(result.log).toContain('boom');
+        expect(result.webout).toBe('');
+    });
+    it('collects service console output into the log', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: 'console.log("hello", { a: 1 }); _webout = "ok";'
+        });
+        expect(result.log).toContain('hello {"a":1}');
+        expect(result.webout).toBe('ok');
+    });
+    it('resolves the full path the adapter sends', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "full";',
+                            _a))];
+                case 1:
+                    _b.sent();
+                    result = runtime.run({ program: "".concat(appLoc, "/services/public/getdata") });
+                    expect(result.error).toBeNull();
+                    expect(result.webout).toBe('full');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('resolves an appLoc-relative reference under services, jobs or tests', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "apploc-relative";',
+                            _a[drivePath('jobs/public/loaddata.js')] = '_webout = "job";',
+                            _a))
+                        // the adapter prepends the appLoc when the app passes no leading slash
+                    ];
+                case 1:
+                    _b.sent();
+                    // the adapter prepends the appLoc when the app passes no leading slash
+                    expect(runtime.run({ program: "".concat(appLoc, "/public/getdata") }).webout).toBe('apploc-relative');
+                    expect(runtime.run({ program: 'public/loaddata' }).webout).toBe('job');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('gives a service the virtual drive to work on', function () {
+        var runtime = loadRuntime();
+        var folder = "/sasjs/drive/files".concat(appLoc, "/data");
+        var result = runtime.run({
+            code: [
+                "fs.mkdirSync('".concat(folder, "');"),
+                "fs.writeFileSync('".concat(folder, "/a.txt', 'hello');"),
+                "fs.copyFileSync('".concat(folder, "/a.txt', '").concat(folder, "/b.txt');"),
+                "const seen = [fs.existsSync('".concat(folder, "/a.txt'), fs.readFileSync('").concat(folder, "/b.txt'), fs.statSync('").concat(folder, "/a.txt').size, fs.readdirSync('").concat(folder, "').join()];"),
+                "fs.unlinkSync('".concat(folder, "/b.txt');"),
+                "_webout = seen.join('|') + '|' + fs.existsSync('".concat(folder, "/b.txt');")
+            ].join('\n')
+        });
+        expect(result.error).toBeNull();
+        expect(result.webout).toBe('true|hello|5|a.txt,b.txt|false');
+    });
+    it('reports a missing drive file the way the server does', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: "_webout = String(require('fs').readFileSync('/no/such/file'))"
+        });
+        expect(result.error).toContain('ENOENT');
+    });
+    it('hands the headers a service writes back to the host', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: "require('fs').writeFileSync(_SASJS_WEBOUT_HEADERS, 'content-type: application/json');"
+        });
+        expect(result.headers).toBe('content-type: application/json');
+    });
+    it('lists folders and builds the drive tree', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, listing, tree;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "x";',
+                            _a[drivePath('data/a.txt')] = 'a',
+                            _a))];
+                case 1:
+                    _b.sent();
+                    listing = runtime.list("".concat(appLoc, "/services/public"));
+                    expect(listing.files).toEqual(['getdata.js']);
+                    tree = runtime.tree();
+                    expect(JSON.stringify(tree)).toContain('getdata.js');
+                    expect(runtime.read("".concat(appLoc, "/data/a.txt")).contents).toBe('a');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports the files a run changed, and the whole drive on demand', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "x";',
+                            _a))];
+                case 1:
+                    _b.sent();
+                    runtime.takeDirty();
+                    runtime.run({
+                        code: "require('fs').writeFileSync('/sasjs/drive/files".concat(appLoc, "/data/new.txt', 'n');")
+                    });
+                    expect(Object.keys(runtime.takeDirty())).toEqual([
+                        "/sasjs/drive/files".concat(appLoc, "/data/new.txt")
+                    ]);
+                    expect(Object.keys(runtime.dumpAll()).some(function (k) { return k.endsWith('new.txt'); })).toBe(true);
+                    // the seed, the three session files and the one the service wrote
+                    expect(runtime.stats().files).toBe(5);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('clears the drive and re-seeds on reset', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
+                            _a))];
+                case 1:
+                    _b.sent();
+                    runtime.run({
+                        code: "require('fs').writeFileSync('/sasjs/drive/files".concat(appLoc, "/temp.txt', 't');")
+                    });
+                    expect(runtime.dumpAll()["/sasjs/drive/files".concat(appLoc, "/temp.txt")]).toBe('t');
+                    return [4 /*yield*/, runtime.reset()];
+                case 2:
+                    _b.sent();
+                    expect(runtime.dumpAll()["/sasjs/drive/files".concat(appLoc, "/temp.txt")]).toBe(undefined);
+                    expect(runtime.run({ program: "".concat(appLoc, "/services/public/getdata") }).webout).toBe('seeded');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails a run that names a program the drive does not hold', function () {
+        var runtime = loadRuntime();
+        expect(function () { return runtime.run({ program: 'services/public/missing' }); }).toThrow(/Program not found in drive/);
+    });
+});

package/build/commands/build/internal/mockSite/spec/sw.spec.d.ts

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

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

@@ -0,0 +1,361 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The other half of the parity claim: the service worker is what turns an
+ * /SASjsApi/ request into a response, so its framing (webout body, the _debug
+ * log shape, the 400 and the 500) is tested against the file the site ships.
+ */
+var appLoc = '/Public/app/test';
+var origin = 'https://mock.example.com';
+var LOGS_SEPARATOR = 'SASJS_LOGS_SEPARATOR_163ee17b6ff24f028928972d80a26784';
+var drivePath = function (relative) {
+    return "/sasjs/drive/files".concat(appLoc, "/").concat(relative);
+};
+var loadWorker = function () {
+    jest.resetModules();
+    var handlers = {};
+    var self = {
+        location: { origin: origin },
+        addEventListener: function (type, fn) {
+            handlers[type] = handlers[type] || [];
+            handlers[type].push(fn);
+        },
+        skipWaiting: function () { },
+        clients: { claim: function () { }, matchAll: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, []];
+            }); }); } }
+    };
+    global.self = self;
+    global.importScripts = function (path) {
+        if (path.includes('md5'))
+            return;
+        require('../assets/runtime-core.js');
+    };
+    require('../assets/sw.js');
+    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            return [2 /*return*/, String(url).includes('vfs-seed')
+                    ? jsonResponse({
+                        files: (_a = {},
+                            _a[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
+                            _a)
+                    })
+                    : jsonResponse({ appLoc: appLoc })];
+        });
+    }); });
+    var runtime = self.SASjsMockRuntime;
+    var dispatch = function (path, init) {
+        if (init === void 0) { init = {}; }
+        var request = new Request(origin + path, init);
+        var event = {
+            request: request,
+            respondWith: function (response) {
+                event.response = response;
+            }
+        };
+        (handlers.fetch || [])[0](event);
+        return event.response;
+    };
+    var message = function (data) {
+        var replies = [];
+        var event = {
+            data: data,
+            source: { postMessage: function (m) { return replies.push(m); } },
+            waitUntil: function (promise) {
+                event.pending = promise;
+            }
+        };
+        (handlers.message || []).forEach(function (fn) { return fn(event); });
+        return { replies: replies, pending: event.pending };
+    };
+    var lifecycle = function (type) {
+        var event = { waitUntil: function () { } };
+        (handlers[type] || []).forEach(function (fn) { return fn(event); });
+    };
+    return { runtime: runtime, dispatch: dispatch, message: message, lifecycle: lifecycle, self: self };
+};
+var jsonResponse = function (body) { return ({
+    ok: true,
+    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, body];
+    }); }); }
+}); };
+var runRequest = function (body) { return ({
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body)
+}); };
+describe('service worker host', function () {
+    afterEach(function () {
+        delete global.self;
+        delete global.importScripts;
+        delete global.fetch;
+    });
+    var seeded = function () {
+        var _a;
+        var worker = loadWorker();
+        worker.runtime.load((_a = {},
+            _a[drivePath('services/public/getdata.js')] = 'console.log("hello"); _webout = "seeded";',
+            _a));
+        return worker;
+    };
+    it('returns the webout as the response body', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/getdata")))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('seeded');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('frames the log behind the separator when _debug is set', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/getdata")) +
+                            '&_debug=log')
+                        // the log lands between the separators, not the empty string the framing
+                        // would produce if the lines were dropped
+                    ];
+                case 1:
+                    response = _b.sent();
+                    // the log lands between the separators, not the empty string the framing
+                    // would produce if the lines were dropped
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    // the log lands between the separators, not the empty string the framing
+                    // would produce if the lines were dropped
+                    _a.apply(void 0, [_b.sent()]).toBe(['seeded', LOGS_SEPARATOR, 'hello', LOGS_SEPARATOR].join('\n'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers 400 when a request names neither a program nor code', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute')];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(400);
+                    _a = expect;
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toEqual({ message: '_program is required' });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers 500 with the failure shape when the service throws', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, runtime, dispatch, response, body;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = seeded(), runtime = _a.runtime, dispatch = _a.dispatch;
+                    runtime.load((_b = {},
+                        _b[drivePath('services/public/broken.js')] = 'throw new Error("boom")',
+                        _b));
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/broken")))];
+                case 1:
+                    response = _c.sent();
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    body = _c.sent();
+                    expect(response.status).toBe(500);
+                    expect(body.status).toBe('failure');
+                    expect(body.error).toContain('boom');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('runs code carried by a code/execute request', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/code/execute', runRequest({ code: '_webout = "inline";', params: {} }))];
+                case 1:
+                    response = _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('inline');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a file off the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/getdata.js")))];
+                case 1:
+                    response = _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('console.log("hello"); _webout = "seeded";');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers the API info and drive routes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, info, _a, folder, _b, tree, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/info')];
+                case 1:
+                    info = _f.sent();
+                    _a = expect;
+                    return [4 /*yield*/, info.json()];
+                case 2:
+                    _a.apply(void 0, [_f.sent()]).toEqual(expect.objectContaining({ protocol: 'browser', runTimes: ['js'] }));
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/folder?_folderPath=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public")))];
+                case 3:
+                    folder = _f.sent();
+                    _b = expect;
+                    return [4 /*yield*/, folder.json()];
+                case 4:
+                    _b.apply(void 0, [(_f.sent()).files]).toContain('getdata.js');
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/filetree')];
+                case 5:
+                    tree = _f.sent();
+                    _c = expect;
+                    _e = (_d = JSON).stringify;
+                    return [4 /*yield*/, tree.json()];
+                case 6:
+                    _c.apply(void 0, [_e.apply(_d, [_f.sent()])]).toContain('getdata.js');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('accepts a multipart request body', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, form, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    form = new FormData();
+                    form.append('_program', "".concat(appLoc, "/services/public/getdata"));
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute', {
+                            method: 'POST',
+                            body: form
+                        })];
+                case 1:
+                    response = _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('seeded');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('acknowledges a load, a seed, a reset and a snapshot from the page', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, message, runtime, files, load, seed, snapshot, reset, stats;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = seeded(), message = _a.message, runtime = _a.runtime;
+                    files = (_b = {}, _b[drivePath('services/public/other.js')] = '_webout = "x";', _b);
+                    load = message({ type: 'sasjs-load', files: files });
+                    return [4 /*yield*/, load.pending];
+                case 1:
+                    _c.sent();
+                    expect(load.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-load-ack' }));
+                    seed = message({ type: 'sasjs-seed' });
+                    return [4 /*yield*/, seed.pending];
+                case 2:
+                    _c.sent();
+                    expect(seed.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-seed-ack' }));
+                    runtime.load(files);
+                    snapshot = message({ type: 'sasjs-snapshot' });
+                    expect(snapshot.replies[0].type).toBe('sasjs-snapshot');
+                    expect(Object.keys(snapshot.replies[0].files).length).toBe(1);
+                    reset = message({ type: 'sasjs-reset' });
+                    return [4 /*yield*/, reset.pending];
+                case 3:
+                    _c.sent();
+                    expect(reset.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-reset-ack' }));
+                    stats = message({ type: 'sasjs-stats' });
+                    return [4 /*yield*/, stats.pending];
+                case 4:
+                    _c.sent();
+                    expect(stats.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-stats' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('claims the clients on install and activate', function () {
+        var lifecycle = seeded().lifecycle;
+        expect(function () { return lifecycle('install'); }).not.toThrow();
+        expect(function () { return lifecycle('activate'); }).not.toThrow();
+    });
+    it('leaves requests outside /SASjsApi/ to the static host', function () {
+        var dispatch = seeded().dispatch;
+        expect(dispatch('/index.html')).toBeUndefined();
+    });
+});

package/build/commands/index.d.ts

@@ -3,6 +3,7 @@ export { addCredential } from './add/addCredential';
 export { compile } from './compile/compile';
 export { compileSingleFile } from './compile/compileSingleFile';
 export { build, getBuildVars } from './build/build';
+export { buildMockSite } from './build/internal/mockSite/mockSite';
 export { init } from './init/init';
 export { create } from './create/create';
 export { generateDocs } from './docs/generateDocs';