@sasjs/cli 6.11.0 → 6.12.1

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

@@ -35,7 +35,12 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
 var utils_1 = require("@sasjs/utils");
 var mockSite_1 = require("../mockSite");
 /**
@@ -249,6 +254,83 @@ describe('browser runtime', function () {
         expect(result.log).toContain('boom');
         expect(result.webout).toBe('');
     });
+    /**
+     * The shims a service reaches for are node's, refusals included: a mock that
+     * answered a copy from a missing file with an empty file, or accepted
+     * `createHash('sha256')`, would let a service pass here and fail on the server.
+     */
+    it("refuses what the fs, path and crypto shims refuse, with node's words", function () {
+        var runtime = loadRuntime();
+        var failure = function (code) { return runtime.run({ code: code }).error; };
+        expect(failure("fs.copyFileSync('/missing.csv', '/x.csv')")).toMatch(/ENOENT: no such file, copy/);
+        expect(failure("fs.statSync('/missing.csv')")).toMatch(/ENOENT: no such file or directory, stat/);
+        expect(failure("fs.readFileSync('/missing.csv')")).toMatch(/ENOENT: no such file or directory, open/);
+        expect(failure("fs.writeFileSync('/x.csv', 'x', { flag: 'r' })")).toMatch(/Unsupported flag 'r' in the browser host/);
+        expect(failure("require('crypto').createHash('sha256')")).toMatch(/Unsupported hash in browser host: sha256/);
+        expect(failure("require('net')")).toMatch(/Cannot find module 'net' in the browser runtime host/);
+    });
+    it('answers the path and Buffer helpers a service uses', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: [
+                "const path = require('path')",
+                '_webout = JSON.stringify({',
+                "  ext: path.extname('/data/a.csv'),",
+                "  none: path.extname('csv'),",
+                "  base: path.basename('/data/a.csv'),",
+                "  dir: path.dirname('/data/a.csv')",
+                '})'
+            ].join('\n')
+        });
+        expect(JSON.parse(result.webout)).toEqual({
+            ext: '.csv',
+            none: '',
+            base: 'a.csv',
+            dir: '/data'
+        });
+    });
+    it('hashes with the md5 the worker imports, as node does', function () {
+        var runtime = loadRuntime();
+        // md5.js declares its hash in the global scope of the worker that imports
+        // it; a jest module would hide it, so it is evaluated the way the worker
+        // does - which is also what makes this the real md5 rather than a stub
+        var source = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'assets', 'md5.js'), 'utf8');
+        global.MD5 = new Function("".concat(source, "\nreturn MD5"))();
+        var result = runtime.run({
+            code: "_webout = require('crypto').createHash('md5').update('abc').digest('hex')"
+        });
+        // md5('abc'), the digest node gives for the same call
+        expect(result.webout).toBe('900150983cd24fb0d6963f7d28e17f72');
+    });
+    it('reports a write that fails through the callback node hands it', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: [
+                'let reported = null',
+                "fs.writeFile('/x.csv', 'x', { flag: 'r' }, (err) => { reported = err && err.message })",
+                '_webout = String(reported)'
+            ].join('\n')
+        });
+        expect(result.webout).toMatch(/Unsupported flag 'r' in the browser host/);
+    });
+    it('refuses to boot a worker that has neither a seed nor a snapshot', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, info;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    global.fetch = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({ ok: false })];
+                    }); }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 1:
+                    info = _a.sent();
+                    expect(info.booted).toBe(false);
+                    expect(info.error).toMatch(/No drive to load/);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('collects service console output into the log', function () {
         var runtime = loadRuntime();
         var result = runtime.run({
@@ -847,24 +929,37 @@ describe('browser runtime', function () {
         });
         expect(result.webout).toBe('AQID');
     });
-    it('lists folders and builds the drive tree', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var runtime, listing, tree;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+    it('hands the API a store over the drive it seeded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, listing, _a, _b;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     runtime = loadRuntime();
-                    return [4 /*yield*/, seedDrive(runtime, (_a = {},
-                            _a[drivePath('services/public/getdata.js')] = '_webout = "x";',
-                            _a[drivePath('data/a.txt')] = 'a',
-                            _a))];
+                    return [4 /*yield*/, seedDrive(runtime, (_c = {},
+                            _c[drivePath('services/public/getdata.js')] = '_webout = "x";',
+                            _c[drivePath('data/a.txt')] = 'a',
+                            _c))
+                        // drive-relative paths, the form every @sasjs/api service speaks: the app
+                        // loc is part of the path, the host's own root is not
+                    ];
                 case 1:
-                    _b.sent();
-                    listing = runtime.list("".concat(appLoc, "/services/public"));
+                    _d.sent();
+                    return [4 /*yield*/, runtime.driveStore.list(appLoc + '/services/public')];
+                case 2:
+                    listing = _d.sent();
                     expect(listing.files).toEqual(['getdata.js']);
-                    tree = runtime.tree();
-                    expect(JSON.stringify(tree)).toContain('getdata.js');
-                    expect(runtime.read("".concat(appLoc, "/data/a.txt")).contents).toBe('a');
+                    _a = expect;
+                    return [4 /*yield*/, runtime.driveStore.read(appLoc + '/data/a.txt')];
+                case 3:
+                    _a.apply(void 0, [_d.sent()]).toBe('a');
+                    _b = expect;
+                    return [4 /*yield*/, runtime.driveStore.stat(appLoc + '/data')];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toEqual({
+                        directory: true,
+                        size: 0
+                    });
                     return [2 /*return*/];
             }
         });
@@ -949,9 +1044,11 @@ 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
+    describe('drive store', function () {
+        // the store the API is handed: drive-relative paths in, the drive's own
+        // absolute keys behind. What a status or a message should be is the
+        // package's business (spec/sw.spec.ts runs its corpus through this worker),
+        // so these cases are the storage contract only.
         var root = '/sasjs/drive/files';
         var seededRuntime = function () { return __awaiter(void 0, void 0, void 0, function () {
             var runtime;
@@ -975,220 +1072,344 @@ describe('browser runtime', function () {
                 }
             });
         }); };
-        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) {
+        it('reads text as text and hands back the entry it holds', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.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
+                        runtime = _e.sent();
+                        store = runtime.driveStore;
+                        _a = expect;
+                        return [4 /*yield*/, store.exists('/data/keep.csv')];
+                    case 2:
+                        _a.apply(void 0, [_e.sent()]).toBe(true);
+                        _b = expect;
+                        return [4 /*yield*/, store.exists('/data/missing.csv')];
+                    case 3:
+                        _b.apply(void 0, [_e.sent()]).toBe(false);
+                        _c = expect;
+                        return [4 /*yield*/, store.read('/data/keep.csv')];
+                    case 4:
+                        _c.apply(void 0, [_e.sent()]).toBe('a,b\n1,2\n');
+                        _d = expect;
+                        return [4 /*yield*/, store.stat('/data/keep.csv')];
+                    case 5:
+                        _d.apply(void 0, [_e.sent()]).toEqual({
+                            directory: false,
+                            size: 8
                         });
                         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) {
+        it('keeps an entry written as bytes as bytes, and measures it in bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.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
+                        runtime = _c.sent();
+                        store = runtime.driveStore;
+                        return [4 /*yield*/, store.write('/data/pack.zip', Uint8Array.from([80, 75, 3, 4]))];
+                    case 2:
+                        _c.sent();
+                        _a = expect;
+                        return [4 /*yield*/, store.read('/data/pack.zip')];
+                    case 3:
+                        _a.apply(void 0, [_c.sent()]).toEqual(Uint8Array.from([80, 75, 3, 4]));
+                        _b = expect;
+                        return [4 /*yield*/, store.stat('/data/pack.zip')];
+                    case 4:
+                        _b.apply(void 0, [_c.sent()]).toEqual({
+                            directory: false,
+                            size: 4
                         });
-                        // 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 () {
+        it('reports a write to the page, so the entry is persisted', 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 [4 /*yield*/, runtime.driveStore.write('/data/new/deep/up.csv', 'x,y')];
+                    case 2:
+                        _a.sent();
+                        expect(Object.keys(runtime.takeDirty())).toEqual([
+                            "".concat(root, "/data/new/deep/up.csv")
+                        ]);
+                        expect(runtime.dumpAll()["".concat(root, "/data/new/deep/up.csv")]).toBe('x,y');
                         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) {
+        it('reports a deletion, so the page drops the entry', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.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);
+                        runtime = _c.sent();
+                        return [4 /*yield*/, runtime.driveStore.remove('/data/keep.csv')];
+                    case 2:
+                        _c.sent();
+                        expect(runtime.takeDirty()).toEqual((_b = {}, _b["".concat(root, "/data/keep.csv")] = null, _b));
+                        _a = expect;
+                        return [4 /*yield*/, runtime.driveStore.exists('/data/keep.csv')];
+                    case 3:
+                        _a.apply(void 0, [_c.sent()]).toBe(false);
                         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) {
+        it('creates a folder and lists the immediate children of a folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.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);
+                        runtime = _c.sent();
+                        store = runtime.driveStore;
+                        return [4 /*yield*/, store.mkdirp('/data/reports/nested')];
+                    case 2:
+                        _c.sent();
+                        return [4 /*yield*/, store.write('/data/reports/a.csv', 'a')];
+                    case 3:
+                        _c.sent();
+                        _a = expect;
+                        return [4 /*yield*/, store.list('/data')];
+                    case 4:
+                        _a.apply(void 0, [_c.sent()]).toEqual({
+                            files: ['keep.csv'],
+                            folders: ['reports']
+                        });
+                        _b = expect;
+                        return [4 /*yield*/, store.list('/data/reports')];
+                    case 5:
+                        _b.apply(void 0, [_c.sent()]).toEqual({
+                            files: ['a.csv'],
+                            folders: ['nested']
+                        });
                         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) {
+        it('removes a folder with everything under it, and reports each entry', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.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);
+                        runtime = _d.sent();
+                        store = runtime.driveStore;
+                        return [4 /*yield*/, store.mkdirp('/data/reports')];
+                    case 2:
+                        _d.sent();
+                        return [4 /*yield*/, store.write('/data/reports/a.csv', 'a')];
+                    case 3:
+                        _d.sent();
+                        return [4 /*yield*/, store.write('/data/reports/nested/b.csv', 'b')];
+                    case 4:
+                        _d.sent();
+                        runtime.takeDirty();
+                        return [4 /*yield*/, store.remove('/data/reports')];
+                    case 5:
+                        _d.sent();
+                        _a = expect;
+                        return [4 /*yield*/, store.exists('/data/reports')];
+                    case 6:
+                        _a.apply(void 0, [_d.sent()]).toBe(false);
+                        _b = expect;
+                        return [4 /*yield*/, store.list('/data')];
+                    case 7:
+                        _b.apply(void 0, [_d.sent()]).toEqual({
+                            files: ['keep.csv'],
+                            folders: []
+                        });
+                        // every file the removal took goes to the page, or IndexedDB keeps it
+                        expect(runtime.takeDirty()).toEqual((_c = {},
+                            _c["".concat(root, "/data/reports/a.csv")] = null,
+                            _c["".concat(root, "/data/reports/nested/b.csv")] = null,
+                            _c));
                         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) {
+        it('moves a file, and marks both ends', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, _a, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.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();
+                        runtime = _d.sent();
+                        return [4 /*yield*/, runtime.driveStore.move('/data/keep.csv', '/data/kept.csv')];
+                    case 2:
+                        _d.sent();
+                        _a = expect;
+                        return [4 /*yield*/, runtime.driveStore.read('/data/kept.csv')];
+                    case 3:
+                        _a.apply(void 0, [_d.sent()]).toBe('a,b\n1,2\n');
+                        _b = expect;
+                        return [4 /*yield*/, runtime.driveStore.exists('/data/keep.csv')];
+                    case 4:
+                        _b.apply(void 0, [_d.sent()]).toBe(false);
+                        expect(runtime.takeDirty()).toEqual((_c = {},
+                            _c["".concat(root, "/data/kept.csv")] = 'a,b\n1,2\n',
+                            _c["".concat(root, "/data/keep.csv")] = null,
+                            _c));
                         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) {
+        it('moves a folder with its contents, bytes and all', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.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'
+                        runtime = _d.sent();
+                        store = runtime.driveStore;
+                        return [4 /*yield*/, store.mkdirp('/data/reports')];
+                    case 2:
+                        _d.sent();
+                        return [4 /*yield*/, store.write('/data/reports/a.csv', 'a')];
+                    case 3:
+                        _d.sent();
+                        return [4 /*yield*/, store.write('/data/reports/nested/pack.zip', Uint8Array.from([1, 2, 3]))];
+                    case 4:
+                        _d.sent();
+                        return [4 /*yield*/, store.move('/data/reports', '/archive')];
+                    case 5:
+                        _d.sent();
+                        _a = expect;
+                        return [4 /*yield*/, store.list('/archive')];
+                    case 6:
+                        _a.apply(void 0, [_d.sent()]).toEqual({
+                            files: ['a.csv'],
+                            folders: ['nested']
                         });
-                        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']);
+                        _b = expect;
+                        return [4 /*yield*/, store.read('/archive/nested/pack.zip')];
+                    case 7:
+                        _b.apply(void 0, [_d.sent()]).toEqual(Uint8Array.from([1, 2, 3]));
+                        _c = expect;
+                        return [4 /*yield*/, store.exists('/data/reports')];
+                    case 8:
+                        _c.apply(void 0, [_d.sent()]).toBe(false);
                         return [2 /*return*/];
                 }
             });
         }); });
-        it('refuses a rename onto something that exists', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var runtime;
+        it('refuses a write under a path that is a file, rather than writing through it', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()
+                        // mkdirp would otherwise turn the file into a folder to hold the child
+                    ];
+                    case 1:
+                        runtime = _b.sent();
+                        // mkdirp would otherwise turn the file into a folder to hold the child
+                        return [4 /*yield*/, expect(runtime.driveStore.write('/data/keep.csv/child.csv', 'b')).rejects.toThrow(/an ancestor of the path is a file/)];
+                    case 2:
+                        // mkdirp would otherwise turn the file into a folder to hold the child
+                        _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, runtime.driveStore.read('/data/keep.csv')];
+                    case 3:
+                        _a.apply(void 0, [_b.sent()]).toBe('a,b\n1,2\n');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("refuses a path it does not hold, in the drive's own words", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store;
             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);
+                        store = runtime.driveStore;
+                        // the API checks existence before it reads, so these are the store's own
+                        // refusals rather than answers a client normally sees
+                        return [4 /*yield*/, expect(store.read('/data/missing.csv')).rejects.toThrow("File doesn't exist.")];
+                    case 2:
+                        // the API checks existence before it reads, so these are the store's own
+                        // refusals rather than answers a client normally sees
+                        _a.sent();
+                        return [4 /*yield*/, expect(store.stat('/data/missing.csv')).rejects.toThrow(/ENOENT/)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, expect(store.move('/data/missing.csv', '/data/x.csv')).rejects.toThrow(/no such folder/)];
+                    case 4:
+                        _a.sent();
                         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
-                    ];
+        it('refuses a path that climbs out of the drive, whatever the caller', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, store, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, seededRuntime()];
                     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'
-                        });
+                        runtime = _b.sent();
+                        store = runtime.driveStore;
+                        // the API refuses these first, with the wording a client sees; this is the
+                        // storage boundary refusing on its own, because the store is handed out and
+                        // a caller that skips the package must not be able to leave the drive
+                        return [4 /*yield*/, expect(store.read('/../escape.csv')).rejects.toThrow(/Can't reach a path outside the drive/)];
+                    case 2:
+                        // the API refuses these first, with the wording a client sees; this is the
+                        // storage boundary refusing on its own, because the store is handed out and
+                        // a caller that skips the package must not be able to leave the drive
+                        _b.sent();
+                        return [4 /*yield*/, expect(store.write('/data/../../escape.csv', 'x')).rejects.toThrow(/Can't reach a path outside the drive/)];
+                    case 3:
+                        _b.sent();
+                        return [4 /*yield*/, expect(store.list('/..')).rejects.toThrow(/Can't reach a path outside the drive/)];
+                    case 4:
+                        _b.sent();
+                        _a = expect;
+                        return [4 /*yield*/, store.exists('/data/keep.csv')];
+                    case 5:
+                        _a.apply(void 0, [_b.sent()]).toBe(true);
                         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) {
+        it('counts the root as a folder, and its children as the listing', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var runtime, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.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
+                        runtime = _c.sent();
+                        _a = expect;
+                        return [4 /*yield*/, runtime.driveStore.stat('')];
+                    case 2:
+                        _a.apply(void 0, [_c.sent()]).toEqual({
+                            directory: true,
+                            size: 0
+                        });
+                        // the seed's own folder sits under the root too, alongside the app loc the
+                        // host creates at boot, so the listing is the drive as it stands
+                        _b = expect;
+                        return [4 /*yield*/, runtime.driveStore.list('')];
+                    case 3:
+                        // the seed's own folder sits under the root too, alongside the app loc the
+                        // host creates at boot, so the listing is the drive as it stands
+                        _b.apply(void 0, [_c.sent()]).toEqual({
+                            files: [],
+                            folders: ['Public', 'data']
                         });
-                        expect(runtime.stats().files).toBe(2);
                         return [2 /*return*/];
                 }
             });