@xenon-device-management/xenon 2.1.0 → 2.3.0

package/lib/src/generated/client/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-2fecbe6024329bf05b69cdf448f1b687e32645450beda6a210a882d44a7ffb8d",
+  "name": "prisma-client-631e8540dfbb77c390eb0db189885974a87d3fa754d038cb48bcc6a9f3489314",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",

package/lib/src/generated/client/schema.prisma

@@ -204,6 +204,10 @@ model Device {
   // On a hub, what the phone's node last reported: busy there. `busy` is the
   // claim OR this. Always false for a phone this server drives.
   nodeBusy                     Boolean? @default(false)
+  // On a hub, who holds the phone there: the preview hold (manual_<user>_<udid>)
+  // in the node's report of its session_id, else null. Shown, never judged:
+  // the node decides access. Always null for a phone this server drives.
+  nodeHold                     String?
 
   @@id([udid, host])
   @@index([owningSessionId])

package/lib/src/generated/client/wasm.js

@@ -285,7 +285,8 @@ exports.Prisma.DeviceScalarFieldEnum = {
   teamId: 'teamId',
   claimSessionId: 'claimSessionId',
   claimedAt: 'claimedAt',
-  nodeBusy: 'nodeBusy'
+  nodeBusy: 'nodeBusy',
+  nodeHold: 'nodeHold'
 };
 
 exports.Prisma.PendingSessionScalarFieldEnum = {

package/lib/src/middleware/deviceAccessGuard.js

@@ -21,6 +21,7 @@ const controlDevice_1 = require("./controlDevice");
 const SessionOwnerResolver_1 = require("../services/device-access/SessionOwnerResolver");
 const deviceAccessPolicy_1 = require("../services/device-access/deviceAccessPolicy");
 const actor_1 = require("../services/device-access/actor");
+const deviceClaims_1 = require("../data-service/deviceClaims");
 const STATE_CHANGING = new Set(['POST', 'PUT', 'DELETE', 'PATCH']);
 /**
  * Mutations under /control that this guard must NOT handle.
@@ -129,7 +130,9 @@ function deviceAccessGuard(deps = {}) {
             }
             const decision = (0, deviceAccessPolicy_1.evaluateDeviceAccess)({
                 udid,
-                busy: !!device.busy,
+                // Not device.busy: a node's phone busy only by its node's report is
+                // the node's to judge (heldHere).
+                busy: (0, deviceClaims_1.heldHere)(device),
                 sessionId: device.session_id,
                 sessionOwnerUserId,
                 actorUserId: actor.userId,

package/lib/src/services/ServerManager.js

@@ -63,6 +63,7 @@ const networkAddresses_1 = require("../helpers/networkAddresses");
 const logger_1 = __importDefault(require("../logger"));
 const h264StreamWs_1 = require("../app/ws/h264StreamWs");
 const logcatWs_1 = require("../app/ws/logcatWs");
+const nodeSocketRelay_1 = require("../app/ws/nodeSocketRelay");
 const upgradeRouter_1 = require("../app/ws/upgradeRouter");
 const StreamTicketService_1 = require("./token/StreamTicketService");
 const AndroidH264StreamService_1 = __importDefault(require("../device-managers/android/AndroidH264StreamService"));
@@ -147,6 +148,8 @@ let ServerManager = ServerManager_1 = class ServerManager {
                     // streaming.androidH264 config itself, so this WS auto-start honours a
                     // { source: 'screenrecord' } rollback just like the REST stream/start.
                     startStream: (udid) => typedi_1.Container.get(AndroidH264StreamService_1.default).start(udid),
+                    // A node's phone is streamed by its node and relayed from here.
+                    nodeSocket: (udid, actor) => (0, nodeSocketRelay_1.openNodeSocket)({ udid, actor, path: 'stream/h264' }),
                 });
                 // Continuous logcat WebSocket (Android; replaces the 3s dump-poll).
                 // A route of the upgrade router: only /logcat upgrades reach it.
@@ -191,6 +194,16 @@ let ServerManager = ServerManager_1 = class ServerManager {
                         // server-side level filter applies.
                         return { mux: yield typedi_1.Container.get(LogcatStreamService_1.LogcatStreamService).start(udid) };
                     }),
+                    // A node's phone: its node streams the log, with the same filter.
+                    nodeSocket: (udid, actor, filter) => {
+                        var _a;
+                        return (0, nodeSocketRelay_1.openNodeSocket)({
+                            udid,
+                            actor,
+                            path: 'logcat',
+                            query: new URLSearchParams(Object.assign(Object.assign({}, (((_a = filter.levels) === null || _a === void 0 ? void 0 : _a.length) ? { levels: filter.levels.join(',') } : {})), (filter.process ? { process: filter.process } : {}))),
+                        });
+                    },
                 });
             }
             // Principal Cleaning: Attempt to recover remote sessions before marking as failed

package/lib/src/services/device-access/ticketActorAccess.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTicketActorAuthorizer = makeTicketActorAuthorizer;
 const manualLock_1 = require("../recording/manualLock");
 const deviceAccessPolicy_1 = require("./deviceAccessPolicy");
+const deviceClaims_1 = require("../../data-service/deviceClaims");
 /**
  * Build the ownership check for a caller authenticated by a stream ticket.
  *
@@ -54,7 +55,8 @@ function makeTicketActorAuthorizer(deps) {
                 : null;
             return (0, deviceAccessPolicy_1.evaluateDeviceAccess)({
                 udid,
-                busy: !!device.busy,
+                // heldHere, as deviceAccessGuard reads it.
+                busy: (0, deviceClaims_1.heldHere)(device),
                 sessionId: device.session_id,
                 sessionOwnerUserId,
                 // The ticket's actorId is a User id — see StreamTicketService.

package/lib/src/services/lease/LeaseOrphanSweeper.js

@@ -36,11 +36,13 @@ const logger_1 = __importDefault(require("../../logger"));
  */
 function leaseReapReason(lease, now) {
     var _a;
+    // The end time first: past it, heartbeats are refused, so a lease that
+    // expired has missed its heartbeats too by the next sweep.
+    if (lease.expiresAt < now)
+        return `expired at ${new Date(lease.expiresAt).toISOString()}`;
     const thresholdMs = ((_a = lease.heartbeatSeconds) !== null && _a !== void 0 ? _a : 30) * 1000 * 3;
     if (lease.lastHeartbeatAt + thresholdMs < now)
         return 'missed heartbeats';
-    if (lease.expiresAt < now)
-        return `expired at ${new Date(lease.expiresAt).toISOString()}`;
     return null;
 }
 let LeaseOrphanSweeper = class LeaseOrphanSweeper {

package/lib/test/helpers/own-node-id.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OWN_NODE_ID = void 0;
+exports.useOwnNodeId = useOwnNodeId;
+const typedi_1 = require("typedi");
+const PluginContext_1 = require("../../src/PluginContext");
+/**
+ * The node id of "this server" in a spec, for fake rows that are its own
+ * phones. /control sends another server's phone's actions to that server
+ * (src/app/routers/nodePhoneControl.ts) and decides whose a phone is by its
+ * row's nodeId, which discovery always writes. A fake row without one, whose
+ * host isn't one of this server's, is another server's phone.
+ */
+exports.OWN_NODE_ID = 'this-server';
+/**
+ * Give the PluginContext OWN_NODE_ID for each test of the enclosing
+ * `describe`, and put the old one back after it. Call it inside a describe.
+ */
+function useOwnNodeId() {
+    let saved = '';
+    beforeEach(() => {
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = context.nodeId;
+        context.nodeId = exports.OWN_NODE_ID;
+    });
+    afterEach(() => {
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeId = saved;
+    });
+}

package/lib/test/setup/scratch-default-database.js

@@ -0,0 +1,32 @@
+"use strict";
+// Loaded with --require by `npm run test:all`, before any spec.
+//
+// src/config.ts reads DATABASE_URL once, at import time, and falls back to
+// ~/.cache/xenon/xenon.db. Specs that don't stub the store (EventLogService,
+// MetricsService and others writing in passing) used to write their rows into
+// that file, the database a developer's own server uses. This points the whole
+// run at a freshly migrated scratch file instead, and removes it at exit.
+// Specs that need a database of their own still use useScratchDatabase().
+/* eslint-disable @typescript-eslint/no-var-requires -- plain CommonJS, loaded before ts-node */
+const { execSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const dbPath = path.join(os.tmpdir(), `xenon-test-run-${process.pid}-${Date.now()}.db`);
+const url = `file:${dbPath}`;
+execSync('npx prisma migrate deploy', {
+    cwd: path.resolve(__dirname, '../..'),
+    env: Object.assign(Object.assign({}, process.env), { DATABASE_URL: url }),
+    stdio: 'pipe',
+});
+process.env.DATABASE_URL = url;
+process.on('exit', () => {
+    for (const f of [dbPath, `${dbPath}-journal`]) {
+        try {
+            fs.unlinkSync(f);
+        }
+        catch (_a) {
+            // already gone
+        }
+    }
+});

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

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const sinon_1 = __importDefault(require("sinon"));
+const AndroidDeviceManager_1 = require("../../src/device-managers/AndroidDeviceManager");
 const adbkit_1 = __importDefault(require("@devicefarmer/adbkit"));
 const appium_adb_1 = require("appium-adb");
 const chai_1 = require("chai");
@@ -165,6 +166,43 @@ describe('Android Device Manager', () => {
         (0, chai_1.expect)(devices.length).to.be.equal(1);
         (0, chai_1.expect)(devices[0]).to.have.property('udid', 'emulator-7777');
     }));
+    // adb install answers when the phone has installed the app, and appium-adb
+    // cut every adbExec at 20 s (adbExecTimeout): an install that took longer
+    // was reported as failed though it had worked.
+    it('gives adb install as long as an install takes, not adbExec’s 20 s', () => __awaiter(void 0, void 0, void 0, function* () {
+        const manager = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        const adbExec = sandbox.stub().resolves('Success');
+        sandbox.stub(manager, 'getAdb').resolves({ adbInstance: { adbExec } });
+        yield manager.installApp('p1', '/tmp/app.apk');
+        (0, chai_1.expect)(adbExec.firstCall.args[0]).to.deep.equal(['-s', 'p1', 'install', '-r', '/tmp/app.apk']);
+        (0, chai_1.expect)(adbExec.firstCall.args[1]).to.deep.equal({ timeout: AndroidDeviceManager_1.ANDROID_INSTALL_TIMEOUT_MS });
+        (0, chai_1.expect)(AndroidDeviceManager_1.ANDROID_INSTALL_TIMEOUT_MS).to.be.at.least(5 * 60000);
+    }));
+    // A phone adb reports as plugged (and every phone connected when the server
+    // starts) went through onDeviceAdded with no androidDeviceType check: a
+    // hub set to emulators only listed a real phone until its next sync pruned
+    // it, and could hand it to a session meanwhile.
+    describe('a plugged phone', () => {
+        const plug = (androidDeviceType, real) => __awaiter(void 0, void 0, void 0, function* () {
+            const manager = (0, test_container_1.createTestAndroidManager)({ platform: 'android', androidDeviceType });
+            sandbox.stub(manager, 'waitBootComplete').resolves(true);
+            sandbox.stub(manager, 'isRealDevice').resolves(real);
+            // Stands for the rest of the add: the port lease, the row, the hub.
+            const deviceInfo = sandbox.stub(manager, 'deviceInfo').resolves(undefined);
+            yield manager.onDeviceAdded(adb, { id: 'plugged-1', type: 'device' });
+            return deviceInfo.called;
+        });
+        it('is ignored when the server doesn’t serve its kind', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield plug('simulated', true), 'a real phone, emulators only').to.equal(false);
+            (0, chai_1.expect)(yield plug('real', false), 'an emulator, real phones only').to.equal(false);
+        }));
+        it('is added when the server serves its kind', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield plug('simulated', false)).to.equal(true);
+            (0, chai_1.expect)(yield plug('real', true)).to.equal(true);
+            (0, chai_1.expect)(yield plug('both', true)).to.equal(true);
+            (0, chai_1.expect)(yield plug('both', false)).to.equal(true);
+        }));
+    });
     it('should handle device never completing boot', () => __awaiter(void 0, void 0, void 0, function* () {
         const androidDevices = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
         // @ts-expect-error - Accessing private member for testing
@@ -183,3 +221,25 @@ describe('Android Device Manager', () => {
         }).to.not.throw();
     }));
 });
+// The one rule discovery and a plugged phone both apply.
+describe('includesAndroidDevice', () => {
+    const real = { deviceType: 'real', state: 'device' };
+    const emulator = { deviceType: 'emulator', state: 'device' };
+    const offlineEmulator = { deviceType: 'emulator', state: 'offline' };
+    it('real: real phones only', () => {
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(real, 'real')).to.equal(true);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(emulator, 'real')).to.equal(false);
+    });
+    it('simulated: emulators only, booted ones when bootedEmulators is on', () => {
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(real, 'simulated')).to.equal(false);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(emulator, 'simulated')).to.equal(true);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(offlineEmulator, 'simulated')).to.equal(true);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(offlineEmulator, 'simulated', true)).to.equal(false);
+    });
+    it('both: everything, emulators booted when bootedEmulators is on', () => {
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(real, 'both')).to.equal(true);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(emulator, 'both', true)).to.equal(true);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(offlineEmulator, 'both', true)).to.equal(false);
+        (0, chai_1.expect)((0, AndroidDeviceManager_1.includesAndroidDevice)(Object.assign(Object.assign({}, real), { state: 'offline' }), 'both', true)).to.equal(true);
+    });
+});

package/lib/test/unit/android-h264-service.spec.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (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 AndroidH264StreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidH264StreamService"));
 const PluginContext_1 = require("../../src/PluginContext");
@@ -50,6 +51,23 @@ describe('AndroidH264StreamService', () => {
         (0, chai_1.expect)(mux).to.equal(svc.getMultiplexer('udid-x'));
         (0, chai_1.expect)(mux.clientCount).to.equal(0);
     }));
+    it('start() leaves no timer behind once the config packet arrives', () => __awaiter(void 0, void 0, void 0, function* () {
+        const clock = sinon_1.default.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+        try {
+            const svc = make();
+            svc.openCapture = (_udid, onPacket) => __awaiter(void 0, void 0, void 0, function* () {
+                onPacket({ type: 'config', data: Buffer.from([0]), ptsMs: 0 });
+                return { kill: () => undefined };
+            });
+            yield svc.start('udid-t');
+            // The 3 s wait is only a cap: a start that got its config in time must
+            // not leave it pending for the process to wait out.
+            (0, chai_1.expect)(clock.countTimers()).to.equal(0);
+        }
+        finally {
+            clock.restore();
+        }
+    }));
     it('start() is idempotent per udid (concurrent starts share one capture)', () => __awaiter(void 0, void 0, void 0, function* () {
         const svc = make();
         let opens = 0;

package/lib/test/unit/clipboard-route.spec.js

@@ -26,6 +26,7 @@ const clipboardErrors_1 = require("../../src/device-managers/clipboardErrors");
 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");
 /**
  * GET/POST /control/:udid/clipboard answered 200 whatever happened on the
  * device: the Android manager swallowed its errors, and its "set" had no
@@ -58,6 +59,8 @@ function buildApp() {
     return app;
 }
 describe('GET/POST /control/:udid/clipboard', () => {
+    // The fake rows are this server's own phones.
+    (0, own_node_id_1.useOwnNodeId)();
     let manager;
     let restoreContainer;
     // Served on 127.0.0.1, not by request(app): that listens on every address
@@ -73,6 +76,7 @@ describe('GET/POST /control/:udid/clipboard', () => {
                 return ({
                     udid: UDID,
                     host: '127.0.0.1',
+                    nodeId: own_node_id_1.OWN_NODE_ID,
                     platform: 'android',
                     busy: false,
                     session_id: null,

package/lib/test/unit/control-forward-decision.spec.js

@@ -21,11 +21,11 @@ const typedi_1 = require("typedi");
 const control_1 = __importDefault(require("../../src/app/routers/control"));
 const device_store_1 = require("../../src/data-service/device-store");
 const device_managers_1 = require("../../src/device-managers");
-const InternalHttpClient_1 = require("../../src/InternalHttpClient");
 const PluginContext_1 = require("../../src/PluginContext");
 const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
 const authMiddleware_1 = require("../../src/middleware/authMiddleware");
 const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
 /**
  * Whether a /control action is forwarded to another server is decided by the
  * phone's own row (its nodeId, else its exact host against this server's own
@@ -64,8 +64,8 @@ function buildApp() {
     return app;
 }
 describe('/control forwards only another server’s phone', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
     let manager;
-    let post;
     let restore;
     let context;
     let savedContext;
@@ -80,13 +80,13 @@ describe('/control forwards only another server’s phone', () => {
         sinon_1.default
             .stub(device_store_1.DeviceStoreFactory, 'getStore')
             .returns({ findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return (Object.assign({}, device)); }) });
-        post = sinon_1.default.stub(InternalHttpClient_1.InternalHttpClient, 'post').resolves({ data: {} });
     });
-    afterEach(() => {
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
         Object.assign(context, savedContext);
         sinon_1.default.restore();
         restore();
-    });
+        yield loopback.closeAll();
+    }));
     const tap = (udid, hostHeader) => (0, loopbackRequest_1.default)(buildApp())
         .post(`/xenon/api/control/${udid}/tap`)
         .set('Host', hostHeader)
@@ -96,20 +96,20 @@ describe('/control forwards only another server’s phone', () => {
         const res = yield tap('own-1', 'localhost:4723');
         (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
         (0, chai_1.expect)(manager.taps).to.deep.equal(['own-1']);
-        (0, chai_1.expect)(post.called, 'never forwarded to itself').to.equal(false);
     }));
-    it('forwards a node’s phone once, never retried', () => __awaiter(void 0, void 0, void 0, function* () {
-        device = {
-            udid: 'node-phone',
-            host: 'http://10.0.0.9:4725',
-            nodeId: 'node-9',
-            platform: 'android',
-        };
+    it('forwards a node’s phone once, never retried, and relays its answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        const hits = [];
+        node.use((req, res) => {
+            hits.push(req.originalUrl);
+            res.status(503).json({ error: 'node busy' });
+        });
+        const nodeOrigin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        device = { udid: 'node-phone', host: nodeOrigin, nodeId: 'node-9', platform: 'android' };
         const res = yield tap('node-phone', '192.168.0.104:4723');
-        (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+        (0, chai_1.expect)(res.status).to.equal(503);
+        (0, chai_1.expect)(res.body).to.deep.equal({ error: 'node busy' });
         (0, chai_1.expect)(manager.taps).to.deep.equal([]);
-        (0, chai_1.expect)(post.calledOnce).to.equal(true);
-        (0, chai_1.expect)(post.firstCall.args[0]).to.equal('http://10.0.0.9:4725/xenon/api/control/node-phone/tap');
-        (0, chai_1.expect)(post.firstCall.args[2]).to.include({ retry: false });
+        (0, chai_1.expect)(hits).to.deep.equal(['/xenon/api/control/node-phone/tap']);
     }));
 });

package/lib/test/unit/device-access-guard.spec.js

@@ -261,3 +261,41 @@ describe('deviceAccessGuard', () => {
         (0, chai_1.expect)(res.body.reached).to.equal(true);
     }));
 });
+/**
+ * On a hub, a node's phone is busy when its node reports it busy (nodeBusy):
+ * a preview the node holds, say. The hub has no holder on record for that:
+ * no session and no hold of its own. Failing closed on "busy, owner unknown"
+ * refused every non-admin, the preview's own holder included, so the hub
+ * leaves that decision to the node, whose own guard knows the holder and
+ * judges every call the hub forwards. What the hub holds itself (a claim, a
+ * session, a hold) it still judges.
+ */
+describe('deviceAccessGuard on a node’s phone', () => {
+    const nodePhone = (row) => appWith({ actorUserId: BOB, findDeviceImpl: () => __awaiter(void 0, void 0, void 0, function* () { return row; }), sessionOwner: ALICE });
+    it('leaves a phone busy only by its node’s report to the node', () => __awaiter(void 0, void 0, void 0, function* () {
+        const app = nodePhone({ busy: true, nodeBusy: true, session_id: null });
+        const tap = yield (0, loopbackRequest_1.default)(app).post(`/control/${UDID}/tap`);
+        (0, chai_1.expect)(tap.status).to.equal(200);
+        (0, chai_1.expect)(tap.body.reached).to.equal(true);
+        const logs = yield (0, loopbackRequest_1.default)(app).get(`/control/${UDID}/logs`);
+        (0, chai_1.expect)(logs.status).to.equal(200);
+    }));
+    it('still judges a session this server routed to the node', () => __awaiter(void 0, void 0, void 0, function* () {
+        const tap = yield (0, loopbackRequest_1.default)(nodePhone({
+            busy: true,
+            nodeBusy: true,
+            session_id: 'appium-1',
+            claimSessionId: 'appium-1',
+        })).post(`/control/${UDID}/tap`);
+        (0, chai_1.expect)(tap.status).to.equal(409);
+        (0, chai_1.expect)(tap.body.error).to.equal('device_in_use_by_session');
+    }));
+    it('still refuses while this server’s own create for the phone is pending', () => __awaiter(void 0, void 0, void 0, function* () {
+        const tap = yield (0, loopbackRequest_1.default)(nodePhone({ busy: true, nodeBusy: true, session_id: null, claimedAt: 1790000000000 })).post(`/control/${UDID}/tap`);
+        (0, chai_1.expect)(tap.status).to.equal(409);
+    }));
+    it('still refuses this server’s own phone busy with no holder on record', () => __awaiter(void 0, void 0, void 0, function* () {
+        const tap = yield (0, loopbackRequest_1.default)(nodePhone({ busy: true, session_id: null })).post(`/control/${UDID}/tap`);
+        (0, chai_1.expect)(tap.status).to.equal(409);
+    }));
+});