@xenon-device-management/xenon 2.15.0 → 2.16.0

package/lib/test/unit/command-log-network-capture.spec.js

@@ -0,0 +1,191 @@
+"use strict";
+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 sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const commandLogFields_1 = require("../../src/dashboard/commandLogFields");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SelectorStateService_1 = require("../../src/services/SelectorStateService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const typedi_1 = require("typedi");
+const scratch_database_1 = require("../helpers/scratch-database");
+const container_registration_1 = require("../helpers/container-registration");
+/**
+ * A session's network capture (its requests, its HAR, its mocks) is for admins
+ * only: the /interceptor routes, the Network panel and the live events. The
+ * command log is read by anyone who can see the session (`session_log`, bug
+ * reports). A hub records every command it forwards to a node, so a test's own
+ * `xenon: exportHar` put the whole capture, sign-in headers included, in front
+ * of every member of the phone's team.
+ */
+describe('The command log keeps no network capture', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'cl-session-1';
+    const SECRET = 'eyJ-app-access-token';
+    const HAR = {
+        log: {
+            entries: [{ request: { headers: [{ name: 'authorization', value: `Bearer ${SECRET}` }] } }],
+        },
+    };
+    let restore;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(SocketServer_1.SocketServer);
+        typedi_1.Container.set(SocketServer_1.SocketServer, {
+            emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+            hasScopedDashboard: () => false,
+        });
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+        yield scratch.db.team.deleteMany({});
+        yield scratch.db.team.create({ data: { id: 'team-a', name: 'Team A' } });
+        yield scratch.db.device.create({
+            data: {
+                udid: 'cl-phone-a',
+                host: 'http://node:4723',
+                platform: 'android',
+                teamId: 'team-a',
+            },
+        });
+        yield scratch.db.session.create({
+            data: {
+                id: SESSION,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+                device_udid: 'cl-phone-a',
+                device_platform: 'android',
+                device_version: '14',
+            },
+        });
+        sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns({
+            getId: () => SESSION,
+            getDevice: () => ({ udid: 'cl-phone-a', name: 'P', platform: 'android' }),
+            getXenonOption: () => undefined,
+            getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
+        });
+        sinon_1.default.stub(SelectorStateService_1.SelectorStateService.prototype, 'onHealRecorded').resolves(null);
+    }));
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    /** A command as the hub's gateway hands it over: the client's W3C body and the node's answer. */
+    function forwarded(script, args, answer) {
+        return event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(SESSION, 'execute', null, {
+            body: { script, args },
+            method: 'POST',
+            originalUrl: `/wd/hub/session/${SESSION}/execute/sync`,
+        }, {}, JSON.stringify(answer));
+    }
+    /** What a member of the phone's team reads. */
+    function sessionLogAsMember() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = (0, express_1.default)();
+            app.use((req, _res, next) => {
+                req.auth = {
+                    kind: 'user-session',
+                    userId: 'cl-u-member',
+                    role: 'MEMBER',
+                    scopes: 'devices,sessions,read',
+                    teamIds: ['team-a'],
+                };
+                next();
+            });
+            dashboard_1.default.register(app);
+            const res = yield (0, loopbackRequest_1.default)(app).get(`/session/${SESSION}/session_log`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            return res.body;
+        });
+    }
+    it('records which network script ran and whether it worked, never its arguments or its answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield forwarded('xenon: exportHar', [], { value: HAR });
+        yield forwarded('xe:getRequests', [], { value: [HAR] });
+        yield forwarded('getMocks', [], { value: [{ respond: { body: { token: SECRET } } }] });
+        yield forwarded('xenon: addMock', [{ respond: { body: { token: SECRET } } }], {
+            value: { id: 'm1' },
+        });
+        yield forwarded('xenon: removeMock', [{ id: 'm1' }], { value: { removed: true } });
+        yield forwarded('xenon: clearMocks', [], { value: { ok: true } });
+        const rows = yield sessionLogAsMember();
+        (0, chai_1.expect)(rows).to.have.length(6);
+        for (const row of rows) {
+            (0, chai_1.expect)(`${row.body}${row.response}`).to.not.include(SECRET);
+            (0, chai_1.expect)(row.is_success).to.equal(true);
+            // Every one, removeMock and clearMocks included, whose answers hold no secret.
+            (0, chai_1.expect)(JSON.parse(row.response), (_a = row.body) !== null && _a !== void 0 ? _a : '').to.deep.equal({
+                value: commandLogFields_1.NETWORK_CAPTURE_NOT_KEPT,
+            });
+            (0, chai_1.expect)(JSON.parse((_b = row.body) !== null && _b !== void 0 ? _b : '{}').args).to.equal(commandLogFields_1.NETWORK_CAPTURE_NOT_KEPT);
+        }
+        (0, chai_1.expect)(rows.map((r) => { var _a; return JSON.parse((_a = r.body) !== null && _a !== void 0 ? _a : '{}').script; })).to.have.members([
+            'xenon: exportHar',
+            'xe:getRequests',
+            'getMocks',
+            'xenon: addMock',
+            'xenon: removeMock',
+            'xenon: clearMocks',
+        ]);
+    }));
+    it('keeps a failed network script’s error, which carries no capture', () => __awaiter(void 0, void 0, void 0, function* () {
+        const error = {
+            value: {
+                error: 'unknown error',
+                message: `Interceptor not active for session ${SESSION}`,
+                stacktrace: '',
+            },
+        };
+        yield forwarded('xenon: exportHar', [], error);
+        const [row] = yield sessionLogAsMember();
+        (0, chai_1.expect)(row.is_success).to.equal(false);
+        (0, chai_1.expect)(JSON.parse(row.response)).to.deep.equal(error);
+    }));
+    it('on the server that drives the phone, a failed network script keeps its error but not its arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // CommandInterceptor answers these scripts before its hooks; only a throw
+        // (no capture running) reaches the log, from its catch, with the
+        // command's arguments as they came: [script, args].
+        const error = {
+            value: { error: `Interceptor not active for session ${SESSION}` },
+            sessionId: SESSION,
+        };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(SESSION, 'execute', null, {
+            body: ['xenon: addMock', [{ respond: { body: { token: SECRET } } }]],
+            method: 'POST',
+            originalUrl: '/execute',
+        }, {}, JSON.stringify(error));
+        const [row] = yield sessionLogAsMember();
+        (0, chai_1.expect)(row.body).to.not.include(SECRET);
+        (0, chai_1.expect)(JSON.parse((_a = row.body) !== null && _a !== void 0 ? _a : '[]')[0]).to.equal('xenon: addMock');
+        (0, chai_1.expect)(JSON.parse(row.response)).to.deep.equal(error);
+        (0, chai_1.expect)(row.is_success).to.equal(false);
+    }));
+    it('logs every other script, and a script the node’s interceptor doesn’t answer, whole', () => __awaiter(void 0, void 0, void 0, function* () {
+        // `plugin:` is only the autowait commands' prefix: `plugin: exportHar` is
+        // never a network script, and its answer is the driver's.
+        yield forwarded('mobile: shell', [{ command: 'echo' }], { value: SECRET });
+        yield forwarded('plugin: exportHar', [], { value: SECRET });
+        const rows = yield sessionLogAsMember();
+        (0, chai_1.expect)(rows).to.have.length(2);
+        for (const row of rows)
+            (0, chai_1.expect)(row.response).to.include(SECRET);
+    }));
+});

package/lib/test/unit/dashboard-events-device-logs.spec.js

@@ -50,6 +50,7 @@ const chai_1 = require("chai");
 const sinon_1 = __importDefault(require("sinon"));
 const typedi_1 = require("typedi");
 const event_manager_1 = require("../../src/dashboard/event-manager");
+const XenonCapabilityManager_1 = require("../../src/XenonCapabilityManager");
 const assets = __importStar(require("../../src/dashboard/asset-manager"));
 const sessionService = __importStar(require("../../src/dashboard/services/session-service"));
 const SessionManager_1 = require("../../src/sessions/SessionManager");
@@ -84,6 +85,7 @@ describe('EventManager: an Android session’s device log', () => {
         deviceLogs = {
             start: sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return order.push('device logs'); })),
             stop: sinon_1.default.stub().resolves(),
+            noteOff: sinon_1.default.stub().resolves(),
         };
         typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, deviceLogs);
         typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, {
@@ -101,32 +103,78 @@ describe('EventManager: an Android session’s device log', () => {
         sinon_1.default.restore();
         restore();
     });
-    it("starts once the session's row is written, from when the phone was given to it", () => __awaiter(void 0, void 0, void 0, function* () {
+    function startSession(platform, deviceLog) {
         sinon_1.default.stub(assets, 'prepareDirectory');
         sinon_1.default.stub(sessionService, 'getOrCreateNewBuild').resolves({ id: 'b-logs' });
         sinon_1.default.stub(TracingService_1.TracingService.prototype, 'getTraceId').returns('t-1');
         sinon_1.default.stub(MetricsService_1.MetricsService.prototype, 'incrementSessionStart');
-        sinon_1.default.stub(prisma_1.prisma.session, 'create').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(prisma_1.prisma.session, 'create').callsFake(() => __awaiter(this, void 0, void 0, function* () {
             order.push('row');
             return {};
         }));
-        const session = {
-            getId: () => 's-logs-1',
-            getCapabilities: () => ({ platformName: 'Android' }),
-            getLiveVideoUrl: () => null,
-            apiKeyId: null,
-            userId: null,
-            allocatedAt: 1700000000000,
-        };
-        const device = { udid: 'phone-l', platform: 'android', host: 'h', name: 'S9', sdk: '10' };
+        const session = Object.assign({ getId: () => 's-logs-1', getCapabilities: () => ({ platformName: platform }), getLiveVideoUrl: () => null, startPerformanceRecording: sinon_1.default.stub().resolves(), apiKeyId: null, userId: null, allocatedAt: 1700000000000 }, (deviceLog ? { deviceLog } : {}));
+        const device = { udid: 'phone-l', platform, host: 'h', name: 'phone', sdk: '10' };
+        return { session, device };
+    }
+    it("starts once the session's row is written, from when the phone was given to it", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = startSession('android');
         yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, session, device);
         (0, chai_1.expect)(order).to.deep.equal(['row', 'device logs']);
         (0, chai_1.expect)(deviceLogs.start.firstCall.args[0]).to.deep.equal({
             sessionId: 's-logs-1',
             device,
             since: 1700000000000,
+            driverLog: undefined,
+            appUnderTest: undefined,
         });
     }));
+    // The switch, from the session's capabilities as the create parses them.
+    const parsed = (alwaysMatch) => (0, XenonCapabilityManager_1.getXenonCapabilities)({ alwaysMatch, firstMatch: [{}] });
+    function stubSessionStart() {
+        sinon_1.default.stub(assets, 'prepareDirectory');
+        sinon_1.default.stub(sessionService, 'getOrCreateNewBuild').resolves({ id: 'b-logs' });
+        sinon_1.default.stub(TracingService_1.TracingService.prototype, 'getTraceId').returns('t-1');
+        sinon_1.default.stub(MetricsService_1.MetricsService.prototype, 'incrementSessionStart');
+        sinon_1.default.stub(prisma_1.prisma.session, 'create').resolves({});
+        return {
+            session: {
+                getId: () => 's-logs-off',
+                getCapabilities: () => ({ platformName: 'Android' }),
+                getLiveVideoUrl: () => null,
+                apiKeyId: null,
+                userId: null,
+            },
+            device: { udid: 'phone-l', platform: 'android', host: 'h', name: 'S9', sdk: '10' },
+        };
+    }
+    it('records it when the session says nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = stubSessionStart();
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({}), session, device);
+        (0, chai_1.expect)(deviceLogs.start.calledOnce).to.equal(true);
+        (0, chai_1.expect)(deviceLogs.noteOff.called).to.equal(false);
+    }));
+    it('keeps none, and says so, for a session that turned it off', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = stubSessionStart();
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({ 'xe:save_device_logs': false }), session, device);
+        (0, chai_1.expect)(deviceLogs.start.called).to.equal(false);
+        (0, chai_1.expect)(deviceLogs.noteOff.calledOnceWithExactly('s-logs-off')).to.equal(true);
+    }));
+    it("doesn't listen to an iPhone's driver log when the session turned it off", () => __awaiter(void 0, void 0, void 0, function* () {
+        const driverLog = { on: sinon_1.default.stub(), removeListener: sinon_1.default.stub() };
+        const { session, device } = startSession('ios', () => driverLog);
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({ 'xe:saveDeviceLogs': 'false' }), session, device);
+        (0, chai_1.expect)(deviceLogs.start.called).to.equal(false);
+        (0, chai_1.expect)(deviceLogs.noteOff.calledOnceWithExactly('s-logs-1')).to.equal(true);
+        (0, chai_1.expect)(driverLog.on.called).to.equal(false);
+    }));
+    it("hands an iPhone's session the log its driver captures, and its app", () => __awaiter(void 0, void 0, void 0, function* () {
+        const driverLog = { on() { }, removeListener() { } };
+        const { session, device } = startSession('ios', () => driverLog);
+        session.appUnderTest = () => 'com.example.shop';
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, session, device);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].driverLog).to.equal(driverLog);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].appUnderTest).to.equal('com.example.shop');
+    }));
     it('writes it to the end when the session stops, even one no longer in memory', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns(undefined);
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({ getDevices: () => __awaiter(void 0, void 0, void 0, function* () { return []; }) });

package/lib/test/unit/dashboard-events-team-scope.spec.js

@@ -332,7 +332,7 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
             config_1.config.sessionAssetsPath = assets;
             fs_1.default.rmSync(dir, { recursive: true, force: true });
         });
-        it("request, started and stopped: the session's device, even after stop() drops the state", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("request, started and stopped: the session's device, admins only, even after stop() drops the state", () => __awaiter(void 0, void 0, void 0, function* () {
             const svc = new InterceptorService_1.InterceptorService();
             typedi_1.Container.set(PortAllocator_1.PortAllocator, { releaseForUdid: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }) });
             svc.androidAdapter = {
@@ -353,16 +353,19 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
             svc.emit({ type: 'request', sessionId: 's4', payload: { id: 'q1' } }, 'phone-a');
             svc.emit({ type: 'session_started', sessionId: 's4', port: 1, host: 'h' }, 'phone-a');
             yield svc.stop('s4');
+            // Captured traffic (headers, bodies) is for admins only, as REST's
+            // /interceptor routes are; so are the capture's start and stop.
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_REQUEST)[0].args.slice(1)).to.deep.equal([
                 { id: 'q1' },
-                { udid: 'phone-a' },
+                { udid: 'phone-a', adminOnly: true },
             ]);
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_SESSION_STARTED)[0].args[2]).to.deep.equal({
                 udid: 'phone-a',
+                adminOnly: true,
             });
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_SESSION_STOPPED)[0].args.slice(1)).to.deep.equal([
                 { sessionId: 's4' },
-                { udid: 'phone-a' },
+                { udid: 'phone-a', adminOnly: true },
             ]);
         }));
     });

package/lib/test/unit/database-check.spec.js

@@ -27,6 +27,7 @@ describe('checkDatabase', () => {
         });
         (0, chai_1.expect)(warning).to.be.a('string');
         (0, chai_1.expect)(warning).to.match(/databaseProvider/);
+        (0, chai_1.expect)(warning).to.match(/has no effect/);
         (0, chai_1.expect)(warning).to.match(/SQLite/);
         (0, chai_1.expect)(warning).to.include('/Users/me/.cache/xenon/xenon.db');
     });

package/lib/test/unit/device-utils.spec.js

@@ -192,9 +192,14 @@ describe('Device Utils', () => {
         }
         const foundDevice = (yield getFilteredDevice(allocatedDeviceForFirstSession.udid, allocatedDeviceForFirstSession.host))[0];
         expect(foundDevice.busy).to.be.true;
-        yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).catch((error) => expect(error)
+        // The other phone on that host, so nothing matching is left.
+        const allocatedDeviceForSecondSession = yield DeviceUtils.allocateDeviceForSession(capabilities, 1000, 1000, pluginArgs);
+        expect(allocatedDeviceForSecondSession.host).to.not.equal(allocatedDeviceForFirstSession.host);
+        // Resolving must fail the test, not skip the check.
+        const refused = yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).then(() => null, (error) => error);
+        expect(refused, 'the allocation was refused')
             .to.be.an('error')
-            .with.property('message', 'Device is busy or blocked.. Device request: {"platform":"android","udid":"emulator-5555","filterByHost":"192.168.0.226"}'));
+            .with.property('message', 'Device is busy or blocked. Device request: {"platform":"android","udid":["emulator-5555"],"filterByHost":"192.168.0.226"}');
     }));
     it('Allocating device should set device to be busy', function () {
         return __awaiter(this, void 0, void 0, function* () {
@@ -236,9 +241,13 @@ describe('Device Utils', () => {
             })
                 .data()[0];
             expect(foundSecondDevice.busy).to.be.true;
-            yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).catch((error) => expect(error)
+            // The first allocation wrote its udid into `capabilities`, so three phones
+            // match: take the third, and nothing matching is left.
+            yield DeviceUtils.allocateDeviceForSession(capabilities, 1000, 1000, pluginArgs);
+            const refused = yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).then(() => null, (error) => error);
+            expect(refused, 'the allocation was refused')
                 .to.be.an('error')
-                .with.property('message', `Device is busy or blocked.. Device request: {"platform":"android","udid":"${allocatedDeviceForFirstSession.udid}","filterByHost":"192.168.0.226"}`));
+                .with.property('message', `Device is busy or blocked. Device request: {"platform":"android","udid":["${allocatedDeviceForFirstSession.udid}"]}`);
         });
     });
     it('should release blocked devices that have no activity for more than the timeout', () => __awaiter(void 0, void 0, void 0, function* () {

package/lib/test/unit/event-log-session-data.spec.js

@@ -217,9 +217,11 @@ describe("The event log keeps no copy of a session's own data", () => {
             }
         }));
     });
-    it("every other event is logged once and whole, by either emit; a command's own fields are named", () => __awaiter(void 0, void 0, void 0, function* () {
+    it("every other event is logged once and whole, by every emit; a command's own fields are named", () => __awaiter(void 0, void 0, void 0, function* () {
         const server = typedi_1.Container.get(SocketServer_1.SocketServer);
-        server.emitToDashboard(SocketEvents_1.SocketEvents.INTERCEPTOR_REQUEST, capturedRequest('q3'));
+        // The unscoped emit is private (node events only), but logs by the same rule.
+        const emitUnscoped = (event, data) => server.emitToDashboard(event, data);
+        emitUnscoped(SocketEvents_1.SocketEvents.INTERCEPTOR_REQUEST, capturedRequest('q3'));
         yield server.emitToDashboardForDevices(SocketEvents_1.SocketEvents.INTERCEPTOR_REQUEST, capturedRequest('q4'), { udid: 'phone-a' });
         (0, chai_1.expect)(appendSafe.called).to.equal(false);
         const payload = { session_id: 's', command_name: 'click', body: '["hunter2"]', extra: 1 };
@@ -227,7 +229,11 @@ describe("The event log keeps no copy of a session's own data", () => {
         for (const event of others) {
             yield server.emitToDashboardForDevices(event, payload, { udid: 'phone-a' });
         }
-        server.emitToDashboard(SocketEvents_1.SocketEvents.SESSION_COMMAND, payload);
+        emitUnscoped(SocketEvents_1.SocketEvents.SESSION_COMMAND, payload);
+        yield server.emitToDashboardForSelector(SocketEvents_1.SocketEvents.SELECTOR_MUTED, payload, {
+            strategy: 'xpath',
+            selector: '//x',
+        });
         (0, chai_1.expect)(appendSafe.getCalls().map((c) => c.args[0])).to.deep.equal([
             ...others.map((event) => ({
                 type: event,
@@ -236,9 +242,10 @@ describe("The event log keeps no copy of a session's own data", () => {
                     : payload,
             })),
             { type: SocketEvents_1.SocketEvents.SESSION_COMMAND, payload: { session_id: 's', command_name: 'click' } },
+            { type: SocketEvents_1.SocketEvents.SELECTOR_MUTED, payload },
         ]);
         // The writes are fire-and-forget: let them land here, or they land in the
         // next test's table after its beforeEach emptied it.
-        (0, chai_1.expect)(yield eventLogRows(others.length + 1)).to.have.length(others.length + 1);
+        (0, chai_1.expect)(yield eventLogRows(others.length + 2)).to.have.length(others.length + 2);
     }));
 });

package/lib/test/unit/failure-analysis.spec.js

@@ -110,11 +110,25 @@ describe('failure analysis of a failed session', () => {
                 .stub(AIService_1.AI_SERVICE, 'analyzeFailure')
                 .callsFake(() => new Promise((resolve) => answers.push(resolve)));
         }));
-        const settle = () => new Promise((r) => setTimeout(r, 50));
+        /**
+         * Waits for the analyses to reach the AI. Each first reads its session's
+         * logs, which a loaded machine (a parallel suite) makes slow, so a fixed
+         * pause isn't enough. Waiting can't hide one too many: which analyses run
+         * is decided when they are asked for, and the next only starts when an
+         * answer is given.
+         */
+        const askedTimes = (n) => __awaiter(void 0, void 0, void 0, function* () {
+            for (let waited = 0; analyzeFailure.callCount < n; waited += 10) {
+                if (waited > 15000)
+                    throw new Error(`asked ${analyzeFailure.callCount} times, not ${n}`);
+                yield new Promise((r) => setTimeout(r, 10));
+            }
+        });
         it('asks once for a session whose analysis is already running', () => __awaiter(void 0, void 0, void 0, function* () {
             const first = (0, failure_analysis_service_1.explainSessionFailure)(ID);
             const second = (0, failure_analysis_service_1.explainSessionFailure)(ID);
-            yield settle();
+            (0, chai_1.expect)(second).to.equal(first);
+            yield askedTimes(1);
             (0, chai_1.expect)(analyzeFailure.callCount).to.equal(1);
             answers[0]('Root Cause: once.');
             yield Promise.all([first, second]);
@@ -138,15 +152,15 @@ describe('failure analysis of a failed session', () => {
                 });
             }
             const all = ids.map((id) => (0, failure_analysis_service_1.explainSessionFailure)(id));
-            yield settle();
+            yield askedTimes(failure_analysis_service_1.MAX_CONCURRENT_FAILURE_ANALYSES);
+            // Still that many a moment later: the others wait for a turn.
+            yield new Promise((r) => setTimeout(r, 50));
             (0, chai_1.expect)(analyzeFailure.callCount).to.equal(failure_analysis_service_1.MAX_CONCURRENT_FAILURE_ANALYSES);
             answers[0](null);
-            yield settle();
+            yield askedTimes(failure_analysis_service_1.MAX_CONCURRENT_FAILURE_ANALYSES + 1);
             (0, chai_1.expect)(analyzeFailure.callCount).to.equal(failure_analysis_service_1.MAX_CONCURRENT_FAILURE_ANALYSES + 1);
-            for (let i = 0; i < 10 && answers.length < ids.length; i++) {
-                answers.forEach((answer) => answer(null));
-                yield settle();
-            }
+            answers.forEach((answer) => answer(null));
+            yield askedTimes(ids.length);
             answers.forEach((answer) => answer(null));
             yield Promise.all(all);
             (0, chai_1.expect)(analyzeFailure.callCount).to.equal(ids.length);

package/lib/test/unit/failure-categories.spec.js

@@ -9,18 +9,20 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const swagger_1 = require("../../src/app/swagger");
-const failure_analysis_service_1 = require("../../src/dashboard/services/failure-analysis-service");
-const SessionManager_1 = require("../../src/sessions/SessionManager");
+const failureCategories_1 = require("../../src/dashboard/services/failureCategories");
 /**
  * A Session's `failure_category` is written in two places: the failure
  * analysis (one of ANALYSIS_CATEGORIES) and a restart's recovery
- * (HUB_RESTART). Both write upper case.
+ * (HUB_RESTART). Both write upper case. Sessions filed through 2.15 may also
+ * hold a category no longer written (RETIRED_CATEGORIES).
  *
  * The API reference showed `element_not_found`, a value the server never
  * writes, and the dashboard had a runbook for "Infrastructure", a category
  * nothing ever assigns. These hold both to what the server writes.
  */
-const WRITTEN = [...failure_analysis_service_1.ANALYSIS_CATEGORIES, SessionManager_1.HUB_RESTART_CATEGORY];
+const WRITTEN = [...new Set([...failureCategories_1.ANALYSIS_CATEGORIES, failureCategories_1.HUB_RESTART_CATEGORY])];
+/** Every value a session's row can hold. */
+const STORED = [...WRITTEN, ...failureCategories_1.RETIRED_CATEGORIES];
 /**
  * The dashboard's runbooks. web/ is an ES module package, so its .ts can't be
  * required from here; the file imports nothing, so it is compiled and run.
@@ -66,7 +68,7 @@ function csvExampleCategories() {
 }
 describe('failure categories', () => {
     it('are written upper case, as the API reference and the dashboard read them', () => {
-        (0, chai_1.expect)(failure_analysis_service_1.ANALYSIS_CATEGORIES).to.include('UNKNOWN');
+        (0, chai_1.expect)(failureCategories_1.ANALYSIS_CATEGORIES).to.include('UNKNOWN');
         for (const category of WRITTEN)
             (0, chai_1.expect)(category).to.match(/^[A-Z_]+$/);
     });
@@ -81,46 +83,46 @@ describe('failure categories', () => {
             for (const value of shown)
                 (0, chai_1.expect)(WRITTEN, String(value)).to.include(value);
         });
-        it("the session record's description names every category, and no other", () => {
+        it("the session record's description names every category a row can hold, and no other", () => {
             const described = valuesUnder(swagger_1.swaggerSpec, 'failure_category')
                 .filter((v) => !!(v === null || v === void 0 ? void 0 : v.description))
                 .map((v) => v.description);
             (0, chai_1.expect)(described).to.have.length(1);
             const named = Array.from(described[0].matchAll(/`([A-Z_]+)`/g), (m) => m[1]);
-            (0, chai_1.expect)([...named].sort()).to.deep.equal([...WRITTEN].sort());
+            (0, chai_1.expect)([...named].sort()).to.deep.equal([...STORED].sort());
         });
     });
     describe("in the dashboard's runbooks", () => {
-        it('every category the server writes has a runbook of its own', () => {
-            for (const category of WRITTEN) {
+        it('every category a session can hold has a runbook of its own, the retired ones included', () => {
+            for (const category of STORED) {
                 (0, chai_1.expect)(Object.keys(RUNBOOKS), category).to.include(runbookKey(category));
             }
         });
         it("each quotes a text that files a failure under its category, not just the category's name", () => {
-            // The names mislead: "Xenon command failure" is a "command failed"
-            // message, rarely Xenon's, and few real crashes are worded the way App
-            // crash's patterns expect. A runbook has to say what really files a
-            // failure there, so it must quote one of its category's texts. Only
-            // quoted text in the body counts: the title ("# WDA failure") and the
-            // prose around a quote ("says a command failed") would pass anything.
-            for (const { category, patterns } of failure_analysis_service_1.ERROR_PATTERNS) {
+            // A category's name can mislead (a tester's "app crash" on Android is
+            // mostly filed Element not found), so a runbook has to say what really
+            // files a failure there: it must quote one of its rule's codes or
+            // phrases. Only quoted text in the body counts: the title and the prose
+            // around a quote would pass anything.
+            for (const { category, codes, phrases } of failureCategories_1.FAILURE_RULES) {
                 const { markdown } = RUNBOOKS[runbookKey(category)];
                 const body = markdown.split('\n').slice(1).join(' ').replace(/\s+/g, ' ');
-                const quoted = Array.from(body.matchAll(/"([^"]+)"/g), (m) => m[1]);
-                (0, chai_1.expect)(patterns.some((p) => quoted.some((q) => new RegExp(p, 'i').test(q))), `the ${category} runbook quotes none of ${JSON.stringify(patterns)}`).to.equal(true);
+                const quoted = Array.from(body.matchAll(/"([^"]+)"/g), (m) => m[1].toLowerCase());
+                const texts = [...codes, ...phrases];
+                (0, chai_1.expect)(texts.some((t) => quoted.some((q) => q.includes(t.toLowerCase()))), `the ${category} runbook quotes none of ${JSON.stringify(texts)}`).to.equal(true);
             }
         });
-        it('every runbook is for a category the server writes', () => {
-            const written = WRITTEN.map(runbookKey);
+        it('every runbook is for a category a session can hold', () => {
+            const stored = STORED.map(runbookKey);
             for (const key of Object.keys(RUNBOOKS)) {
-                (0, chai_1.expect)(written, `runbook "${key}"`).to.include(key);
+                (0, chai_1.expect)(stored, `runbook "${key}"`).to.include(key);
             }
         });
         it('a stored category opens its own runbook from the "Why it failed" card', () => {
             var _a, _b;
             // failure-summary.tsx links /runbooks/<the category, lower case>.
             const linked = (category) => RUNBOOKS[runbookKey(category.toLowerCase())];
-            (0, chai_1.expect)((_a = linked(SessionManager_1.HUB_RESTART_CATEGORY)) === null || _a === void 0 ? void 0 : _a.title).to.equal('Hub restart');
+            (0, chai_1.expect)((_a = linked(failureCategories_1.HUB_RESTART_CATEGORY)) === null || _a === void 0 ? void 0 : _a.title).to.equal('Hub restart');
             (0, chai_1.expect)((_b = linked('TIMEOUT')) === null || _b === void 0 ? void 0 : _b.title).to.equal('Timeout');
             (0, chai_1.expect)(linked('UNKNOWN')).to.equal(RUNBOOKS.unknown);
         });