@xenon-device-management/xenon 2.8.1 → 2.8.3

package/lib/src/app/routers/control.js

@@ -963,6 +963,14 @@ router.get('/:udid/stream/status', (req, res) => __awaiter(void 0, void 0, void
  */
 router.get('/:udid/stream', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
     const { udid } = req.params;
+    // Note a hang-up from the start. Starting the stream below can take
+    // seconds, and the viewer is counted only after it. A browser that left in
+    // the meantime had already fired `close`, so its viewer was counted and
+    // never uncounted, holding the phone's preview for nobody.
+    let hungUp = false;
+    res.once('close', () => {
+        hungUp = true;
+    });
     const device = yield getDeviceInfo(udid);
     if (!device)
         return res.status(404).send('Device not found');
@@ -1015,6 +1023,9 @@ router.get('/:udid/stream', (req, res) => __awaiter(void 0, void 0, void 0, func
             return res.status(503).send({ error: 'Android stream failed', message: err.message });
         }
     }
+    // Nobody is left to serve: count no viewer and open no proxy.
+    if (hungUp)
+        return;
     if (!mjpegPort) {
         return res.status(404).send({
             error: 'MJPEG port not found for device',

package/lib/src/app/routers/dashboard.js

@@ -129,7 +129,13 @@ function getSessions(request, response) {
         const cursor = readQuery(response, () => (0, sessionInsights_1.cursorWhere)(request.query.before, request.query.beforeId));
         if (cursor === undefined)
             return;
+        const ids = readQuery(response, () => (0, sessionInsights_1.parseIds)(request.query.ids));
+        if (ids === undefined)
+            return;
         const where = {};
+        if (ids) {
+            where.id = { in: ids };
+        }
         if (since) {
             where.createdAt = { gte: since };
         }

package/lib/src/app/routers/sessionInsights.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_PAGE_MAX = exports.SESSION_PAGE_DEFAULT = exports.InvalidQueryError = void 0;
+exports.SESSION_IDS_MAX = exports.SESSION_PAGE_MAX = exports.SESSION_PAGE_DEFAULT = exports.InvalidQueryError = void 0;
 exports.sessionOutcome = sessionOutcome;
 exports.parseSince = parseSince;
 exports.parseLimit = parseLimit;
+exports.parseIds = parseIds;
 exports.cursorWhere = cursorWhere;
 exports.describeSessions = describeSessions;
 exports.percentile = percentile;
@@ -77,6 +78,27 @@ function parseLimit(raw) {
     }
     return Math.min(n, exports.SESSION_PAGE_MAX);
 }
+/** The most ids one GET /session takes. */
+exports.SESSION_IDS_MAX = 200;
+/**
+ * The `ids` query parameter: null when absent; else the comma-separated
+ * session ids, 1 to SESSION_IDS_MAX of them, or InvalidQueryError. The
+ * Sessions page re-reads older rows still running by id.
+ */
+function parseIds(raw) {
+    if (raw === undefined)
+        return null;
+    const ids = typeof raw === 'string'
+        ? raw
+            .split(',')
+            .map((id) => id.trim())
+            .filter(Boolean)
+        : [];
+    if (ids.length === 0 || ids.length > exports.SESSION_IDS_MAX) {
+        throw new InvalidQueryError('invalid_ids', `ids must list 1 to ${exports.SESSION_IDS_MAX} session ids, separated by commas`);
+    }
+    return ids;
+}
 /**
  * Where the next page starts: after the last row of the page before, given
  * as its `createdAt` (`before`) and `id` (`beforeId`). Pages go newest first

package/lib/src/device-managers/ios/IOSStreamService.js

@@ -853,6 +853,14 @@ let IOSStreamService = class IOSStreamService {
                         session.status = 'error';
                         session.lastError = error.message;
                     }
+                    // A start that got its tunnel up and then failed (WDA didn't launch)
+                    // stops that tunnel, so it doesn't run on, holding its ports, until
+                    // the phone's next start. Not while an Appium session may use it.
+                    if ((session === null || session === void 0 ? void 0 : session.tunnelPort) != null &&
+                        !(yield this.appiumSessionMayUse(udid, "the failed start's go-ios tunnel"))) {
+                        yield this.tunnels().stop(udid);
+                        session.tunnelPort = null;
+                    }
                     // Back off before the next attempt so a polling client can't drive a
                     // restart loop against a device that keeps failing to start.
                     this.markRecoveryAttempt(udid);

package/lib/src/device-managers/ios/IOSTunnels.js

@@ -20,6 +20,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IOSTunnels = exports.TUNNEL_CHECK_MS = exports.TUNNEL_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
 exports.iosVersionOf = iosVersionOf;
+exports.goIosReason = goIosReason;
 /**
  * One go-ios tunnel per iOS 17+ phone, each on its own leased pair of ports.
  *
@@ -74,6 +75,40 @@ function iosVersionOf(info) {
     const match = versionStr.match(/(\d+\.?\d*)/);
     return match ? parseFloat(match[0]) : 0;
 }
+/** The longest go-ios reason kept for an error message. */
+const REASON_MAX = 200;
+/**
+ * The last error or warning in a chunk of go-ios's stderr, for an error
+ * message. go-ios logs JSON lines: an ERROR or WARN line gives its `msg` and
+ * `error`, an INFO line gives nothing, and a line that isn't JSON (a panic)
+ * is kept as it is.
+ */
+function goIosReason(text) {
+    var _a;
+    let reason;
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch (_b) {
+            entry = undefined;
+        }
+        if (entry && typeof entry === 'object') {
+            const level = String((_a = entry.level) !== null && _a !== void 0 ? _a : '').toUpperCase();
+            if ((level === 'ERROR' || level === 'WARN') && entry.msg) {
+                reason = entry.error ? `${entry.msg}: ${entry.error}` : String(entry.msg);
+            }
+        }
+        else {
+            reason = line;
+        }
+    }
+    return reason === null || reason === void 0 ? void 0 : reason.slice(0, REASON_MAX);
+}
 /** An answer that puts the phone's traffic anywhere but its leased P + 1. */
 function moved(info, port) {
     return info.state === 'up' && info.userspacePort !== undefined && info.userspacePort !== port + 1;
@@ -144,14 +179,15 @@ let IOSTunnels = class IOSTunnels {
                 this.log.warn(`[${udid}] go-ios tunnel failed: ${err.message}`);
                 ended();
             });
-            this.logOutput(udid, proc);
+            this.logOutput(udid, tunnel);
             this.log.info(`[${udid}] iOS ${version}: starting a go-ios tunnel on ${port} (traffic on ${port + 1})`);
             const polls = exports.TUNNEL_READY_TIMEOUT_MS / exports.TUNNEL_READY_POLL_MS;
             for (let poll = 0; poll <= polls; poll++) {
                 if (poll > 0)
                     yield this.sleep(exports.TUNNEL_READY_POLL_MS);
                 if (this.tunnels.get(udid) !== tunnel) {
-                    throw new Error(`The go-ios tunnel for ${udid} exited before it was ready (exit code ${proc.exitCode})`);
+                    throw new Error(`The go-ios tunnel for ${udid} exited before it was ready (exit code ${proc.exitCode})` +
+                        (tunnel.reason ? `: ${tunnel.reason}` : ''));
                 }
                 const info = yield this.tunnelInfo(port, udid);
                 if (moved(info, port)) {
@@ -278,13 +314,16 @@ let IOSTunnels = class IOSTunnels {
     }
     /**
      * go-ios's output, at debug. Its repeated warning about a connected
-     * pre-iOS 17 phone (which needs no tunnel) is logged once per phone.
+     * pre-iOS 17 phone (which needs no tunnel) is logged once per phone. Its
+     * last error or warning is kept, for the error if the tunnel fails.
      */
-    logOutput(udid, proc) {
+    logOutput(udid, tunnel) {
         var _a, _b;
+        const proc = tunnel.process;
         (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => this.log.debug(`Tunnel [${udid}]: ${data}`));
         const loggedUnsupported = new Set();
         (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+            var _a;
             const text = String(data);
             const { unsupported, udid: targetUdid } = (0, iosStreamDiagnostics_1.classifyTunnelStderr)(text);
             if (unsupported) {
@@ -295,6 +334,7 @@ let IOSTunnels = class IOSTunnels {
                 }
                 return;
             }
+            tunnel.reason = (_a = goIosReason(text)) !== null && _a !== void 0 ? _a : tunnel.reason;
             this.log.debug(`Tunnel Err [${udid}]: ${text}`);
         });
     }

package/lib/test/unit/ios-stream-port-leases.spec.js

@@ -108,6 +108,8 @@ describe('iOS stream port leases (fake processes, real sockets, scratch DB)', ()
     let appiumWdaPorts;
     let ios;
     let android;
+    /** The stream's runwda exits at once, as when WebDriverAgent fails to launch. */
+    let runwdaExits;
     let tunnels;
     beforeEach(() => {
         allocator = new PortAllocator_1.PortAllocator();
@@ -123,6 +125,7 @@ describe('iOS stream port leases (fake processes, real sockets, scratch DB)', ()
         spawned = [];
         extraServers = [];
         appiumWdaPorts = new Set();
+        runwdaExits = false;
         tunnels = {
             ensure: sinon_1.default.stub().resolves(null),
             envFor: sinon_1.default.stub().callsFake(() => (Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }))),
@@ -150,6 +153,8 @@ describe('iOS stream port leases (fake processes, real sockets, scratch DB)', ()
                 server = listenNow(Number(args[args.length - 1].split(':')[0]));
             }
             const proc = new FakeProcess(command, args, server, opts);
+            if (runwdaExits && args[0] === 'runwda')
+                proc.exitCode = 1;
             spawned.push(proc);
             return proc;
         }));
@@ -236,6 +241,27 @@ describe('iOS stream port leases (fake processes, real sockets, scratch DB)', ()
         const runwda = spawned.find((p) => p.command === ios.goIOSPath && p.args[0] === 'runwda');
         (0, chai_1.expect)((_c = (_b = runwda === null || runwda === void 0 ? void 0 : runwda.opts) === null || _b === void 0 ? void 0 : _b.env) === null || _c === void 0 ? void 0 : _c.GO_IOS_AGENT_PORT, "runwda finds this phone's tunnel").to.equal('12100');
     }));
+    describe("a start whose WebDriverAgent fails after the iPhone's tunnel came up", () => {
+        beforeEach(() => {
+            tunnels.ensure.resolves(12100);
+            runwdaExits = true;
+            sinon_1.default.stub(ios, 'isGoIOSAvailable').resolves(true);
+        });
+        it('stops that tunnel, so it neither lingers nor holds its ports', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            const err = yield ios.startStream(IPHONE).then(() => null, (e) => e);
+            (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/WDA process exited/);
+            (0, chai_1.expect)(tunnels.stop.calledWith(IPHONE)).to.equal(true);
+            (0, chai_1.expect)((_a = ios.getStreamStatus(IPHONE)) === null || _a === void 0 ? void 0 : _a.status).to.equal('error');
+            (0, chai_1.expect)((_b = ios.getStreamStatus(IPHONE)) === null || _b === void 0 ? void 0 : _b.tunnelPort).to.equal(null);
+        }));
+        it('leaves it running while an Appium session holds the iPhone', () => __awaiter(void 0, void 0, void 0, function* () {
+            Object.assign(devices.get(IPHONE), { busy: true, session_id: '7f0c5a52-appium-session' });
+            const err = yield ios.startStream(IPHONE).then(() => null, (e) => e);
+            (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/WDA process exited/);
+            (0, chai_1.expect)(tunnels.stop.called).to.equal(false);
+        }));
+    });
     it('stopping a stale iOS session never deletes a lease another device holds', () => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         // The S9+ has since been leased the port the stale iPhone session names.

package/lib/test/unit/ios-tunnels.spec.js

@@ -181,6 +181,18 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
         (0, chai_1.expect)(t.portFor(PHONE_A)).to.equal(undefined);
         (0, chai_1.expect)([...t.ports.leased.keys()]).to.deep.equal([]);
     }));
+    it("says why the tunnel exited before it was ready, in go-ios's words", () => __awaiter(void 0, void 0, void 0, function* () {
+        t.answers = () => {
+            const proc = t.spawned[0].proc;
+            proc.stderr.emit('data', Buffer.from('{"level":"INFO","msg":"Using userspace networking"}\n' +
+                '{"level":"ERROR","msg":"failed to start tunnel","error":"listen tcp 127.0.0.1:12101: bind: address already in use"}\n'));
+            proc.exit(1);
+            return false;
+        };
+        const err = yield t.ensure(PHONE_A).then(() => null, (e) => e);
+        (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.equal(`The go-ios tunnel for ${PHONE_A} exited before it was ready (exit code 1): ` +
+            'failed to start tunnel: listen tcp 127.0.0.1:12101: bind: address already in use');
+    }));
     it('fails the start when the tunnel comes up on another traffic port, and stops it', () => __awaiter(void 0, void 0, void 0, function* () {
         t.answers = () => ({ state: 'up', userspacePort: 12102 });
         const err = yield t.ensure(PHONE_A).then(() => null, (e) => e);
@@ -320,6 +332,18 @@ describe('IOSTunnels: a phone that goes away (go-ios keeps its agent running)',
         }
     }));
 });
+describe('goIosReason', () => {
+    it("reads go-ios's last error or warning", () => {
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('{"level":"INFO","msg":"Tunnel server started"}\n')).to.equal(undefined);
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('{"level":"WARN","msg":"failed to get tunnel info","udid":"X"}')).to.equal('failed to get tunnel info');
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('{"level":"ERROR","msg":"first"}\n{"level":"ERROR","msg":"failed to start tunnel","error":"EOF"}\n')).to.equal('failed to start tunnel: EOF');
+    });
+    it('keeps a line that is not JSON, trimmed and at most 200 characters', () => {
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('  panic: runtime error  \n')).to.equal('panic: runtime error');
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('x'.repeat(500))).to.have.length(200);
+        (0, chai_1.expect)((0, IOSTunnels_1.goIosReason)('\n  \n')).to.equal(undefined);
+    });
+});
 describe('iosVersionOf', () => {
     it('reads the version ios info reports', () => {
         (0, chai_1.expect)((0, IOSTunnels_1.iosVersionOf)({ ProductVersion: '17.2.1' })).to.equal(17.2);

package/lib/test/unit/session-list-insights.spec.js

@@ -111,6 +111,63 @@ describe('Sessions page data', () => {
                 (0, chai_1.expect)(ids(res)).to.deep.equal(['a', 'c', 'b', 'd']);
             }));
         });
+        // The Sessions page re-reads, by id, the rows of its older pages that were
+        // still running when loaded. Those pages aren't polled, so a session that
+        // had finished kept showing "running" there.
+        describe('by id', () => {
+            const ids = (res) => res.body.map((r) => r.id);
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                // A shared-pool phone, so a member may see these sessions too.
+                yield scratch.db.device.create({
+                    data: {
+                        udid: 'phone-1',
+                        host: 'http://127.0.0.1:4723',
+                        nodeId: 'hub-1',
+                        platform: 'android',
+                    },
+                });
+                yield session({ id: 'a', createdAt: ago(1 * MIN) });
+                yield session({ id: 'b', createdAt: ago(2 * MIN), status: 'running' });
+                yield session({ id: 'c', createdAt: ago(3 * MIN) });
+            }));
+            it('answers just the sessions asked for, newest first', () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield (0, loopbackRequest_1.default)(app()).get('/session?ids=c,b');
+                (0, chai_1.expect)(res.status).to.equal(200);
+                (0, chai_1.expect)(ids(res)).to.deep.equal(['b', 'c']);
+            }));
+            it('leaves out an id it does not know', () => __awaiter(void 0, void 0, void 0, function* () {
+                (0, chai_1.expect)(ids(yield (0, loopbackRequest_1.default)(app()).get('/session?ids=b,nope'))).to.deep.equal(['b']);
+            }));
+            it('refuses an empty list, or more than 200 ids', () => __awaiter(void 0, void 0, void 0, function* () {
+                const many = Array.from({ length: 201 }, (_, i) => `x${i}`).join(',');
+                for (const q of ['ids=', 'ids=,', `ids=${many}`]) {
+                    const res = yield (0, loopbackRequest_1.default)(app()).get(`/session?${q}`);
+                    (0, chai_1.expect)(res.status, q.slice(0, 12)).to.equal(400);
+                    (0, chai_1.expect)(res.body.error, q.slice(0, 12)).to.equal('invalid_ids');
+                }
+            }));
+            it('answers only the sessions the caller may see', () => __awaiter(void 0, void 0, void 0, function* () {
+                const team = yield scratch.db.team.create({ data: { name: 'by-id-team' } });
+                yield scratch.db.device.create({
+                    data: {
+                        udid: 'team-b',
+                        host: 'http://127.0.0.1:4723',
+                        nodeId: 'hub-1',
+                        platform: 'android',
+                        teamId: team.id,
+                    },
+                });
+                yield session({ id: 'hidden', device_udid: 'team-b', status: 'running' });
+                caller = {
+                    kind: 'user-session',
+                    userId: 'member-1',
+                    role: 'MEMBER',
+                    scopes: 'sessions',
+                    teamIds: [],
+                };
+                (0, chai_1.expect)(ids(yield (0, loopbackRequest_1.default)(app()).get('/session?ids=b,hidden'))).to.deep.equal(['b']);
+            }));
+        });
         it('keeps the sessions created since the given time, newest first', () => __awaiter(void 0, void 0, void 0, function* () {
             yield session({ id: 'old', createdAt: ago(3 * HOUR) });
             yield session({ id: 'recent', createdAt: ago(30 * MIN) });

package/lib/test/unit/stream-viewer-hangup.spec.js

@@ -0,0 +1,151 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const control_1 = __importDefault(require("../../src/app/routers/control"));
+const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
+const device_store_1 = require("../../src/data-service/device-store");
+const authMiddleware_1 = require("../../src/middleware/authMiddleware");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
+/**
+ * GET /control/:udid/stream counted its viewer only once the stream had
+ * started, which takes seconds on a cold start, and only then listened for
+ * `close`. A browser that hung up during that wait had already fired `close`,
+ * so its viewer was counted and never uncounted, and the phone's preview and
+ * hold were never released.
+ *
+ * Seen on the lab (2.8.1): an Android tile with H.264 preview did this every
+ * time. It opens an MJPEG warm-up and drops it as soon as H.264 is ready, and
+ * the phone stayed held for "1 other viewer(s)" with nothing connected.
+ */
+function buildApp() {
+    const app = (0, express_1.default)();
+    const apiRouter = express_1.default.Router();
+    apiRouter.use((req, _res, next) => {
+        req.auth = {
+            kind: 'user-session',
+            userId: 'usr_me',
+            role: 'MEMBER',
+            scopes: (0, authMiddleware_1.scopesForRole)('MEMBER'),
+            rateLimit: 100,
+        };
+        next();
+    });
+    control_1.default.register(apiRouter);
+    app.use('/xenon/api', apiRouter);
+    return app;
+}
+/** An MJPEG source that answers and then stays quiet, like a phone at rest. */
+function mjpegSource() {
+    const server = http_1.default.createServer((_req, res) => {
+        res.writeHead(200, { 'Content-Type': 'multipart/x-mixed-replace; boundary=frame' });
+    });
+    return new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server)));
+}
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function until(check_1) {
+    return __awaiter(this, arguments, void 0, function* (check, ms = 2000) {
+        for (const end = Date.now() + ms; Date.now() < end && !check();)
+            yield pause(20);
+    });
+}
+describe('GET /control/:udid/stream counts only viewers who are still there', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let source;
+    let startCalled;
+    let finishStart;
+    let viewers;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        source = yield mjpegSource();
+        const sourcePort = source.address().port;
+        let markCalled;
+        startCalled = new Promise((resolve) => (markCalled = resolve));
+        let release;
+        const held = new Promise((resolve) => (release = resolve));
+        finishStart = release;
+        // A cold start: the stream is ready only when the test says so.
+        const android = typedi_1.Container.get(AndroidStreamService_1.default);
+        sinon_1.default.stub(android, 'startStream').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            markCalled();
+            yield held;
+            return { mjpegPort: sourcePort };
+        }));
+        viewers = 0;
+        sinon_1.default.stub(android, 'updateViewerCount').callsFake((_udid, delta) => {
+            viewers += delta;
+        });
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
+            findDevice: (_a) => __awaiter(void 0, [_a], void 0, function* ({ udid }) {
+                return ({
+                    udid,
+                    host: '127.0.0.1',
+                    nodeId: own_node_id_1.OWN_NODE_ID,
+                    platform: 'android',
+                    busy: false,
+                    session_id: null,
+                    screenWidth: '1080',
+                    screenHeight: '2220',
+                });
+            }),
+        });
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        sinon_1.default.restore();
+        yield loopback.closeAll();
+        (_a = source.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(source);
+        yield new Promise((resolve) => source.close(() => resolve(undefined)));
+    }));
+    function watch(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const server = yield loopback.serve(buildApp());
+            const { port } = server.address();
+            const req = http_1.default.get({
+                host: '127.0.0.1',
+                port,
+                path: `/xenon/api/control/${udid}/stream?t=0`,
+                agent: false,
+            });
+            req.on('error', () => undefined);
+            return req;
+        });
+    }
+    it('never counts a viewer who hung up while the stream was starting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = yield watch('HANGUP-DURING-START');
+        yield startCalled;
+        req.destroy(); // the tile switched to H.264, or was closed
+        yield pause(100);
+        finishStart();
+        yield pause(300);
+        (0, chai_1.expect)(viewers).to.equal(0);
+    }));
+    it('counts a viewer who stays, and uncounts them when they leave', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = yield watch('STAYS-THEN-LEAVES');
+        yield startCalled;
+        finishStart();
+        yield until(() => viewers === 1);
+        (0, chai_1.expect)(viewers, 'watching').to.equal(1);
+        req.destroy();
+        yield until(() => viewers === 0);
+        (0, chai_1.expect)(viewers, 'left').to.equal(0);
+    }));
+});