@xenon-device-management/xenon 2.15.0 → 2.16.0

package/lib/src/sessions/SessionManager.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_MANAGER = exports.SessionManager = exports.HUB_RESTART_CATEGORY = void 0;
+exports.SESSION_MANAGER = exports.SessionManager = void 0;
 const os_1 = __importDefault(require("os"));
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
@@ -62,12 +62,9 @@ const device_store_1 = require("../data-service/device-store");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
-/**
- * The `failure_category` of a session a restart ended: one still running at
- * boot that couldn't be picked up again. The failure analysis writes every
- * other category (`ANALYSIS_CATEGORIES`).
- */
-exports.HUB_RESTART_CATEGORY = 'HUB_RESTART';
+// A session still running at boot that can't be picked up again is filed
+// under it; the failure analysis also writes it for a shutdown's drain.
+const failureCategories_1 = require("../dashboard/services/failureCategories");
 /**
  * SessionManager with persistence and recovery capabilities.
  *
@@ -312,7 +309,7 @@ let SessionManager = class SessionManager {
                         status: 'failed',
                         endTime: new Date(),
                         failure_reason: reason,
-                        failure_category: exports.HUB_RESTART_CATEGORY,
+                        failure_category: failureCategories_1.HUB_RESTART_CATEGORY,
                     },
                 });
             }

package/lib/test/helpers/driver-log.js

@@ -0,0 +1,38 @@
+"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 });
+exports.TestDriverLog = void 0;
+const line_consuming_log_1 = require("appium-xcuitest-driver/build/lib/device/log/line-consuming-log");
+const quietLog = { debug() { }, info() { }, warn() { }, error() { } };
+/**
+ * The XCUITest driver's own log class, as an iPhone's (`IOSDeviceLog`) and a
+ * simulator's (`IOSSimulatorLog`) `logs.syslog` extend it, with `line()` in
+ * place of a device: what Xenon reads is what the driver keeps.
+ */
+class TestDriverLog extends line_consuming_log_1.LineConsumingLog {
+    constructor() {
+        super({ log: quietLog });
+    }
+    startCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    stopCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    get isCapturing() {
+        return true;
+    }
+    /** A line from the device, as the driver's capture hands it on. */
+    line(message) {
+        this.broadcast(message);
+    }
+}
+exports.TestDriverLog = TestDriverLog;

package/lib/test/helpers/fake-http-proxy.js

@@ -0,0 +1,106 @@
+"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 });
+exports.startFakeProxy = startFakeProxy;
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+/**
+ * An HTTP proxy on 127.0.0.1 that forwards what it is sent and notes it: a
+ * request in absolute form (http-proxy-agent, axios) is passed on to its
+ * target, a CONNECT (https-proxy-agent, so WebSockets) becomes a tunnel, or
+ * is refused with `refuseConnect`. A spec can then tell a call that went
+ * through the proxy from one that went straight to the target.
+ */
+function startFakeProxy() {
+    return __awaiter(this, arguments, void 0, function* (opts = {}) {
+        const seen = [];
+        const authorizations = [];
+        const sockets = new Set();
+        const resolve = (host) => { var _a, _b; return (_b = (_a = opts.hosts) === null || _a === void 0 ? void 0 : _a[host]) !== null && _b !== void 0 ? _b : host; };
+        const server = http_1.default.createServer((req, res) => {
+            var _a, _b;
+            seen.push(`${req.method} ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            let target;
+            try {
+                target = new URL((_b = req.url) !== null && _b !== void 0 ? _b : '');
+            }
+            catch (_c) {
+                res.writeHead(400).end();
+                return;
+            }
+            const upstream = http_1.default.request(Object.assign(Object.assign({}, urlParts(target)), { hostname: resolve(target.hostname), method: req.method, headers: req.headers }), (answer) => {
+                var _a;
+                res.writeHead((_a = answer.statusCode) !== null && _a !== void 0 ? _a : 502, answer.headers);
+                answer.pipe(res);
+            });
+            upstream.on('error', () => res.writeHead(502).end());
+            req.pipe(upstream);
+        });
+        server.on('connect', (req, client, head) => {
+            var _a;
+            seen.push(`CONNECT ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            if (opts.ignoreConnect) {
+                sockets.add(client);
+                client.on('error', () => client.destroy());
+                return;
+            }
+            if (opts.refuseConnect) {
+                client.end('HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n');
+                return;
+            }
+            const [host, port] = String(req.url).split(':');
+            const upstream = net_1.default.connect(Number(port), resolve(host), () => {
+                client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+                if (head.length)
+                    upstream.write(head);
+                upstream.pipe(client);
+                client.pipe(upstream);
+            });
+            sockets.add(upstream).add(client);
+            const drop = () => {
+                upstream.destroy();
+                client.destroy();
+            };
+            upstream.on('error', drop);
+            client.on('error', drop);
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: `http://127.0.0.1:${port}`,
+            seen,
+            authorizations,
+            close: () => new Promise((resolve) => {
+                var _a;
+                for (const socket of sockets)
+                    socket.destroy();
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+function urlParts(url) {
+    return {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port,
+        path: `${url.pathname}${url.search}`,
+    };
+}

package/lib/test/helpers/otlp-probe.js

@@ -0,0 +1,107 @@
+"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 });
+exports.startOtlpProbe = startOtlpProbe;
+exports.attributeOf = attributeOf;
+exports.resetOtelGlobals = resetOtelGlobals;
+exports.flushOtelGlobals = flushOtelGlobals;
+const http_1 = __importDefault(require("http"));
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+/**
+ * A stand-in OTLP/HTTP collector on 127.0.0.1. It answers every request 200
+ * and keeps what it was sent, so a spec can see where Xenon's telemetry went
+ * and in which encoding (Xenon's own exporters send OTLP/JSON; the ones the
+ * OTel SDK builds from OTEL_* variables send protobuf).
+ */
+function startOtlpProbe() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requests = [];
+        const server = http_1.default.createServer((req, res) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                var _a, _b;
+                const body = Buffer.concat(chunks);
+                const contentType = String((_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : '');
+                let json;
+                if (contentType.includes('json')) {
+                    try {
+                        json = JSON.parse(body.toString('utf8'));
+                    }
+                    catch (_c) {
+                        json = undefined;
+                    }
+                }
+                requests.push({ path: (_b = req.url) !== null && _b !== void 0 ? _b : '', contentType, body, json });
+                if (contentType.includes('json')) {
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end('{}');
+                }
+                else {
+                    res.writeHead(200, { 'content-type': 'application/x-protobuf' });
+                    res.end();
+                }
+            });
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: (path) => `http://127.0.0.1:${port}${path}`,
+            requests,
+            spans: () => requests.flatMap((r) => {
+                var _a, _b;
+                return ((_b = (_a = r.json) === null || _a === void 0 ? void 0 : _a.resourceSpans) !== null && _b !== void 0 ? _b : []).flatMap((rs) => { var _a; return ((_a = rs.scopeSpans) !== null && _a !== void 0 ? _a : []).flatMap((ss) => { var _a; return ((_a = ss.spans) !== null && _a !== void 0 ? _a : []); }); });
+            }),
+            close: () => new Promise((resolve) => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+/** A span attribute's value, whatever its OTLP/JSON type. */
+function attributeOf(attributes, key) {
+    const found = attributes === null || attributes === void 0 ? void 0 : attributes.find((a) => a.key === key);
+    if (!found)
+        return undefined;
+    return Object.values(found.value)[0];
+}
+/**
+ * Takes every OTel global (tracer, meter and logger providers, context
+ * manager, propagator) off the API, so the next registration wins. The API
+ * keeps the first registration for the life of the process and refuses the
+ * rest: a spec that leaves one behind decides what every later spec exports.
+ */
+function resetOtelGlobals() {
+    api_1.trace.disable();
+    api_1.metrics.disable();
+    api_logs_1.logs.disable();
+    api_1.context.disable();
+    api_1.propagation.disable();
+}
+/** Exports whatever the registered meter and logger providers hold now. */
+function flushOtelGlobals() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const meterProvider = api_1.metrics.getMeterProvider();
+        yield ((_a = meterProvider.forceFlush) === null || _a === void 0 ? void 0 : _a.call(meterProvider));
+        const loggerProvider = api_logs_1.logs.getLoggerProvider();
+        yield ((_b = loggerProvider.forceFlush) === null || _b === void 0 ? void 0 : _b.call(loggerProvider));
+    });
+}

package/lib/test/integration/androidDevices.spec.js

@@ -133,6 +133,6 @@ describe('Android Test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'Device is busy or blocked.. Device request: {"platform":"android"}'));
+            .with.property('message', 'Device is busy or blocked. Device request: {"platform":"android"}'));
     }));
 });

package/lib/test/integration/ios/01iOSSimulator.spec.js

@@ -145,7 +145,7 @@ describe('Max sessions CLI argument test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 6000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'Device is busy or blocked.. Device request: {"platform":"ios","name":"iPhone","deviceType":"simulator"}'));
+            .with.property('message', 'Device is busy or blocked. Device request: {"platform":"ios","name":"iPhone","deviceType":"simulator"}'));
     }));
 });
 describe('IOS Simulator Test', () => {

package/lib/test/integration/ios/02iOSDevices.spec.js

@@ -53,7 +53,7 @@ describe('IOS Test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 6000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'No device matching request.. Device request: {"platform":"ios","name":"iPhone","deviceType":"real"}'));
+            .with.property('message', 'No device matching request. Device request: {"platform":"ios","name":"iPhone","deviceType":"real"}'));
     }));
     it('Should throw error if the IPA does not match with device type real', () => __awaiter(void 0, void 0, void 0, function* () {
         yield (0, device_utils_1.initializeStorage)();

package/lib/test/integration/selector-state-flow.spec.js

@@ -105,7 +105,7 @@ describe('Selector state full flow (integration)', function () {
             stdio: 'pipe',
         });
         prisma = new client_1.PrismaClient({ datasources: { db: { url } } });
-        socketStub = { emitToDashboard: sinon_1.default.stub() };
+        socketStub = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         stateService = new SelectorStateService_1.SelectorStateService(prisma, socketStub);
         verifier = new SelectorVerificationJob_1.SelectorVerificationJob(prisma, socketStub);
     }));
@@ -116,7 +116,7 @@ describe('Selector state full flow (integration)', function () {
             fs.unlinkSync(dbPath);
     }));
     beforeEach(() => __awaiter(this, void 0, void 0, function* () {
-        socketStub.emitToDashboard.resetHistory();
+        socketStub.emitToDashboardForSelector.resetHistory();
         // SessionLog → Session → Build — delete children before parents.
         yield prisma.sessionLog.deleteMany({});
         yield prisma.session.deleteMany({});
@@ -156,7 +156,7 @@ describe('Selector state full flow (integration)', function () {
         });
         (0, chai_1.expect)(fixed.status).to.equal('pending');
         (0, chai_1.expect)(fixed.fixed_at).to.be.instanceOf(Date);
-        (0, chai_1.expect)(socketStub.emitToDashboard.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
         // Three distinct CI builds, each with one un-healed findElement on the tuple.
         for (const buildId of ['b-1', 'b-2', 'b-3']) {
             const sid = `s-${buildId}`;
@@ -190,7 +190,7 @@ describe('Selector state full flow (integration)', function () {
         (0, chai_1.expect)(final.status).to.equal('resolved');
         (0, chai_1.expect)(final.clean_builds_count).to.equal(3);
         (0, chai_1.expect)(final.resolved_at).to.be.instanceOf(Date);
-        const resolvedEmits = socketStub.emitToDashboard
+        const resolvedEmits = socketStub.emitToDashboardForSelector
             .getCalls()
             .filter((c) => c.args[0] === SocketEvents_1.SocketEvents.SELECTOR_RESOLVED);
         (0, chai_1.expect)(resolvedEmits.length).to.equal(1);
@@ -226,6 +226,6 @@ describe('Selector state full flow (integration)', function () {
         (0, chai_1.expect)(after.regression_count).to.equal(1);
         (0, chai_1.expect)(after.resolved_at).to.be.null;
         (0, chai_1.expect)(after.fixed_at).to.be.null;
-        (0, chai_1.expect)(socketStub.emitToDashboard.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
     }));
 });

package/lib/test/unit/XenonCapabilityManager.spec.js

@@ -60,3 +60,26 @@ describe('XenonCapabilityManager.getXenonCapabilities — interceptor activation
         expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(true);
     });
 });
+/**
+ * `xe:save_device_logs` is a switch like `xe:record_video`: on by default,
+ * on only for `true` or "true" once set. Through 2.15 it was read nowhere.
+ */
+describe('XenonCapabilityManager.getXenonCapabilities — xe:save_device_logs', () => {
+    const saved = (always) => (0, XenonCapabilityManager_1.getXenonCapabilities)(caps(always))[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS];
+    it('is on when the session says nothing', () => {
+        expect(saved({})).to.equal(true);
+    });
+    it('is on for true or "true"', () => {
+        expect(saved({ 'xe:save_device_logs': true })).to.equal(true);
+        expect(saved({ 'xe:saveDeviceLogs': 'true' })).to.equal(true);
+    });
+    it('is off for false, and for any other value, as every switch is', () => {
+        for (const value of [false, 'false', 'yes', 1]) {
+            expect(saved({ 'xe:save_device_logs': value }), String(value)).to.equal(false);
+        }
+    });
+    it('is read from xe:options and its xenon:options alias too', () => {
+        expect(saved({ 'xe:options': { save_device_logs: false } })).to.equal(false);
+        expect(saved({ 'xenon:options': { saveDeviceLogs: false } })).to.equal(false);
+    });
+});

package/lib/test/unit/android-adb-retry.spec.js

@@ -0,0 +1,112 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const adbkit_1 = __importDefault(require("@devicefarmer/adbkit"));
+const appium_adb_1 = require("appium-adb");
+const test_container_1 = require("../helpers/test-container");
+const RETRY_MS = 60000;
+/**
+ * When adb couldn't be started, or its device tracking couldn't, the server
+ * logged "Could not find ADB" without the reason and never looked again: every
+ * later discovery answered no phones until a restart, even once adb worked
+ * (an SDK installed, a stuck adb server killed). It now says why, and tries
+ * again a minute later.
+ */
+describe('Android discovery when adb is unavailable', () => {
+    const sandbox = sinon_1.default.createSandbox();
+    let manager;
+    let createADB;
+    let trackDevices;
+    let errors;
+    let clock;
+    let savedNodeEnv;
+    const workingAdb = () => ({
+        adbRemoteHost: null,
+        getConnectedDevices: sandbox.stub().resolves([]),
+    });
+    beforeEach(() => {
+        savedNodeEnv = process.env.NODE_ENV;
+        clock = sandbox.useFakeTimers({ now: Date.now(), toFake: ['Date'] });
+        createADB = sandbox.stub(appium_adb_1.ADB, 'createADB');
+        trackDevices = sandbox.stub().resolves({ on: sandbox.stub() });
+        sandbox.stub(adbkit_1.default, 'createClient').returns({ trackDevices });
+        manager = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        sandbox.stub(manager, 'requireSdkRoot').resolves();
+        errors = sandbox.stub(manager.log, 'error');
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox.restore();
+        if (savedNodeEnv === undefined)
+            delete process.env.NODE_ENV;
+        else
+            process.env.NODE_ENV = savedNodeEnv;
+        yield (0, test_container_1.resetTestContainer)();
+    }));
+    const discover = () => manager.getDevices({ androidDeviceType: 'both' }, []);
+    it('says why adb could not be started', () => __awaiter(void 0, void 0, void 0, function* () {
+        createADB.rejects(new Error('Could not find adb. spawn adb ENOENT'));
+        (0, chai_1.expect)(yield discover()).to.deep.equal([]);
+        const logged = errors.getCalls().map((c) => String(c.args[0]));
+        (0, chai_1.expect)(logged.some((m) => m.includes('spawn adb ENOENT')), logged.join('\n')).to.equal(true);
+    }));
+    it('tries adb again a minute later, and not before', () => __awaiter(void 0, void 0, void 0, function* () {
+        const adb = workingAdb();
+        createADB.onFirstCall().rejects(new Error('spawn adb ENOENT'));
+        createADB.onSecondCall().resolves(adb);
+        yield discover();
+        clock.tick(RETRY_MS - 1000);
+        yield discover();
+        (0, chai_1.expect)(createADB.callCount, 'within the minute').to.equal(1);
+        clock.tick(2000);
+        yield discover();
+        (0, chai_1.expect)(createADB.callCount, 'after the minute').to.equal(2);
+        (0, chai_1.expect)(adb.getConnectedDevices.called, 'discovery ran').to.equal(true);
+    }));
+    it('says why device tracking failed, keeps listing phones, and tries it again', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.NODE_ENV = 'development';
+        const adb = workingAdb();
+        createADB.resolves(adb);
+        trackDevices.onFirstCall().rejects(new Error('connect ECONNREFUSED 127.0.0.1:5037'));
+        yield discover();
+        const logged = errors.getCalls().map((c) => String(c.args[0]));
+        (0, chai_1.expect)(logged.some((m) => m.includes('ECONNREFUSED')), logged.join('\n')).to.equal(true);
+        yield discover();
+        (0, chai_1.expect)(adb.getConnectedDevices.callCount, 'phones still listed').to.equal(2);
+        (0, chai_1.expect)(trackDevices.callCount, 'within the minute').to.equal(1);
+        clock.tick(RETRY_MS + 1000);
+        yield discover();
+        (0, chai_1.expect)(trackDevices.callCount, 'after the minute').to.equal(2);
+    }));
+    it('starts one device tracker when two discoveries start adb at once', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Each tracker runs the whole plug-in handling again for every phone
+        // plugged in, and nothing could end the extra one.
+        process.env.NODE_ENV = 'development';
+        createADB.resolves(workingAdb());
+        const pending = [];
+        trackDevices.callsFake(() => new Promise((resolve) => pending.push(() => resolve({ on: sandbox.stub() }))));
+        const both = Promise.all([discover(), discover()]);
+        while (pending.length === 0)
+            yield new Promise((r) => setImmediate(r));
+        // Time for a second discovery to reach the tracker too, if it would.
+        for (let i = 0; i < 20; i++)
+            yield new Promise((r) => setImmediate(r));
+        pending.forEach((start) => start());
+        yield both;
+        (0, chai_1.expect)(createADB.callCount, 'adb started').to.equal(1);
+        (0, chai_1.expect)(trackDevices.callCount, 'trackers started').to.equal(1);
+    }));
+});