@xenon-device-management/xenon 2.1.0 → 2.2.0

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

@@ -72,6 +72,10 @@ 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 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 +90,50 @@ 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.installApp = () => __awaiter(this, void 0, void 0, function* () { return this.at('installApp'); });
+    }
+    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 +150,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);
         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 +209,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 +295,264 @@ 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 yet: uploads need a relayed body, an app from the hub's
+        // library isn't on the node, and a path is a path on one machine.
+        // Omni's AI settings are the hub's. Anything added later is refused the
+        // same way until it is on the list.
+        const REFUSED = [
+            ['post', 'install', { appPath: '/tmp/app.apk' }],
+            ['post', 'install-repository-app', { appId: 'app-1' }],
+            ['post', 'upload-install'],
+            ['get', 'omni-scan'],
+            ['post', 'test-locator', { strategy: '-custom:ai-text', selector: 'OK' }],
+            ['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);
+            }));
+        });
+        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,31 @@ 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);
+            (0, chai_1.expect)(yield row('s9')).to.include({ busy: true, nodeBusy: true, 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 });
+        }));
+        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 });
+        }));
+    });
     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,53 @@
+"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);
+        const rows = model.find({ udid: 'mark-node-busy-s9' });
+        const byHost = Object.fromEntries(rows.map((r) => [r.host, [r.busy, r.nodeBusy]]));
+        (0, chai_1.expect)(byHost).to.deep.equal({
+            [NODE]: [true, true],
+            'http://10.0.0.8:4725': [false, false],
+        });
+    }));
+    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([]);
+    }));
+});

package/lib/test/unit/node-phone-control.spec.js

@@ -0,0 +1,131 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodePhoneControl_1 = require("../../src/app/routers/nodePhoneControl");
+/**
+ * The gate in front of /control's handlers, on its own: what it does when the
+ * phone's node is slow or its row can't be read. The actions themselves are
+ * in hub-node-control-forward.spec.ts.
+ */
+describe('nodePhoneControl', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let context;
+    let saved;
+    let findDevice;
+    let held;
+    beforeEach(() => {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        context.setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), 1, 'hub-1', '');
+        held = [];
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        yield loopback.closeAll();
+    }));
+    const app = (timeoutMs = 60000) => {
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use('/xenon/api/control', (0, nodePhoneControl_1.nodePhoneControl)({ findDevice: (udid) => findDevice(udid), timeoutMs }), (_req, res) => res.status(299).json({ handledHere: true }));
+        return a;
+    };
+    it('a node that doesn’t answer in time: 504, naming it', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        node.use((req) => held.push(req)); // never answers
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app(150)).get('/xenon/api/control/p/screenshot');
+        (0, chai_1.expect)(res.status).to.equal(504);
+        (0, chai_1.expect)(res.body.error).to.equal('node_timeout');
+        (0, chai_1.expect)(res.body.message).to.include(origin);
+        (0, chai_1.expect)(held).to.have.length(1);
+    }));
+    it('a device row that can’t be read: 503, and no handler runs it here', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new Error('database is locked');
+        });
+        const res = yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({ x: 1, y: 2 });
+        (0, chai_1.expect)(res.status).to.equal(503);
+        (0, chai_1.expect)(res.body.error).to.equal('device_ownership_unavailable');
+    }));
+    it('this server’s own phone, and an unknown one, go to the handlers', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: 'http://10.0.0.9:4725', nodeId: 'hub-1' }); });
+        yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({}).expect(299);
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return null; });
+        yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({}).expect(299);
+    }));
+    it('a stream outlives the timeout once the node has answered', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        node.get('/xenon/api/control/p/stream', (_req, res) => {
+            // Text, so the test's client doesn't try to parse it; an MJPEG
+            // answer is relayed the same way.
+            res.writeHead(200, { 'content-type': 'text/plain' });
+            res.write('frame one;');
+            setTimeout(() => res.end('frame two;'), 400);
+        });
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app(150)).get('/xenon/api/control/p/stream');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.text).to.equal('frame one;frame two;');
+    }));
+    it('sends the node none of the caller’s ticket, and the rest of the query', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        const seen = [];
+        node.use((req, res) => {
+            seen.push(req.originalUrl);
+            res.json({ status: 'stopped' });
+        });
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/control/p/stream/status?ticket=spent&t=1&r=2').expect(200);
+        (0, chai_1.expect)(seen).to.deep.equal(['/xenon/api/control/p/stream/status?t=1&r=2']);
+    }));
+    it('marks the phone busy for its node once the node has started a preview, and only then', () => __awaiter(void 0, void 0, void 0, function* () {
+        let answer = 200;
+        const node = (0, express_1.default)();
+        node.use((_req, res) => res.status(answer).json({}));
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const marked = [];
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use('/xenon/api/control', (0, nodePhoneControl_1.nodePhoneControl)({
+            findDevice: (udid) => findDevice(udid),
+            markNodeBusy: (udid, host) => __awaiter(void 0, void 0, void 0, function* () {
+                marked.push(`${udid}@${host}`);
+            }),
+        }));
+        yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/start').send({}).expect(200);
+        answer = 409;
+        yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/start').send({}).expect(409);
+        answer = 200;
+        yield (0, loopbackRequest_1.default)(a).get('/xenon/api/control/p/stream/status').expect(200);
+        (0, chai_1.expect)(marked).to.deep.equal([`p@${origin}`]);
+    }));
+    it('refuses a host it must never call', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: 'http://169.254.169.254', nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/control/p/screenshot');
+        (0, chai_1.expect)(res.status).to.equal(400);
+        (0, chai_1.expect)(res.body).to.deep.equal({ error: 'Unsafe device host' });
+    }));
+});