@xenon-device-management/xenon 2.1.0 → 2.3.0

package/lib/test/unit/hub-node-control-forward.spec.js

@@ -72,6 +72,11 @@ const config_1 = require("../../src/config");
 const container_registration_1 = require("../helpers/container-registration");
 const scratch_database_1 = require("../helpers/scratch-database");
 const loopbackServer_1 = require("../helpers/loopbackServer");
+const InspectorService_1 = require("../../src/services/InspectorService");
+const OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
+const http_1 = __importDefault(require("http"));
+const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
+const AndroidH264StreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidH264StreamService"));
 /**
  * A hub forwards five of its /control actions on a node's phone (tap, swipe,
  * text, keyevent, touchAndHold) to the phone's node. It sent them with no
@@ -86,12 +91,54 @@ const loopbackServer_1 = require("../helpers/loopbackServer");
  * knows (LiveSessionOwners).
  */
 // Named like the real manager: /control picks one by constructor.name.
+// Hub and node share this process, so each call records the server it ran
+// on: an action the hub ran on its own would show up as `hub-1:...`.
 class AndroidDeviceManager {
     constructor() {
         this.taps = [];
+        this.calls = [];
+        this.failLogs = false;
         this.tap = (udid) => __awaiter(this, void 0, void 0, function* () {
             this.taps.push(udid);
         });
+        this.getScreenshot = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('getScreenshot');
+            return 'A'.repeat(200);
+        });
+        this.getClipboard = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('getClipboard');
+            return 'copied';
+        });
+        this.setClipboard = () => __awaiter(this, void 0, void 0, function* () { return this.at('setClipboard'); });
+        this.lock = () => __awaiter(this, void 0, void 0, function* () { return this.at('lock'); });
+        this.unlock = () => __awaiter(this, void 0, void 0, function* () { return this.at('unlock'); });
+        this.getDisplayState = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('getDisplayState');
+            return 'on';
+        });
+        this.uninstallApp = () => __awaiter(this, void 0, void 0, function* () { return this.at('uninstallApp'); });
+        this.listApps = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('listApps');
+            return [{ bundleId: 'com.example' }];
+        });
+        this.getLogs = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('getLogs');
+            if (this.failLogs)
+                throw new Error('logcat failed on the node');
+            return 'a log line';
+        });
+        this.executeShell = () => __awaiter(this, void 0, void 0, function* () {
+            this.at('executeShell');
+            return 'uid=2000(shell)';
+        });
+        this.installedBytes = [];
+        this.installApp = (_udid, appPath) => __awaiter(this, void 0, void 0, function* () {
+            this.at('installApp');
+            this.installedBytes.push(fs_1.default.readFileSync(appPath, 'utf8'));
+        });
+    }
+    at(name) {
+        this.calls.push(`${typedi_1.Container.get(PluginContext_1.PluginContext).nodeId}:${name}`);
     }
 }
 describe('the hub’s device control on a node’s phone', () => {
@@ -108,17 +155,25 @@ describe('the hub’s device control on a node’s phone', () => {
     let nodeOrigin;
     let nodePort;
     let nodeArgs;
+    let nodeRequests;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         dirs = [fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-control-keys-'))];
         hubKeys = new JwtKeyService_1.JwtKeyService();
         yield hubKeys.init(dirs[0]);
-        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, SessionOwnerResolver_1.SessionOwnerResolver, LiveSessionOwners_1.LiveSessionOwners);
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, SessionOwnerResolver_1.SessionOwnerResolver, LiveSessionOwners_1.LiveSessionOwners, InspectorService_1.InspectorService, OmniVisionService_1.OmniVisionService);
         typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
         typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
         typedi_1.Container.set(SessionOwnerResolver_1.SessionOwnerResolver, new SessionOwnerResolver_1.SessionOwnerResolver());
         typedi_1.Container.set(LiveSessionOwners_1.LiveSessionOwners, new LiveSessionOwners_1.LiveSessionOwners());
         manager = new AndroidDeviceManager();
         typedi_1.Container.set(device_managers_1.XenonManager, { deviceInstances: () => __awaiter(void 0, void 0, void 0, function* () { return [manager]; }) });
+        typedi_1.Container.set(InspectorService_1.InspectorService, {
+            getSnapshot: () => __awaiter(void 0, void 0, void 0, function* () {
+                manager.calls.push(`${typedi_1.Container.get(PluginContext_1.PluginContext).nodeId}:getSnapshot`);
+                return { source: '<hierarchy/>' };
+            }),
+        });
+        nodeRequests = [];
         context = typedi_1.Container.get(PluginContext_1.PluginContext);
         saved = {
             context: Object.assign({}, context),
@@ -159,6 +214,15 @@ describe('the hub’s device control on a node’s phone', () => {
         hubApp.use('/xenon/api', hubApi);
         // The node: its CSRF check, its login and its /control, as ServerManager mounts them.
         const node = (0, express_1.default)();
+        node.use((req, _res, next) => {
+            nodeRequests.push({
+                method: req.method,
+                path: req.path,
+                url: req.originalUrl,
+                headers: Object.assign({}, req.headers),
+            });
+            next();
+        });
         node.use((_req, _res, next) => {
             context.setContext(nodeArgs, nodePort, 'node-1', '');
             next();
@@ -236,6 +300,315 @@ describe('the hub’s device control on a node’s phone', () => {
         yield (0, auth_1.issueToken)({ userId: 'alice', role: 'ADMIN', scopes: 'admin' }, { audience: hubSessionToken_1.HUB_CONTROL_AUDIENCE }).catch((error) => (refused = error));
         (0, chai_1.expect)(refused === null || refused === void 0 ? void 0 : refused.message).to.include('unsupported audience');
     }));
+    describe('which actions reach the node', () => {
+        const asAlice = (method, action, body) => {
+            const req = (0, loopbackRequest_1.default)(hubApp)[method](`/xenon/api/control/phone-1/${action}`);
+            req.set('x-test-user', 'alice');
+            return method === 'post' ? req.send(body !== null && body !== void 0 ? body : {}) : req;
+        };
+        const nodeSaw = (action) => nodeRequests.filter((r) => r.path === `/xenon/api/control/phone-1/${action}`);
+        // Each runs on the node and answers with the node's own reply.
+        const FORWARDED = [
+            {
+                method: 'get',
+                action: 'screenshot',
+                call: 'getScreenshot',
+                reply: { screenshot: 'A'.repeat(200) },
+            },
+            { method: 'get', action: 'clipboard', call: 'getClipboard', reply: { content: 'copied' } },
+            {
+                method: 'post',
+                action: 'clipboard',
+                send: { content: 'x' },
+                call: 'setClipboard',
+                reply: { success: true },
+            },
+            { method: 'post', action: 'lock', call: 'lock', reply: { success: true } },
+            { method: 'post', action: 'unlock', call: 'unlock', reply: { success: true } },
+            { method: 'get', action: 'display', call: 'getDisplayState', reply: { state: 'on' } },
+            {
+                method: 'post',
+                action: 'uninstall',
+                send: { bundleId: 'com.example' },
+                call: 'uninstallApp',
+                reply: { success: true },
+            },
+            { method: 'get', action: 'apps', call: 'listApps', reply: [{ bundleId: 'com.example' }] },
+            { method: 'get', action: 'logs', call: 'getLogs', reply: { logs: 'a log line' } },
+            {
+                method: 'post',
+                action: 'shell',
+                send: { command: 'id' },
+                call: 'executeShell',
+                reply: { output: 'uid=2000(shell)' },
+            },
+            {
+                method: 'get',
+                action: 'inspector/snapshot',
+                call: 'getSnapshot',
+                reply: { source: '<hierarchy/>' },
+            },
+        ];
+        for (const { method, action, send, call, reply } of FORWARDED) {
+            it(`${method.toUpperCase()} ${action} runs on the node and answers with the node's reply`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield asAlice(method, action, send);
+                (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+                (0, chai_1.expect)(res.body).to.deep.equal(reply);
+                (0, chai_1.expect)(manager.calls).to.deep.equal([`node-1:${call}`]);
+                (0, chai_1.expect)(nodeSaw(action)).to.have.length(1);
+            }));
+        }
+        it('relays the node’s own error answer unchanged, sent once', () => __awaiter(void 0, void 0, void 0, function* () {
+            manager.failLogs = true;
+            const res = yield asAlice('get', 'logs');
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body).to.deep.equal({ error: 'logcat failed on the node' });
+            (0, chai_1.expect)(nodeSaw('logs')).to.have.length(1);
+        }));
+        it('sends the node none of the caller’s credentials, only its own token', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, loopbackRequest_1.default)(hubApp)
+                .post('/xenon/api/control/phone-1/lock')
+                .set('x-test-user', 'alice')
+                .set('cookie', 'xenon_dashboard_session=secret-session')
+                .set('authorization', 'Bearer secret-jwt')
+                .set('x-xenon-access-key', 'secret-key')
+                .set('x-xenon-token', 'secret-token')
+                .send({})
+                .expect(200);
+            const [sent] = nodeSaw('lock');
+            for (const name of [
+                'cookie',
+                'authorization',
+                'x-xenon-access-key',
+                'x-xenon-token',
+                'x-test-user',
+            ]) {
+                (0, chai_1.expect)(sent.headers, name).to.not.have.property(name);
+            }
+            (0, chai_1.expect)(sent.headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.be.a('string');
+        }));
+        it('answers appium-session itself: the session is routed through the hub', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield asAlice('get', 'appium-session');
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body).to.include({ status: 'success', sessionId: 's-1' });
+            (0, chai_1.expect)(nodeSaw('appium-session')).to.have.length(0);
+        }));
+        // Not passed on: a path is a path on one machine. Anything added later is
+        // refused the same way until it is on a list.
+        const REFUSED = [
+            ['post', 'install', { appPath: '/tmp/app.apk' }],
+            ['post', 'an-action-added-later'],
+        ];
+        describe('the live preview', () => {
+            // phone-2 is free: a preview holds it on the node.
+            const preview = (method, action) => {
+                const req = (0, loopbackRequest_1.default)(hubApp)[method](`/xenon/api/control/phone-2/${action}`);
+                req.set('x-test-user', 'alice');
+                return method === 'post' ? req.send({}) : req;
+            };
+            const nodeSawPreview = (action) => nodeRequests.filter((r) => r.path === `/xenon/api/control/phone-2/${action}`);
+            let started;
+            let stopped;
+            let mjpegPort;
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                started = [];
+                stopped = [];
+                // The camera the node's MJPEG fan-out reads: a frame every 50 ms.
+                const camera = (0, express_1.default)();
+                camera.get('/', (_req, res) => {
+                    res.writeHead(200, { 'content-type': 'multipart/x-mixed-replace; boundary=f' });
+                    const timer = setInterval(() => res.write('--f\r\nFAKE-JPEG-FRAME\r\n'), 50);
+                    res.on('close', () => clearInterval(timer));
+                });
+                mjpegPort = (yield loopback.serve(camera)).address().port;
+                const mjpeg = typedi_1.Container.get(AndroidStreamService_1.default);
+                const h264 = typedi_1.Container.get(AndroidH264StreamService_1.default);
+                const where = () => typedi_1.Container.get(PluginContext_1.PluginContext).nodeId;
+                sinon_1.default.stub(mjpeg, 'startStream').callsFake((udid) => __awaiter(void 0, void 0, void 0, function* () {
+                    started.push(`${where()}:${udid}`);
+                    return { mjpegPort };
+                }));
+                sinon_1.default.stub(mjpeg, 'stopStream').callsFake((udid) => __awaiter(void 0, void 0, void 0, function* () {
+                    stopped.push(`${where()}:${udid}`);
+                }));
+                sinon_1.default.stub(mjpeg, 'getStreamStatus').returns(undefined);
+                sinon_1.default.stub(mjpeg, 'updateViewerCount');
+                sinon_1.default.stub(h264, 'stop').resolves();
+                sinon_1.default.stub(h264, 'getMultiplexer').returns(undefined);
+            }));
+            it('starts on the node, which holds the phone, and the hub marks it busy for the node at once', () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield preview('post', 'stream/start');
+                (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+                (0, chai_1.expect)(res.body).to.include({ success: true, type: 'mjpeg' });
+                (0, chai_1.expect)(started).to.deep.equal(['node-1:phone-2']);
+                const row = yield scratch.db.device.findFirst({ where: { udid: 'phone-2' } });
+                (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.session_id).to.equal('manual_alice_phone-2');
+                (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.nodeBusy).to.equal(true);
+                (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.busy).to.equal(true);
+            }));
+            it('status, leave and stop are the node’s answers', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield preview('post', 'stream/start').expect(200);
+                const status = yield preview('get', 'stream/status');
+                (0, chai_1.expect)(status.status).to.equal(200);
+                (0, chai_1.expect)(status.body).to.include({ udid: 'phone-2', status: 'stopped' });
+                yield preview('post', 'stream/leave').expect(202);
+                yield preview('post', 'stream/stop').expect(200);
+                (0, chai_1.expect)(stopped).to.deep.equal(['node-1:phone-2']);
+                for (const action of ['stream/status', 'stream/leave', 'stream/stop']) {
+                    (0, chai_1.expect)(nodeSawPreview(action), action).to.have.length(1);
+                }
+            }));
+            it('mints the viewer’s ticket here, where the team check ran', () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield preview('post', 'stream/ticket');
+                (0, chai_1.expect)(res.status).to.equal(200);
+                (0, chai_1.expect)(res.body.ticket).to.be.a('string');
+                (0, chai_1.expect)(nodeSawPreview('stream/ticket')).to.have.length(0);
+            }));
+            it('relays the node’s MJPEG stream to the viewer, without the viewer’s ticket', () => __awaiter(void 0, void 0, void 0, function* () {
+                const hubPort = (yield loopback.serve(hubApp)).address().port;
+                const got = yield new Promise((resolve, reject) => {
+                    const req = http_1.default.get({
+                        host: '127.0.0.1',
+                        port: hubPort,
+                        path: '/xenon/api/control/phone-2/stream?ticket=spent&t=1',
+                        headers: { 'x-test-user': 'alice' },
+                    }, (res) => {
+                        let body = '';
+                        res.on('data', (chunk) => {
+                            body += chunk.toString();
+                            if (body.split('FAKE-JPEG-FRAME').length > 3) {
+                                req.destroy();
+                                resolve({ type: String(res.headers['content-type']), body });
+                            }
+                        });
+                    });
+                    req.on('error', (e) => (e.code === 'ECONNRESET' ? undefined : reject(e)));
+                });
+                (0, chai_1.expect)(got.type).to.include('multipart/x-mixed-replace');
+                (0, chai_1.expect)(started).to.deep.equal(['node-1:phone-2']);
+                (0, chai_1.expect)(nodeSawPreview('stream').map((r) => r.url)).to.deep.equal([
+                    '/xenon/api/control/phone-2/stream?t=1',
+                ]);
+                yield preview('post', 'stream/stop').expect(200);
+            }));
+        });
+        describe('apps and Omni-Vision', () => {
+            it('installs an upload on the node, streamed through the hub', () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield (0, loopbackRequest_1.default)(hubApp)
+                    .post('/xenon/api/control/phone-1/upload-install')
+                    .set('x-test-user', 'alice')
+                    .attach('app', Buffer.from('uploaded-apk'), 'build-42.apk');
+                (0, chai_1.expect)(res.status, res.text).to.equal(200);
+                (0, chai_1.expect)(res.body.success).to.equal(true);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:installApp']);
+                (0, chai_1.expect)(manager.installedBytes).to.deep.equal(['uploaded-apk']);
+            }));
+            it('installs an app from the hub’s library on the node, sending the file there', () => __awaiter(void 0, void 0, void 0, function* () {
+                const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-library-'));
+                dirs.push(dir);
+                const file = path_1.default.join(dir, 'stored-app');
+                fs_1.default.writeFileSync(file, 'library-apk');
+                const app = yield scratch.db.app.create({
+                    data: {
+                        name: 'Library App',
+                        filename: 'library-app.apk',
+                        filepath: file,
+                        mimetype: 'application/vnd.android.package-archive',
+                        size: 11,
+                    },
+                });
+                const res = yield asAlice('post', 'install-repository-app', { appId: app.id });
+                (0, chai_1.expect)(res.status, res.text).to.equal(200);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:installApp']);
+                (0, chai_1.expect)(manager.installedBytes).to.deep.equal(['library-apk']);
+                const upload = nodeSaw('upload-install');
+                (0, chai_1.expect)(upload).to.have.length(1);
+                (0, chai_1.expect)(String(upload[0].headers['content-type'])).to.match(/^multipart\/form-data/);
+            }));
+            it('runs Omni-Vision here, on the node’s screenshot', () => __awaiter(void 0, void 0, void 0, function* () {
+                const seen = [];
+                typedi_1.Container.set(OmniVisionService_1.OmniVisionService, {
+                    analyzeScreen: (driver) => __awaiter(void 0, void 0, void 0, function* () {
+                        seen.push(`scan:${(yield driver.getScreenshot()).length}`);
+                        return { elements: [] };
+                    }),
+                    findByText: (driver, text) => __awaiter(void 0, void 0, void 0, function* () {
+                        seen.push(`text:${text}:${(yield driver.getScreenshot()).length}`);
+                        return [{ text }];
+                    }),
+                });
+                const scan = yield asAlice('get', 'omni-scan');
+                (0, chai_1.expect)(scan.status, scan.text).to.equal(200);
+                const locator = yield asAlice('post', 'test-locator', {
+                    strategy: '-custom:ai-text',
+                    selector: 'Sign in',
+                });
+                (0, chai_1.expect)(locator.status, locator.text).to.equal(200);
+                (0, chai_1.expect)(locator.body.value).to.deep.equal([{ text: 'Sign in' }]);
+                (0, chai_1.expect)(seen).to.deep.equal(['scan:200', 'text:Sign in:200']);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:getScreenshot', 'node-1:getScreenshot']);
+            }));
+        });
+        it('refuses the rest, naming the node, and runs none of it on the hub', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [method, action, body] of REFUSED) {
+                const res = yield asAlice(method, action, body);
+                (0, chai_1.expect)(res.status, `${method} ${action}`).to.equal(501);
+                (0, chai_1.expect)(res.body.error, `${method} ${action}`).to.equal('not_available_through_hub');
+                (0, chai_1.expect)(res.body.message, `${method} ${action}`).to.include(nodeOrigin);
+            }
+            (0, chai_1.expect)(nodeRequests).to.have.length(0);
+            (0, chai_1.expect)(manager.calls).to.deep.equal([]);
+        }));
+        it('sends nothing to a cloud provider’s phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            const provider = (0, express_1.default)();
+            let reached = 0;
+            provider.use((_req, res) => {
+                reached++;
+                res.status(200).json({});
+            });
+            const providerOrigin = `http://127.0.0.1:${(yield loopback.serve(provider)).address().port}`;
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'cloud-1',
+                    host: providerOrigin,
+                    platform: 'android',
+                    name: 'cloud-1',
+                    cloud: JSON.stringify({ cloudName: 'example-cloud' }),
+                },
+            });
+            for (const [method, action, body] of [
+                ['post', 'tap', { x: 1, y: 2 }],
+                ['get', 'screenshot'],
+                ['post', 'text', { text: 'a secret' }],
+            ]) {
+                const req = (0, loopbackRequest_1.default)(hubApp)[method](`/xenon/api/control/cloud-1/${action}`)
+                    .set('x-test-user', 'alice');
+                const res = yield (method === 'post' ? req.send(body !== null && body !== void 0 ? body : {}) : req);
+                (0, chai_1.expect)(res.status, action).to.equal(501);
+                (0, chai_1.expect)(res.body.error, action).to.equal('not_available_for_cloud_phone');
+            }
+            (0, chai_1.expect)(reached).to.equal(0);
+            (0, chai_1.expect)(manager.taps).to.deep.equal([]);
+        }));
+        it('a node that can’t be reached: 502, naming the node', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'gone-1',
+                    host: 'http://127.0.0.1:1',
+                    nodeId: 'node-2',
+                    platform: 'android',
+                    name: 'gone-1',
+                },
+            });
+            const res = yield (0, loopbackRequest_1.default)(hubApp)
+                .get('/xenon/api/control/gone-1/screenshot')
+                .set('x-test-user', 'alice');
+            (0, chai_1.expect)(res.status).to.equal(502);
+            (0, chai_1.expect)(res.body.error).to.equal('node_unreachable');
+            (0, chai_1.expect)(res.body.message).to.include('http://127.0.0.1:1');
+            (0, chai_1.expect)(manager.calls).to.deep.equal([]);
+        }));
+    });
     describe('on the node', () => {
         it('the node’s own ownership guard judges the user the hub named', () => __awaiter(void 0, void 0, void 0, function* () {
             const asBob = yield controlToken({ userId: 'bob' });

package/lib/test/unit/hub-node-race.spec.js

@@ -376,6 +376,57 @@ describe('The hub/node busy race', function () {
             (0, chai_1.expect)(alive.calledWith(HUB)).to.equal(false);
         }));
     });
+    describe('a preview the node has just started', () => {
+        it('is busy on the hub at once, and the node’s next report settles it', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            // The node answered a forwarded stream/start: it holds the phone now,
+            // though its last report said free.
+            yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('s9', NODE, 'manual_u1_s9');
+            (0, chai_1.expect)(yield row('s9')).to.include({
+                busy: true,
+                nodeBusy: true,
+                nodeHold: 'manual_u1_s9',
+                session_id: null,
+            });
+            let session;
+            try {
+                session = yield (0, device_utils_1.allocateDeviceForSession)(caps('s9'), 200, 50, pluginArgs);
+            }
+            catch (err) {
+                session = err;
+            }
+            (0, chai_1.expect)(session, 'not handed to a session').to.be.an('error');
+            // The preview ended, and the node says so.
+            yield report(nodePhone('s9', { busy: false }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ busy: false, nodeBusy: false, nodeHold: null });
+        }));
+        it('touches no other server’s row for the same udid', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('s9', 'http://10.9.9.9:4725');
+            (0, chai_1.expect)(yield row('s9')).to.include({ busy: false, nodeBusy: false });
+        }));
+    });
+    // The node's report is its own row, session_id included. A preview's hold
+    // there (manual_<user>_<udid>) is who holds the phone, which the hub shows
+    // (nodeHold); session_id itself stays the hub's.
+    describe('who holds a node’s phone', () => {
+        it('is the node’s preview hold, from its report, until the node lets the phone go', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            yield report(nodePhone('s9', { busy: true, session_id: 'manual_u1_s9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: 'manual_u1_s9', session_id: null });
+            yield report(nodePhone('s9', { busy: false, session_id: null }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: null, busy: false });
+        }));
+        it('is not a session the node runs', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            yield report(nodePhone('s9', { busy: true, session_id: 'appium-9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: null, nodeBusy: true, session_id: null });
+        }));
+        it('is taken from the report of a phone the hub didn’t know yet', () => __awaiter(this, void 0, void 0, function* () {
+            yield report(nodePhone('s9', { busy: true, session_id: 'manual_u1_s9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: 'manual_u1_s9', busy: true });
+        }));
+    });
     describe('a standalone server', () => {
         it('allocates, runs and frees its own phone as before', () => __awaiter(this, void 0, void 0, function* () {
             yield scratch.db.device.create({

package/lib/test/unit/install-repository-app-team.spec.js

@@ -25,6 +25,7 @@ const device_managers_1 = require("../../src/device-managers");
 const app_service_1 = require("../../src/dashboard/services/app-service");
 const authMiddleware_1 = require("../../src/middleware/authMiddleware");
 const container_registration_1 = require("../helpers/container-registration");
+const own_node_id_1 = require("../helpers/own-node-id");
 /**
  * Installing an uploaded app onto a phone hands over its binary as surely as
  * downloading it does, so POST /control/:udid/install-repository-app follows
@@ -63,6 +64,8 @@ function buildApp(teamIds) {
     return app;
 }
 describe('POST /control/:udid/install-repository-app follows the app team rule', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let manager;
     let restore;
     beforeEach(() => {
@@ -74,6 +77,7 @@ describe('POST /control/:udid/install-repository-app follows the app team rule',
                 return ({
                     udid: UDID,
                     host: '127.0.0.1',
+                    nodeId: own_node_id_1.OWN_NODE_ID,
                     platform: 'android',
                     busy: false,
                     session_id: null,

package/lib/test/unit/lease/lease-sweeper-expiry.spec.js

@@ -90,3 +90,18 @@ describe('LeaseOrphanSweeper: a lease ends at expiresAt (scratch DB)', () => {
         (0, chai_1.expect)(releaseLeaseLock.called).to.equal(false);
     }));
 });
+describe('leaseReapReason', () => {
+    // Past expiresAt, heartbeat and extend refuse the lease (410), so by the next
+    // sweep its heartbeats are missed too. The end time is the cause; the lab's
+    // log said "missed heartbeats" for every such lease.
+    it('names the end time for a lease past expiresAt, even when its heartbeats are missed too', () => {
+        const now = Date.now();
+        const reason = (0, LeaseOrphanSweeper_1.leaseReapReason)({ heartbeatSeconds: 10, lastHeartbeatAt: now - 60000, expiresAt: now - 1000 }, now);
+        (0, chai_1.expect)(reason).to.match(/^expired at /);
+    });
+    it('names missed heartbeats for a lease before its end time', () => {
+        const now = Date.now();
+        const reason = (0, LeaseOrphanSweeper_1.leaseReapReason)({ heartbeatSeconds: 10, lastHeartbeatAt: now - 60000, expiresAt: now + 60000 }, now);
+        (0, chai_1.expect)(reason).to.equal('missed heartbeats');
+    });
+});

package/lib/test/unit/logcat-ws.spec.js

@@ -419,6 +419,14 @@ describe('makeTicketActorAuthorizer', () => {
         });
         return { fn, calls };
     };
+    it('leaves a node’s phone busy only by its node’s report to the node', () => __awaiter(void 0, void 0, void 0, function* () {
+        // The hub relays this socket from the node, whose own check knows the
+        // holder (deviceAccessGuard's spec says why).
+        const { fn } = authorizer({ busy: true, nodeBusy: true, session_id: null }, ALICE);
+        (0, chai_1.expect)(yield fn(UDID, { actorId: BOB })).to.equal(true);
+        const routed = authorizer({ busy: true, nodeBusy: true, session_id: 'appium-1', claimSessionId: 'appium-1' }, ALICE);
+        (0, chai_1.expect)(yield routed.fn(UDID, { actorId: BOB })).to.equal(false);
+    }));
     it('denies a device the store cannot resolve', () => __awaiter(void 0, void 0, void 0, function* () {
         // Fail-closed, and deliberately unlike deviceAccessGuard's fall-through:
         // there is no 404 behind this call, and getAdbForDevice happily runs

package/lib/test/unit/mark-node-busy-loki.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const db_1 = require("../../src/data-service/db");
+const device_store_1 = require("../../src/data-service/device-store");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * markNodeBusy on the in-memory store: the hub's note that a node has just
+ * taken its phone for a preview. The Prisma store is covered with the hub's
+ * allocation in hub-node-race.spec.ts.
+ */
+describe('markNodeBusy (in-memory store)', () => {
+    (0, loki_stores_1.useLokiStores)();
+    const NODE = 'http://10.0.0.9:4725';
+    const phone = (host) => ({
+        udid: 'mark-node-busy-s9',
+        host,
+        platform: 'android',
+        busy: false,
+        nodeBusy: false,
+        offline: false,
+        userBlocked: false,
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        (yield db_1.XenonDatabase.DeviceModel).findAndRemove({ udid: 'mark-node-busy-s9' });
+    }));
+    it('sets nodeBusy and busy on that phone of that node only', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = yield db_1.XenonDatabase.DeviceModel;
+        model.insert(phone(NODE));
+        model.insert(phone('http://10.0.0.8:4725'));
+        yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('mark-node-busy-s9', NODE, 'manual_u1_s9');
+        const rows = model.find({ udid: 'mark-node-busy-s9' });
+        const byHost = Object.fromEntries(rows.map((r) => { var _a; return [r.host, [r.busy, r.nodeBusy, (_a = r.nodeHold) !== null && _a !== void 0 ? _a : null]]; }));
+        (0, chai_1.expect)(byHost).to.deep.equal({
+            [NODE]: [true, true, 'manual_u1_s9'],
+            'http://10.0.0.8:4725': [false, false, null],
+        });
+    }));
+    it('takes the holder from a node’s report: a preview hold, not a session', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = yield db_1.XenonDatabase.DeviceModel;
+        model.insert(phone(NODE));
+        const store = device_store_1.DeviceStoreFactory.getStore();
+        const reported = (session_id, busy) => store.addDevices([Object.assign(Object.assign({}, phone(NODE)), { busy, session_id })], { nodeReport: true });
+        const hold = () => model.findOne({ udid: 'mark-node-busy-s9', host: NODE }).nodeHold;
+        yield reported('manual_u1_mark-node-busy-s9', true);
+        (0, chai_1.expect)(hold()).to.equal('manual_u1_mark-node-busy-s9');
+        yield reported('appium-9', true);
+        (0, chai_1.expect)(hold()).to.equal(null);
+        yield reported(null, false);
+        (0, chai_1.expect)(hold()).to.equal(null);
+    }));
+    it('does nothing for a phone it doesn’t have', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('mark-node-busy-s9', NODE);
+        (0, chai_1.expect)((yield db_1.XenonDatabase.DeviceModel).find({ udid: 'mark-node-busy-s9' })).to.deep.equal([]);
+    }));
+});