@xenon-device-management/xenon 2.1.0 → 2.2.0

package/lib/test/unit/node-socket-relay.spec.js

@@ -0,0 +1,357 @@
+"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 http_1 = __importDefault(require("http"));
+const events_1 = require("events");
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const ws_1 = require("ws");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodeSocketRelay_1 = require("../../src/app/ws/nodeSocketRelay");
+const h264StreamWs_1 = require("../../src/app/ws/h264StreamWs");
+const logcatWs_1 = require("../../src/app/ws/logcatWs");
+/**
+ * The H.264 and logcat sockets for a node's phone, on a hub: the hub checks
+ * its own ticket, opens the same socket on the node with a ticket of the
+ * node's own, and relays it. Frames and close codes pass unchanged, and a
+ * viewer that falls behind holds the node back rather than growing the
+ * hub's memory, so the node's own slow-viewer rule applies (dropped H.264
+ * frames, a visible "lines dropped" record in logcat).
+ */
+const opened = (ws) => new Promise((resolve, reject) => {
+    ws.once('open', () => resolve());
+    ws.once('error', reject);
+});
+const closed = (ws) => new Promise((resolve) => ws.once('close', (code, reason) => resolve({ code, reason: reason.toString() })));
+const nextMessage = (ws) => new Promise((resolve) => ws.once('message', (data, isBinary) => resolve({ data: data, isBinary })));
+/** An upstream socket as openNodeSocket hands one over: open and paused. */
+const nodeSocketAt = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const up = new ws_1.WebSocket(url);
+    yield new Promise((resolve, reject) => {
+        up.once('open', () => {
+            up.pause();
+            resolve();
+        });
+        up.once('error', reject);
+    });
+    return up;
+});
+describe('nodeSocketRelay', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const sockets = [];
+    let context;
+    let saved;
+    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', '');
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        for (const wss of sockets.splice(0)) {
+            for (const client of wss.clients)
+                client.terminate();
+            wss.close();
+        }
+        yield loopback.closeAll();
+    }));
+    /** A node: a ticket route and a socket on the same server. */
+    function fakeNode() {
+        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            const seen = [];
+            const app = (0, express_1.default)();
+            app.post('/xenon/api/control/:udid/stream/ticket', (req, res) => {
+                var _a;
+                seen.push({ url: req.originalUrl, hubToken: req.header('x-xenon-hub-token') });
+                res.status((_a = opts.ticketStatus) !== null && _a !== void 0 ? _a : 200).json({ ticket: 'node-ticket', expiresIn: 60 });
+            });
+            const server = yield loopback.serve(app);
+            const wss = new ws_1.WebSocketServer({ server });
+            sockets.push(wss);
+            wss.on('connection', (ws, req) => {
+                var _a;
+                seen.push({ url: req.url });
+                (_a = opts.onSocket) === null || _a === void 0 ? void 0 : _a.call(opts, ws, req.url);
+            });
+            const origin = `http://127.0.0.1:${server.address().port}`;
+            return { origin, seen, wss };
+        });
+    }
+    /** A hub socket whose connections are relayed to `upstream()`. */
+    function relayingHub(upstream, highWaterBytes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const server = yield loopback.serve((0, express_1.default)());
+            const wss = new ws_1.WebSocketServer({ server });
+            sockets.push(wss);
+            wss.on('connection', (client) => __awaiter(this, void 0, void 0, function* () {
+                (0, nodeSocketRelay_1.relaySocket)(client, yield upstream(), highWaterBytes);
+            }));
+            return `ws://127.0.0.1:${server.address().port}`;
+        });
+    }
+    describe('relaySocket', () => {
+        it('passes messages both ways, binary and text as they were', () => __awaiter(void 0, void 0, void 0, function* () {
+            let atNode;
+            const node = yield fakeNode({ onSocket: (ws) => (atNode = ws) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            yield opened(viewer);
+            yield new Promise((r) => setTimeout(r, 50));
+            const binary = nextMessage(viewer);
+            atNode.send(Buffer.from([1, 2, 3]));
+            (0, chai_1.expect)(yield binary).to.deep.equal({ data: Buffer.from([1, 2, 3]), isBinary: true });
+            const text = nextMessage(viewer);
+            atNode.send('{"message":"a line"}');
+            const got = yield text;
+            (0, chai_1.expect)(got.isBinary).to.equal(false);
+            (0, chai_1.expect)(got.data.toString()).to.equal('{"message":"a line"}');
+            const fromViewer = nextMessage(atNode);
+            viewer.send('hello');
+            (0, chai_1.expect)((yield fromViewer).data.toString()).to.equal('hello');
+            viewer.close();
+        }));
+        it('closes the viewer with the node’s own code and reason', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [code, reason] of [
+                [1012, 'stream ended'],
+                [1008, 'device held by another user'],
+                [1011, 'stream failed'],
+            ]) {
+                const node = yield fakeNode({
+                    onSocket: (ws) => setTimeout(() => ws.close(code, reason), 30),
+                });
+                const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+                const viewer = new ws_1.WebSocket(hub);
+                (0, chai_1.expect)(yield closed(viewer)).to.deep.equal({ code, reason });
+            }
+        }));
+        it('a node connection that drops is 1011 to the viewer, who retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => setTimeout(() => ws.terminate(), 30) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            (0, chai_1.expect)((yield closed(viewer)).code).to.equal(1011);
+        }));
+        it('the viewer leaving closes the node’s socket', () => __awaiter(void 0, void 0, void 0, function* () {
+            let atNode;
+            const node = yield fakeNode({ onSocket: (ws) => (atNode = ws) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            yield opened(viewer);
+            yield new Promise((r) => setTimeout(r, 50));
+            const nodeClosed = closed(atNode);
+            viewer.close();
+            yield nodeClosed;
+        }));
+        it('stops reading from the node while the viewer is behind, and resumes once it catches up', () => {
+            class FakeSocket extends events_1.EventEmitter {
+                constructor() {
+                    super(...arguments);
+                    this.readyState = ws_1.WebSocket.OPEN;
+                    this.paused = false;
+                    this.pending = [];
+                }
+                send(_data, _opts, cb) {
+                    this.pending.push(cb);
+                }
+                pause() {
+                    this.paused = true;
+                }
+                resume() {
+                    this.paused = false;
+                }
+                close() { }
+                terminate() { }
+            }
+            const viewer = new FakeSocket();
+            const node = new FakeSocket();
+            (0, nodeSocketRelay_1.relaySocket)(viewer, node, 100);
+            node.emit('message', Buffer.alloc(60), true);
+            (0, chai_1.expect)(node.paused).to.equal(false);
+            node.emit('message', Buffer.alloc(60), true);
+            (0, chai_1.expect)(node.paused, '120 bytes unwritten').to.equal(true);
+            const written = () => viewer.pending.shift()();
+            written();
+            (0, chai_1.expect)(node.paused, '60 bytes unwritten').to.equal(true);
+            written();
+            (0, chai_1.expect)(node.paused, 'all written').to.equal(false);
+        });
+    });
+    describe('openNodeSocket', () => {
+        const actor = { actorId: 'alice', isAdmin: false };
+        it('is null for this server’s own phone, and asks nothing of anyone', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, nodeId: 'hub-1' }); }) });
+            (0, chai_1.expect)(socket).to.equal(null);
+            (0, chai_1.expect)(node.seen).to.deep.equal([]);
+        }));
+        it('opens the node’s socket with a ticket of the node’s own, asked for with the hub’s token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({
+                udid: 'a b',
+                actor,
+                path: 'logcat',
+                query: new URLSearchParams({ levels: 'error', process: 'App' }),
+            }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'a b', host: node.origin, nodeId: 'node-1' }); }),
+                controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return 'signed-for-alice'; }),
+            });
+            (0, chai_1.expect)(socket).to.be.instanceOf(ws_1.WebSocket);
+            socket.close();
+            (0, chai_1.expect)(node.seen).to.deep.equal([
+                { url: '/xenon/api/control/a%20b/stream/ticket', hubToken: 'signed-for-alice' },
+                { url: '/xenon/api/control/a%20b/logcat?levels=error&process=App&ticket=node-ticket' },
+            ]);
+        }));
+        it('holds what the node sends first until something reads it', () => __awaiter(void 0, void 0, void 0, function* () {
+            // H.264's config packet and logcat's replay go out the moment the
+            // node's socket opens; lost, the preview never decodes.
+            const node = yield fakeNode({ onSocket: (ws) => ws.send('first frame') });
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, nodeId: 'node-1' }); }),
+                controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            });
+            const up = socket;
+            yield new Promise((r) => setTimeout(r, 100));
+            const first = nextMessage(up);
+            up.resume();
+            (0, chai_1.expect)((yield first).data.toString()).to.equal('first frame');
+            up.close();
+        }));
+        it('a node that refuses the ticket is a refusal, one that can’t be reached is not', () => __awaiter(void 0, void 0, void 0, function* () {
+            const refusing = yield fakeNode({ ticketStatus: 409 });
+            const find = (host) => () => __awaiter(void 0, void 0, void 0, function* () {
+                return ({
+                    udid: 'p',
+                    host,
+                    nodeId: 'node-1',
+                });
+            });
+            let error;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: find(refusing.origin), controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+            error = undefined;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: find('http://127.0.0.1:1'), controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(Error);
+            (0, chai_1.expect)(error).to.not.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+        }));
+        it('a cloud provider’s phone is refused without a request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            let error;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, cloud: '{"cloudName":"x"}' }); }),
+            }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+            (0, chai_1.expect)(node.seen).to.deep.equal([]);
+        }));
+    });
+    describe('the hub’s own sockets', () => {
+        function hubWith(attach) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const server = http_1.default.createServer();
+                attach(server);
+                yield new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+                loopbackServersCleanup.push(server);
+                return `ws://127.0.0.1:${server.address().port}`;
+            });
+        }
+        const loopbackServersCleanup = [];
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            for (const s of loopbackServersCleanup.splice(0)) {
+                (_a = s.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(s);
+                yield new Promise((r) => s.close(r));
+            }
+        }));
+        it('H.264: a node’s phone is relayed from its node, with the ticket’s user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => ws.send(Buffer.from([0, 9, 9])) });
+            const asked = [];
+            const hub = yield hubWith((server) => (0, h264StreamWs_1.attachH264Ws)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice', isAdmin: true }); }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('not this server’s phone');
+                }),
+                nodeSocket: (udid, who) => __awaiter(void 0, void 0, void 0, function* () {
+                    asked.push({ udid, who });
+                    return nodeSocketAt(`${node.origin.replace('http', 'ws')}/h264`);
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/stream/h264?ticket=t`);
+            (0, chai_1.expect)((yield nextMessage(viewer)).data).to.deep.equal(Buffer.from([0, 9, 9]));
+            (0, chai_1.expect)(asked).to.deep.equal([{ udid: 'p', who: { actorId: 'alice', isAdmin: true } }]);
+            viewer.close();
+        }));
+        it('H.264: a refusal from the node is 1008, anything else 1011', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [thrown, code] of [
+                [new nodeSocketRelay_1.NodeSocketRefused('the node refused the ticket'), 1008],
+                [new Error('ECONNREFUSED'), 1011],
+            ]) {
+                const hub = yield hubWith((server) => (0, h264StreamWs_1.attachH264Ws)(server, {
+                    redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice' }); }),
+                    startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                        throw new Error('not this server’s phone');
+                    }),
+                    nodeSocket: () => __awaiter(void 0, void 0, void 0, function* () {
+                        throw thrown;
+                    }),
+                }));
+                const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/stream/h264?ticket=t`);
+                (0, chai_1.expect)((yield closed(viewer)).code).to.equal(code);
+            }
+        }));
+        it('logcat: relayed after this server’s own ownership check, with the filter', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => ws.send('{"message":"from the node"}') });
+            const asked = [];
+            let authorized = 0;
+            const hub = yield hubWith((server) => (0, logcatWs_1.attachLogcatWs)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice' }); }),
+                authorize: () => __awaiter(void 0, void 0, void 0, function* () {
+                    authorized++;
+                    return true;
+                }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('not this server’s phone');
+                }),
+                nodeSocket: (udid, who, filter) => __awaiter(void 0, void 0, void 0, function* () {
+                    asked.push({ udid, filter });
+                    return nodeSocketAt(`${node.origin.replace('http', 'ws')}/logcat`);
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/logcat?ticket=t&levels=error&process=App`);
+            (0, chai_1.expect)((yield nextMessage(viewer)).data.toString()).to.equal('{"message":"from the node"}');
+            (0, chai_1.expect)(authorized).to.equal(1);
+            (0, chai_1.expect)(asked).to.deep.equal([{ udid: 'p', filter: { levels: ['error'], process: 'App' } }]);
+            viewer.close();
+        }));
+        it('logcat: a phone this server may not show isn’t asked of the node', () => __awaiter(void 0, void 0, void 0, function* () {
+            let asked = 0;
+            const hub = yield hubWith((server) => (0, logcatWs_1.attachLogcatWs)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'bob' }); }),
+                authorize: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('unused');
+                }),
+                nodeSocket: () => __awaiter(void 0, void 0, void 0, function* () {
+                    asked++;
+                    return null;
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/logcat?ticket=t`);
+            (0, chai_1.expect)((yield closed(viewer)).code).to.equal(1008);
+            (0, chai_1.expect)(asked).to.equal(0);
+        }));
+    });
+});

package/lib/test/unit/stream-leave-route.spec.js

@@ -62,6 +62,7 @@ const AndroidH264StreamService_1 = __importDefault(require("../../src/device-man
 const authMiddleware_1 = require("../../src/middleware/authMiddleware");
 const container_registration_1 = require("../helpers/container-registration");
 const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
 const UDID = 'DEV-1';
 const ALICE = 'usr_alice';
 const BOB = 'usr_bob';
@@ -84,6 +85,8 @@ function buildApp(userId) {
     return app;
 }
 describe('POST /control/:udid/stream/leave', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let deviceRow;
     let unblock;
     let androidStop;
@@ -101,6 +104,7 @@ describe('POST /control/:udid/stream/leave', () => {
         deviceRow = {
             udid: UDID,
             host: '127.0.0.1',
+            nodeId: own_node_id_1.OWN_NODE_ID,
             platform: 'android',
             busy: true,
             session_id: `manual_${ALICE}_${UDID}`,

package/lib/test/unit/stream-stop-ownership.spec.js

@@ -62,6 +62,7 @@ const AndroidH264StreamService_1 = __importDefault(require("../../src/device-man
 const authMiddleware_1 = require("../../src/middleware/authMiddleware");
 const container_registration_1 = require("../helpers/container-registration");
 const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
 /**
  * Round-trip guard for POST /control/:udid/stream/stop.
  *
@@ -119,6 +120,8 @@ function buildApp(caller) {
     return app;
 }
 describe('POST /control/:udid/stream/stop — lock ownership round-trip', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let unblock;
     let androidStop;
     let h264Stop;
@@ -131,6 +134,7 @@ describe('POST /control/:udid/stream/stop — lock ownership round-trip', () =>
         deviceRow = {
             udid: UDID,
             host: '127.0.0.1',
+            nodeId: own_node_id_1.OWN_NODE_ID,
             platform: 'android',
             busy: sessionId !== null,
             session_id: sessionId,

package/lib/test/unit/stream-stop-recording.spec.js

@@ -62,6 +62,7 @@ const AndroidH264StreamService_1 = __importDefault(require("../../src/device-man
 const authMiddleware_1 = require("../../src/middleware/authMiddleware");
 const container_registration_1 = require("../helpers/container-registration");
 const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
 /**
  * POST /control/:udid/stream/stop must not stop the stream under a live
  * recording. The recording reads from that stream: measured 2026-09-26 on a
@@ -94,6 +95,8 @@ function buildApp(caller) {
     return app;
 }
 describe('POST /control/:udid/stream/stop — a device being recorded', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let unblock;
     let androidStop;
     let h264Stop;
@@ -110,6 +113,7 @@ describe('POST /control/:udid/stream/stop — a device being recorded', () => {
                 return ({
                     udid: UDID,
                     host: '127.0.0.1',
+                    nodeId: own_node_id_1.OWN_NODE_ID,
                     platform: 'android',
                     busy: true,
                     session_id: `manual_${ALICE}_${UDID}`,

package/lib/test/unit/stream-ticket-identity.spec.js

@@ -31,6 +31,7 @@ const UserSessionService_1 = require("../../src/services/UserSessionService");
 const device_store_1 = require("../../src/data-service/device-store");
 const container_registration_1 = require("../helpers/container-registration");
 const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
 /**
  * `req.auth.userId` must always hold a User id.
  *
@@ -51,6 +52,8 @@ const UDID = 'UDID-1';
 const ALICE_USER = 'usr_alice';
 const ALICE_KEY = 'key_abc';
 describe('stream/ticket carries the user identity, not the credential', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let dir;
     let ticketSvc;
     function buildApp(caller = {}) {
@@ -103,7 +106,14 @@ describe('stream/ticket carries the user identity, not the credential', () => {
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
             findDevice: (_a) => __awaiter(void 0, [_a], void 0, function* ({ udid }) {
                 return udid === UDID
-                    ? { udid, host: 'h', platform: 'android', screenWidth: '1080', screenHeight: '1920' }
+                    ? {
+                        udid,
+                        host: 'h',
+                        nodeId: own_node_id_1.OWN_NODE_ID,
+                        platform: 'android',
+                        screenWidth: '1080',
+                        screenHeight: '1920',
+                    }
                     : null;
             }),
         });

package/lib/test/unit/stream-watchdog-timers.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+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 sinon_1 = __importDefault(require("sinon"));
+const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
+const AndroidH264StreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidH264StreamService"));
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+/**
+ * The stream services start their watchdogs in their constructors. On a
+ * server the HTTP listener keeps the process alive, so those intervals only
+ * need to fire while it runs; referenced, they also kept a test run (or any
+ * script that merely constructs a service) alive after its work was done.
+ */
+describe('stream service watchdogs', () => {
+    let created;
+    beforeEach(() => {
+        created = [];
+        const realSetInterval = global.setInterval;
+        sinon_1.default.stub(global, 'setInterval').callsFake(((fn, ms) => {
+            const timer = realSetInterval(fn, ms);
+            created.push(timer);
+            return timer;
+        }));
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        for (const timer of created)
+            clearInterval(timer);
+    });
+    for (const [name, Service] of [
+        ['AndroidStreamService', AndroidStreamService_1.default],
+        ['AndroidH264StreamService', AndroidH264StreamService_1.default],
+        ['IOSStreamService', IOSStreamService_1.default],
+    ]) {
+        it(`${name}'s intervals don't keep the process alive`, () => {
+            new Service();
+            (0, chai_1.expect)(created.length, 'the constructor starts its watchdog').to.be.greaterThan(0);
+            for (const timer of created)
+                (0, chai_1.expect)(timer.hasRef(), 'unref()ed').to.equal(false);
+        });
+    }
+});