@sasjs/cli 6.10.1 → 6.12.0

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

@@ -35,7 +35,39 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+var api_1 = require("@sasjs/api");
 /**
  * The other half of the parity claim: the service worker is what turns an
  * /SASjsApi/ request into a response, so its framing (webout body, the _debug
@@ -47,6 +79,13 @@ var LOGS_SEPARATOR = 'SASJS_LOGS_SEPARATOR_163ee17b6ff24f028928972d80a26784';
 var drivePath = function (relative) {
     return "/sasjs/drive/files".concat(appLoc, "/").concat(relative);
 };
+/**
+ * The browser build of @sasjs/api that mockSite.ts copies into the site, from the
+ * installed package - the worker under test must be the worker the build ships.
+ */
+var apiBrowserBuild = function () {
+    return path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
+};
 var loadWorker = function () {
     jest.resetModules();
     var handlers = {};
@@ -65,6 +104,8 @@ var loadWorker = function () {
     global.importScripts = function (path) {
         if (path.includes('md5'))
             return;
+        if (path.includes('api-browser'))
+            return require(apiBrowserBuild());
         require('../assets/runtime-core.js');
     };
     require('../assets/sw.js');
@@ -514,9 +555,9 @@ describe('service worker host', function () {
                     response = _b.sent();
                     expect(response.status).toBe(404);
                     _a = expect;
-                    return [4 /*yield*/, response.json()];
+                    return [4 /*yield*/, response.text()];
                 case 2:
-                    _a.apply(void 0, [(_b.sent()).message]).toBe('File not found');
+                    _a.apply(void 0, [_b.sent()]).toBe("File doesn't exist.");
                     return [2 /*return*/];
             }
         });
@@ -567,9 +608,9 @@ describe('service worker host', function () {
                     response = _c.sent();
                     expect(response.status).toBe(500);
                     _a = expect;
-                    return [4 /*yield*/, response.json()];
+                    return [4 /*yield*/, response.text()];
                 case 2:
-                    _a.apply(void 0, [(_c.sent()).message]).toContain('Corrupt binary entry');
+                    _a.apply(void 0, [_c.sent()]).toContain('Corrupt binary entry');
                     return [2 /*return*/];
             }
         });
@@ -799,4 +840,669 @@ describe('service worker host', function () {
         var dispatch = seeded().dispatch;
         expect(dispatch('/index.html')).toBeUndefined();
     });
+    describe('drive writes', function () {
+        /**
+         * The response as a client sees it. A drive refusal is plain text (the
+         * server sends `res.status(code).send(err.message)`), a success is JSON.
+         */
+        var answer = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+            var resolved, type, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, response];
+                    case 1:
+                        resolved = _c.sent();
+                        type = resolved.headers.get('content-type') || '';
+                        _b = {
+                            status: resolved.status
+                        };
+                        if (!type.includes('application/json')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, resolved.json()];
+                    case 2:
+                        _a = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, resolved.text()];
+                    case 4:
+                        _a = _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, (_b.body = _a,
+                            _b)];
+                }
+            });
+        }); };
+        it('answers a drive refusal as text, the way the server sends one', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/missing.csv'))
+                            // the server's drive routes answer `res.status(code).send(err.message)`,
+                            // and its own suite asserts `res.text` - so a client that reads the body
+                            // as text must get the message here too, not a JSON envelope
+                        ];
+                    case 1:
+                        response = _b.sent();
+                        // the server's drive routes answer `res.status(code).send(err.message)`,
+                        // and its own suite asserts `res.text` - so a client that reads the body
+                        // as text must get the message here too, not a JSON envelope
+                        expect(response.status).toBe(404);
+                        expect(response.headers.get('content-type')).toContain('text/plain');
+                        _a = expect;
+                        return [4 /*yield*/, response.text()];
+                    case 2:
+                        _a.apply(void 0, [_b.sent()]).toBe("File doesn't exist.");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('creates a file, which the drive then serves', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, created, read, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/users.csv'), (function () {
+                                var form = new FormData();
+                                form.set('file', new Blob(['id,name\n1,Ann\n']), 'users.csv');
+                                return { method: 'POST', body: form };
+                            })()))];
+                    case 1:
+                        created = _b.sent();
+                        expect(created).toEqual({ status: 200, body: { status: 'success' } });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/users.csv'))];
+                    case 2:
+                        read = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, read.text()];
+                    case 3:
+                        _a.apply(void 0, [_b.sent()]).toBe('id,name\n1,Ann\n');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('creates a file at the path in the form when the query has none', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, created, read, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['x']), 'x.txt');
+                        form.set('filePath', '/data/from-form.txt');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file', { method: 'POST', body: form }))];
+                    case 1:
+                        created = _b.sent();
+                        expect(created.body).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/from-form.txt'))];
+                    case 2:
+                        read = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, read.text()];
+                    case 3:
+                        _a.apply(void 0, [_b.sent()]).toBe('x');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('answers 409 for a create over an existing file, 404 for a replace of a missing one', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, again, missing;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = function () {
+                            var f = new FormData();
+                            f.set('file', new Blob(['x']), 'x.csv');
+                            return f;
+                        };
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/x.csv'), { method: 'POST', body: form() })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/x.csv'), { method: 'POST', body: form() }))];
+                    case 2:
+                        again = _a.sent();
+                        expect(again.status).toBe(409);
+                        expect(again.body).toEqual('File already exists.');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/missing.csv'), { method: 'PATCH', body: form() }))];
+                    case 3:
+                        missing = _a.sent();
+                        expect(missing.status).toBe(404);
+                        expect(missing.body).toEqual("File doesn't exist.");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('replaces a file and deletes one', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, replacement, replaced, read, _a, removed, gone;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['v1']), 'v.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/v.csv'), { method: 'POST', body: form })];
+                    case 1:
+                        _b.sent();
+                        replacement = new FormData();
+                        replacement.set('file', new Blob(['v2']), 'v.csv');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/v.csv'), { method: 'PATCH', body: replacement }))];
+                    case 2:
+                        replaced = _b.sent();
+                        expect(replaced.body).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/v.csv'))];
+                    case 3:
+                        read = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, read.text()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toBe('v2');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/v.csv'), { method: 'DELETE' }))];
+                    case 5:
+                        removed = _b.sent();
+                        expect(removed.body).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/v.csv'))];
+                    case 6:
+                        gone = _b.sent();
+                        expect(gone.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses an upload with no file, no path, or a blocked extension', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, empty, noFile, form, noPath, sh, blocked;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        empty = new FormData();
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/x.csv'), { method: 'POST', body: empty }))];
+                    case 1:
+                        noFile = _a.sent();
+                        expect(noFile.status).toBe(400);
+                        expect(noFile.body).toEqual('"file" is not present.');
+                        form = new FormData();
+                        form.set('file', new Blob(['x']), 'x.csv');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file', { method: 'POST', body: form }))];
+                    case 2:
+                        noPath = _a.sent();
+                        expect(noPath.status).toBe(400);
+                        expect(noPath.body).toEqual('"_filePath" is required');
+                        sh = new FormData();
+                        sh.set('file', new Blob(['x']), 'run.sh');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/run.sh'), { method: 'POST', body: sh }))];
+                    case 3:
+                        blocked = _a.sent();
+                        expect(blocked.status).toBe(400);
+                        expect(blocked.body).toEqual('Invalid file extension');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a path outside the drive on every write route', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, outside, rename;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['x']), 'x.csv');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/../escape.csv'), { method: 'POST', body: form }))];
+                    case 1:
+                        outside = _a.sent();
+                        expect(outside.status).toBe(400);
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/rename', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({ oldPath: '/../x', newPath: '/data/y' })
+                            }))];
+                    case 2:
+                        rename = _a.sent();
+                        expect(rename.status).toBe(400);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('creates a folder, lists it, and deletes it with its contents', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, made, form, listed, _a, removed, gone;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/folder', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({ folderPath: '/data/reports' })
+                            }))];
+                    case 1:
+                        made = _b.sent();
+                        expect(made.body).toEqual({ status: 'success' });
+                        form = new FormData();
+                        form.set('file', new Blob(['a']), 'a.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/reports/a.csv'), { method: 'POST', body: form })];
+                    case 2:
+                        _b.sent();
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/folder?_folderPath=' + encodeURIComponent('/data'))];
+                    case 3:
+                        listed = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, listed.json()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toEqual({
+                            files: [],
+                            folders: ['reports']
+                        });
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/folder?_folderPath=' +
+                                encodeURIComponent('/data/reports'), { method: 'DELETE' }))];
+                    case 5:
+                        removed = _b.sent();
+                        expect(removed.body).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/reports/a.csv'))];
+                    case 6:
+                        gone = _b.sent();
+                        expect(gone.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a folder delete with no path', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, removed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/folder', { method: 'DELETE' }))];
+                    case 1:
+                        removed = _a.sent();
+                        expect(removed.status).toBe(400);
+                        expect(removed.body).toEqual('"_folderPath" is required');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a rename into a blocked extension, as the server does', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, toBlocked, read;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['r']), 'r.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/old.csv'), { method: 'POST', body: form })];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/rename', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    oldPath: '/data/old.csv',
+                                    newPath: '/data/x.sh'
+                                })
+                            }))
+                            // The extension rule is the drive's file-path rule, and a rename is a
+                            // file operation: sasjs/api (since 0.2.1, sasjs/api#12) applies the rule
+                            // to a rename whose target is a file, so both hosts refuse the move and
+                            // no entry can be created that the API itself cannot read back. A folder
+                            // is not subject to the file-path schema, so renaming a folder to a
+                            // dotted name stays allowed.
+                        ];
+                    case 2:
+                        toBlocked = _a.sent();
+                        // The extension rule is the drive's file-path rule, and a rename is a
+                        // file operation: sasjs/api (since 0.2.1, sasjs/api#12) applies the rule
+                        // to a rename whose target is a file, so both hosts refuse the move and
+                        // no entry can be created that the API itself cannot read back. A folder
+                        // is not subject to the file-path schema, so renaming a folder to a
+                        // dotted name stays allowed.
+                        expect(toBlocked.status).toBe(400);
+                        expect(toBlocked.body).toBe('Invalid file extension');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/old.csv')))];
+                    case 3:
+                        read = _a.sent();
+                        expect(read.status).toBe(200);
+                        expect(read.body).toBe('r');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a file where a folder already holds the path', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, atFolder;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/folder', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({ folderPath: '/data/reports' })
+                            })];
+                    case 1:
+                        _a.sent();
+                        form = new FormData();
+                        form.set('file', new Blob(['r']), 'r.csv');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/reports'), { method: 'POST', body: form }))
+                            // the server fails this at the filesystem (EISDIR); naming it as a conflict
+                            // keeps the drive from holding one path as both a file and a folder
+                        ];
+                    case 2:
+                        atFolder = _a.sent();
+                        // the server fails this at the filesystem (EISDIR); naming it as a conflict
+                        // keeps the drive from holding one path as both a file and a folder
+                        expect(atFolder.status).toBe(409);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a file under a path that is already a file', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, child, under, stillAFile, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['a']), 'a.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/a.csv'), { method: 'POST', body: form })];
+                    case 1:
+                        _b.sent();
+                        child = new FormData();
+                        child.set('file', new Blob(['b']), 'b.csv');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/a.csv/child.csv'), { method: 'POST', body: child }))
+                            // mkdirp would otherwise turn the file into a folder to hold the child.
+                            // The server loses this at the filesystem (ENOTDIR) and answers a 500, so
+                            // this answers a 500 too: the refusal is the point, the status is the
+                            // server's class, and the message says which path was in the way.
+                        ];
+                    case 2:
+                        under = _b.sent();
+                        // mkdirp would otherwise turn the file into a folder to hold the child.
+                        // The server loses this at the filesystem (ENOTDIR) and answers a 500, so
+                        // this answers a 500 too: the refusal is the point, the status is the
+                        // server's class, and the message says which path was in the way.
+                        expect(under.status).toBe(500);
+                        expect(under.body).toEqual({
+                            message: 'ENOTDIR: an ancestor of the path is a file: /data/a.csv'
+                        });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/a.csv'))];
+                    case 3:
+                        stillAFile = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, stillAFile.text()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toBe('a');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('serves a download with the type its extension implies', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, csv, _a, sas, program;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['id,name\n1,Ann\n']), 'users.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/users.csv'), { method: 'POST', body: form })];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/users.csv'))
+                            // an upload is stored as bytes, as multer leaves it on the server; the
+                            // extension is what makes it answer text/csv rather than octet-stream
+                        ];
+                    case 2:
+                        csv = _b.sent();
+                        // an upload is stored as bytes, as multer leaves it on the server; the
+                        // extension is what makes it answer text/csv rather than octet-stream
+                        expect(csv.headers.get('content-type')).toBe('text/csv');
+                        _a = expect;
+                        return [4 /*yield*/, csv.text()];
+                    case 3:
+                        _a.apply(void 0, [_b.sent()]).toBe('id,name\n1,Ann\n');
+                        sas = new FormData();
+                        sas.set('file', new Blob(['data _null_; run;']), 'p.sas');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/p.sas'), { method: 'POST', body: sas })];
+                    case 4:
+                        _b.sent();
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/p.sas'))];
+                    case 5:
+                        program = _b.sent();
+                        expect(program.headers.get('content-type')).toBe('text/plain');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses an upload larger than the host allows, before reading it', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, runtime, form, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        runtime = loadWorker().runtime;
+                        form = new FormData();
+                        form.set('file', new Blob([new Uint8Array(runtime.MAX_UPLOAD_BYTES + 1)]), 'big.bin');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/big.bin'), { method: 'POST', body: form }))];
+                    case 1:
+                        response = _a.sent();
+                        expect(response.status).toBe(413);
+                        expect(response.body).toContain('larger than the browser host allows');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renames a file through the route the API documents', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, renamed, read, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        form = new FormData();
+                        form.set('file', new Blob(['r']), 'r.csv');
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/old.csv'), { method: 'POST', body: form })];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/rename', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    oldPath: '/data/old.csv',
+                                    newPath: '/data/new.csv'
+                                })
+                            }))];
+                    case 2:
+                        renamed = _b.sent();
+                        expect(renamed.body).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/new.csv'))];
+                    case 3:
+                        read = _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, read.text()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toBe('r');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('conformance corpus', function () {
+        var e_1, _a;
+        /**
+         * The corpus is what "the same API" means: the cases @sasjs/api runs against
+         * its own services, and against a live sasjs/server, run here against this
+         * worker's HTTP surface. A case that answers differently is this host
+         * drifting from the server - the failure mode the hand-written drive routes
+         * used to have - and it is a test rather than a review.
+         */
+        var httpFor = function (testCase) {
+            var e_2, _a;
+            var _b;
+            var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
+            var query = new URLSearchParams();
+            try {
+                for (var _d = __values(Object.entries(testCase.request.query || {})), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var _f = __read(_e.value, 2), key = _f[0], value = _f[1];
+                    if (value !== undefined)
+                        query.set(key, String(value));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            var suffix = query.toString() ? "?".concat(query) : '';
+            var init = { method: method };
+            var file = testCase.request.file;
+            if (file) {
+                var form = new FormData();
+                // the Blob types want a view over an ArrayBuffer; a Uint8Array from the
+                // corpus is typed over ArrayBufferLike, which a Blob does not accept
+                var bytes = typeof file.contents === 'string'
+                    ? new TextEncoder().encode(file.contents)
+                    : new Uint8Array(file.contents);
+                form.set('file', new Blob([bytes]), file.name);
+                var formPath = (_b = testCase.request.body) === null || _b === void 0 ? void 0 : _b.filePath;
+                if (formPath !== undefined)
+                    form.set('filePath', String(formPath));
+                init.body = form;
+            }
+            else if (testCase.request.body) {
+                init.body = JSON.stringify(testCase.request.body);
+                init.headers = { 'content-type': 'application/json' };
+            }
+            return { path: routePath + suffix, init: init };
+        };
+        /**
+         * The case's own files, at the paths the drive stores them under. `load`
+         * restores the seed snapshot, which is a map of strings - a byte entry is a
+         * snapshot of an upload, so it goes in through the store the way an upload
+         * does.
+         */
+        var seedDrive = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_3_1;
+            var e_4, _g, e_3, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        text = {};
+                        try {
+                            for (_a = __values(Object.entries(testCase.seed || {})), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = __read(_b.value, 2), file = _c[0], contents = _c[1];
+                                if (typeof contents === 'string')
+                                    text["/sasjs/drive/files".concat(file)] = contents;
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        return [4 /*yield*/, runtime.load(text)];
+                    case 1:
+                        _j.sent();
+                        _j.label = 2;
+                    case 2:
+                        _j.trys.push([2, 7, 8, 9]);
+                        _d = __values(Object.entries(testCase.seed || {})), _e = _d.next();
+                        _j.label = 3;
+                    case 3:
+                        if (!!_e.done) return [3 /*break*/, 6];
+                        _f = __read(_e.value, 2), file = _f[0], contents = _f[1];
+                        if (!(typeof contents !== 'string')) return [3 /*break*/, 5];
+                        return [4 /*yield*/, runtime.driveStore.write(file, contents)];
+                    case 4:
+                        _j.sent();
+                        _j.label = 5;
+                    case 5:
+                        _e = _d.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_3_1 = _j.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); };
+        var _loop_1 = function (testCase) {
+            it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, requestPath, init, response, _b, want, _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            worker = loadWorker();
+                            return [4 /*yield*/, seedDrive(worker.runtime, testCase)];
+                        case 1:
+                            _f.sent();
+                            _a = httpFor(testCase), requestPath = _a.path, init = _a.init;
+                            return [4 /*yield*/, worker.dispatch(requestPath, init)];
+                        case 2:
+                            response = _f.sent();
+                            expect(response.status).toBe(testCase.expect.status);
+                            if (!(testCase.expect.error !== undefined)) return [3 /*break*/, 4];
+                            _b = expect;
+                            return [4 /*yield*/, response.text()];
+                        case 3:
+                            _b.apply(void 0, [_f.sent()]).toBe(testCase.expect.error);
+                            _f.label = 4;
+                        case 4:
+                            want = testCase.expect.contents;
+                            if (!(typeof want === 'string')) return [3 /*break*/, 6];
+                            _c = expect;
+                            return [4 /*yield*/, response.text()];
+                        case 5:
+                            _c.apply(void 0, [_f.sent()]).toBe(want);
+                            return [3 /*break*/, 8];
+                        case 6:
+                            if (!(want !== undefined)) return [3 /*break*/, 8];
+                            _d = expect;
+                            _e = Uint8Array.bind;
+                            return [4 /*yield*/, response.arrayBuffer()];
+                        case 7:
+                            _d.apply(void 0, [new (_e.apply(Uint8Array, [void 0, _f.sent()]))()]).toEqual(want);
+                            _f.label = 8;
+                        case 8: return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        try {
+            for (var DRIVE_CORPUS_1 = __values(api_1.DRIVE_CORPUS), DRIVE_CORPUS_1_1 = DRIVE_CORPUS_1.next(); !DRIVE_CORPUS_1_1.done; DRIVE_CORPUS_1_1 = DRIVE_CORPUS_1.next()) {
+                var testCase = DRIVE_CORPUS_1_1.value;
+                _loop_1(testCase);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (DRIVE_CORPUS_1_1 && !DRIVE_CORPUS_1_1.done && (_a = DRIVE_CORPUS_1.return)) _a.call(DRIVE_CORPUS_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
 });