@sasjs/cli 6.10.1 → 6.12.0

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

@@ -167,7 +167,8 @@ describe('browser-hosted build', function () {
                             'md5.js',
                             'runtime-core.js',
                             'persist.js',
-                            'intercept.js'
+                            'intercept.js',
+                            'api-browser.js'
                         ]), _b = _a.next(); !_b.done; _b = _a.next()) {
                             asset = _b.value;
                             expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', asset))).toBe(true);
@@ -189,6 +190,124 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('ships the @sasjs/api build the CLI resolves, and versions both imports', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var shipped, installed, sw;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                    // the same file the installed package carries: a vendored copy is exactly
+                    // how the worker and the server drift apart
+                ];
+                case 1:
+                    _a.sent();
+                    shipped = fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'api-browser.js'));
+                    installed = fs_1.default.readFileSync(path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js'));
+                    expect(shipped.equals(installed)).toBe(true);
+                    sw = fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8');
+                    // both imports carry the host version: a worker caches what it imports, so
+                    // a rebuild that changes either file has to change the URL
+                    expect(sw).toMatch(/importScripts\('\/host\/runtime-core\.js\?v=[0-9a-f]{10}'\)/);
+                    expect(sw).toMatch(/importScripts\('\/host\/api-browser\.js\?v=[0-9a-f]{10}'\)/);
+                    expect(sw).not.toContain("importScripts('/host/runtime-core.js')");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('names the package when its browser build is missing, and keeps the previous site', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var browserBuild, exists;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    write(path_1.default.join(out(), 'stale.txt'), 'previous');
+                    browserBuild = path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
+                    exists = jest.spyOn(fs_1.default, 'existsSync');
+                    exists.mockImplementation(function (checked) { return String(checked) !== browserBuild; });
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 4, 5]);
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/@sasjs\/api browser build is missing/)];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    exists.mockRestore();
+                    return [7 /*endfinally*/];
+                case 5:
+                    // and the refusal lands before anything is written, so the site that was
+                    // there is still there
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'stale.txt'))).toBe(true);
+                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'stale.txt'), 'utf8')).toBe('previous');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The worker's scripts share one global scope, so a name declared at the top
+     * level of two of them is a SyntaxError in the browser - and invisible to this
+     * suite, where each file is a module of its own. `importScripts` is the
+     * browser's rule: evaluate the files the build wrote, in one context, once.
+     */
+    it('evaluates the shipped scripts in one global scope, the way a worker does', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var vm, sandbox, context, imported;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    vm = require('vm');
+                    sandbox = {
+                        console: console,
+                        Request: Request,
+                        Response: Response,
+                        Headers: Headers,
+                        URL: URL,
+                        FormData: FormData,
+                        Blob: Blob,
+                        TextEncoder: TextEncoder,
+                        TextDecoder: TextDecoder,
+                        Uint8Array: Uint8Array,
+                        ArrayBuffer: ArrayBuffer,
+                        atob: atob,
+                        btoa: btoa,
+                        setTimeout: setTimeout,
+                        clearTimeout: clearTimeout,
+                        location: { origin: 'https://mock.example.com' },
+                        clients: { claim: function () { }, matchAll: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, []];
+                            }); }); } },
+                        skipWaiting: function () { },
+                        addEventListener: function () { },
+                        fetch: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, new Response('{}', { headers: { 'content-type': 'application/json' } })];
+                        }); }); }
+                    };
+                    sandbox.self = sandbox;
+                    context = vm.createContext(sandbox);
+                    imported = new Set();
+                    sandbox.importScripts = function (url) {
+                        if (imported.has(url))
+                            return;
+                        imported.add(url);
+                        var file = path_1.default.join(out(), url.replace(/^\//, '').split('?')[0]);
+                        vm.runInContext(fs_1.default.readFileSync(file, 'utf8'), context, {
+                            filename: file
+                        });
+                    };
+                    expect(function () {
+                        return vm.runInContext(fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8'), context, {
+                            filename: 'sw.js'
+                        });
+                    }).not.toThrow();
+                    // both scripts are loaded, and the drive the API is handed came from the
+                    // runtime rather than a second implementation
+                    expect(Object.keys(sandbox.SASjsMockRuntime)).toContain('driveStore');
+                    expect(typeof sandbox.SASjsApi.createDriveService).toBe('function');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('ships the webout() block with sentinels the runtime fills in', function () { return __awaiter(void 0, void 0, void 0, function () {
         var prelude, _a, _b, sentinel;
         var e_2, _c;

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,4 +1044,375 @@ describe('browser runtime', function () {
         var runtime = loadRuntime();
         expect(function () { return runtime.run({ program: 'services/public/missing' }); }).toThrow(/Program not found in drive/);
     });
+    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;
+            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];
+                }
+            });
+        }); };
+        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 = _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('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 = _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
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        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();
+                        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('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 = _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('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 = _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('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 = _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('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 = _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('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 = _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']
+                        });
+                        _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 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();
+                        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 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 = _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('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 = _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']
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });