@xenon-device-management/xenon 2.9.0 → 2.9.2

package/lib/src/services/ServerManager.js

@@ -130,6 +130,8 @@ let ServerManager = ServerManager_1 = class ServerManager {
             }
             yield this.syncDatabaseAndAIConfig(pluginArgs);
             yield this.initializeCoreSubsystems(pluginArgs, cliArgs.port);
+            // Before anything below starts go-ios: the reap would kill it too.
+            yield this.reapLeftoverGoIos();
             this.registerRoutes(expressApp, httpServer, cliArgs, pluginArgs);
             yield this.bootEmulators(pluginArgs);
             this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
@@ -364,6 +366,26 @@ let ServerManager = ServerManager_1 = class ServerManager {
             typedi_1.Container.set(ARTIFACT_STORE, new FsArtifactStore(config_1.config.recordingsAssetsPath));
         });
     }
+    /**
+     * Reap what a previous run (or a hard-killed one) left of go-ios: tunnels
+     * whose agents keep self-forking, WebDriverAgent runners and log streams.
+     * It kills every process running the go-ios binary, this process's own
+     * included, so it runs before anything here starts one. It used to run at
+     * the end of boot, after device detection had started, and killed the
+     * `ios info` call detection makes in the background for each plugged-in
+     * iPhone ("Failed to fetch IP via go-ios" at every boot).
+     */
+    reapLeftoverGoIos() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('../device-managers/ios/IOSStreamService')));
+                yield typedi_1.Container.get(IOSStreamService).reapOrphanTunnels();
+            }
+            catch (err) {
+                this.logger.warn(`Reaping go-ios left by a previous run failed: ${err === null || err === void 0 ? void 0 : err.message}`);
+            }
+        });
+    }
     registerRoutes(expressApp, httpServer, cliArgs, pluginArgs) {
         expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs));
         // The session gateway goes in front of Appium's routes: Xenon's own

package/lib/test/unit/PortAllocator.test.js

@@ -93,7 +93,7 @@ describe('PortAllocator', () => {
         (0, chai_1.expect)(deleteStub.calledWith({ where: { port: 9100 } })).to.be.true;
         (0, chai_1.expect)(createStub.called, 'should allocate a replacement lease').to.be.true;
     }));
-    it('releaseForUdid deletes all leases for that UDID', () => __awaiter(void 0, void 0, void 0, function* () {
+    it("releaseForUdid deletes that UDID's leases", () => __awaiter(void 0, void 0, void 0, function* () {
         deleteManyStub.resolves({ count: 2 });
         const allocator = makeAllocator({ wda: [8100, 8102] });
         yield allocator.releaseForUdid('udid-1');

package/lib/test/unit/boot-go-ios-reap.spec.js

@@ -0,0 +1,80 @@
+"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 typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const RecordingOrchestrator_1 = require("../../src/services/recording/RecordingOrchestrator");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * At boot Xenon reaps what a previous run left of go-ios (tunnels whose agents
+ * self-fork, WebDriverAgent runners, log streams). The reap kills every process
+ * running the vendored go-ios binary, so it also kills this process's own
+ * go-ios calls. It used to run last, after device detection had started:
+ * detection asks `ios info` about each plugged-in iPhone in the background,
+ * and those calls were killed ("Failed to fetch IP via go-ios" for every
+ * iPhone, at every boot). It now runs as soon as the database is ready,
+ * before this process starts go-ios at all.
+ */
+describe('reaping go-ios left by a previous run, at boot', () => {
+    let statics;
+    beforeEach(() => {
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    it('runs once the database is ready, before routes and device detection start', () => __awaiter(void 0, void 0, void 0, function* () {
+        const steps = [];
+        const step = (name) => () => {
+            steps.push(name);
+            return Promise.resolve();
+        };
+        const boot = ServerManager_1.ServerManager.prototype;
+        sinon_1.default.stub(boot, 'resolvePluginArgs').resolves({});
+        sinon_1.default.stub(logger_1.default, 'banner');
+        sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+        sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').callsFake(step('database config'));
+        sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(step('database and migrations'));
+        sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').callsFake(step('reap'));
+        // Everything that starts go-ios (device managers, detection, the hub's and
+        // node's discovery crons) comes after the routes; stop there.
+        sinon_1.default.stub(boot, 'registerRoutes').callsFake(() => {
+            steps.push('routes');
+            throw new Error('boot stopped by the test');
+        });
+        const booting = typedi_1.Container.get(ServerManager_1.ServerManager).updateServer({}, null, { port: 4723 });
+        yield booting.then(() => chai_1.expect.fail('the stubbed routes step should have stopped the boot'), (err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+        (0, chai_1.expect)(steps).to.deep.equal(['database config', 'database and migrations', 'reap', 'routes']);
+    }));
+    it('is not left to the plugin, which boots after detection has started', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(ServerManager_1.ServerManager.prototype, 'updateServer').resolves();
+        sinon_1.default.stub(RecordingOrchestrator_1.RecordingOrchestrator.prototype, 'recoverOnBoot').resolves();
+        const reap = sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').resolves();
+        yield plugin_1.XenonPlugin.updateServer({}, null, {});
+        (0, chai_1.expect)(reap.called).to.equal(false);
+    }));
+});

package/lib/test/unit/ios-discovery-same-host.spec.js

@@ -95,7 +95,6 @@ describe("iOS discovery takes only its own host's row for a udid", () => {
         });
         svc.trackingInitialized = true; // no usbmux listener
         sinon_1.default.stub(svc, 'getConnectedDevices').resolves(connected);
-        sinon_1.default.stub(svc, 'fetchRealDeviceNetworkIp').resolves(''); // no go-ios
         return svc;
     }
     beforeEach(() => {

package/lib/test/unit/ios-no-network-fallback.spec.js

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 axios_1 = __importDefault(require("axios"));
+const child_process_1 = __importDefault(require("child_process"));
+const events_1 = require("events");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const appium_ios_device_1 = require("appium-ios-device");
+const IOSDiscoveryService_1 = require("../../src/device-managers/ios/IOSDiscoveryService");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const WDAClient_1 = require("../../src/device-managers/ios/WDAClient");
+const ownDeviceRow = __importStar(require("../../src/device-managers/ownDeviceRow"));
+const device_store_1 = require("../../src/data-service/device-store");
+const deviceUtils = __importStar(require("../../src/device-utils"));
+const PluginContext_1 = require("../../src/PluginContext");
+const PortAllocator_1 = require("../../src/services/PortAllocator");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+/**
+ * Xenon never reaches WebDriverAgent over the network, only through the
+ * phone's own forwarded port on 127.0.0.1.
+ *
+ * An iPhone's network address was meant to come from go-ios `ios info`, which
+ * has no such value (its lockdown values carry no IPAddress), so detection
+ * asked for it on every pass for nothing. The fallbacks that used it never
+ * ran for an iPhone. A simulator's address is the Mac's own, so they sent a
+ * simulator's commands to this Mac's port 8100, which can be an iPhone's
+ * WebDriverAgent: WDA names no phone.
+ */
+const IP = '192.168.0.104';
+const PHONE = 'test-iphone-00008110-net';
+const ADDRESS = '10.9.8.7';
+describe('iOS: WebDriverAgent only through the phone’s own forwarded port', () => {
+    beforeEach(() => {
+        sinon_1.default.stub(process, 'kill');
+    });
+    afterEach(() => sinon_1.default.restore());
+    describe('detection', () => {
+        let commands;
+        function discovery() {
+            var _a;
+            const ctx = new PluginContext_1.PluginContext();
+            ctx.setContext(Object.assign({}, IPluginArgs_1.DefaultPluginArgs, { bindHostOrIp: IP }), 4724, 'test', '');
+            const svc = new IOSDiscoveryService_1.IOSDiscoveryService(ctx);
+            // resetTestContainer() stubs this on the prototype in a full run.
+            const proto = IOSDiscoveryService_1.IOSDiscoveryService.prototype;
+            svc.fetchLocalIOSDevices =
+                (_a = proto.fetchLocalIOSDevices.wrappedMethod) !== null && _a !== void 0 ? _a : proto.fetchLocalIOSDevices;
+            svc.trackingInitialized = true; // no usbmux listener
+            sinon_1.default.stub(svc, 'getConnectedDevices').resolves([PHONE]);
+            return svc;
+        }
+        beforeEach(() => {
+            commands = [];
+            // The go-ios binary is present, and every command it would run is recorded.
+            const exists = fs_extra_1.default.existsSync;
+            sinon_1.default
+                .stub(fs_extra_1.default, 'existsSync')
+                .callsFake((p) => String(p).endsWith('goIOS/ios') || exists(p));
+            sinon_1.default.stub(child_process_1.default, 'exec').callsFake(((cmd, ...rest) => {
+                commands.push(cmd);
+                const done = rest.find((a) => typeof a === 'function');
+                done === null || done === void 0 ? void 0 : done(null, '{}', '');
+                return new events_1.EventEmitter();
+            }));
+            sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({ findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) });
+            const real = typedi_1.Container.get.bind(typedi_1.Container);
+            sinon_1.default.stub(typedi_1.Container, 'get').callsFake((token) => {
+                if (token === PortAllocator_1.PortAllocator)
+                    return { tryAcquire: () => __awaiter(void 0, void 0, void 0, function* () { return 28400; }) };
+                if (token === IOSStreamService_1.default)
+                    return { getStreamStatus: () => undefined };
+                return real(token);
+            });
+            sinon_1.default.stub(deviceUtils, 'getUtilizationTime').resolves(0);
+            sinon_1.default.stub(appium_ios_device_1.utilities, 'getOSVersion').resolves('26.5');
+            sinon_1.default.stub(appium_ios_device_1.utilities, 'getDeviceName').resolves('iPhone 14 Plus');
+            sinon_1.default.stub(appium_ios_device_1.utilities, 'getDeviceInfo').rejects(new Error('no lockdown in tests'));
+        });
+        const asksForAnAddress = () => commands.filter((c) => /\binfo --udid\b/.test(c));
+        it('asks go-ios nothing about a known iPhone on each pass', () => __awaiter(void 0, void 0, void 0, function* () {
+            const own = { udid: PHONE, host: `http://${IP}:4724`, platform: 'ios', ip: '' };
+            const [phone] = yield discovery().fetchLocalIOSDevices([own]);
+            (0, chai_1.expect)(phone.udid).to.equal(PHONE);
+            (0, chai_1.expect)(asksForAnAddress()).to.deep.equal([]);
+        }));
+        it('asks go-ios nothing about the address of an iPhone it adds', () => __awaiter(void 0, void 0, void 0, function* () {
+            const phone = yield discovery().getDeviceInfo(PHONE);
+            (0, chai_1.expect)(phone.ip).to.equal('');
+            (0, chai_1.expect)(asksForAnAddress()).to.deep.equal([]);
+        }));
+    });
+    describe('WDAClient', () => {
+        it("retries a failed command on no host but 127.0.0.1, even with the phone's address", () => __awaiter(void 0, void 0, void 0, function* () {
+            const urls = [];
+            const refuse = (url) => __awaiter(void 0, void 0, void 0, function* () {
+                urls.push(url);
+                throw Object.assign(new Error(`connect ECONNREFUSED ${url}`), { code: 'ECONNREFUSED' });
+            });
+            sinon_1.default.stub(axios_1.default, 'post').callsFake(refuse);
+            sinon_1.default.stub(axios_1.default, 'get').callsFake(refuse);
+            sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: PHONE, wdaLocalPort: 28100, ip: ADDRESS }); }),
+            });
+            const real = typedi_1.Container.get.bind(typedi_1.Container);
+            sinon_1.default.stub(typedi_1.Container, 'get').callsFake((token) => {
+                if (token === IOSStreamService_1.default) {
+                    return {
+                        getStreamStatus: () => undefined,
+                        getWDASessionId: () => undefined,
+                        setWDASessionId: () => undefined,
+                    };
+                }
+                return real(token);
+            });
+            const err = yield new WDAClient_1.WDAClient()
+                .sendWDACommand(PHONE, 'post', '/wda/tap', { x: 10, y: 10 })
+                .then(() => null, (e) => e);
+            (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/ECONNREFUSED/);
+            (0, chai_1.expect)(urls).to.not.deep.equal([]);
+            (0, chai_1.expect)(urls.filter((u) => !u.startsWith('http://127.0.0.1:28100/'))).to.deep.equal([]);
+        }));
+    });
+    describe('the stream watchdog', () => {
+        let spawned;
+        function fakeProcess(exitCode) {
+            return Object.assign(new events_1.EventEmitter(), { exitCode, kill: () => true });
+        }
+        function streamWith(forwardExitCode) {
+            // Bypass the constructor: it starts watchdog intervals.
+            const svc = Object.create(IOSStreamService_1.default.prototype);
+            svc.sessions = new Map([
+                [
+                    PHONE,
+                    {
+                        udid: PHONE,
+                        status: 'running',
+                        wdaPort: 28100,
+                        mjpegPort: 29100,
+                        wdaProcess: fakeProcess(null),
+                        forwardWDAProcess: fakeProcess(forwardExitCode),
+                        forwardMJPEGProcess: fakeProcess(null),
+                    },
+                ],
+            ]);
+            return svc;
+        }
+        beforeEach(() => {
+            spawned = [];
+            sinon_1.default.stub(child_process_1.default, 'spawn').callsFake(((cmd, args) => {
+                spawned.push([cmd, ...(args !== null && args !== void 0 ? args : [])].join(' '));
+                return fakeProcess(null);
+            }));
+            // Something answers ready on the phone's address, port 8100; the
+            // phone's own forwarded port refuses.
+            sinon_1.default.stub(axios_1.default, 'get').callsFake(((url) => __awaiter(void 0, void 0, void 0, function* () {
+                if (url.startsWith(`http://${ADDRESS}:`))
+                    return { status: 200, data: { value: { ready: true } } };
+                throw Object.assign(new Error('connect ECONNREFUSED'), { code: 'ECONNREFUSED' });
+            })));
+            sinon_1.default.stub(ownDeviceRow, 'findOwnDevice').resolves({ udid: PHONE, ip: ADDRESS });
+        });
+        it('calls a stream whose forward died unresponsive, whatever answers on the network', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield streamWith(1).isStreamResponsive(PHONE)).to.equal(false);
+            (0, chai_1.expect)(spawned, 'no forward-only restart').to.deep.equal([]);
+        }));
+        it('calls a stream whose forward is hung unresponsive, whatever answers on the network', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield streamWith(null).isStreamResponsive(PHONE)).to.equal(false);
+            (0, chai_1.expect)(spawned, 'no forward-only restart').to.deep.equal([]);
+        }));
+    });
+});

package/lib/test/unit/ios-stream-appium-tunnel.spec.js

@@ -105,7 +105,6 @@ function iosService() {
     svc.startFlight = new singleFlight_1.SingleFlight();
     svc.recoveryCooldowns = new Map();
     svc.RECOVERY_COOLDOWN_MS = 30000;
-    svc.STREAM_PORT_TTL_MS = 90 * 60 * 1000;
     svc.goIOSPath = '/nonexistent/go-ios';
     return svc;
 }

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

@@ -89,7 +89,6 @@ function iosService() {
     svc.startFlight = new singleFlight_1.SingleFlight();
     svc.recoveryCooldowns = new Map();
     svc.RECOVERY_COOLDOWN_MS = 30000;
-    svc.STREAM_PORT_TTL_MS = 90 * 60 * 1000;
     svc.goIOSPath = '/nonexistent/go-ios';
     return svc;
 }

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

@@ -114,6 +114,7 @@ class TestTunnels extends IOSTunnels_1.IOSTunnels {
     sleep(ms) {
         return __awaiter(this, void 0, void 0, function* () {
             this.sleeps.push(ms);
+            this.clock += ms;
         });
     }
     killGroup(pid) {
@@ -150,7 +151,9 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
     it("leases a pair and starts the phone's own agent on it", () => __awaiter(void 0, void 0, void 0, function* () {
         const port = yield t.ensure(PHONE_A);
         (0, chai_1.expect)(port).to.equal(12100);
-        (0, chai_1.expect)(t.ports.acquirePair.calledOnceWithExactly('tunnel', PHONE_A, { ttlMs: IOSTunnels_1.TUNNEL_LEASE_TTL_MS })).to.equal(true);
+        (0, chai_1.expect)(t.ports.acquirePair.calledOnceWithExactly('tunnel', PHONE_A, {
+            ttlMs: IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS,
+        })).to.equal(true);
         (0, chai_1.expect)(t.spawned.map((s) => s.args)).to.deep.equal([
             ['tunnel', 'start', '--udid', PHONE_A, '--userspace', '--tunnel-info-port', '12100'],
         ]);
@@ -176,6 +179,25 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
         (0, chai_1.expect)(t.sleeps.reduce((a, b) => a + b, 0)).to.equal(IOSTunnels_1.TUNNEL_READY_TIMEOUT_MS);
         (0, chai_1.expect)(t.portFor(PHONE_A), 'still tracked').to.equal(12100);
     }));
+    it('goes on at the 20 s deadline when each check is slow to answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const started = t.clock;
+        t.answers = () => {
+            t.clock += 1000; // a check that runs into its 1 s timeout
+            return { state: 'unknown' };
+        };
+        (0, chai_1.expect)(yield t.ensure(PHONE_A)).to.equal(12100);
+        // At most the one check that was under way at the deadline.
+        (0, chai_1.expect)(t.clock - started).to.be.at.most(IOSTunnels_1.TUNNEL_READY_TIMEOUT_MS + 1000);
+    }));
+    it('outlives a second error from the tunnel process, and gives its ports back once', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield t.ensure(PHONE_A);
+        const proc = t.spawned[0].proc;
+        proc.emit('error', new Error('spawn EACCES'));
+        (0, chai_1.expect)(() => proc.emit('error', new Error('kill ESRCH'))).not.to.throw();
+        yield settle();
+        (0, chai_1.expect)(t.portFor(PHONE_A)).to.equal(undefined);
+        (0, chai_1.expect)(t.ports.release.callCount, 'P and P + 1, once each').to.equal(2);
+    }));
     it('fails the start when the tunnel exits before it is ready, and gives its ports back', () => __awaiter(void 0, void 0, void 0, function* () {
         t.answers = () => {
             t.spawned[0].proc.exit(1);
@@ -270,8 +292,8 @@ describe('IOSTunnels: a go-ios tunnel per iPhone', () => {
         yield t.touch(PHONE_A);
         yield t.touch(PHONE_B); // no tunnel: nothing to touch
         (0, chai_1.expect)(t.ports.touch.args).to.deep.equal([
-            [12100, IOSTunnels_1.TUNNEL_LEASE_TTL_MS],
-            [12101, IOSTunnels_1.TUNNEL_LEASE_TTL_MS],
+            [12100, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS],
+            [12101, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS],
         ]);
     }));
 });

package/lib/test/unit/port-allocator-pairs.spec.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
 const net_1 = __importDefault(require("net"));
+const prisma_1 = require("../../src/prisma");
 const PortAllocator_1 = require("../../src/services/PortAllocator");
 const scratch_port_leases_1 = require("../helpers/scratch-port-leases");
 /**
@@ -73,6 +74,31 @@ describe('PortAllocator.acquirePair (go-ios tunnel ports)', () => {
         (0, chai_1.expect)(yield a.acquirePair('tunnel', 'phone-b')).to.equal(b + 2);
         (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([b + 2, b + 3]);
     }));
+    it('gives two phones asking at once different pairs', () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const a = allocator([b, b + 9]);
+        const [first, second] = yield Promise.all([
+            a.acquirePair('tunnel', 'phone-a'),
+            a.acquirePair('tunnel', 'phone-b'),
+        ]);
+        (0, chai_1.expect)(first).to.not.equal(second);
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([first, first + 1]);
+        (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([second, second + 1]);
+    }));
+    it('gives the first port back when the second is taken mid-pair, and moves on', () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const create = prisma_1.prisma.portLease.create;
+        create.callsFake((args) => __awaiter(void 0, void 0, void 0, function* () {
+            if (args.data.port === b + 1 && args.data.leasedToUdid === 'phone-a') {
+                // Another phone takes P + 1 after the free ports were read.
+                yield leaseTo('phone-b', b + 1, 'tunnel');
+            }
+            return scratch.db.portLease.create(args);
+        }));
+        (0, chai_1.expect)(yield allocator([b, b + 5]).acquirePair('tunnel', 'phone-a')).to.equal(b + 2);
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([b + 2, b + 3]);
+        (0, chai_1.expect)(yield leasesOf('phone-b')).to.deep.equal([b + 1]);
+    }));
     it('skips a pair whose second port is leased, whatever for, and keeps none of it', () => __awaiter(void 0, void 0, void 0, function* () {
         const b = scratch.base;
         yield leaseTo('another-device', b + 1, 'wda');
@@ -99,6 +125,14 @@ describe('PortAllocator.acquirePair (go-ios tunnel ports)', () => {
         (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/tunnel/);
         (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([]);
     }));
+    it("releaseForUdid, when a session ends, leaves the phone's tunnel pair to its tunnel", () => __awaiter(void 0, void 0, void 0, function* () {
+        const b = scratch.base;
+        const a = allocator([b, b + 5]);
+        yield a.acquirePair('tunnel', 'phone-a');
+        yield leaseTo('phone-a', b + 50, 'wda');
+        yield a.releaseForUdid('phone-a');
+        (0, chai_1.expect)(yield leasesOf('phone-a')).to.deep.equal([b, b + 1]);
+    }));
     it("releasePurpose deletes only that purpose's leases", () => __awaiter(void 0, void 0, void 0, function* () {
         const b = scratch.base;
         const a = allocator([b, b + 5]);