@xenon-device-management/xenon 2.1.0 → 2.2.0

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,31 @@ 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');
     }));
+    // 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 +209,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);
+    }));
+});