@sasjs/cli 6.30.1 → 6.31.0

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

@@ -0,0 +1,1371 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @jest-environment jsdom
+ */
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+/**
+ * The API console, as a page.
+ *
+ * The build's own specs prove the files are written and that the operations come
+ * from the route table; they cannot prove the page works. This one drives it in a
+ * DOM: it loads the real `api-index.html` (so a rename of an id fails here rather
+ * than in a browser), stubs the two files the page reads and the host bridge, and
+ * asserts the request a form sends - including the bearer token, which is the
+ * part that has to survive the reload `as()` performs.
+ *
+ * The service worker is deliberately absent: jsdom has none, and the page has to
+ * render without it (a site whose `host/persist.js` cannot load must still show
+ * the route list).
+ */
+var page = function () {
+    return fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'assets', 'api-index.html'), 'utf8');
+};
+var bodyOf = function (html) {
+    var start = html.indexOf('<body>');
+    var end = html.indexOf('</body>');
+    return start < 0 || end < 0 ? html : html.slice(start + 6, end);
+};
+var operations = [
+    {
+        id: 'POST /SASjsApi/user',
+        method: 'POST',
+        path: '/SASjsApi/user',
+        tag: 'User',
+        summary: 'Create a user',
+        params: [
+            { name: 'username', in: 'body', required: true, type: 'string' },
+            { name: 'password', in: 'body', required: true, type: 'string' },
+            { name: 'isAdmin', in: 'body', required: false, type: 'boolean' }
+        ],
+        requestBodies: ['application/json'],
+        responses: [{ status: 200, description: 'Ok' }],
+        implemented: true
+    },
+    {
+        id: 'GET /SASjsApi/user',
+        method: 'GET',
+        path: '/SASjsApi/user',
+        tag: 'User',
+        summary: 'List all users',
+        params: [],
+        requestBodies: [],
+        responses: [{ status: 200, description: 'Ok' }],
+        implemented: true
+    }
+];
+var fixture = {
+    format: 1,
+    users: [
+        {
+            uid: 'user-admin',
+            username: 'sasjsadmin',
+            password: 'Orion123',
+            isAdmin: true
+        },
+        {
+            uid: 'user-restricted',
+            username: 'sasjsuser',
+            password: 'Orion123',
+            isAdmin: false
+        }
+    ]
+};
+var jsonResponse = function (body) { return ({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    headers: { get: function () { return 'application/json'; } },
+    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, body];
+    }); }); },
+    text: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, JSON.stringify(body)];
+    }); }); }
+}); };
+/** A service worker the page can register, and drive by hand. */
+var withServiceWorker = function (options) {
+    if (options === void 0) { options = {}; }
+    var listeners = [];
+    var sw = {
+        controller: null,
+        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (options.registerFails)
+                    throw new Error('the browser refused');
+                return [2 /*return*/, {}];
+            });
+        }); }),
+        addEventListener: function (type, fn) {
+            if (type === 'controllerchange')
+                listeners.push(fn);
+        }
+    };
+    Object.defineProperty(navigator, 'serviceWorker', {
+        value: sw,
+        configurable: true
+    });
+    return {
+        sw: sw,
+        takeControl: function () {
+            sw.controller = {};
+            listeners.forEach(function (fn) { return fn(); });
+        }
+    };
+};
+/**
+ * Records the scripts the page asks for, and answers each one.
+ *
+ * jsdom does not fetch a script it is given, so the load event is dispatched
+ * here - otherwise the page would wait forever for `persist.js`.
+ */
+var stubScripts = function () {
+    var realCreate = document.createElement.bind(document);
+    var requested = [];
+    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+        var node = realCreate(tag);
+        if (String(tag).toLowerCase() === 'script') {
+            setTimeout(function () {
+                requested.push(node.src);
+                node.dispatchEvent(new Event('load'));
+            }, 0);
+        }
+        return node;
+    });
+    return { requested: requested };
+};
+/** Boots the page against a stubbed host and returns what it asked for. */
+/** Waits for the render an assertion depends on, rather than for a wall clock. */
+var settle = function (check) { return __awaiter(void 0, void 0, void 0, function () {
+    var i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < 400)) return [3 /*break*/, 4];
+                if (check())
+                    return [2 /*return*/];
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                i++;
+                return [3 /*break*/, 1];
+            case 4: throw new Error('the page did not reach the state the case expected');
+        }
+    });
+}); };
+var loadConsole = function () {
+    var args_1 = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args_1[_i] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([], __read(args_1), false), void 0, function (before, table, identity) {
+        var calls, i;
+        if (before === void 0) { before = function () { }; }
+        if (table === void 0) { table = operations; }
+        if (identity === void 0) { identity = fixture; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.resetModules();
+                    document.body.innerHTML = bodyOf(page());
+                    // the version lives in the head, so the cases that care about it set it there
+                    document.head.innerHTML = '';
+                    before();
+                    calls = [];
+                    global.fetch = jest.fn(function (url_1) {
+                        var args_2 = [];
+                        for (var _i = 1; _i < arguments.length; _i++) {
+                            args_2[_i - 1] = arguments[_i];
+                        }
+                        return __awaiter(void 0, __spreadArray([url_1], __read(args_2), false), void 0, function (url, init) {
+                            if (init === void 0) { init = {}; }
+                            return __generator(this, function (_a) {
+                                if (String(url).includes('operations.json'))
+                                    return [2 /*return*/, jsonResponse(table)];
+                                if (String(url).includes('identity.json'))
+                                    return [2 /*return*/, jsonResponse(identity)];
+                                calls.push({ url: String(url), init: init });
+                                return [2 /*return*/, jsonResponse({ created: true })];
+                            });
+                        });
+                    });
+                    require('../assets/api-console.js');
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < 200)) return [3 /*break*/, 4];
+                    if (document.querySelectorAll('#routes .route').length)
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, { calls: calls }];
+            }
+        });
+    });
+};
+var selectRoute = function (id) { return __awaiter(void 0, void 0, void 0, function () {
+    var button;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                button = __spreadArray([], __read(document.querySelectorAll('#routes .route')), false).find(function (candidate) { return candidate.dataset.id === id; });
+                button.click();
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var fill = function (name, value) {
+    var input = document.querySelector("#form [data-name=\"".concat(name, "\"]"));
+    input.value = value;
+};
+var sendAndWait = function (calls_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([calls_1], __read(args_1), false), void 0, function (calls, want) {
+        var i;
+        if (want === void 0) { want = 1; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ;
+                    document.getElementById('send').click();
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < 200)) return [3 /*break*/, 4];
+                    if (calls.length >= want)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+describe('the API console', function () {
+    afterEach(function () {
+        delete navigator.serviceWorker;
+        delete window.__sasjsMockReady;
+    });
+    beforeEach(function () {
+        // jsdom has no service worker, and the page says so on the console; that is
+        // the path under test, not a warning worth printing
+        jest.spyOn(console, 'warn').mockImplementation(function () { });
+        jest.spyOn(console, 'error').mockImplementation(function () { });
+    });
+    afterEach(function () {
+        jest.restoreAllMocks();
+        delete global.fetch;
+        delete global.SASjsMock;
+        sessionStorage.clear();
+    });
+    it('lists the operations it was built with, grouped by tag', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var routes;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    _a.sent();
+                    routes = __spreadArray([], __read(document.querySelectorAll('#routes .route')), false);
+                    expect(routes).toHaveLength(2);
+                    expect(document.querySelector('#routes h3').textContent).toBe('User');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('sends the route it was given, with the parameters typed into the form', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/user')];
+                case 2:
+                    _a.sent();
+                    fill('username', 'demo_reviewer');
+                    fill('password', 'Orion123');
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    expect(calls[0].url).toMatch(/\/SASjsApi\/user$/);
+                    expect(calls[0].init.method).toBe('POST');
+                    // an untouched optional boolean is absent: the API reads `false` as a value
+                    // it must act on, so sending it would change what was not asked for
+                    expect(JSON.parse(calls[0].init.body)).toEqual({
+                        username: 'demo_reviewer',
+                        password: 'Orion123'
+                    });
+                    expect(calls[0].init.headers.authorization).toBeUndefined();
+                    i = 0;
+                    _a.label = 4;
+                case 4:
+                    if (!(i < 200)) return [3 /*break*/, 7];
+                    if ((document.getElementById('status').textContent || '').includes('200'))
+                        return [3 /*break*/, 7];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 5:
+                    _a.sent();
+                    _a.label = 6;
+                case 6:
+                    i++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    expect(document.getElementById('status').textContent).toContain('200');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('sends the token the host issued for the account it is acting as', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // `as()` reloads the page, so the console reads the pair it stored before the
+                    // navigation: a token held only in memory would be gone by the time the form
+                    // is usable again
+                    sessionStorage.setItem('mock-console-token', 'token-for-sasjsuser');
+                    return [4 /*yield*/, loadConsole()];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    expect(calls[0].url).toMatch(/\/SASjsApi\/user$/);
+                    expect(calls[0].init.headers.authorization).toBe('Bearer token-for-sasjsuser');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('filters the list, and says so when nothing matches', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var filter;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    _a.sent();
+                    filter = document.getElementById('filter');
+                    filter.value = 'group';
+                    filter.dispatchEvent(new Event('input'));
+                    expect(document.querySelectorAll('#routes .route')).toHaveLength(0);
+                    expect(document.getElementById('routes').textContent).toContain('No route matches that.');
+                    filter.value = 'user';
+                    filter.dispatchEvent(new Event('input'));
+                    expect(document.querySelectorAll('#routes .route')).toHaveLength(2);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('marks a route the host does not implement, and one that takes an upload', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var extra, i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    extra = [
+                        {
+                            id: 'POST /SASjsApi/drive/deploy/upload',
+                            method: 'POST',
+                            path: '/SASjsApi/drive/deploy/upload',
+                            tag: 'Drive',
+                            summary: 'Upload a deployment',
+                            params: [],
+                            requestBodies: ['multipart/form-data'],
+                            responses: [],
+                            implemented: true
+                        },
+                        {
+                            id: 'GET /SASjsApi/session/{sessionId}/log',
+                            method: 'GET',
+                            path: '/SASjsApi/session/{sessionId}/log',
+                            tag: 'Session',
+                            summary: 'A session log',
+                            params: [
+                                { name: 'sessionId', in: 'path', required: true, type: 'string' }
+                            ],
+                            requestBodies: [],
+                            responses: [],
+                            implemented: false,
+                            reason: 'this host keeps no log file'
+                        }
+                    ];
+                    jest.resetModules();
+                    document.body.innerHTML = bodyOf(page());
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(extra)
+                                    : jsonResponse(fixture)];
+                        });
+                    }); });
+                    require('../assets/api-console.js');
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < 200)) return [3 /*break*/, 4];
+                    if (document.querySelectorAll('#routes .route').length)
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    ;
+                    global.fetch = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, jsonResponse({})];
+                    }); }); });
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/drive/deploy/upload')];
+                case 5:
+                    _a.sent();
+                    expect(document.getElementById('form').textContent).toContain('does not send');
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/session/{sessionId}/log')];
+                case 6:
+                    _a.sent();
+                    expect(document.getElementById('summary').textContent).toContain('does not implement');
+                    // a path parameter is rendered as a field, and the URL it builds carries it
+                    expect(document.querySelector('#form [data-name="sessionId"]')).not.toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports a body that is not the JSON it claims to be, without sending it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, operations, field;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()
+                    // a parameter the table describes as an object is sent as typed
+                ];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    operations = __spreadArray([], __read(document.querySelectorAll('#routes .route')), false);
+                    expect(operations.length).toBeGreaterThan(0);
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/user')
+                        // the user route's fields are strings, so drive the object branch directly:
+                        // an array parameter is the same code path
+                    ];
+                case 2:
+                    _a.sent();
+                    field = document.querySelector('#form [data-name="username"]');
+                    field.dataset.type = 'object';
+                    field.value = '{not json';
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () {
+                            return /must be JSON/.test(document.getElementById('body').textContent || '');
+                        })];
+                case 3:
+                    _a.sent();
+                    expect(calls).toHaveLength(0);
+                    expect(document.getElementById('body').textContent).toContain('must be JSON');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('shows a non-JSON answer as it came, and an empty one as empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 2:
+                    _a.sent();
+                    global.fetch = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, ({
+                                    ok: true,
+                                    status: 200,
+                                    statusText: 'OK',
+                                    headers: { get: function () { return 'text/plain'; } },
+                                    text: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, 'NOTE: hello'];
+                                    }); }); }
+                                })];
+                        });
+                    }); });
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return document.getElementById('body').textContent === 'NOTE: hello'; })];
+                case 4:
+                    _a.sent();
+                    expect(document.getElementById('body').textContent).toBe('NOTE: hello');
+                    global.fetch = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, ({
+                                    ok: true,
+                                    status: 200,
+                                    statusText: 'OK',
+                                    headers: { get: function () { return 'application/json'; } },
+                                    text: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ''];
+                                    }); }); }
+                                })];
+                        });
+                    }); });
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () { return document.getElementById('body').textContent === '(empty body)'; })];
+                case 5:
+                    _a.sent();
+                    expect(document.getElementById('body').textContent).toBe('(empty body)');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports a request that never reached the host', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 2:
+                    _a.sent();
+                    global.fetch = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            throw new Error('the network is gone');
+                        });
+                    }); });
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () { return document.getElementById('status').textContent === 'request failed'; })];
+                case 3:
+                    _a.sent();
+                    expect(document.getElementById('status').textContent).toBe('request failed');
+                    expect(document.getElementById('body').textContent).toContain('the network is gone');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('copies the answer, and survives a clipboard that refuses', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var written;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 2:
+                    _a.sent();
+                    written = [];
+                    navigator.clipboard = {
+                        writeText: function (text) { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                written.push(text);
+                                return [2 /*return*/];
+                            });
+                        }); }
+                    };
+                    document.getElementById('body').textContent = '{"a":1}';
+                    document.getElementById('copy').click();
+                    return [4 /*yield*/, settle(function () { return written.length === 1; })];
+                case 3:
+                    _a.sent();
+                    expect(written).toEqual(['{"a":1}']);
+                    expect(document.getElementById('copy').textContent).toBe('Copied');
+                    navigator.clipboard = {
+                        writeText: function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                throw new Error('denied');
+                            });
+                        }); }
+                    };
+                    document.getElementById('copy').click();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 20); })];
+                case 4:
+                    _a.sent();
+                    expect(document.getElementById('copy').textContent).toBe('Copied');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('selects the route named in the URL, so a reload comes back to it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.resetModules();
+                    document.body.innerHTML = bodyOf(page());
+                    history.replaceState({}, '', '/api/?route=' + encodeURIComponent('GET /SASjsApi/user'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(operations)
+                                    : jsonResponse(fixture)];
+                        });
+                    }); });
+                    require('../assets/api-console.js');
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < 200)) return [3 /*break*/, 4];
+                    if (document.getElementById('title').textContent)
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    expect(document.getElementById('title').textContent).toBe('GET /SASjsApi/user');
+                    history.replaceState({}, '', '/api/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('stores the token acting as another account returns, and sends it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, actAs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole(function () {
+                        ;
+                        window.SASjsMock = {
+                            identity: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, ({ fixture: fixture, subject: null })];
+                            }); }); },
+                            as: function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({
+                                            accessToken: 'token-for-sasjsuser',
+                                            refreshToken: 'refresh-for-sasjsuser'
+                                        })];
+                                });
+                            }); }
+                        };
+                    })];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    actAs = __spreadArray([], __read(document.querySelectorAll('#accounts button')), false).find(function (candidate) { return candidate.dataset.user === 'sasjsuser'; });
+                    expect(actAs).toBeTruthy();
+                    actAs.click();
+                    return [4 /*yield*/, settle(function () {
+                            return sessionStorage.getItem('mock-console-token') === 'token-for-sasjsuser';
+                        })];
+                case 2:
+                    _a.sent();
+                    expect(sessionStorage.getItem('mock-console-token')).toBe('token-for-sasjsuser');
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 4:
+                    _a.sent();
+                    expect(calls[0].init.headers.authorization).toBe('Bearer token-for-sasjsuser');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers the versioned worker, waits for control, and hands over the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var requested, host;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    requested = stubScripts().requested;
+                    host = withServiceWorker();
+                    return [4 /*yield*/, loadConsole(function () {
+                            document.head.innerHTML =
+                                '<meta name="sasjs-mock-version" content="1.2.3" />';
+                            window.__sasjsMockReady = Promise.resolve({ booted: true });
+                        })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return host.sw.register.mock.calls.length === 1; })
+                        // the app's loader registers this exact URL: two URLs for one scope replace
+                        // each other, which is an install nobody asked for
+                    ];
+                case 2:
+                    _a.sent();
+                    // the app's loader registers this exact URL: two URLs for one scope replace
+                    // each other, which is an install nobody asked for
+                    expect(host.sw.register.mock.calls[0][0]).toContain('sw.js?v=1.2.3');
+                    expect(host.sw.register.mock.calls[0][1]).toEqual(expect.objectContaining({ scope: '/', updateViaCache: 'none' }));
+                    // a registration completes before the navigation commits, so the page waits
+                    host.takeControl();
+                    return [4 /*yield*/, settle(function () { return requested.some(function (url) { return url.includes('host/persist.js'); }); })];
+                case 3:
+                    _a.sent();
+                    expect(requested.some(function (url) { return url.includes('host/persist.js'); })).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers the plain worker URL while the page carries the placeholder', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var host;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    host = withServiceWorker();
+                    // the placeholder is what a hand-copied asset carries: it is not a version
+                    return [4 /*yield*/, loadConsole(function () {
+                            document.head.innerHTML =
+                                '<meta name="sasjs-mock-version" content="__MOCK_VERSION__" />';
+                        })];
+                case 1:
+                    // the placeholder is what a hand-copied asset carries: it is not a version
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return host.sw.register.mock.calls.length === 1; })];
+                case 2:
+                    _a.sent();
+                    expect(host.sw.register.mock.calls[0][0]).not.toContain('?v=');
+                    // let the page past its wait: a registration nobody claims leaves a 4s timer
+                    // that fires during whatever test runs next, and its reload throws there
+                    host.takeControl();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 20); })];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('says so when the browser refuses the registration', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error, host;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    error = jest.spyOn(console, 'error').mockImplementation(function () { });
+                    host = withServiceWorker({ registerFails: true });
+                    return [4 /*yield*/, loadConsole()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return error.mock.calls.length > 0; })];
+                case 2:
+                    _a.sent();
+                    expect(error.mock.calls[0][0]).toContain('could not register');
+                    expect(host.sw.register).toHaveBeenCalled();
+                    error.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('says so when the drive could not be handed over', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var error, requested, host;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    error = jest.spyOn(console, 'error').mockImplementation(function () { });
+                    requested = stubScripts().requested;
+                    host = withServiceWorker();
+                    return [4 /*yield*/, loadConsole(function () {
+                            ;
+                            window.__sasjsMockReady = Promise.reject(new Error('no storage in this browser'));
+                        })];
+                case 1:
+                    _a.sent();
+                    host.takeControl();
+                    return [4 /*yield*/, settle(function () {
+                            return error.mock.calls.some(function (call) { return /handed over/.test(String(call[0])); });
+                        })];
+                case 2:
+                    _a.sent();
+                    expect(error.mock.calls.some(function (call) { return /handed over/.test(String(call[0])); })).toBe(true);
+                    expect(requested.some(function (url) { return url.includes('host/persist.js'); })).toBe(true);
+                    error.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('prefills the sign-in route from the demo administrator', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var signIn, username, password;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    signIn = [
+                        {
+                            id: 'POST /SASLogon/login',
+                            method: 'POST',
+                            path: '/SASLogon/login',
+                            tag: 'Auth',
+                            summary: 'Sign in',
+                            params: [
+                                { name: 'username', in: 'body', required: true, type: 'string' },
+                                { name: 'password', in: 'body', required: true, type: 'string' }
+                            ],
+                            requestBodies: ['application/json'],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, signIn)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, selectRoute('POST /SASLogon/login')
+                        // the credentials are published on purpose, and this is where a visitor needs
+                        // them: the route they sign in with
+                    ];
+                case 2:
+                    _a.sent();
+                    username = document.querySelector('#form [data-name="username"]');
+                    password = document.querySelector('#form [data-name="password"]');
+                    expect(username.value).toBe('sasjsadmin');
+                    expect(password.value).toBe('Orion123');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('puts a query parameter in the URL, and leaves it off when empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var withQuery, calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    withQuery = [
+                        {
+                            id: 'GET /SASjsApi/user/list',
+                            method: 'GET',
+                            path: '/SASjsApi/user/list',
+                            tag: 'User',
+                            summary: 'List with a filter',
+                            params: [
+                                { name: 'search', in: 'query', required: false, type: 'string' }
+                            ],
+                            requestBodies: [],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, withQuery)];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user/list')];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    expect(calls[0].url).toMatch(/\/SASjsApi\/user\/list$/);
+                    // the button is disabled while a request is in flight, and a disabled button
+                    // ignores a click, so wait for the first answer to land
+                    return [4 /*yield*/, settle(function () { return !document.getElementById('send').disabled; })];
+                case 4:
+                    // the button is disabled while a request is in flight, and a disabled button
+                    // ignores a click, so wait for the first answer to land
+                    _a.sent();
+                    fill('search', 'demo reviewer');
+                    return [4 /*yield*/, sendAndWait(calls, 2)];
+                case 5:
+                    _a.sent();
+                    expect(calls[1].url).toBe('/SASjsApi/user/list?search=demo+reviewer');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('says so when the host refuses to act as an account', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var alert, error, actAs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    alert = jest.spyOn(window, 'alert').mockImplementation(function () { });
+                    error = jest.spyOn(console, 'error').mockImplementation(function () { });
+                    return [4 /*yield*/, loadConsole(function () {
+                            ;
+                            window.SASjsMock = {
+                                identity: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({ fixture: fixture, subject: null })];
+                                }); }); },
+                                as: function () { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        throw new Error('no such account');
+                                    });
+                                }); }
+                            };
+                        })];
+                case 1:
+                    _a.sent();
+                    actAs = __spreadArray([], __read(document.querySelectorAll('#accounts button')), false).find(function (candidate) { return candidate.dataset.user === 'sasjsuser'; });
+                    actAs.click();
+                    return [4 /*yield*/, settle(function () { return alert.mock.calls.length > 0; })];
+                case 2:
+                    _a.sent();
+                    expect(String(alert.mock.calls[0][0])).toContain('no such account');
+                    expect(document.getElementById('who').textContent).not.toContain('sasjsuser');
+                    alert.mockRestore();
+                    error.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a route whose required field is empty, instead of sending the placeholder', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, loadConsole()];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/user')
+                        // username is required, and nothing is typed into it
+                    ];
+                case 2:
+                    _a.sent();
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () { return document.getElementById('status').textContent === 'missing input'; })];
+                case 3:
+                    _a.sent();
+                    expect(calls).toHaveLength(0);
+                    expect(document.getElementById('body').textContent).toContain('username');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a number that is not a number, rather than sending null', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var withNumber, calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    withNumber = [
+                        {
+                            id: 'POST /SASjsApi/code/trigger',
+                            method: 'POST',
+                            path: '/SASjsApi/code/trigger',
+                            tag: 'Code',
+                            summary: 'Trigger a scheduled run',
+                            params: [
+                                {
+                                    name: 'expiresAfterMins',
+                                    in: 'body',
+                                    required: false,
+                                    type: 'number'
+                                }
+                            ],
+                            requestBodies: ['application/json'],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, withNumber)];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/code/trigger')];
+                case 2:
+                    _a.sent();
+                    fill('expiresAfterMins', 'ten');
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () {
+                            return /must be a number/.test(document.getElementById('body').textContent || '');
+                        })
+                        // JSON.stringify writes NaN as null, which the host would read as "absent"
+                    ];
+                case 3:
+                    _a.sent();
+                    // JSON.stringify writes NaN as null, which the host would read as "absent"
+                    expect(calls).toHaveLength(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('does not demand an upload it cannot take', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var upload, calls;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    upload = [
+                        {
+                            id: 'POST /SASjsApi/drive/deploy/upload',
+                            method: 'POST',
+                            path: '/SASjsApi/drive/deploy/upload',
+                            tag: 'Drive',
+                            summary: 'Upload a deployment',
+                            params: [
+                                { name: 'file', in: 'formData', required: true, type: 'string' }
+                            ],
+                            requestBodies: ['multipart/form-data'],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, upload)];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/drive/deploy/upload')];
+                case 2:
+                    _a.sent();
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () {
+                            return calls.length > 0 ||
+                                /does not send/.test(document.getElementById('form').textContent || '');
+                        })];
+                case 3:
+                    _a.sent();
+                    expect(document.getElementById('status').textContent).not.toBe('missing input');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('clears the drive and starts again when the URL asks it to', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var reset;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reset = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); }); });
+                    sessionStorage.setItem('mock-console-token', 'stale');
+                    sessionStorage.setItem('mock-console-reloaded', '1');
+                    // jsdom does not navigate, and the redirect is the last thing the page does:
+                    // what matters here is that the drive was reset before it
+                    return [4 /*yield*/, loadConsole(function () {
+                            history.replaceState({}, '', '/api/?reset=1');
+                            window.SASjsMock = { reset: reset };
+                        })];
+                case 1:
+                    // jsdom does not navigate, and the redirect is the last thing the page does:
+                    // what matters here is that the drive was reset before it
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return reset.mock.calls.length > 0; })];
+                case 2:
+                    _a.sent();
+                    expect(reset).toHaveBeenCalled();
+                    expect(sessionStorage.length).toBe(0);
+                    history.replaceState({}, '', '/api/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('waits for the delete when there is no host to ask, and says so if it is blocked', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var blocked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    blocked = {};
+                    global.indexedDB = {
+                        deleteDatabase: jest.fn(function () {
+                            setTimeout(function () { return blocked.onblocked && blocked.onblocked(); }, 5);
+                            return blocked;
+                        })
+                    };
+                    return [4 /*yield*/, loadConsole(function () {
+                            // no host bridge on this page at all
+                            delete window.SASjsMock;
+                            history.replaceState({}, '', '/api/?reset=1');
+                        })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () {
+                            return /could not be reset/.test(document.getElementById('routes').textContent || '');
+                        })];
+                case 2:
+                    _a.sent();
+                    expect(global.indexedDB.deleteDatabase).toHaveBeenCalledWith('sasjs-mock-host');
+                    expect(document.getElementById('routes').textContent).toContain('still holds the drive');
+                    history.replaceState({}, '', '/api/');
+                    delete global.indexedDB;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the drive alone for any other value of the reset flag', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var reset;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reset = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); }); });
+                    sessionStorage.setItem('mock-console-token', 'kept');
+                    return [4 /*yield*/, loadConsole(function () {
+                            history.replaceState({}, '', '/api/?reset=0');
+                            window.SASjsMock = { reset: reset };
+                        })];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, settle(function () { return document.querySelectorAll('#routes .route').length > 0; })];
+                case 2:
+                    _a.sent();
+                    expect(reset).not.toHaveBeenCalled();
+                    expect(sessionStorage.getItem('mock-console-token')).toBe('kept');
+                    history.replaceState({}, '', '/api/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('omits an untouched optional boolean on a patch, and sends it when chosen', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var patch, calls, untouched;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    patch = [
+                        {
+                            id: 'PATCH /SASjsApi/user/{uid}',
+                            method: 'PATCH',
+                            path: '/SASjsApi/user/{uid}',
+                            tag: 'User',
+                            summary: 'Update a user',
+                            params: [
+                                { name: 'uid', in: 'path', required: true, type: 'string' },
+                                {
+                                    name: 'displayName',
+                                    in: 'body',
+                                    required: true,
+                                    type: 'string'
+                                },
+                                { name: 'username', in: 'body', required: true, type: 'string' },
+                                { name: 'password', in: 'body', required: true, type: 'string' },
+                                { name: 'isAdmin', in: 'body', required: false, type: 'boolean' }
+                            ],
+                            requestBodies: ['application/json'],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, patch)];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('PATCH /SASjsApi/user/{uid}')];
+                case 2:
+                    _a.sent();
+                    fill('uid', 'user-restricted');
+                    fill('displayName', 'Restricted user');
+                    fill('username', 'sasjsuser');
+                    fill('password', 'Orion123');
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    untouched = JSON.parse(calls[0].init.body);
+                    expect(untouched.isAdmin).toBeUndefined();
+                    expect(calls[0].url).toMatch(/\/SASjsApi\/user\/user-restricted$/);
+                    // and choosing a value sends it, as a boolean rather than the string
+                    return [4 /*yield*/, settle(function () { return !document.getElementById('send').disabled; })];
+                case 4:
+                    // and choosing a value sends it, as a boolean rather than the string
+                    _a.sent();
+                    document.querySelector('#form select[data-name="isAdmin"]').value = 'true';
+                    return [4 /*yield*/, sendAndWait(calls, 2)];
+                case 5:
+                    _a.sent();
+                    expect(JSON.parse(calls[1].init.body).isAdmin).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('sends a named shape as JSON, while an enum stays the word that was typed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var deploy, calls, body;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    deploy = [
+                        {
+                            id: 'POST /SASjsApi/drive/deploy',
+                            method: 'POST',
+                            path: '/SASjsApi/drive/deploy',
+                            tag: 'Drive',
+                            summary: 'Deploy a bundle',
+                            params: [
+                                { name: 'appLoc', in: 'body', required: true, type: 'string' },
+                                { name: 'fileTree', in: 'body', required: true, type: 'FileTree' },
+                                { name: 'runTime', in: 'body', required: false, type: 'RunTimeType' }
+                            ],
+                            requestBodies: ['application/json'],
+                            responses: [{ status: 200, description: 'Ok' }],
+                            implemented: true
+                        }
+                    ];
+                    return [4 /*yield*/, loadConsole(function () { }, deploy)];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    return [4 /*yield*/, selectRoute('POST /SASjsApi/drive/deploy')];
+                case 2:
+                    _a.sent();
+                    fill('appLoc', '/Public/app/demo');
+                    fill('fileTree', JSON.stringify({
+                        members: [{ name: 'services', type: 'folder', members: [] }]
+                    }));
+                    fill('runTime', 'sas');
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 3:
+                    _a.sent();
+                    body = JSON.parse(calls[0].init.body);
+                    expect(typeof body.fileTree).toBe('object');
+                    expect(body.fileTree.members[0].name).toBe('services');
+                    // an enum is not JSON and must not be coerced
+                    expect(body.runTime).toBe('sas');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('names the account it falls back to when the fixture ships no administrator', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var plain, note, back;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    plain = {
+                        format: 1,
+                        users: [
+                            { uid: 'u1', username: 'plain1', password: 'Orion123', isAdmin: false },
+                            { uid: 'u2', username: 'plain2', password: 'Orion123', isAdmin: false }
+                        ]
+                    };
+                    return [4 /*yield*/, loadConsole(function () {
+                            ;
+                            window.SASjsMock = {
+                                identity: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({ fixture: plain, subject: 'plain1' })];
+                                }); }); },
+                                as: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({ accessToken: 't', refreshToken: 'r' })];
+                                }); }); }
+                            };
+                        }, operations, plain)];
+                case 1:
+                    _a.sent();
+                    note = document.getElementById('accounts').textContent || '';
+                    expect(note).toContain('no administrator');
+                    expect(note).toContain('plain1');
+                    __spreadArray([], __read(document.querySelectorAll('#accounts button')), false).find(function (button) { return button.dataset.user === 'plain2'; }).click();
+                    return [4 /*yield*/, (function () { return __awaiter(void 0, void 0, void 0, function () {
+                            var i, found;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        i = 0;
+                                        _a.label = 1;
+                                    case 1:
+                                        if (!(i < 200)) return [3 /*break*/, 4];
+                                        found = __spreadArray([], __read(document.querySelectorAll('#accounts button')), false).find(function (button) { return /^Back to/.test(button.textContent || ''); });
+                                        if (found)
+                                            return [2 /*return*/, found];
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                                    case 2:
+                                        _a.sent();
+                                        _a.label = 3;
+                                    case 3:
+                                        i++;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [2 /*return*/, undefined];
+                                }
+                            });
+                        }); })()];
+                case 2:
+                    back = _a.sent();
+                    expect(back).toBeDefined();
+                    expect(back.textContent).toBe('Back to plain1');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops the token when the visitor goes back to the demo administrator', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, back;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sessionStorage.setItem('mock-console-token', 'token-for-sasjsuser');
+                    global.SASjsMock = {
+                        as: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({ accessToken: 'admin-token' })];
+                        }); }); },
+                        identity: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({ subject: 'sasjsuser' })];
+                        }); }); }
+                    };
+                    return [4 /*yield*/, loadConsole()
+                        // the page offers the way back only while it is acting as someone
+                    ];
+                case 1:
+                    calls = (_a.sent()).calls;
+                    back = __spreadArray([], __read(document.querySelectorAll('#accounts button')), false).find(function (button) { return (button.textContent || '').includes('Back to the demo'); });
+                    expect(back).toBeDefined();
+                    back.click();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
+                case 2:
+                    _a.sent();
+                    expect(sessionStorage.getItem('mock-console-token')).toBeNull();
+                    return [4 /*yield*/, selectRoute('GET /SASjsApi/user')];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, sendAndWait(calls)];
+                case 4:
+                    _a.sent();
+                    expect(calls[0].init.headers.authorization).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});