@xenon-device-management/xenon 2.17.0 → 2.17.1

package/lib/test/unit/internal-call.spec.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
+const http_1 = __importDefault(require("http"));
 const path_1 = __importDefault(require("path"));
 const sinon_1 = __importDefault(require("sinon"));
 const express_1 = __importDefault(require("express"));
@@ -166,6 +167,104 @@ describe('internal calls (/wd-internal with the per-process secret)', () => {
                 }
                 (0, chai_1.expect)(ran).to.deep.equal([]);
             }));
+            /**
+             * The plugin's handle, deep inside Appium's route, is never given the
+             * request, so an accepted call's context is how it knows the command
+             * is Xenon's own and not the test's.
+             */
+            describe('the plugin can tell an internal call from a test’s command', () => {
+                let seen;
+                let release;
+                function labSeeing() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        seen = [];
+                        release = undefined;
+                        const app = makeExpress();
+                        app.use(express_1.default.json());
+                        // A route that, like Appium's, answers after awaiting the driver.
+                        app.get('/wd/hub/session/:sessionId/source', (req, res) => __awaiter(this, void 0, void 0, function* () {
+                            if (req.query.hold)
+                                yield new Promise((resolve) => (release = resolve));
+                            yield new Promise((resolve) => setTimeout(resolve, 5));
+                            seen.push({ url: req.originalUrl, inside: (0, internalCall_1.isInsideInternalCall)() });
+                            res.json({ value: '<page/>' });
+                        }));
+                        (0, registerCommandAuth_1.registerCommandAuth)(app, { basePath: '/wd/hub' }, {
+                            enabled: () => false,
+                            authDisabled: () => false,
+                            verifier: new commandCaller_1.CommandCallerVerifier({
+                                verifyKeyPair: sinon_1.default.stub().resolves(null),
+                                verifyBearer: sinon_1.default.stub().resolves(null),
+                            }),
+                            ownerOf,
+                            logger: { info: () => undefined, warn: () => undefined, error: () => undefined },
+                        });
+                        app.use((_req, res) => res.status(404).json(UNKNOWN_ROUTE));
+                        return loopback.serve(app);
+                    });
+                }
+                it('inside an accepted call, across the route’s awaits', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set((0, internalCall_1.internalCallHeaders)());
+                    (0, chai_1.expect)(seen).to.deep.equal([{ url: '/wd/hub/session/s1/source', inside: true }]);
+                    (0, chai_1.expect)((0, internalCall_1.isInsideInternalCall)(), 'outside any request').to.equal(false);
+                }));
+                it('never for a test’s command, a refused call, or a request after one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').set((0, internalCall_1.internalCallHeaders)());
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set((0, internalCall_1.internalCallHeaders)())
+                        .expect(200);
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set(internalCall_1.INTERNAL_CALL_HEADER, 'not-the-secret')
+                        .expect(404);
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').expect(200);
+                    (0, chai_1.expect)(seen.map((s) => s.inside)).to.deep.equal([false, true, false]);
+                }));
+                it('never for a request on the same kept-alive connection after one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const server = yield labSeeing();
+                    const port = server.address().port;
+                    const agent = new http_1.default.Agent({ keepAlive: true, maxSockets: 1 });
+                    const get = (path, headers) => new Promise((resolve, reject) => {
+                        const req = http_1.default.get({ host: '127.0.0.1', port, path, headers, agent }, (res) => {
+                            res.resume();
+                            res.on('end', () => resolve(req.reusedSocket));
+                        });
+                        req.on('error', reject);
+                    });
+                    try {
+                        yield get('/wd/hub/wd-internal/session/s1/source', (0, internalCall_1.internalCallHeaders)());
+                        (0, chai_1.expect)(yield get('/wd/hub/session/s1/source', {}), 'the socket was reused').to.equal(true);
+                    }
+                    finally {
+                        agent.destroy();
+                    }
+                    (0, chai_1.expect)(seen.map((s) => s.inside)).to.deep.equal([true, false]);
+                }));
+                it('never for a test’s command running alongside one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    const internal = (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source?hold=1')
+                        .set((0, internalCall_1.internalCallHeaders)())
+                        .then((r) => r);
+                    for (let i = 0; i < 100 && !release; i++)
+                        yield new Promise((r) => setTimeout(r, 10));
+                    const held = release;
+                    if (!held)
+                        throw new Error('the internal call never reached its route');
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').expect(200);
+                    held();
+                    yield internal;
+                    (0, chai_1.expect)(seen).to.deep.equal([
+                        { url: '/wd/hub/session/s1/source', inside: false },
+                        { url: '/wd/hub/session/s1/source?hold=1', inside: true },
+                    ]);
+                }));
+            });
             it('puts the internal-call layer ahead of the session layer, both ahead of the routes', () => __awaiter(void 0, void 0, void 0, function* () {
                 const { raw } = yield lab();
                 const stack = (0, insertBeforeRoutes_1.routerStackOf)(raw);

package/lib/test/unit/internal-calls-session-record.spec.js

@@ -0,0 +1,312 @@
+"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 http_1 = __importDefault(require("http"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const plugin_1 = require("../../src/plugin");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const LocalSession_1 = require("../../src/sessions/LocalSession");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const AIService_1 = require("../../src/services/AIService");
+const failure_analysis_service_1 = require("../../src/dashboard/services/failure-analysis-service");
+const deviceService = __importStar(require("../../src/data-service/device-service"));
+const SessionStatus_1 = require("../../src/types/SessionStatus");
+const scratch_database_1 = require("../helpers/scratch-database");
+const loki_stores_1 = require("../helpers/loki-stores");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * Xenon's own calls to a session it runs, in Appium 3's own server(): Appium's
+ * umbrella driver with Xenon's plugin and the production session gateway, on
+ * a dashboard-on server, over a scratch database.
+ *
+ * A LocalSession asks its driver in-process first. When that fails it asks
+ * again over HTTP, at `<basePath>/wd-internal/session/<id>/...` with the
+ * per-process secret (gateway/internalCall.ts), and that request goes through
+ * Appium's route, the umbrella and the plugin's `handle` like a test's.
+ * Through 2.16 the plugin couldn't tell: the marker was on the Express request,
+ * which `handle` is never given. So a performance recording's stop the driver
+ * refused at the end of a session was recorded as a failed `execute` of the
+ * session, and the session, whose own commands had all passed, ended failed:
+ * "marked as FAILED due to error in command: execute", the driver's refusal
+ * as its reason, failure analysis, a `session_failed` webhook. Observed on a
+ * simulator on 2026-10-05 (2.16 no longer stops one there, #503); on an
+ * iPhone whenever the recording's start failed.
+ */
+const SESSION = 'internal-calls-session';
+const UDID = 'iphone-1';
+const BASE = '/wd/hub';
+const REFUSAL = 'No Time Profiler recording was started on this device';
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+/** An iPhone driver as far as these calls go: it refuses the performance recording. */
+function iPhoneLikeDriverClass() {
+    const { BaseDriver, errors } = (0, appium_umbrella_1.appiumBaseDriver)();
+    return class IPhoneLikeDriver extends BaseDriver {
+        constructor() {
+            super(...arguments);
+            this.calls = [];
+            this.pageSourceFailures = 0;
+        }
+        getUrl() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push('getUrl');
+                return 'https://app.example/';
+            });
+        }
+        execute(script) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push(`execute ${script}`);
+                if (script === 'mobile: startPerfRecord' || script === 'mobile: stopPerfRecord') {
+                    throw new errors.UnknownError(REFUSAL);
+                }
+                return null;
+            });
+        }
+        getPageSource() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push('getPageSource');
+                if (this.pageSourceFailures > 0) {
+                    this.pageSourceFailures--;
+                    throw new errors.UnknownError('The page source took too long');
+                }
+                if (this.held)
+                    yield this.held;
+                return '<XCUIElementTypeApplication name="Shop"/>';
+            });
+        }
+        /** Commands waiting in base-driver's queue, read as base-driver reads it. */
+        queued() {
+            var _a, _b, _c, _d;
+            return (_d = (_c = (_b = (_a = this.commandsQueueGuard) === null || _a === void 0 ? void 0 : _a.queues) === null || _b === void 0 ? void 0 : _b[BaseDriver.name]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+        }
+    };
+}
+describe('Xenon’s own calls to a session (/wd-internal), in Appium 3’s own server()', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    (0, loki_stores_1.usePrismaStores)();
+    let appiumLogs;
+    let server;
+    let url;
+    let inner;
+    let session;
+    let notified;
+    let isHubBefore;
+    before(() => {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+    });
+    after(() => appiumLogs.restore());
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        // A hub or a standalone server, with the dashboard recording its sessions.
+        isHubBefore = plugin_1.XenonPlugin.IS_HUB;
+        plugin_1.XenonPlugin.IS_HUB = true;
+        notified = sinon_1.default.stub(NotificationService_1.NotificationService.prototype, 'notifySessionFailed').resolves();
+        // A failed session's analysis never reaches an AI provider from here.
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'isEnabled').returns(false);
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.log.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+        const umbrella = (0, appium_umbrella_1.umbrellaWith)([[plugin_1.XenonPlugin, 'xenon']]);
+        umbrella.args.plugin = { xenon: { enableDashboard: true } };
+        server = yield baseDriver.server({
+            routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+            port: 0,
+            hostname: '127.0.0.1',
+            basePath: BASE,
+            cliArgs: { basePath: BASE },
+            serverUpdaters: [
+                (app) => (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: BASE }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => false, authDisabled: () => false, logger: quiet })),
+            ],
+        });
+        const port = server.address().port;
+        url = `http://127.0.0.1:${port}`;
+        // Where a LocalSession's loopback calls go: the server it runs on.
+        Object.assign(umbrella.opts, { address: '127.0.0.1', port, basePath: BASE });
+        // The session as Appium holds it once created.
+        const Driver = iPhoneLikeDriverClass();
+        inner = new Driver({}, false);
+        inner.sessionId = SESSION;
+        inner.caps = { platformName: 'iOS', automationName: appium_umbrella_1.FAKE_AUTOMATION, udid: UDID };
+        inner.newCommandTimeoutMs = 0;
+        umbrella.sessions[SESSION] = inner;
+        // ... and as Xenon records it.
+        yield scratch.db.session.create({
+            data: {
+                id: SESSION,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+                device_udid: UDID,
+                device_platform: 'ios',
+                device_version: '18.0',
+            },
+        });
+        session = new LocalSession_1.LocalSession({
+            sessionId: SESSION,
+            device: { udid: UDID, platform: 'ios', realDevice: true, host: url },
+            sessionResponse: {},
+            xenonOption: {},
+            driver: umbrella,
+        });
+        SessionManager_1.SESSION_MANAGER.addSession(SESSION, session);
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        SessionManager_1.SESSION_MANAGER.removeSession(SESSION);
+        plugin_1.XenonPlugin.IS_HUB = isHubBefore;
+        sinon_1.default.restore();
+        server.closeAllConnections();
+        yield new Promise((resolve) => http_1.default.Server.prototype.close.call(server, () => resolve()));
+    }));
+    /** The session's recorded commands, oldest first. */
+    function recorded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield scratch.db.sessionLog.findMany({
+                where: { session_id: SESSION },
+                orderBy: { createdAt: 'asc' },
+            });
+            return rows.map((row) => ({ command: row.command_name, failed: row.is_error }));
+        });
+    }
+    /** The session's end as every ending reaches it, and what its row says then. */
+    function end() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(SESSION);
+            const row = yield scratch.db.session.findUniqueOrThrow({ where: { id: SESSION } });
+            return { status: row.status, reason: row.failure_reason };
+        });
+    }
+    /** Waits for a condition the test can't be told about. */
+    function until(condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 200 && !condition(); i++)
+                yield new Promise((r) => setTimeout(r, 10));
+            (0, chai_1.expect)(condition(), 'waited 2 s').to.equal(true);
+        });
+    }
+    /** A command the test sends, through the public route. */
+    const testCommand = () => (0, loopbackRequest_1.default)(url).get(`${BASE}/session/${SESSION}/url`);
+    it('a performance recording’s stop the driver refuses doesn’t fail a session whose commands all passed', () => __awaiter(this, void 0, void 0, function* () {
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(yield session.stopPerformanceRecording()).to.equal(null);
+        // The stop was asked in-process, then over the loopback, which reached the driver.
+        (0, chai_1.expect)(inner.calls).to.deep.equal([
+            'getUrl',
+            'execute mobile: stopPerfRecord',
+            'execute mobile: stopPerfRecord',
+        ]);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+        (0, chai_1.expect)(notified.called, 'a session_failed webhook').to.equal(false);
+    }));
+    it('nor does a refused start of the recording, at the session’s first moments', () => __awaiter(this, void 0, void 0, function* () {
+        yield session.startPerformanceRecording();
+        (0, chai_1.expect)(inner.calls).to.deep.equal([
+            'execute mobile: startPerfRecord',
+            'execute mobile: startPerfRecord',
+        ]);
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+    }));
+    it('a page source read over the loopback is not put in the session’s command log', () => __awaiter(this, void 0, void 0, function* () {
+        inner.pageSourceFailures = 1;
+        (0, chai_1.expect)(yield session.getPageSource()).to.equal('<XCUIElementTypeApplication name="Shop"/>');
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([]);
+    }));
+    it('a page source read that fails over the loopback too is not a failed command of the session', () => __awaiter(this, void 0, void 0, function* () {
+        inner.pageSourceFailures = 2;
+        yield session.getPageSource().then(() => chai_1.expect.fail('the read succeeded'), (error) => { var _a; return (0, chai_1.expect)((_a = error.response) === null || _a === void 0 ? void 0 : _a.status).to.equal(500); });
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+    }));
+    it('isn’t the session’s activity: only the test’s commands reset its idle clock', () => __awaiter(this, void 0, void 0, function* () {
+        const touched = sinon_1.default.stub(deviceService, 'updateCmdExecutedTime').resolves();
+        inner.pageSourceFailures = 1;
+        yield session.stopPerformanceRecording();
+        yield session.getPageSource();
+        (0, chai_1.expect)(inner.calls).to.have.length(4);
+        (0, chai_1.expect)(touched.called).to.equal(false);
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(touched.calledOnceWith(SESSION)).to.equal(true);
+    }));
+    it('a test’s command queued in the driver behind one is recorded, as the test’s', () => __awaiter(this, void 0, void 0, function* () {
+        let release = () => { };
+        inner.held = new Promise((resolve) => (release = resolve));
+        inner.pageSourceFailures = 1;
+        // Xenon's read reaches the driver over the loopback and holds its queue.
+        const read = session.getPageSource();
+        yield until(() => inner.calls.length === 2);
+        // The test's command waits in the driver's queue behind it, and runs when
+        // Xenon's read lets go.
+        const command = testCommand().then((res) => res);
+        yield until(() => inner.queued() === 1);
+        release();
+        (0, chai_1.expect)(yield read).to.equal('<XCUIElementTypeApplication name="Shop"/>');
+        (0, chai_1.expect)((yield command).status).to.equal(200);
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource', 'getUrl']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+    }));
+    it('the same refusal of the test’s own command is recorded and fails the session, as before', () => __awaiter(this, void 0, void 0, function* () {
+        yield (0, loopbackRequest_1.default)(url)
+            .post(`${BASE}/session/${SESSION}/execute/sync`)
+            .send({ script: 'mobile: stopPerfRecord', args: [{ profileName: 'Time Profiler' }] })
+            .expect(500);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'execute', failed: true }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.FAILED, reason: REFUSAL });
+        (0, chai_1.expect)(notified.calledOnce, 'a session_failed webhook').to.equal(true);
+        // The analysis the failure started ends with the test, not after it.
+        yield (0, failure_analysis_service_1.explainSessionFailure)(SESSION);
+    }));
+});