@xenon-device-management/xenon 2.15.0 → 2.16.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/observability-example-loki.spec.js

@@ -0,0 +1,25 @@
+"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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+/**
+ * The example Loki config set `limits_config.retention_period: 24h`, but Loki
+ * deletes nothing unless its compactor runs retention, so the logs it kept
+ * grew for ever. Loki 3 also refuses to start with retention enabled and no
+ * store for delete requests.
+ */
+describe('examples/observability/loki.yml', () => {
+    const config = js_yaml_1.default.load(fs_1.default.readFileSync(path_1.default.join(__dirname, '../../examples/observability/loki.yml'), 'utf8'));
+    it('keeps logs for the retention period it sets', () => {
+        var _a, _b, _c;
+        (0, chai_1.expect)(config.limits_config.retention_period).to.equal('24h');
+        (0, chai_1.expect)((_a = config.compactor) === null || _a === void 0 ? void 0 : _a.retention_enabled, 'compactor.retention_enabled').to.equal(true);
+        (0, chai_1.expect)((_b = config.compactor) === null || _b === void 0 ? void 0 : _b.delete_request_store, 'compactor.delete_request_store').to.equal(config.schema_config.configs[0].object_store);
+        (0, chai_1.expect)((_c = config.compactor) === null || _c === void 0 ? void 0 : _c.working_directory, 'compactor.working_directory').to.be.a('string');
+    });
+});

package/lib/test/unit/openapi-for-site.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+// scripts/ is plain CommonJS that the export script also loads, so it is
+// required rather than imported.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const site = require('../../scripts/lib/openapi-for-site');
+const { forSite, VERSION_TOKEN, assertNoRawDocumentLink } = site;
+/**
+ * The documentation site publishes the server's OpenAPI document. The spec
+ * names the version it was built from in `info`, so a committed copy would
+ * change on every release. forSite swaps that version for a token the site's
+ * build fills in, and points the "raw document" link at the user's own server,
+ * since the link would otherwise lead to the docs host.
+ */
+describe('openapi for the documentation site', () => {
+    const version = '2.13.1';
+    const makeSpec = () => ({
+        info: {
+            version,
+            description: `This reference describes version **${version}**. The raw OpenAPI document is at [\`/xenon/api-docs.json\`](/xenon/api-docs.json).`,
+        },
+        paths: { '/api/devices': {} },
+    });
+    it('puts the version token where the version was', () => {
+        const result = forSite(makeSpec(), version);
+        (0, chai_1.expect)(result.info.version).to.equal('__XENON_VERSION__');
+        (0, chai_1.expect)(VERSION_TOKEN).to.equal('__XENON_VERSION__');
+        (0, chai_1.expect)(result.info.description).to.contain('version **__XENON_VERSION__**');
+    });
+    it('leaves no trace of the version anywhere in the result', () => {
+        (0, chai_1.expect)(JSON.stringify(forSite(makeSpec(), version))).to.not.contain(version);
+    });
+    it('points the raw-document line at the reader’s own server, with no link', () => {
+        const { description } = forSite(makeSpec(), version).info;
+        (0, chai_1.expect)(description).to.contain('`/xenon/api-docs.json` on your server');
+        (0, chai_1.expect)(description).to.not.contain('](/xenon/api-docs.json)');
+    });
+    it('keeps the paths exactly as they were', () => {
+        (0, chai_1.expect)(forSite(makeSpec(), version).paths).to.deep.equal(makeSpec().paths);
+    });
+    it('does not change the object it is given', () => {
+        const spec = makeSpec();
+        forSite(spec, version);
+        (0, chai_1.expect)(spec).to.deep.equal(makeSpec());
+    });
+    it('refuses an empty or missing version', () => {
+        (0, chai_1.expect)(() => forSite(makeSpec(), '')).to.throw(/version/);
+        (0, chai_1.expect)(() => forSite(makeSpec(), undefined)).to.throw(/version/);
+        (0, chai_1.expect)(() => forSite(makeSpec(), 2.13)).to.throw(/version/);
+    });
+    it('only touches the version inside info', () => {
+        const spec = makeSpec();
+        spec.paths['/api/version'] = { get: { example: { pluginVersion: version } } };
+        const result = forSite(spec, version);
+        (0, chai_1.expect)(result.paths['/api/version'].get.example.pluginVersion).to.equal(version);
+    });
+    describe('the guard against a link to the raw document', () => {
+        const guarded = (description) => {
+            const spec = makeSpec();
+            spec.info.description = description;
+            return JSON.stringify(forSite(spec, version), null, 2);
+        };
+        it('passes the introduction as the server writes it, once forSite has rewritten the link', () => {
+            (0, chai_1.expect)(() => assertNoRawDocumentLink(guarded(makeSpec().info.description))).to.not.throw();
+        });
+        it('catches the link when the introduction is reworded', () => {
+            const text = guarded('Download the [raw document](/xenon/api-docs.json).');
+            (0, chai_1.expect)(() => assertNoRawDocumentLink(text)).to.throw(/still links to \/xenon\/api-docs\.json[\s\S]*src\/app\/swagger\.ts/);
+        });
+        it('catches a link that has a space, an angle bracket or a fragment in its target', () => {
+            (0, chai_1.expect)(() => assertNoRawDocumentLink('a [b]( /xenon/api-docs.json)')).to.throw();
+            (0, chai_1.expect)(() => assertNoRawDocumentLink('a [b](</xenon/api-docs.json>)')).to.throw();
+            (0, chai_1.expect)(() => assertNoRawDocumentLink('a [b](/xenon/api-docs.json#info "title")')).to.throw();
+        });
+        it('lets plain code and other links through', () => {
+            (0, chai_1.expect)(() => assertNoRawDocumentLink('at `/xenon/api-docs.json` on your server, see [the profile](/xenon/profile)')).to.not.throw();
+        });
+    });
+});