@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/test/unit/logcat-ws.spec.js

@@ -73,6 +73,10 @@ function harness(over) {
         const mux = new LogcatMultiplexer_1.LogcatMultiplexer();
         const state = { startCalls: 0, authorizeCalls: 0, authorizeActors: [] };
         const server = http_1.default.createServer();
+        const connectionsClosed = [];
+        server.on('connection', (socket) => {
+            connectionsClosed.push(new Promise((r) => socket.once('close', () => r())));
+        });
         const userAuthorize = (_a = over.authorize) !== null && _a !== void 0 ? _a : (() => __awaiter(this, void 0, void 0, function* () { return true; }));
         const deps = {
             redeem: (_b = over.redeem) !== null && _b !== void 0 ? _b : (() => __awaiter(this, void 0, void 0, function* () { return ({ actorId: 'usr_alice' }); })),
@@ -109,6 +113,13 @@ function harness(over) {
             get authorizeActors() {
                 return state.authorizeActors;
             },
+            serverSawClose: () => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.all(connectionsClosed);
+                // ws emits the server WebSocket's 'close' from the TCP socket's 'close'
+                // listener, or from a process.nextTick after it (its receiver's
+                // 'finish'). Either has run by the event loop's next check phase.
+                yield new Promise((r) => setImmediate(r));
+            }),
             close: () => new Promise((r) => {
                 var _a;
                 // http.Server#close only fires its callback once every connection has
@@ -159,6 +170,50 @@ function connectCollecting(h_1) {
         return { code, got };
     });
 }
+/**
+ * Holds one handshake step until the test releases it, and says when the
+ * server has reached it, so a test acts while that step is in flight instead
+ * of guessing how long the steps before it take. Under load a fixed 50 ms
+ * wasn't enough: the client was still CONNECTING, and terminate() there
+ * raised an uncaught error.
+ */
+function heldStep() {
+    let enter = () => undefined;
+    let release = () => undefined;
+    const entered = new Promise((r) => (enter = r));
+    const released = new Promise((r) => (release = r));
+    return {
+        entered,
+        release,
+        /** For the stubbed step: marks it entered, then waits for the release. */
+        hold: () => __awaiter(this, void 0, void 0, function* () {
+            enter();
+            yield released;
+        }),
+    };
+}
+/**
+ * Connects, drops the connection once it is open and `step` is in flight,
+ * and resolves when the server has seen it go.
+ */
+function dropDuring(h, step) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ws = new ws_1.WebSocket(url(h.port));
+        // terminate() waits for 'open', so it never raises the 'error' it raises on
+        // a CONNECTING socket. Any other unhandled 'error' would be an uncaught
+        // exception, failing whichever test is running when it lands.
+        ws.on('error', () => undefined);
+        yield Promise.all([new Promise((r) => ws.once('open', r)), step.entered]);
+        ws.terminate();
+        yield h.serverSawClose();
+    });
+}
+/**
+ * Lets the handshake run on after a held step is released. Everything after
+ * a step is promise continuations (the harness's steps do no I/O), so it has
+ * all run by the event loop's next check phase.
+ */
+const handshakeSettled = () => new Promise((r) => setImmediate(r));
 describe('attachLogcatWs handshake', () => {
     it('accepts a valid ticket for a device the caller may use', () => __awaiter(void 0, void 0, void 0, function* () {
         const h = yield harness({});
@@ -265,26 +320,21 @@ describe('attachLogcatWs handshake', () => {
     // The trap documented in h264StreamWs: without cleanup registered before the
     // awaits, clientCount stays inflated and the idle watchdog never fires.
     it('leaves no client registered when the socket drops mid-handshake during redeem', () => __awaiter(void 0, void 0, void 0, function* () {
-        let release = () => undefined;
-        const gate = new Promise((r) => (release = r));
+        const step = heldStep();
         const h = yield harness({
             redeem: () => __awaiter(void 0, void 0, void 0, function* () {
-                yield gate;
+                yield step.hold();
                 return { actorId: 'usr_alice' };
             }),
         });
-        const ws = new ws_1.WebSocket(url(h.port));
-        yield new Promise((r) => setTimeout(r, 50));
-        ws.terminate(); // disconnect while redeem is still pending
-        // Let the server actually observe the close (a real socket teardown is a
-        // macrotask; resolving `gate` below is a same-tick microtask chain that
-        // would otherwise race ahead of it) BEFORE unblocking redeem. Otherwise
-        // this proves nothing about the post-redeem guard: the client could get
-        // registered first and only be torn down afterward by the 'close'
-        // listener firing late — same end state, different (unguarded) mechanism.
-        yield new Promise((r) => setTimeout(r, 100));
-        release();
-        yield new Promise((r) => setTimeout(r, 150));
+        // Disconnect while redeem is still pending, and let the server see the
+        // close BEFORE redeem resolves. Otherwise this proves nothing about the
+        // post-redeem guard: the client could get registered first and only be
+        // torn down afterward by the 'close' listener firing late — same end
+        // state, different (unguarded) mechanism.
+        yield dropDuring(h, step);
+        step.release();
+        yield handshakeSettled();
         (0, chai_1.expect)(h.mux.clientCount).to.equal(0);
         // The final clientCount alone can't distinguish "the post-redeem guard
         // short-circuited" from "a later guard cleaned up after the fact" — both
@@ -301,20 +351,16 @@ describe('attachLogcatWs handshake', () => {
     // session owner) when the caller disconnects. Same reasoning as the two
     // neighbours — the observable is the adb spawn that must not happen.
     it('leaves no client registered when the socket drops mid-handshake during authorize', () => __awaiter(void 0, void 0, void 0, function* () {
-        let release = () => undefined;
-        const gate = new Promise((r) => (release = r));
+        const step = heldStep();
         const h = yield harness({
             authorize: () => __awaiter(void 0, void 0, void 0, function* () {
-                yield gate;
+                yield step.hold();
                 return true;
             }),
         });
-        const ws = new ws_1.WebSocket(url(h.port));
-        yield new Promise((r) => setTimeout(r, 50));
-        ws.terminate(); // disconnect while authorize is still pending
-        yield new Promise((r) => setTimeout(r, 100));
-        release();
-        yield new Promise((r) => setTimeout(r, 150));
+        yield dropDuring(h, step); // disconnect while authorize is still pending
+        step.release();
+        yield handshakeSettled();
         (0, chai_1.expect)(h.authorizeCalls, 'authorize was already in flight').to.equal(1);
         (0, chai_1.expect)(h.startCalls, 'must not start a logcat process once the caller is gone').to.equal(0);
         (0, chai_1.expect)(h.mux.clientCount).to.equal(0);
@@ -324,25 +370,20 @@ describe('attachLogcatWs handshake', () => {
     // but startStream (which can shell out to adb) is still in flight when the
     // caller disconnects.
     it('leaves no client registered when the socket drops mid-handshake during startStream', () => __awaiter(void 0, void 0, void 0, function* () {
-        let release = () => undefined;
-        const gate = new Promise((r) => (release = r));
+        const step = heldStep();
         const gatedMux = new LogcatMultiplexer_1.LogcatMultiplexer();
         const h = yield harness({
             startStream: () => __awaiter(void 0, void 0, void 0, function* () {
-                yield gate;
+                yield step.hold();
                 return { mux: gatedMux };
             }),
         });
-        const ws = new ws_1.WebSocket(url(h.port));
-        yield new Promise((r) => setTimeout(r, 50));
-        ws.terminate(); // disconnect while startStream is still pending
-        // See the matching comment in the redeem-timing test above: give the
-        // server's close listener time to actually run before startStream
-        // resolves, or this races the wrong way and proves nothing about the
-        // post-startStream guard.
-        yield new Promise((r) => setTimeout(r, 100));
-        release();
-        yield new Promise((r) => setTimeout(r, 150));
+        // As in the redeem test above: the server sees the close before
+        // startStream resolves, or this proves nothing about the post-startStream
+        // guard.
+        yield dropDuring(h, step);
+        step.release();
+        yield handshakeSettled();
         (0, chai_1.expect)(gatedMux.clientCount).to.equal(0);
         yield h.close();
     }));

package/lib/test/unit/logger-json-levels.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const logger_1 = require("../../src/logger");
+/**
+ * In JSON log mode every line was written through Appium's `info`, whatever
+ * its level: a debug line printed at `--log-level info`, and an error went to
+ * stdout, since Appium's console sends only its `error` level to stderr. Each
+ * line now goes out at its own level, as in text mode.
+ */
+describe('XenonLogger in JSON mode writes each line at its own level', () => {
+    let wasJson;
+    let base;
+    let logger;
+    beforeEach(() => {
+        wasJson = logger_1.XenonLogger.isJsonLogging;
+        logger_1.XenonLogger.configure({ enableJsonLogging: true });
+        base = {
+            debug: sinon_1.default.stub(),
+            info: sinon_1.default.stub(),
+            warn: sinon_1.default.stub(),
+            error: sinon_1.default.stub(),
+        };
+        logger = new logger_1.XenonLogger('probe');
+        logger.baseLogger = base;
+    });
+    afterEach(() => {
+        logger_1.XenonLogger.configure({ enableJsonLogging: wasJson });
+    });
+    for (const level of ['debug', 'info', 'warn', 'error']) {
+        it(level, () => {
+            logger[level](`a ${level} line`);
+            const written = Object.keys(base).filter((l) => base[l].called);
+            (0, chai_1.expect)(written).to.deep.equal([level]);
+            const entry = JSON.parse(base[level].firstCall.args[0]);
+            (0, chai_1.expect)(entry.level).to.equal(level);
+            (0, chai_1.expect)(entry.message).to.equal(`a ${level} line`);
+        });
+    }
+});

package/lib/test/unit/mcp-token-ttl.spec.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const mcpTokenTtl_1 = require("../../src/services/token/mcpTokenTtl");
+/**
+ * XENON_MCP_TOKEN_TTL_SEC=abc made every xenon-mcp token's lifetime NaN.
+ * A value that isn't a whole number of seconds above 0 now warns and keeps
+ * the default.
+ */
+describe('XENON_MCP_TOKEN_TTL_SEC', () => {
+    it('is the default (a day) when unset or empty, without a warning', () => {
+        const warn = sinon_1.default.stub();
+        (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)(undefined, warn)).to.equal(86400);
+        (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)('', warn)).to.equal(86400);
+        (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)('  ', warn)).to.equal(86400);
+        (0, chai_1.expect)(mcpTokenTtl_1.DEFAULT_MCP_TOKEN_TTL_SEC).to.equal(86400);
+        (0, chai_1.expect)(warn.called).to.equal(false);
+    });
+    it('is the number of seconds it gives', () => {
+        const warn = sinon_1.default.stub();
+        (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)('3600', warn)).to.equal(3600);
+        (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)(' 120 ', warn)).to.equal(120);
+        (0, chai_1.expect)(warn.called).to.equal(false);
+    });
+    for (const bad of ['abc', '0', '-60', '1.5', '1e400', 'Infinity', '12s']) {
+        it(`warns and keeps the default for "${bad}"`, () => {
+            const warn = sinon_1.default.stub();
+            (0, chai_1.expect)((0, mcpTokenTtl_1.mcpTokenTtlSec)(bad, warn)).to.equal(86400);
+            (0, chai_1.expect)(warn.calledOnce).to.equal(true);
+            (0, chai_1.expect)(warn.firstCall.args[0]).to.include('XENON_MCP_TOKEN_TTL_SEC');
+            (0, chai_1.expect)(warn.firstCall.args[0]).to.include(bad);
+        });
+    }
+});

package/lib/test/unit/node-device-log-store.spec.js

@@ -0,0 +1,102 @@
+"use strict";
+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 NodeDeviceLogStore_1 = require("../../src/services/logcat/NodeDeviceLogStore");
+const nodeDeviceLogs_1 = require("../../src/services/logcat/nodeDeviceLogs");
+const row = (n) => ({ message: `line ${n}`, timestamp: new Date(1000 + n) });
+const rows = (from, to) => Array.from({ length: to - from + 1 }, (_, i) => row(from + i));
+describe('NodeDeviceLogStore: a node holds a session’s device log lines for its hub', () => {
+    let now;
+    let store;
+    beforeEach(() => {
+        now = 1000000;
+        store = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+        store.now = () => now;
+    });
+    it('numbers each line, and answers every one without `after`', () => {
+        store.begin('s1');
+        store.add('s1', [row(1), row(2)]);
+        store.add('s1', [row(3)]);
+        (0, chai_1.expect)(store.read('s1', null)).to.deep.equal({
+            state: 'recording',
+            more: false,
+            lines: [
+                { seq: 1, message: 'line 1', timestamp: 1001 },
+                { seq: 2, message: 'line 2', timestamp: 1002 },
+                { seq: 3, message: 'line 3', timestamp: 1003 },
+            ],
+        });
+    });
+    it('drops what the hub has: the lines at or before `after`', () => {
+        store.begin('s1');
+        store.add('s1', rows(1, 3));
+        (0, chai_1.expect)(store.read('s1', 2).lines.map((l) => l.seq)).to.deep.equal([3]);
+        // Gone for good, even to an ask that names none.
+        (0, chai_1.expect)(store.read('s1', null).lines.map((l) => l.seq)).to.deep.equal([3]);
+        store.add('s1', [row(4)]);
+        (0, chai_1.expect)(store.read('s1', 3).lines.map((l) => l.seq)).to.deep.equal([4]);
+    });
+    it(`answers at most ${nodeDeviceLogs_1.NODE_DEVICE_LOG_PAGE} lines at a time, and says there are more`, () => {
+        store.begin('s1');
+        store.add('s1', rows(1, nodeDeviceLogs_1.NODE_DEVICE_LOG_PAGE + 5));
+        const first = store.read('s1', null);
+        (0, chai_1.expect)(first.lines).to.have.length(nodeDeviceLogs_1.NODE_DEVICE_LOG_PAGE);
+        (0, chai_1.expect)(first.more).to.equal(true);
+        const second = store.read('s1', nodeDeviceLogs_1.NODE_DEVICE_LOG_PAGE);
+        (0, chai_1.expect)(second.lines.map((l) => l.seq)).to.deep.equal([1, 2, 3, 4, 5].map((n) => nodeDeviceLogs_1.NODE_DEVICE_LOG_PAGE + n));
+        (0, chai_1.expect)(second.more).to.equal(false);
+    });
+    it('says a session ended, and keeps it 10 minutes for the hub’s last ask', () => {
+        store.begin('s1');
+        store.add('s1', rows(1, 2));
+        store.end('s1');
+        (0, chai_1.expect)(store.read('s1', null).state).to.equal('ended');
+        now += nodeDeviceLogs_1.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS - 1;
+        (0, chai_1.expect)(store.read('s1', 1).lines.map((l) => l.seq)).to.deep.equal([2]);
+        now += 1;
+        (0, chai_1.expect)(store.read('s1', null)).to.deep.equal({ state: 'off', lines: [], more: false });
+    });
+    it('forgets an ended session 10 minutes on, though nothing else happens', () => {
+        const clock = sinon_1.default.useFakeTimers({ now });
+        try {
+            const timed = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+            timed.begin('s1');
+            timed.add('s1', rows(1, 3));
+            timed.end('s1');
+            clock.tick(nodeDeviceLogs_1.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS);
+            (0, chai_1.expect)(timed.entries.has('s1')).to.equal(false);
+        }
+        finally {
+            clock.restore();
+        }
+    });
+    it('forgets an ended session nobody asks about, at the next session', () => {
+        store.begin('s1');
+        store.end('s1');
+        now += nodeDeviceLogs_1.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS;
+        store.begin('s2');
+        (0, chai_1.expect)(store.entries.has('s1')).to.equal(false);
+    });
+    it('says off for a session it holds nothing for, and keeps nothing for it', () => {
+        store.add('nobody', rows(1, 2));
+        (0, chai_1.expect)(store.read('nobody', null)).to.deep.equal({ state: 'off', lines: [], more: false });
+    });
+    it('knows whether a hub has asked about a session', () => {
+        store.begin('s1');
+        (0, chai_1.expect)(store.claimed('s1')).to.equal(false);
+        store.read('s1', null);
+        (0, chai_1.expect)(store.claimed('s1')).to.equal(true);
+        (0, chai_1.expect)(store.claimed('unknown')).to.equal(false);
+    });
+    it('forgets a session it was told to', () => {
+        store.begin('s1');
+        store.add('s1', rows(1, 2));
+        store.forget('s1');
+        (0, chai_1.expect)(store.read('s1', null).state).to.equal('off');
+    });
+});