@sasjs/cli 6.10.0 → 6.11.0

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

@@ -239,6 +239,92 @@ describe('service worker host', function () {
             }
         });
     }); });
+    it('keeps a header appended without a leading newline on its own line', 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 = streaming([
+                        "fs.appendFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: application/json')",
+                        "_webout = '{}'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('application/json');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('{}');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a declared type that happens to equal the seed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatch = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'content-type: text/html; charset=utf-8')",
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([1, 2, 3]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _a.sent();
+                    expect(response.headers.get('content-type')).toBe('text/html; charset=utf-8');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers text/html for a service that declares no type, as a server does', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/getdata")))
+                        // The session header file is seeded with the server's line, so a service
+                        // that assigns _webout and stops answers with a content type instead of
+                        // leaving the choice to the browser.
+                    ];
+                case 1:
+                    response = _b.sent();
+                    // The session header file is seeded with the server's line, so a service
+                    // that assigns _webout and stops answers with a content type instead of
+                    // leaving the choice to the browser.
+                    expect(response.headers.get('content-type')).toBe('text/html; charset=utf-8');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('seeded');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a declared text/html on a byte body, and ignores only the seed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatch = streaming([
+                        "fs.appendFileSync(_SASJS_WEBOUT_HEADERS, '\\nContent-type: text/html')",
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([1, 2, 3]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())
+                        // only the seeded value is treated as undeclared; the same type written by
+                        // the service is a declaration and is applied
+                    ];
+                case 1:
+                    response = _a.sent();
+                    // only the seeded value is treated as undeclared; the same type written by
+                    // the service is a declaration and is applied
+                    expect(response.headers.get('content-type')).toBe('text/html');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('keeps a debug reply text, as the body is the framed log', function () { return __awaiter(void 0, void 0, void 0, function () {
         var dispatch, response, _a;
         return __generator(this, function (_b) {
@@ -428,9 +514,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*/];
             }
         });
@@ -481,9 +567,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*/];
             }
         });
@@ -713,4 +799,490 @@ 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 that would produce a blocked extension', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, toBlocked, fromBlocked;
+            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'
+                                })
+                            }))
+                            // DELETE and PATCH run the same check on the path they are given, so a file
+                            // renamed into a blocked name could not be removed or replaced afterwards
+                        ];
+                    case 2:
+                        toBlocked = _a.sent();
+                        // DELETE and PATCH run the same check on the path they are given, so a file
+                        // renamed into a blocked name could not be removed or replaced afterwards
+                        expect(toBlocked.status).toBe(400);
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/rename', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    oldPath: '/data/x.sh',
+                                    newPath: '/data/new.csv'
+                                })
+                            }))];
+                    case 3:
+                        fromBlocked = _a.sent();
+                        expect(fromBlocked.status).toBe(400);
+                        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
+                        ];
+                    case 2:
+                        under = _b.sent();
+                        // mkdirp would otherwise turn the file into a folder to hold the child
+                        expect(under.status).toBe(400);
+                        expect(under.body).toBe('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*/];
+                }
+            });
+        }); });
+    });
 });

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.10.0"
+  "version": "6.11.0"
 }