@sasjs/cli 6.0.0 → 6.2.0

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

@@ -0,0 +1,716 @@
+"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(path.startsWith('http') ? path : 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*/];
+            }
+        });
+    }); });
+    /**
+     * A worker whose drive holds one service that answers with a download, the
+     * way a streaming service does on the server: the body goes to the webout
+     * fileref and the headers file says what it is.
+     */
+    var streaming = function (code) {
+        var _a;
+        var worker = loadWorker();
+        worker.runtime.load((_a = {},
+            _a[drivePath('services/public/download.js')] = code,
+            _a));
+        return worker;
+    };
+    var downloadPath = function (query) {
+        if (query === void 0) { query = ''; }
+        return '/SASjsApi/stp/execute?_program=' +
+            encodeURIComponent("".concat(appLoc, "/services/public/download")) +
+            query;
+    };
+    it('applies the content type and disposition a service declared', 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 = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: text/csv \\n Content-Disposition: attachment;filename="users.csv"\')',
+                        "_webout = 'a,b\\n1,2'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    expect(response.headers.get('content-type')).toBe('text/csv');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="users.csv"');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('a,b\n1,2');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte body as bytes, under the name the service chose', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: application/zip\\nContent-Disposition: attachment;filename="pack.zip"\')',
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([80, 75, 3, 4]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _c.sent();
+                    expect(response.headers.get('content-type')).toBe('application/zip');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="pack.zip"');
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(new Uint8Array([80, 75, 3, 4]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte body with no declared type as an opaque download', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = streaming('fs.writeFileSync(weboutPath, Uint8Array.from([1, 2, 3]))').dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _c.sent();
+                    expect(response.headers.get('content-type')).toBe('application/octet-stream');
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(new Uint8Array([1, 2, 3]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a debug reply text, as the body is the framed log', 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 = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: application/zip\\nContent-Disposition: attachment;filename="pack.zip"\')',
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([80, 75, 3, 4]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath('&_debug=log'))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('text/plain');
+                    expect(response.headers.get('content-disposition')).toBeNull();
+                    // the body is still bytes, framed with the log rather than corrupted by it
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    // the body is still bytes, framed with the log rather than corrupted by it
+                    _a.apply(void 0, [_b.sent()]).toBe(['UEsDBA==', LOGS_SEPARATOR, '', LOGS_SEPARATOR].join('\n'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('applies nothing it was not asked for, and drops an unusable value', 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 = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Cache-Control: no-store\\nContent-type: text/html\\u0000')",
+                        "_webout = 'plain'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    expect(response.headers.get('cache-control')).toBeNull();
+                    // a NUL would make Response throw, so the header is dropped and the body
+                    // keeps its default type
+                    expect(response.headers.get('content-type')).toBe('text/plain;charset=UTF-8');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('plain');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte file off the drive as bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, runtime, dispatch, response, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _a = seeded(), runtime = _a.runtime, dispatch = _a.dispatch;
+                    runtime.run({
+                        code: "fs.writeFileSync('/sasjs/drive/files/data.bin', Uint8Array.from([1, 2, 3]))"
+                    });
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data.bin'))];
+                case 1:
+                    response = _d.sent();
+                    expect(response.headers.get('content-type')).toBe('application/octet-stream');
+                    _b = expect;
+                    _c = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _b.apply(void 0, [new (_c.apply(Uint8Array, [void 0, _d.sent()]))()]).toEqual(new Uint8Array([1, 2, 3]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a tab inside a header value, as HTTP allows it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;\\tfilename="a.zip"\')',
+                        '_webout = "x"'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _a.sent();
+                    expect(response.headers.get('content-disposition')).toBe('attachment;\tfilename="a.zip"');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('lets the last line for a header win, and an unusable one remove it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var replaced, _a, removed, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    replaced = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: text/plain\\nContent-type: application/json')",
+                        '_webout = "x"'
+                    ].join('\n'));
+                    _a = expect;
+                    return [4 /*yield*/, replaced.dispatch(downloadPath())];
+                case 1:
+                    _a.apply(void 0, [(_c.sent()).headers.get('content-type')]).toBe('application/json');
+                    removed = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: text/plain\\nContent-type: text/html\\u0000')",
+                        '_webout = "x"'
+                    ].join('\n'));
+                    _b = expect;
+                    return [4 /*yield*/, removed.dispatch(downloadPath())];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).headers.get('content-type')]).toBe('text/plain;charset=UTF-8');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('normalises header names and ignores a line that is not a header', 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 = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'CONTENT-TYPE: text/plain\\nnot a header\\n: no name\\nContent-Disposition: attachment;filename="a.txt"\')',
+                        "_webout = 'x'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('text/plain');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="a.txt"');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('x');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a service that declares a type but writes no 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 = streaming("fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: application/json')").dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('application/json');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers the session state, and names a route it does not implement', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, session, _a, unknown, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/session')];
+                case 1:
+                    session = _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, session.json()];
+                case 2:
+                    _a.apply(void 0, [_c.sent()]).toEqual({ state: 'completed' });
+                    return [4 /*yield*/, dispatch('/SASjsApi/unknown/route')];
+                case 3:
+                    unknown = _c.sent();
+                    expect(unknown.status).toBe(404);
+                    _b = expect;
+                    return [4 /*yield*/, unknown.json()];
+                case 4:
+                    _b.apply(void 0, [(_c.sent()).message]).toContain('Not implemented');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers 404 for a drive file the drive does not hold', 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('/missing.txt'))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(404);
+                    _a = expect;
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    _a.apply(void 0, [(_b.sent()).message]).toBe('File not found');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a request to another origin alone', function () {
+        var dispatch = seeded().dispatch;
+        expect(dispatch('https://other.example.com/SASjsApi/info')).toBeUndefined();
+    });
+    it('passes a latin1 header value through as written, and drops one Response cannot carry', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var accented, kept, beyond, dropped;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    accented = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;filename="r\\u00e9sum\\u00e9.csv"\')',
+                        "_webout = 'x'"
+                    ].join('\n'));
+                    return [4 /*yield*/, accented.dispatch(downloadPath())];
+                case 1:
+                    kept = _a.sent();
+                    expect(kept.headers.get('content-disposition')).toBe('attachment;filename="r\u00e9sum\u00e9.csv"');
+                    beyond = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;filename="\\u{1F600}.csv"\')',
+                        "_webout = 'x'"
+                    ].join('\n'));
+                    return [4 /*yield*/, beyond.dispatch(downloadPath())];
+                case 2:
+                    dropped = _a.sent();
+                    expect(dropped.status).toBe(200);
+                    expect(dropped.headers.get('content-disposition')).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers 500 when a byte entry on the drive is not valid base64', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('data.bin')] = '\u0000base64:!!!not base64!!!',
+                        _b));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' +
+                            encodeURIComponent("".concat(appLoc, "/data.bin")))];
+                case 1:
+                    response = _c.sent();
+                    expect(response.status).toBe(500);
+                    _a = expect;
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    _a.apply(void 0, [(_c.sent()).message]).toContain('Corrupt binary entry');
+                    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('reports a corrupt entry in the stats reply rather than leaving the page waiting', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, stats;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('data.bin')] = '\u0000base64:!!!not base64!!!',
+                        _a));
+                    stats = worker.message({ type: 'sasjs-stats' });
+                    return [4 /*yield*/, stats.pending];
+                case 1:
+                    _b.sent();
+                    expect(stats.replies[0]).toEqual(expect.objectContaining({
+                        type: 'sasjs-stats',
+                        error: expect.stringContaining('Corrupt binary entry')
+                    }));
+                    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();
+    });
+});