@sasjs/cli 6.14.0 → 6.16.0

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

@@ -68,6 +68,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
 var api_1 = require("@sasjs/api");
+var os_1 = __importDefault(require("os"));
+var yazl_1 = __importDefault(require("yazl"));
+var mockSite_1 = require("../mockSite");
 /**
  * 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
@@ -86,6 +89,19 @@ var drivePath = function (relative) {
 var apiBrowserBuild = function () {
     return path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
 };
+/**
+ * The lint bundle the site ships, built once for the suite from the installed
+ * packages - the same call `sasjs build` makes, so the worker under test answers
+ * the code routes with the code the site carries.
+ */
+var lintBundlePath;
+var lintBundle = function () {
+    if (!lintBundlePath) {
+        lintBundlePath = path_1.default.join(os_1.default.tmpdir(), "sasjs-lint-".concat(process.pid, ".js"));
+        (0, mockSite_1.buildLintBundle)(lintBundlePath);
+    }
+    return lintBundlePath;
+};
 var loadWorker = function () {
     jest.resetModules();
     var handlers = {};
@@ -107,6 +123,13 @@ var loadWorker = function () {
             return;
         if (path.includes('api-browser'))
             return require(apiBrowserBuild());
+        if (path.includes('lint-browser')) {
+            // the bundle assigns globalThis.SASjsCode, and this harness keeps the
+            // worker's `self` apart from the module global
+            require(lintBundle());
+            self.SASjsCode = global.SASjsCode;
+            return;
+        }
         require('../assets/runtime-core.js');
         // The corpus needs the same drive with its writes refused, without building
         // a second site. The flag is flipped after the case has seeded, because a
@@ -132,10 +155,20 @@ var loadWorker = function () {
         };
     };
     require('../assets/sw.js');
-    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+    global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+        var target;
         var _a;
         return __generator(this, function (_b) {
-            return [2 /*return*/, String(url).includes('vfs-seed')
+            target = typeof input === 'string' ? input : (input && input.url) || String(input);
+            // a navigation back to the site root: the static host's copy of the page
+            if (new URL(target, origin).pathname === '/')
+                return [2 /*return*/, new Response('<html><body>static page</body></html>', {
+                        status: 200,
+                        headers: { 'content-type': 'text/html' }
+                    })];
+            if (target.includes('index.html'))
+                return [2 /*return*/, new Response('<!doctype html><html><head><title>App</title></head><body>home</body></html>', { status: 200, headers: { 'content-type': 'text/html' } })];
+            return [2 /*return*/, target.includes('vfs-seed')
                     ? jsonResponse({
                         files: (_a = {},
                             _a[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
@@ -190,6 +223,24 @@ var jsonResponse = function (body) { return ({
         return [2 /*return*/, body];
     }); }); }
 }); };
+/** A zip archive of text members, written the way a deploy upload ships one.
+ * The first member is stored rather than deflated, so both methods the reader
+ * accepts are exercised by the one case. */
+var zipOf = function (files) {
+    return new Promise(function (resolve, reject) {
+        var zip = new yazl_1.default.ZipFile();
+        Object.keys(files).forEach(function (name, index) {
+            return zip.addBuffer(Buffer.from(files[name]), name, {
+                compress: index !== 0
+            });
+        });
+        zip.end();
+        var chunks = [];
+        zip.outputStream.on('data', function (chunk) { return chunks.push(chunk); });
+        zip.outputStream.on('end', function () { return resolve(Buffer.concat(chunks)); });
+        zip.outputStream.on('error', reject);
+    });
+};
 var runRequest = function (body) { return ({
     method: 'POST',
     headers: { 'content-type': 'application/json' },
@@ -551,31 +602,543 @@ describe('service worker host', function () {
             }
         });
     }); });
-    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) {
+    it('answers the session route with the caller, and names a route it does not have', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, session, _a, refused, _b, unknown, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     dispatch = seeded().dispatch;
                     return [4 /*yield*/, dispatch('/SASjsApi/session')];
                 case 1:
-                    session = _c.sent();
+                    session = _d.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')];
+                    _a.apply(void 0, [_d.sent()]).toEqual({
+                        uid: 'user-admin',
+                        username: 'sasjsadmin',
+                        displayName: 'Demo Admin',
+                        isAdmin: true,
+                        needsToUpdatePassword: false
+                    });
+                    return [4 /*yield*/, dispatch('/SASjsApi/session', {
+                            headers: { authorization: 'Bearer not-a-token' }
+                        })];
                 case 3:
-                    unknown = _c.sent();
-                    expect(unknown.status).toBe(404);
+                    refused = _d.sent();
+                    expect(refused.status).toBe(401);
                     _b = expect;
-                    return [4 /*yield*/, unknown.json()];
+                    return [4 /*yield*/, refused.json()];
                 case 4:
-                    _b.apply(void 0, [(_c.sent()).message]).toContain('Not implemented');
+                    _b.apply(void 0, [(_d.sent()).message]).toBe('Unauthorized');
+                    return [4 /*yield*/, dispatch('/SASjsApi/unknown/route')];
+                case 5:
+                    unknown = _d.sent();
+                    expect(unknown.status).toBe(404);
+                    _c = expect;
+                    return [4 /*yield*/, unknown.json()];
+                case 6:
+                    _c.apply(void 0, [(_d.sent()).message]).toContain('Not part of the API');
                     return [2 /*return*/];
             }
         });
     }); });
+    describe('the API surface the package carries', function () {
+        it('answers the sign-in flow, and the record routes as that caller', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, signedIn, _a, refused, _b, authorized, code, exchanged, pair, users, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        worker = seeded();
+                        return [4 /*yield*/, worker.dispatch('/SASLogon/login', runRequest({ username: 'sasjsadmin', password: 'Orion123' }))];
+                    case 1:
+                        signedIn = _d.sent();
+                        expect(signedIn.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, signedIn.json()];
+                    case 2:
+                        _a.apply(void 0, [(_d.sent()).user.username]).toBe('sasjsadmin');
+                        return [4 /*yield*/, worker.dispatch('/SASLogon/login', runRequest({ username: 'sasjsadmin', password: 'nope' }))];
+                    case 3:
+                        refused = _d.sent();
+                        expect(refused.status).toBe(401);
+                        _b = expect;
+                        return [4 /*yield*/, refused.json()];
+                    case 4:
+                        _b.apply(void 0, [(_d.sent()).message]).toBe('Invalid Password.');
+                        return [4 /*yield*/, worker.dispatch('/SASLogon/authorize', runRequest({ clientId: 'web_app' }))];
+                    case 5:
+                        authorized = _d.sent();
+                        return [4 /*yield*/, authorized.json()];
+                    case 6:
+                        code = (_d.sent()).code;
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/auth/token', runRequest({ clientId: 'web_app', code: code }))];
+                    case 7:
+                        exchanged = _d.sent();
+                        return [4 /*yield*/, exchanged.json()];
+                    case 8:
+                        pair = _d.sent();
+                        expect(pair.accessToken).toBeTruthy();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/user', {
+                                headers: { authorization: "Bearer ".concat(pair.accessToken) }
+                            })];
+                    case 9:
+                        users = _d.sent();
+                        _c = expect;
+                        return [4 /*yield*/, users.json()];
+                    case 10:
+                        _c.apply(void 0, [(_d.sent()).map(function (user) { return user.username; }).sort()]).toEqual(['sasjsadmin', 'sasjsuser']);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('answers the administration records the fixture seeds', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, groups, _a, permissions, _b, clients, _c, mine, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/group')];
+                    case 1:
+                        groups = _g.sent();
+                        _a = expect;
+                        return [4 /*yield*/, groups.json()];
+                    case 2:
+                        _a.apply(void 0, [(_g.sent()).map(function (group) { return group.name; }).sort()]).toEqual(['Admins', 'DCGroup']);
+                        return [4 /*yield*/, dispatch('/SASjsApi/permission')];
+                    case 3:
+                        permissions = _g.sent();
+                        _b = expect;
+                        return [4 /*yield*/, permissions.json()];
+                    case 4:
+                        _b.apply(void 0, [(_g.sent()).length]).toBe(3);
+                        return [4 /*yield*/, dispatch('/SASjsApi/client')];
+                    case 5:
+                        clients = _g.sent();
+                        _c = expect;
+                        return [4 /*yield*/, clients.json()];
+                    case 6:
+                        _c.apply(void 0, [(_g.sent()).map(function (client) { return client.clientId; }).sort()]).toEqual(['sasjs', 'web_app']);
+                        return [4 /*yield*/, dispatch('/SASjsApi/info/myAuthorizedRoutes')];
+                    case 7:
+                        mine = _g.sent();
+                        _d = expect;
+                        _f = (_e = Object).keys;
+                        return [4 /*yield*/, mine.json()];
+                    case 8:
+                        _d.apply(void 0, [_f.apply(_e, [_g.sent()]).length]).toBeGreaterThan(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('answers the Admin reports from the worker activity log', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, empty, _a, afterFirst, _b, listed, lines, infoLines, diagnostics, report, logs, _c, tail, tailBody, wrongName, missing;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/diagnostics')];
+                    case 1:
+                        empty = _d.sent();
+                        _a = expect;
+                        return [4 /*yield*/, empty.json()];
+                    case 2:
+                        _a.apply(void 0, [(_d.sent()).logs]).toEqual({
+                            folder: 'worker memory',
+                            fileCount: 0,
+                            totalBytes: 0,
+                            newestFile: null,
+                            newestModified: null
+                        });
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
+                    case 3:
+                        afterFirst = _d.sent();
+                        _b = expect;
+                        return [4 /*yield*/, afterFirst.json()];
+                    case 4:
+                        _b.apply(void 0, [(_d.sent()).files.length]).toBe(1);
+                        // the file's mtime is the last write, not the moment a report was read:
+                        // /info was the request immediately before this listing
+                        return [4 /*yield*/, dispatch('/SASjsApi/info')];
+                    case 5:
+                        // the file's mtime is the last write, not the moment a report was read:
+                        // /info was the request immediately before this listing
+                        _d.sent();
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
+                    case 6: return [4 /*yield*/, (_d.sent()).json()];
+                    case 7:
+                        listed = (_d.sent())
+                            .files[0];
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/app.log?lines=20')];
+                    case 8: return [4 /*yield*/, (_d.sent()).json()];
+                    case 9:
+                        lines = (_d.sent()).content.split('\n');
+                        infoLines = lines.filter(function (line) {
+                            return line.includes('GET /SASjsApi/info 200');
+                        });
+                        expect(infoLines.length).toBe(1);
+                        expect(infoLines[0].startsWith(listed.modified)).toBe(true);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/diagnostics')];
+                    case 10:
+                        diagnostics = _d.sent();
+                        expect(diagnostics.status).toBe(200);
+                        return [4 /*yield*/, diagnostics.json()];
+                    case 11:
+                        report = _d.sent();
+                        expect(report.server.mode).toBe('browser');
+                        expect(report.filesystem).toBeNull();
+                        expect(report.logs.fileCount).toBe(1);
+                        expect(typeof report.memory.heapTotalBytes).toBe('number');
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
+                    case 12:
+                        logs = _d.sent();
+                        _c = expect;
+                        return [4 /*yield*/, logs.json()];
+                    case 13:
+                        _c.apply(void 0, [(_d.sent()).files.map(function (file) { return file.name; })]).toEqual([
+                            'app.log'
+                        ]);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/app.log?lines=5')];
+                    case 14:
+                        tail = _d.sent();
+                        return [4 /*yield*/, tail.json()];
+                    case 15:
+                        tailBody = _d.sent();
+                        expect(tail.status).toBe(200);
+                        expect(tailBody.content).toContain('GET /SASjsApi/info 200');
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/secret.txt')];
+                    case 16:
+                        wrongName = _d.sent();
+                        expect(wrongName.status).toBe(400);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/other.log')];
+                    case 17:
+                        missing = _d.sent();
+                        expect(missing.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('imports the fixture directory, and unpublishes the site itself', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, synced, _a, unpublished, _b, other;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/authConfig/synchroniseWithLDAP', { method: 'POST' })];
+                    case 1:
+                        synced = _c.sent();
+                        expect(synced.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, synced.json()];
+                    case 2:
+                        _a.apply(void 0, [_c.sent()]).toEqual({ userCount: 0, groupCount: 0 });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
+                                method: 'DELETE',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    streamServiceName: 'Test',
+                                    appLoc: appLoc
+                                })
+                            })];
+                    case 3:
+                        unpublished = _c.sent();
+                        expect(unpublished.status).toBe(200);
+                        _b = expect;
+                        return [4 /*yield*/, unpublished.json()];
+                    case 4:
+                        _b.apply(void 0, [_c.sent()]).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
+                                method: 'DELETE',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    streamServiceName: 'Other',
+                                    appLoc: '/Public/app/other'
+                                })
+                            })];
+                    case 5:
+                        other = _c.sent();
+                        expect(other.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('lints and formats a buffer with the bundled linter', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, linted, diagnostics, formatted, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/code/lint', runRequest({ code: 'data a;\nrun;\n' }))];
+                    case 1:
+                        linted = _b.sent();
+                        expect(linted.status).toBe(200);
+                        return [4 /*yield*/, linted.json()];
+                    case 2:
+                        diagnostics = _b.sent();
+                        expect(Array.isArray(diagnostics)).toBe(true);
+                        expect(diagnostics.length).toBeGreaterThan(0);
+                        expect(diagnostics[0].message).toContain('Doxygen');
+                        return [4 /*yield*/, dispatch('/SASjsApi/code/format', runRequest({ code: 'data a;set b;run;' }))];
+                    case 3:
+                        formatted = _b.sent();
+                        expect(formatted.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, formatted.text()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toContain('@brief');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('serves the build page at the home route, and falls back when it fails', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, _a, runtime, original, fallback, body;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = seeded();
+                        return [4 /*yield*/, worker.dispatch('/')];
+                    case 1:
+                        response = _b.sent();
+                        expect(response.status).toBe(200);
+                        expect(response.headers.get('content-type')).toContain('text/html');
+                        _a = expect;
+                        return [4 /*yield*/, response.text()];
+                    case 2:
+                        _a.apply(void 0, [_b.sent()]).toContain('<body>home</body>');
+                        runtime = worker.self.SASjsMockRuntime;
+                        original = runtime.ensureReady;
+                        runtime.ensureReady = function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                throw new Error('home route exploded');
+                            });
+                        }); };
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, , 6, 7]);
+                        return [4 /*yield*/, worker.dispatch('/')];
+                    case 4:
+                        fallback = _b.sent();
+                        expect(fallback.status).toBe(200);
+                        return [4 /*yield*/, fallback.text()];
+                    case 5:
+                        body = _b.sent();
+                        expect(body).toContain('static page');
+                        expect(body).not.toContain('home route exploded');
+                        return [3 /*break*/, 7];
+                    case 6:
+                        runtime.ensureReady = original;
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        it('matches a path whatever its casing, as the API does', 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/INFO')];
+                    case 1:
+                        response = _b.sent();
+                        expect(response.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        _a.apply(void 0, [(_b.sent()).mode]).toBe('desktop');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('starts a session, then reads its state, log and output', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, program, triggered, sessionId, state, _a, output, _b, log, missing;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        program = encodeURIComponent("".concat(appLoc, "/services/public/getdata"));
+                        return [4 /*yield*/, dispatch('/SASjsApi/stp/trigger?_program=' + program, runRequest({ params: {} }))];
+                    case 1:
+                        triggered = _c.sent();
+                        expect(triggered.status).toBe(200);
+                        return [4 /*yield*/, triggered.json()];
+                    case 2:
+                        sessionId = (_c.sent()).sessionId;
+                        expect(sessionId).toBeTruthy();
+                        return [4 /*yield*/, dispatch("/SASjsApi/session/".concat(sessionId, "/state"))];
+                    case 3:
+                        state = _c.sent();
+                        _a = expect;
+                        return [4 /*yield*/, state.json()];
+                    case 4:
+                        _a.apply(void 0, [_c.sent()]).toEqual({ state: 'completed' });
+                        return [4 /*yield*/, dispatch("/SASjsApi/session/".concat(sessionId, "/output"))];
+                    case 5:
+                        output = _c.sent();
+                        expect(output.status).toBe(200);
+                        _b = expect;
+                        return [4 /*yield*/, output.text()];
+                    case 6:
+                        _b.apply(void 0, [_c.sent()]).toBe('seeded');
+                        return [4 /*yield*/, dispatch("/SASjsApi/session/".concat(sessionId, "/log"))];
+                    case 7:
+                        log = _c.sent();
+                        expect(log.status).toBe(200);
+                        return [4 /*yield*/, dispatch('/SASjsApi/session/not-a-session/state')];
+                    case 8:
+                        missing = _c.sent();
+                        expect(missing.status).toBe(404);
+                        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) {
+                switch (_c.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy/upload', {
+                                method: 'POST',
+                                body: new FormData()
+                            })];
+                    case 1:
+                        empty = _c.sent();
+                        expect(empty.status).toBe(400);
+                        _a = expect;
+                        return [4 /*yield*/, empty.text()];
+                    case 2:
+                        _a.apply(void 0, [_c.sent()]).toBe('"file" is not present.');
+                        form = new FormData();
+                        form.set('file', new Blob([new Uint8Array([1, 2, 3])]), 'not-a-zip.zip');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy/upload', {
+                                method: 'POST',
+                                body: form
+                            })];
+                    case 3:
+                        notZip = _c.sent();
+                        expect(notZip.status).toBe(400);
+                        _b = expect;
+                        return [4 /*yield*/, notZip.text()];
+                    case 4:
+                        _b.apply(void 0, [_c.sent()]).toBe('The archive is not a zip file.');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('takes a token from the query when a link cannot carry a header', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, authorized, code, exchanged, pair, users, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = seeded();
+                        return [4 /*yield*/, worker.dispatch('/SASLogon/authorize', runRequest({ clientId: 'web_app' }))];
+                    case 1:
+                        authorized = _b.sent();
+                        return [4 /*yield*/, authorized.json()];
+                    case 2:
+                        code = (_b.sent()).code;
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/auth/token', runRequest({ clientId: 'web_app', code: code }))];
+                    case 3:
+                        exchanged = _b.sent();
+                        return [4 /*yield*/, exchanged.json()];
+                    case 4:
+                        pair = _b.sent();
+                        return [4 /*yield*/, worker.dispatch("/SASjsApi/user?access_token=".concat(encodeURIComponent(pair.accessToken)))];
+                    case 5:
+                        users = _b.sent();
+                        expect(users.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, users.json()];
+                    case 6:
+                        _a.apply(void 0, [(_b.sent()).length]).toBe(2);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('names a table the page did not name, and takes an archive under any field', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, unnamed, _a, form, _b, _c, _d, _e, _f, upload;
+            var _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        worker = seeded();
+                        worker.runtime.load((_g = {},
+                            _g[drivePath('services/public/echo.js')] = '_webout = _WEBIN_NAME1 + "|" + _WEBIN_FILEREF1;',
+                            _g));
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                                encodeURIComponent("".concat(appLoc, "/services/public/echo")), runRequest({ params: {}, tables: [{ csv: 'A,B\r\n1,2' }] }))];
+                    case 1:
+                        unnamed = _h.sent();
+                        _a = expect;
+                        return [4 /*yield*/, unnamed.text()];
+                    case 2:
+                        _a.apply(void 0, [_h.sent()]).toBe('table1|A,B\r\n1,2');
+                        form = new FormData();
+                        form.set('appLoc', appLoc);
+                        _c = (_b = form).set;
+                        _d = ['archive'];
+                        _e = Blob.bind;
+                        _f = Uint8Array.bind;
+                        return [4 /*yield*/, zipOf({ 'x.txt': 'x' })];
+                    case 3:
+                        _c.apply(_b, _d.concat([new (_e.apply(Blob, [void 0, [new (_f.apply(Uint8Array, [void 0, _h.sent()]))()]]))(),
+                            'deploy.zip']));
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/deploy/upload', {
+                                method: 'POST',
+                                body: form
+                            })];
+                    case 4:
+                        upload = _h.sent();
+                        expect(upload.status).toBe(200);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('expands an uploaded archive into the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, archive, form, response, tree, listing, _a, _b, file, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, zipOf({
+                                'services/public/run.js': '_webout = "deployed";',
+                                'docs/readme.txt': 'hello'
+                            })];
+                    case 1:
+                        archive = _d.sent();
+                        form = new FormData();
+                        form.set('appLoc', appLoc);
+                        form.set('file', new Blob([new Uint8Array(archive)]), 'deploy.zip');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy/upload', {
+                                method: 'POST',
+                                body: form
+                            })];
+                    case 2:
+                        response = _d.sent();
+                        expect(response.status).toBe(200);
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/filetree?_folderPath=' + encodeURIComponent(appLoc))];
+                    case 3:
+                        tree = _d.sent();
+                        _b = (_a = JSON).stringify;
+                        return [4 /*yield*/, tree.json()];
+                    case 4:
+                        listing = _b.apply(_a, [_d.sent()]);
+                        expect(listing).toContain('run.js');
+                        expect(listing).toContain('readme.txt');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent("".concat(appLoc, "/docs/readme.txt")))];
+                    case 5:
+                        file = _d.sent();
+                        _c = expect;
+                        return [4 /*yield*/, file.text()];
+                    case 6:
+                        _c.apply(void 0, [_d.sent()]).toBe('hello');
+                        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) {
@@ -686,12 +1249,12 @@ describe('service worker host', function () {
                     _a = expect;
                     return [4 /*yield*/, response.json()];
                 case 2:
-                    _a.apply(void 0, [_b.sent()]).toEqual({ message: '_program is required' });
+                    _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 () {
+    it('answers the documented failure envelope 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) {
@@ -705,11 +1268,17 @@ describe('service worker host', function () {
                             encodeURIComponent("".concat(appLoc, "/services/public/broken")))];
                 case 1:
                     response = _c.sent();
-                    return [4 /*yield*/, response.json()];
+                    return [4 /*yield*/, response.json()
+                        // the package's decision, and the server's: a run that failed is a 400
+                        // carrying the failure envelope, not a 500 that blames the transport
+                    ];
                 case 2:
                     body = _c.sent();
-                    expect(response.status).toBe(500);
+                    // the package's decision, and the server's: a run that failed is a 400
+                    // carrying the failure envelope, not a 500 that blames the transport
+                    expect(response.status).toBe(400);
                     expect(body.status).toBe('failure');
+                    expect(body.message).toBe('Job execution failed.');
                     expect(body.error).toContain('boom');
                     return [2 /*return*/];
             }
@@ -721,13 +1290,58 @@ describe('service worker host', function () {
             switch (_b.label) {
                 case 0:
                     dispatch = seeded().dispatch;
-                    return [4 /*yield*/, dispatch('/SASjsApi/code/execute', runRequest({ code: '_webout = "inline";', params: {} }))];
+                    return [4 /*yield*/, dispatch('/SASjsApi/code/execute', runRequest({ code: '_webout = "inline";', runTime: 'js', params: {} }))
+                        // a code route's documented body is the webout framed with the log, so the
+                        // run's output is the first section rather than the whole body
+                    ];
                 case 1:
                     response = _b.sent();
+                    // a code route's documented body is the webout framed with the log, so the
+                    // run's output is the first section rather than the whole body
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    // a code route's documented body is the webout framed with the log, so the
+                    // run's output is the first section rather than the whole body
+                    _a.apply(void 0, [(_b.sent()).split(LOGS_SEPARATOR)[0].trim()]).toBe('inline');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reads the table envelope the page bridge posts for an XHR', 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 = seeded();
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('services/public/echo.js')] = '_webout = _WEBIN_NAME1 + "|" + _WEBIN_FILEREF1;',
+                        _b));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/echo")), runRequest({
+                            params: {},
+                            tables: [
+                                {
+                                    name: 'SASControlTable',
+                                    filename: 'SASControlTable.csv',
+                                    csv: 'A,B\r\n1,2'
+                                }
+                            ]
+                        }))
+                        // the bridge hands the worker `{params, tables}`; a stored program sees the
+                        // tables as its _WEBIN variables, not as one `tables` session variable
+                    ];
+                case 1:
+                    response = _c.sent();
+                    // the bridge hands the worker `{params, tables}`; a stored program sees the
+                    // tables as its _WEBIN variables, not as one `tables` session variable
                     _a = expect;
                     return [4 /*yield*/, response.text()];
                 case 2:
-                    _a.apply(void 0, [_b.sent()]).toBe('inline');
+                    // the bridge hands the worker `{params, tables}`; a stored program sees the
+                    // tables as its _WEBIN variables, not as one `tables` session variable
+                    _a.apply(void 0, [_c.sent()]).toBe('SASControlTable|A,B\r\n1,2');
                     return [2 /*return*/];
             }
         });
@@ -1505,42 +2119,55 @@ describe('service worker host', function () {
         }); };
         var _loop_1 = function (testCase) {
             it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
-                var worker, _a, requestPath, init, response, _b, want, _c, _d, _e;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
+                var worker, _a, requestPath, init, response, body, want, _b, _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
                             worker = loadWorker();
                             return [4 /*yield*/, seedDrive(worker.runtime, testCase)];
                         case 1:
-                            _f.sent();
+                            _e.sent();
                             worker.refuseWrites(Boolean(testCase.unwritable));
                             _a = httpFor(testCase), requestPath = _a.path, init = _a.init;
                             return [4 /*yield*/, worker.dispatch(requestPath, init)];
                         case 2:
-                            response = _f.sent();
+                            response = _e.sent();
                             expect(response.status).toBe(testCase.expect.status);
                             if (!(testCase.expect.error !== undefined)) return [3 /*break*/, 4];
-                            _b = expect;
-                            return [4 /*yield*/, response.text()];
+                            return [4 /*yield*/, response.text()
+                                // the routes that answer an envelope - the two deploy routes - send
+                                // `{status, message}`; the rest send the message itself as text, which
+                                // is what the server's `res.status(code).send(err.message)` does
+                            ];
                         case 3:
-                            _b.apply(void 0, [_f.sent()]).toBe(testCase.expect.error);
-                            _f.label = 4;
+                            body = _e.sent();
+                            // the routes that answer an envelope - the two deploy routes - send
+                            // `{status, message}`; the rest send the message itself as text, which
+                            // is what the server's `res.status(code).send(err.message)` does
+                            if ((response.headers.get('content-type') || '').includes('application/json'))
+                                expect(JSON.parse(body)).toEqual({
+                                    status: 'failure',
+                                    message: testCase.expect.error
+                                });
+                            else
+                                expect(body).toBe(testCase.expect.error);
+                            return [3 /*break*/, 8];
                         case 4:
                             want = testCase.expect.contents;
                             if (!(typeof want === 'string')) return [3 /*break*/, 6];
-                            _c = expect;
+                            _b = expect;
                             return [4 /*yield*/, response.text()];
                         case 5:
-                            _c.apply(void 0, [_f.sent()]).toBe(want);
+                            _b.apply(void 0, [_e.sent()]).toBe(want);
                             return [3 /*break*/, 8];
                         case 6:
                             if (!(want !== undefined)) return [3 /*break*/, 8];
-                            _d = expect;
-                            _e = Uint8Array.bind;
+                            _c = expect;
+                            _d = Uint8Array.bind;
                             return [4 /*yield*/, response.arrayBuffer()];
                         case 7:
-                            _d.apply(void 0, [new (_e.apply(Uint8Array, [void 0, _f.sent()]))()]).toEqual(want);
-                            _f.label = 8;
+                            _c.apply(void 0, [new (_d.apply(Uint8Array, [void 0, _e.sent()]))()]).toEqual(want);
+                            _e.label = 8;
                         case 8: return [2 /*return*/];
                     }
                 });