@sasjs/cli 6.10.0 → 6.11.0

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -175,23 +175,27 @@ describe('browser runtime', function () {
                     expect(parsed.SYSPROCESSNAME).toEqual('Browser');
                     expect(parsed.SYSSCPL).toEqual('browser');
                     // The content type is the point: the block sets it, so the worker hands the
-                    // app JSON rather than a string. The mock seeds the file empty (the server
-                    // seeds text/html), so the block's record is the only one here.
+                    // app JSON rather than a string. The session seed is text/html, so this
+                    // record has to come last for the last-line-wins rule to land on JSON.
                     expect(result.headers).toContain('content-type: application/json');
+                    expect(result.headers.trim().split('\n').pop()).toEqual('content-type: application/json');
                     return [2 /*return*/];
             }
         });
     }); });
-    it('leaves the headers alone for a service that only assigns _webout', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('seeds the headers the way a JS session does, for a service that only assigns _webout', function () { return __awaiter(void 0, void 0, void 0, function () {
         var runtime, result;
         return __generator(this, function (_a) {
             runtime = loadRuntime();
             result = runtime.run({ code: "_webout = '<h1>raw</h1>'" });
             expect(result.error).toBeNull();
             expect(result.webout).toEqual('<h1>raw</h1>');
-            // Unchanged behaviour: a raw assignment declares no type here, and the
-            // worker's binary fallback depends on this file staying empty.
-            expect(result.headers).toEqual('');
+            // A service that declares nothing answers text/html on a server, so the
+            // mock starts from the same line rather than from an empty file. The worker
+            // treats this value as undeclared for a byte body, which is why the seed
+            // does not turn a download into text/html.
+            expect(result.headers).toEqual('content-type: text/html; charset=utf-8\n');
+            expect(runtime.HEADERS_SEED).toEqual('content-type: text/html; charset=utf-8\n');
             return [2 /*return*/];
         });
     }); });
@@ -945,4 +949,249 @@ describe('browser runtime', function () {
         var runtime = loadRuntime();
         expect(function () { return runtime.run({ program: 'services/public/missing' }); }).toThrow(/Program not found in drive/);
     });
+    describe('drive writes', function () {
+        // the write API speaks drive-relative paths, and the seed holds absolute
+        // ones, so both sides go through the same root here
+        var root = '/sasjs/drive/files';
+        var seededRuntime = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        runtime = loadRuntime();
+                        return [4 /*yield*/, seedDrive(runtime, (_a = {},
+                                _a["".concat(root, "/data/keep.csv")] = 'a,b\n1,2\n',
+                                _a))
+                            // boot marks the whole drive dirty, so the page persists a complete
+                            // snapshot; clearing it here leaves each test with only its own writes
+                        ];
+                    case 1:
+                        _b.sent();
+                        // boot marks the whole drive dirty, so the page persists a complete
+                        // snapshot; clearing it here leaves each test with only its own writes
+                        runtime.takeDirty();
+                        return [2 /*return*/, runtime];
+                }
+            });
+        }); };
+        var status = function (fn) {
+            try {
+                fn();
+            }
+            catch (e) {
+                return e.status;
+            }
+            return 200;
+        };
+        it('creates a file, and the page is told to persist it', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _b.sent();
+                        expect(runtime.save('/data/new/deep/up.csv', 'x,y\n')).toEqual({
+                            status: 'success'
+                        });
+                        // the write is what the page receives after the request: a worker is
+                        // terminated between requests, so without this the upload is gone
+                        expect(runtime.takeDirty()).toEqual((_a = {},
+                            _a["".concat(root, "/data/new/deep/up.csv")] = 'x,y\n',
+                            _a));
+                        expect(runtime.read('/data/new/deep/up.csv')).toEqual({
+                            contents: 'x,y\n',
+                            binary: false
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('stores an upload as bytes, the way the server stores one', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        runtime.save('/data/pack.zip', Uint8Array.from([80, 75, 3, 4]));
+                        expect(runtime.read('/data/pack.zip')).toEqual({
+                            contents: 'UEsDBA==',
+                            binary: true
+                        });
+                        // and a service reading it gets a Buffer, as it does on the server
+                        expect(runtime.run({
+                            code: "_webout = typeof require('fs').readFileSync('".concat(root, "/data/pack.zip');")
+                        }).webout).toBe('object');
+                        expect(runtime.run({
+                            code: "_webout = require('fs').readFileSync('".concat(root, "/data/pack.zip', 'base64');")
+                        }).webout).toBe('UEsDBA==');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses to create a file over one that exists', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        expect(status(function () { return runtime.save('/data/keep.csv', 'x'); })).toBe(409);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('replaces a file, and refuses one that is not there', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        expect(runtime.update('/data/keep.csv', 'replaced')).toEqual({
+                            status: 'success'
+                        });
+                        expect(runtime.read('/data/keep.csv').contents).toBe('replaced');
+                        expect(status(function () { return runtime.update('/data/missing.csv', 'x'); })).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('deletes a file, and reports a deletion to the page', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _b.sent();
+                        expect(runtime.remove('/data/keep.csv')).toEqual({ status: 'success' });
+                        expect(runtime.takeDirty()).toEqual((_a = {},
+                            _a["".concat(root, "/data/keep.csv")] = null,
+                            _a));
+                        expect(status(function () { return runtime.read('/data/keep.csv'); })).toBe(404);
+                        expect(status(function () { return runtime.remove('/data/keep.csv'); })).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('creates a folder, and refuses one that already exists', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        expect(runtime.mkdir('/data/reports')).toEqual({ status: 'success' });
+                        expect(runtime.list('/data').folders).toContain('reports');
+                        expect(status(function () { return runtime.mkdir('/data/reports'); })).toBe(409);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('deletes a folder with everything under it', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, cleared;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        runtime.mkdir('/data/reports');
+                        runtime.save('/data/reports/a.csv', 'a');
+                        runtime.save('/data/reports/nested/b.csv', 'b');
+                        expect(runtime.rmdir('/data/reports')).toEqual({ status: 'success' });
+                        expect(runtime.list('/data').folders).not.toContain('reports');
+                        expect(status(function () { return runtime.read('/data/reports/a.csv'); })).toBe(404);
+                        expect(status(function () { return runtime.read('/data/reports/nested/b.csv'); })).toBe(404);
+                        cleared = runtime.takeDirty();
+                        expect(cleared["".concat(root, "/data/reports/a.csv")]).toBeNull();
+                        expect(cleared["".concat(root, "/data/reports/nested/b.csv")]).toBeNull();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('renames a file, and moves a folder with its contents', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        runtime.mkdir('/data/reports');
+                        runtime.save('/data/reports/a.csv', 'a');
+                        expect(runtime.rename('/data/keep.csv', '/data/kept.csv')).toEqual({
+                            status: 'success'
+                        });
+                        expect(runtime.read('/data/kept.csv').contents).toBe('a,b\n1,2\n');
+                        expect(status(function () { return runtime.read('/data/keep.csv'); })).toBe(404);
+                        expect(runtime.rename('/data/reports', '/archive')).toEqual({
+                            status: 'success'
+                        });
+                        expect(runtime.read('/archive/a.csv').contents).toBe('a');
+                        expect(status(function () { return runtime.read('/data/reports/a.csv'); })).toBe(404);
+                        expect(runtime.list('/archive').files).toEqual(['a.csv']);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a rename onto something that exists', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        runtime.save('/data/other.csv', 'o');
+                        expect(status(function () { return runtime.rename('/data/keep.csv', '/data/other.csv'); })).toBe(409);
+                        expect(status(function () { return runtime.rename('/data/nope.csv', '/data/x.csv'); })).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses any path that lands outside the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()
+                        // a leading slash is drive-relative, and '..' is resolved before the
+                        // containment test - the rule the server applies in resolveWithinDrive
+                    ];
+                    case 1:
+                        runtime = _a.sent();
+                        // a leading slash is drive-relative, and '..' is resolved before the
+                        // containment test - the rule the server applies in resolveWithinDrive
+                        expect(status(function () { return runtime.save('/../escape.csv', 'x'); })).toBe(400);
+                        expect(status(function () { return runtime.save('/data/../../escape.csv', 'x'); })).toBe(400);
+                        expect(status(function () { return runtime.remove('/../../etc/passwd'); })).toBe(400);
+                        expect(status(function () { return runtime.rename('/../x', '/data/y'); })).toBe(400);
+                        expect(status(function () { return runtime.rename('/data/keep.csv', '/../y'); })).toBe(400);
+                        // a file whose NAME starts with dots is not a traversal
+                        expect(runtime.save('/data/..weird.csv', 'x')).toEqual({
+                            status: 'success'
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('keeps the bytes of an entry it moves', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
+                    case 1:
+                        runtime = _a.sent();
+                        runtime.save('/data/pack.zip', Uint8Array.from([1, 2, 3]));
+                        runtime.rename('/data/pack.zip', '/data/moved.zip');
+                        expect(runtime.read('/data/moved.zip')).toEqual({
+                            contents: 'AQID',
+                            binary: true
+                        });
+                        expect(runtime.stats().files).toBe(2);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });