@sasjs/cli 6.30.0 → 6.31.0

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

@@ -213,6 +213,10 @@ var loadPersist = function (options) {
         // the identity row lives beside the drive, under its own key
         if (options.seededIdentity)
             fake.rows.set('current', options.seededIdentity);
+        // and the paths a visitor deleted, which a sharded site's index would
+        // otherwise restore
+        if (options.seededDeleted)
+            fake.rows.set('deleted', options.seededDeleted);
         return fake;
     })();
     global.indexedDB = idb;
@@ -228,6 +232,40 @@ var loadPersist = function (options) {
         stored: local
     };
 };
+/**
+ * Waits for the store's own handshake to land.
+ *
+ * A persist message is answered by a chain of transactions - write the files,
+ * read the tombstone list, write it back - and the page does not expose the
+ * promise. A fixed sleep is a race on a slow runner (Windows was the one that
+ * failed), so the assertions poll for the change they expect instead.
+ */
+var settleUntil = function (check_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([check_1], __read(args_1), false), void 0, function (check, timeout) {
+        var started;
+        if (timeout === void 0) { timeout = 4000; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    started = Date.now();
+                    _a.label = 1;
+                case 1:
+                    if (!(Date.now() - started < timeout)) return [3 /*break*/, 3];
+                    if (check())
+                        return [2 /*return*/];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+};
 describe('page-side store', function () {
     afterEach(function () {
         jest.useRealTimers();
@@ -440,7 +478,7 @@ describe('page-side store', function () {
                 case 0:
                     _a = loadPersist(), window = _a.window, reply = _a.reply, rows = _a.rows;
                     reply({ type: 'sasjs-persist', files: { '/sasjs/drive/c.txt': 'ccc' } });
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 20); })];
+                    return [4 /*yield*/, settleUntil(function () { return rows.get('/sasjs/drive/c.txt') === 'ccc'; })];
                 case 1:
                     _b.sent();
                     expect(rows.get('/sasjs/drive/c.txt')).toBe('ccc');
@@ -448,6 +486,146 @@ describe('page-side store', function () {
             }
         });
     }); });
+    /**
+     * A deletion has to outlive the worker, and the page is the only store that can
+     * keep it.
+     *
+     * The drive in a sharded build is not all in the page either: the index lists
+     * every file the build ships, so a file the visitor deleted comes back on the
+     * next load unless the path is remembered here and handed to the worker at
+     * boot.
+     */
+    it('remembers a deleted path, and forgets it when the path is written again', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, reply, rows;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist({
+                        seeded: { '/sasjs/drive/a.txt': 'a', '/sasjs/drive/b.txt': 'b' }
+                    }), window = _a.window, reply = _a.reply, rows = _a.rows;
+                    reply({ type: 'sasjs-persist', files: { '/sasjs/drive/a.txt': null } });
+                    return [4 /*yield*/, settleUntil(function () { return rows.has('deleted'); })];
+                case 1:
+                    _b.sent();
+                    expect(rows.get('deleted')).toEqual(['/sasjs/drive/a.txt']);
+                    // the row itself is gone, and the tombstone is what stops the index bringing
+                    // it back
+                    expect(rows.has('/sasjs/drive/a.txt')).toBe(false);
+                    reply({ type: 'sasjs-persist', files: { '/sasjs/drive/a.txt': 'again' } });
+                    // the tombstone is written back after the file, so poll for it rather than
+                    // for the write that precedes it
+                    return [4 /*yield*/, settleUntil(function () { return !rows.has('deleted'); })];
+                case 2:
+                    // the tombstone is written back after the file, so poll for it rather than
+                    // for the write that precedes it
+                    _b.sent();
+                    expect(rows.has('deleted')).toBe(false);
+                    expect(rows.get('/sasjs/drive/a.txt')).toBe('again');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('writes no file when the worker could not read the drive whole', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, page, listeners, reply, answering, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({})
+                    }), page = _a.window, listeners = _a.listeners, reply = _a.reply;
+                    answering = setInterval(function () {
+                        var asked = controller.postMessage.mock.calls;
+                        if (!asked.length)
+                            return;
+                        __spreadArray([], __read(listeners), false).forEach(function (fn) {
+                            return fn({ data: { type: asked[0][0].type + '-ack', booted: true } });
+                        });
+                    }, 5);
+                    return [4 /*yield*/, page.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    clearInterval(answering);
+                    pending = page.SASjsMock.download();
+                    return [4 /*yield*/, Promise.resolve()
+                        // the worker answers with what it has and says why it could not finish, and a
+                        // file built from that would be a capture with every app bundle missing
+                    ];
+                case 2:
+                    _b.sent();
+                    // the worker answers with what it has and says why it could not finish, and a
+                    // file built from that would be a capture with every app bundle missing
+                    reply({
+                        type: 'sasjs-snapshot',
+                        files: { '/sasjs/drive/a.txt': 'a' },
+                        error: 'ensureAll rejected: ENOENT'
+                    });
+                    return [4 /*yield*/, expect(pending).rejects.toThrow(/could not be read whole/)];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops the recorded deletions with the rest of the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, listeners, rows, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist({
+                        seeded: { '/sasjs/drive/a.txt': 'a' },
+                        seededDeleted: ['/sasjs/drive/a.txt']
+                    }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    pending = window.SASjsMock.reset();
+                    return [4 /*yield*/, Promise.resolve()];
+                case 1:
+                    _b.sent();
+                    __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: { type: 'sasjs-reset-ack' } }); });
+                    return [4 /*yield*/, pending];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, settleUntil(function () { return !rows.has('deleted'); })];
+                case 3:
+                    _b.sent();
+                    expect(rows.has('deleted')).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('tells the worker which paths were deleted, so its index cannot restore them', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, answering;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/b.txt': 'b' },
+                        seededDeleted: ['/sasjs/drive/a.txt']
+                    }), window = _a.window, listeners = _a.listeners;
+                    answering = setInterval(function () {
+                        var asked = controller.postMessage.mock.calls;
+                        if (!asked.length)
+                            return;
+                        var type = asked[0][0].type;
+                        __spreadArray([], __read(listeners), false).forEach(function (fn) {
+                            return fn({ data: { type: type + '-ack', booted: true } });
+                        });
+                    }, 5);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    clearInterval(answering);
+                    expect(controller.postMessage.mock.calls[0][0]).toEqual(expect.objectContaining({
+                        type: 'sasjs-load',
+                        deleted: ['/sasjs/drive/a.txt']
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('resets the worker and the stored drive together', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, window, posted, reply, rows, pending;
         return __generator(this, function (_b) {