@sasjs/cli 6.25.0 → 6.26.1

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

@@ -86,6 +86,7 @@ var fs_1 = __importDefault(require("fs"));
 var os_1 = __importDefault(require("os"));
 var path_1 = __importDefault(require("path"));
 var esbuild_1 = require("esbuild");
+var api_1 = require("@sasjs/api");
 var utils_1 = require("@sasjs/utils");
 /**
  * The webout() block is the one @sasjs/utils generates for the server, emitted
@@ -346,6 +347,36 @@ exports.DRIVE_FORMAT = 1;
 var megabytes = function (bytes) {
     return "".concat(Math.round((bytes / 1024 / 1024) * 10) / 10, " MB");
 };
+/**
+ * The identity the site ships, and which file it came from.
+ *
+ * `mock-identity.json` beside the build wins, exactly as `mock-snapshot.json`
+ * replaces the drive seed: one file, one load path, and which one wins is decided
+ * here rather than at run time. Without it the package's demo fixture ships, so a
+ * mock works with no configuration at all.
+ *
+ * The fixture is validated at build time - a malformed one stops the build while
+ * the person who wrote it is watching, instead of producing a site that boots to
+ * a refusal nobody can connect to a file.
+ */
+var readIdentityFixture = function (buildFolder) {
+    var file = path_1.default.join(buildFolder, 'mock-identity.json');
+    if (!fs_1.default.existsSync(file))
+        return { fixture: api_1.DEFAULT_IDENTITY, source: 'default' };
+    var parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new Error("".concat(file, " is not valid JSON: ").concat((e === null || e === void 0 ? void 0 : e.message) || e));
+    }
+    try {
+        return { fixture: (0, api_1.parseIdentity)(parsed), source: 'mock-identity.json' };
+    }
+    catch (e) {
+        throw new Error("".concat(file, " cannot be used: ").concat((e === null || e === void 0 ? void 0 : e.message) || e));
+    }
+};
 var readDriveFile = function (absolute) {
     var buffer = fs_1.default.readFileSync(absolute);
     var text = buffer.toString('utf8');
@@ -728,7 +759,7 @@ var patchIndexHtml = function (html, version, basePath, outputFolder) {
  */
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, transcriptSource, hasTranscript, indexPath, _d, patched, warnings;
+        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, identity, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, transcriptSource, hasTranscript, indexPath, _d, patched, warnings;
         var e_8, _e;
         var _f, _g, _h, _j, _k, _l;
         return __generator(this, function (_m) {
@@ -812,6 +843,7 @@ function buildMockSite(target) {
                             })
                                 .join(', ')).concat(skipped.length > 3 ? ', ...' : ''));
                     }
+                    identity = readIdentityFixture(buildFolder);
                     // Only now is the previous site expendable.
                     fs_1.default.rmSync(outputFolder, { recursive: true, force: true });
                     fs_1.default.mkdirSync(outputFolder, { recursive: true });
@@ -868,6 +900,11 @@ function buildMockSite(target) {
                             apiServerUrl: exports.WEBOUT_SENTINELS.apiServerUrl
                         })
                     }));
+                    // 2a-ii. the identity the site signs in with: the fixture the build chose, in
+                    // the one place the runtime reads it. `window.SASjsMock.as()` and a reset both
+                    // come back to this file, and the page stores the store's snapshot beside the
+                    // drive so an account created through the routes survives a reload.
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'identity.json'), JSON.stringify(identity.fixture, null, 2));
                     hostVersion = (0, crypto_1.createHash)('md5')
                         .update([
                         'runtime-core.js',
@@ -876,16 +913,20 @@ function buildMockSite(target) {
                         'boot.js',
                         'api-browser.js',
                         'lint-browser.js',
-                        'webout-prelude.json'
+                        'webout-prelude.json',
+                        'identity.json'
                     ]
                         .map(function (asset) { return fs_1.default.readFileSync(path_1.default.join(hostFolder, asset)); })
                         .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
                         .digest('hex')
                         .slice(0, 10);
                     buildStamp = (0, crypto_1.createHash)('md5')
-                        .update(JSON.stringify(Object.keys(seed)
-                        .sort()
-                        .map(function (key) { return [key, seed[key]]; })))
+                        .update(JSON.stringify({
+                        files: Object.keys(seed)
+                            .sort()
+                            .map(function (key) { return [key, seed[key]]; }),
+                        identity: identity.fixture
+                    }))
                         .digest('hex')
                         .slice(0, 10);
                     swPath = path_1.default.join(outputFolder, 'sw.js');
@@ -913,6 +954,7 @@ function buildMockSite(target) {
                         programFolders: PROGRAM_FOLDERS,
                         snapshot: hasSnapshot,
                         sasTranscript: hasTranscript,
+                        identity: identity.source,
                         buildStamp: buildStamp,
                         builtAt: new Date().toISOString()
                     }, null, 2));
@@ -927,7 +969,8 @@ function buildMockSite(target) {
                             jsPrograms: jsPrograms,
                             webFileCount: webFileCount,
                             snapshot: hasSnapshot,
-                            sasTranscript: hasTranscript
+                            sasTranscript: hasTranscript,
+                            identitySource: identity.source
                         }];
             }
         });

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

@@ -1107,4 +1107,154 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    /**
+     * The fixture the site signs in with: one file, and which fixture wins is
+     * decided at build time. A project replaces it the same way it replaces the
+     * drive seed, so a site ships the identity its author chose rather than one
+     * the runtime happens to hold.
+     */
+    it('ships the packaged identity fixture when the project has none', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, shipped;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.identitySource).toBe('default');
+                    expect(readConfig().identity).toBe('default');
+                    shipped = JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'identity.json'), 'utf8'));
+                    expect(shipped.format).toBe(1);
+                    expect(shipped.users.map(function (user) { return user.username; })).toEqual([
+                        'sasjsadmin',
+                        'sasjsuser'
+                    ]);
+                    // the same fixture the package ships, so a mock signs in with no config
+                    expect(shipped.clients.map(function (client) { return client.clientId; })).toEqual([
+                        'web_app',
+                        'sasjs'
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("ships the project's mock-identity.json instead of the packaged fixture", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fixture, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fixture = {
+                        format: 1,
+                        users: [
+                            {
+                                uid: 'user-auditor',
+                                username: 'auditor',
+                                displayName: 'Auditor',
+                                password: 'Orion123',
+                                isAdmin: true,
+                                isActive: true,
+                                needsToUpdatePassword: false
+                            }
+                        ],
+                        groups: [],
+                        permissions: [],
+                        clients: [
+                            {
+                                clientId: 'audit_app',
+                                clientSecret: 'audit_app',
+                                accessTokenExpiration: 3600,
+                                refreshTokenExpiration: 86400
+                            }
+                        ]
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-identity.json'), JSON.stringify(fixture));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.identitySource).toBe('mock-identity.json');
+                    expect(readConfig().identity).toBe('mock-identity.json');
+                    expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'identity.json'), 'utf8'))).toEqual(fixture);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('stamps the build with the fixture, so an identity-only change re-seeds it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var before, fixture;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: 
+                // the stamp decides whether a visitor keeps the drive and identity row they
+                // already have; `host/identity.json` is only read when there is no row, so a
+                // project that edits only mock-identity.json has to move it
+                return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    // the stamp decides whether a visitor keeps the drive and identity row they
+                    // already have; `host/identity.json` is only read when there is no row, so a
+                    // project that edits only mock-identity.json has to move it
+                    _a.sent();
+                    before = readConfig().buildStamp;
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 2:
+                    _a.sent();
+                    expect(readConfig().buildStamp).toBe(before);
+                    fixture = {
+                        format: 1,
+                        users: [
+                            {
+                                uid: 'user-auditor',
+                                username: 'auditor',
+                                displayName: 'Auditor',
+                                password: 'Orion123',
+                                isAdmin: true,
+                                isActive: true,
+                                needsToUpdatePassword: false
+                            }
+                        ],
+                        groups: [],
+                        permissions: [],
+                        clients: [
+                            {
+                                clientId: 'audit_app',
+                                clientSecret: 'audit_app',
+                                accessTokenExpiration: 3600,
+                                refreshTokenExpiration: 86400
+                            }
+                        ]
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-identity.json'), JSON.stringify(fixture));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 3:
+                    _a.sent();
+                    expect(readConfig().buildStamp).not.toBe(before);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a mock-identity.json it cannot read, leaving the previous site in place', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var before, wrongFormat;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    before = fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'identity.json'), 'utf8');
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-identity.json'), '{ not json');
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/mock-identity\.json is not valid JSON/)];
+                case 2:
+                    _a.sent();
+                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'identity.json'), 'utf8')).toBe(before);
+                    wrongFormat = {
+                        format: 0,
+                        users: [],
+                        groups: [],
+                        permissions: [],
+                        clients: []
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-identity.json'), JSON.stringify(wrongFormat));
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/mock-identity\.json cannot be used: The identity fixture states format 0/)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

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

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -94,6 +105,7 @@ var createIndexedDB = function () {
             data().delete(key);
         },
         clear: function () { return data().clear(); },
+        get: function (key) { return request(function () { return data().get(key); }); },
         getAllKeys: function () { return request(function () { return __spreadArray([], __read(data().keys()), false); }); },
         getAll: function () { return request(function () { return __spreadArray([], __read(data().values()), false); }); }
     };
@@ -192,16 +204,17 @@ var loadPersist = function (options) {
                 })];
         });
     }); });
-    var idb = options.seeded
-        ? (function () {
-            var fake = createIndexedDB();
-            Object.entries(options.seeded).forEach(function (_a) {
-                var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                return fake.rows.set(key, value);
-            });
-            return fake;
-        })()
-        : createIndexedDB();
+    var idb = (function () {
+        var fake = createIndexedDB();
+        Object.entries(options.seeded || {}).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            return fake.rows.set(key, value);
+        });
+        // the identity row lives beside the drive, under its own key
+        if (options.seededIdentity)
+            fake.rows.set('current', options.seededIdentity);
+        return fake;
+    })();
     global.indexedDB = idb;
     require('../assets/persist.js');
     var reply = function (data) { return __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: data }); }); };
@@ -512,7 +525,10 @@ describe('page-side store', function () {
                     _b.sent();
                     clearInterval(answering);
                     expect(controller.postMessage).toHaveBeenCalledWith({
-                        type: 'sasjs-seed'
+                        type: 'sasjs-seed',
+                        files: {},
+                        identity: undefined,
+                        subject: undefined
                     });
                     return [2 /*return*/];
             }
@@ -542,6 +558,7 @@ describe('page-side store', function () {
                         controller: controller,
                         ready: Promise.resolve({}),
                         seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        seededIdentity: { fixture: FIXTURE, subject: 'sasjsuser' },
                         buildStamp: 'build-b',
                         storedStamp: 'build-a'
                     }), window = _a.window, listeners = _a.listeners, stored = _a.stored, rows = _a.rows;
@@ -550,9 +567,14 @@ describe('page-side store', function () {
                 case 1:
                     _b.sent();
                     stop();
-                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    expect(controller.postMessage).toHaveBeenCalledWith({
+                        type: 'sasjs-seed',
+                        files: {},
+                        identity: undefined,
+                        subject: undefined
+                    });
                     expect(stored.get('sasjs-mock-build')).toBe('build-b');
-                    // the old drive is gone rather than merged with the new seed
+                    // the old drive and the old fixture are gone, not merged with the new build
                     expect(rows.size).toBe(0);
                     return [2 /*return*/];
             }
@@ -575,7 +597,12 @@ describe('page-side store', function () {
                 case 1:
                     _b.sent();
                     stop();
-                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    expect(controller.postMessage).toHaveBeenCalledWith({
+                        type: 'sasjs-seed',
+                        files: {},
+                        identity: undefined,
+                        subject: undefined
+                    });
                     return [2 /*return*/];
             }
         });
@@ -671,7 +698,300 @@ describe('page-side store', function () {
                     expect(String(url)).toBe('https://host.test/demo/host/mock-config.json');
                     expect(init).toEqual({ cache: 'no-store' });
                     // and the stamp it read is acted on
-                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    expect(controller.postMessage).toHaveBeenCalledWith({
+                        type: 'sasjs-seed',
+                        files: {},
+                        identity: undefined,
+                        subject: undefined
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The fixture a stored identity carries. The page never reads inside it - the
+     * worker parses it - so this only has to be the object that was stored.
+     */
+    /**
+     * Waits for an asynchronous write rather than guessing how long it takes: the
+     * page persists through IndexedDB, whose requests settle on their own
+     * schedule, and a fixed sleep that is comfortable on one runner is too short
+     * on another.
+     */
+    var until = function (ready_1) {
+        var args_1 = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args_1[_i - 1] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([ready_1], __read(args_1), false), void 0, function (ready, timeout) {
+            var started;
+            if (timeout === void 0) { timeout = 2000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        started = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!!ready()) return [3 /*break*/, 3];
+                        if (Date.now() - started > timeout)
+                            throw new Error('timed out waiting for the write');
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    var FIXTURE = {
+        format: 1,
+        users: [{ username: 'sasjsadmin' }, { username: 'sasjsuser' }],
+        groups: [],
+        permissions: [],
+        clients: [{ clientId: 'web_app' }]
+    };
+    /**
+     * Answers every question the page has asked, once each.
+     *
+     * The page asks the worker more than one thing at boot (a seed or a load, and
+     * whatever a caller asked for next), and the order is not fixed: both go
+     * through `waitForController`. Answering "the last call" therefore answers the
+     * wrong one as often as the right one.
+     */
+    var answerAll = function (controller, listeners, payload) {
+        var answered = new Set();
+        var answering = setInterval(function () {
+            controller.postMessage.mock.calls.forEach(function (_a, index) {
+                var _b = __read(_a, 1), message = _b[0];
+                if (answered.has(index))
+                    return;
+                answered.add(index);
+                __spreadArray([], __read(listeners), false).forEach(function (fn) {
+                    return fn({
+                        data: __assign({ type: message.type + '-ack' }, payload(index, message.type))
+                    });
+                });
+            });
+        }, 5);
+        return function () { return clearInterval(answering); };
+    };
+    it('hands a stored fixture and subject to the worker at boot', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        seededIdentity: { fixture: FIXTURE, subject: 'sasjsuser' }
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({
+                        type: 'sasjs-load',
+                        identity: FIXTURE,
+                        subject: 'sasjsuser'
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('stores the fixture the worker reports when a route changed it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, reply, rows;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({ controller: controller }), reply = _a.reply, rows = _a.rows;
+                    reply({ type: 'sasjs-persist', files: {}, identity: FIXTURE });
+                    return [4 /*yield*/, until(function () { return rows.has('current'); })];
+                case 1:
+                    _b.sent();
+                    expect(rows.get('current')).toEqual({
+                        fixture: FIXTURE,
+                        subject: undefined
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops a stored fixture this build cannot read, and boots from its own', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, rows, stop, boot;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        seededIdentity: { fixture: __assign(__assign({}, FIXTURE), { format: 0 }), subject: null }
+                    }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    stop = answerAll(controller, listeners, function (index) {
+                        return index === 0
+                            ? {
+                                error: 'The identity fixture states format 0.',
+                                errorKind: 'identity'
+                            }
+                            : { booted: true };
+                    });
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    boot = _b.sent();
+                    stop();
+                    expect(boot).toEqual({ type: 'sasjs-load-ack', booted: true });
+                    // the retry carries the drive, and none of the fixture it could not read
+                    expect(controller.postMessage.mock.calls[1][0]).toEqual({
+                        type: 'sasjs-load',
+                        files: { '/sasjs/drive/stored.txt': 'stored' }
+                    });
+                    expect(rows.has('current')).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the stored identity when the boot failed for another reason', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, rows, stop, boot;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        seededIdentity: { fixture: FIXTURE, subject: 'sasjsuser' }
+                    }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    stop = answerAll(controller, listeners, function () { return ({
+                        error: 'the drive could not be read',
+                        errorKind: 'host'
+                    }); });
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    boot = _b.sent();
+                    stop();
+                    expect(boot.error).toBe('the drive could not be read');
+                    expect(rows.get('current')).toEqual({
+                        fixture: FIXTURE,
+                        subject: 'sasjsuser'
+                    });
+                    // and it did not re-boot without the fixture
+                    expect(controller.postMessage).toHaveBeenCalledTimes(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('as() stores the subject, returns the pair and restarts the app', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, rows, stop, pair;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({ controller: controller }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    window.location = { reload: jest.fn() };
+                    stop = answerAll(controller, listeners, function (_index, type) {
+                        return type === 'sasjs-as'
+                            ? {
+                                username: 'sasjsuser',
+                                accessToken: 'access-for-user2',
+                                refreshToken: 'refresh-for-user2',
+                                identity: FIXTURE
+                            }
+                            : {};
+                    });
+                    return [4 /*yield*/, window.SASjsMock.as('sasjsuser')];
+                case 1:
+                    pair = _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith({
+                        type: 'sasjs-as',
+                        username: 'sasjsuser'
+                    });
+                    expect(pair).toEqual({
+                        username: 'sasjsuser',
+                        accessToken: 'access-for-user2',
+                        refreshToken: 'refresh-for-user2'
+                    });
+                    // the subject outlives the restart, beside the fixture it names
+                    return [4 /*yield*/, until(function () { return window.location.reload.mock.calls.length > 0; })];
+                case 2:
+                    // the subject outlives the restart, beside the fixture it names
+                    _b.sent();
+                    return [4 /*yield*/, until(function () { return rows.has('current'); })];
+                case 3:
+                    _b.sent();
+                    expect(rows.get('current')).toEqual({
+                        fixture: FIXTURE,
+                        subject: 'sasjsuser'
+                    });
+                    expect(window.location.reload).toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('surfaces a refusal from the worker rather than storing a subject', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, rows, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({ controller: controller }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    stop = answerAll(controller, listeners, function (_index, type) {
+                        return type === 'sasjs-as' ? { error: 'no account named "nobody"' } : {};
+                    });
+                    return [4 /*yield*/, expect(window.SASjsMock.as('nobody')).rejects.toThrow('no account named "nobody"')];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(rows.has('current')).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reset reports a refusal from the worker rather than claiming success', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({ controller: controller }), window = _a.window, listeners = _a.listeners;
+                    stop = answerAll(controller, listeners, function (_index, type) {
+                        return type === 'sasjs-reset'
+                            ? { error: 'host/identity.json cannot be used: it is not readable' }
+                            : {};
+                    });
+                    return [4 /*yield*/, expect(window.SASjsMock.reset()).rejects.toThrow('host/identity.json cannot be used')];
+                case 1:
+                    _b.sent();
+                    stop();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reset clears the identity beside the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, rows, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        seededIdentity: { fixture: FIXTURE, subject: 'sasjsuser' }
+                    }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    stop = answerAll(controller, listeners, function () { return ({}); });
+                    return [4 /*yield*/, window.SASjsMock.reset()];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(rows.has('current')).toBe(false);
+                    expect(rows.has('/sasjs/drive/stored.txt')).toBe(false);
                     return [2 /*return*/];
             }
         });