@xenon-device-management/xenon 2.9.1 → 2.10.0

package/lib/test/unit/selector-health-list.spec.js

@@ -0,0 +1,185 @@
+"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 supertest_1 = __importDefault(require("supertest"));
+const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
+const selectorList_1 = require("../../src/services/selector-health/selectorList");
+describe('selector list: the query', () => {
+    it('reads every field, and falls back for anything it does not know', () => {
+        (0, chai_1.expect)((0, selectorList_1.parseSelectorListQuery)({})).to.deep.equal({
+            tab: 'fix',
+            days: 30,
+            q: '',
+            platform: null,
+            method: null,
+            sort: 'heals',
+            page: 1,
+            pageSize: 50,
+        });
+        (0, chai_1.expect)((0, selectorList_1.parseSelectorListQuery)({
+            tab: 'muted',
+            days: '7',
+            q: '  confirm ',
+            platform: 'ios',
+            method: 'LLM',
+            sort: 'time',
+            page: '3',
+            pageSize: '20',
+        })).to.deep.equal({
+            tab: 'muted',
+            days: 7,
+            q: 'confirm',
+            platform: 'ios',
+            method: 'LLM',
+            sort: 'time',
+            page: 3,
+            pageSize: 20,
+        });
+        (0, chai_1.expect)((0, selectorList_1.parseSelectorListQuery)({
+            tab: 'active',
+            days: '9999',
+            sort: 'random',
+            page: '-2',
+            pageSize: '1000',
+        })).to.include({ tab: 'fix', days: 365, sort: 'heals', page: 1, pageSize: 100 });
+    });
+});
+describe('GET /healing/selectors (real queries)', function () {
+    this.timeout(90000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        yield (0, selector_health_fixture_1.seedSelectorHealth)(scratch.db);
+    }));
+    const list = (auth, qs = '') => (0, supertest_1.default)((0, selector_health_fixture_1.selectorHealthApp)(auth)).get(`/healing/selectors${qs}`);
+    const names = (res) => res.body.items.map((i) => i.selector);
+    it('lists what to fix, most heals first, with every tab counted', () => __awaiter(this, void 0, void 0, function* () {
+        const res = yield list(selector_health_fixture_1.ADMIN);
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(names(res)).to.deep.equal([selector_health_fixture_1.SEL.hot, selector_health_fixture_1.SEL.bOnly, selector_health_fixture_1.SEL.warm, selector_health_fixture_1.SEL.legacy, selector_health_fixture_1.SEL.odd]);
+        (0, chai_1.expect)(res.body.counts).to.deep.equal({ fix: 5, verifying: 1, fixed: 1, muted: 2 });
+        (0, chai_1.expect)(res.body).to.include({
+            tab: 'fix',
+            days: 30,
+            page: 1,
+            pageSize: 50,
+            total: 5,
+            canAct: true,
+        });
+    }));
+    it('describes each selector: heals, sessions, time, method, suggestion and status', () => __awaiter(this, void 0, void 0, function* () {
+        const hot = (yield list(selector_health_fixture_1.ADMIN)).body.items[0];
+        (0, chai_1.expect)(hot).to.deep.include({
+            strategy: 'xpath',
+            selector: selector_health_fixture_1.SEL.hot,
+            heals: 4,
+            sessions: 2,
+            timeSpentMs: 18000,
+            topMethod: 'Visual AI',
+        });
+        (0, chai_1.expect)(hot.suggestion).to.deep.equal({ selector: selector_health_fixture_1.FIX.hot, strategy: 'xpath', share: 0.75 });
+        (0, chai_1.expect)(hot.state).to.include({ status: 'active', brokeAgain: 2 });
+        (0, chai_1.expect)(Date.now() - Date.parse(hot.lastHealedAt)).to.be.within(0.9 * selector_health_fixture_1.HOUR, 1.5 * selector_health_fixture_1.HOUR);
+    }));
+    it('lists a heal with no strategy under an empty one', () => __awaiter(this, void 0, void 0, function* () {
+        const legacy = (yield list(selector_health_fixture_1.ADMIN)).body.items.find((i) => i.selector === selector_health_fixture_1.SEL.legacy);
+        (0, chai_1.expect)(legacy).to.deep.include({ strategy: '', heals: 1 });
+    }));
+    it('shows a member only selectors healed in sessions they can see, and counts only those', () => __awaiter(this, void 0, void 0, function* () {
+        const res = yield list(selector_health_fixture_1.MEMBER_A);
+        (0, chai_1.expect)(names(res)).to.deep.equal([selector_health_fixture_1.SEL.hot, selector_health_fixture_1.SEL.warm, selector_health_fixture_1.SEL.legacy, selector_health_fixture_1.SEL.odd]);
+        (0, chai_1.expect)(res.body.counts).to.deep.equal({ fix: 4, verifying: 1, fixed: 1, muted: 1 });
+    }));
+    it('sorts by most recent and by most time spent healing', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?sort=recent'))).to.deep.equal([
+            selector_health_fixture_1.SEL.hot,
+            selector_health_fixture_1.SEL.legacy,
+            selector_health_fixture_1.SEL.odd,
+            selector_health_fixture_1.SEL.bOnly,
+            selector_health_fixture_1.SEL.warm,
+        ]);
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?sort=time'))).to.deep.equal([
+            selector_health_fixture_1.SEL.warm,
+            selector_health_fixture_1.SEL.hot,
+            selector_health_fixture_1.SEL.bOnly,
+            selector_health_fixture_1.SEL.legacy,
+            selector_health_fixture_1.SEL.odd,
+        ]);
+    }));
+    it('searches the selector and its suggested fix, taking the text literally', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?q=CONFIRM'))).to.deep.equal([selector_health_fixture_1.SEL.hot]);
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, `?q=${encodeURIComponent('cart_total_v2')}`))).to.deep.equal([
+            selector_health_fixture_1.SEL.warm,
+        ]);
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, `?q=${encodeURIComponent('%')}`))).to.deep.equal([selector_health_fixture_1.SEL.odd]);
+    }));
+    it('filters what to fix by platform and by healing method, keeping the counts whole', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?platform=ios'))).to.deep.equal([selector_health_fixture_1.SEL.bOnly]);
+        const llm = yield list(selector_health_fixture_1.ADMIN, '?method=LLM');
+        (0, chai_1.expect)(names(llm)).to.deep.equal([selector_health_fixture_1.SEL.hot]);
+        (0, chai_1.expect)(llm.body.items[0]).to.deep.include({ heals: 1, topMethod: 'LLM' });
+        (0, chai_1.expect)(llm.body.counts.fix).to.equal(5);
+    }));
+    it('pages, and shows the last page for a page past the end', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?pageSize=2&page=2'))).to.deep.equal([selector_health_fixture_1.SEL.warm, selector_health_fixture_1.SEL.legacy]);
+        const past = yield list(selector_health_fixture_1.ADMIN, '?pageSize=2&page=99');
+        (0, chai_1.expect)(past.body.page).to.equal(3);
+        (0, chai_1.expect)(past.body.total).to.equal(5);
+        (0, chai_1.expect)(names(past)).to.deep.equal([selector_health_fixture_1.SEL.odd]);
+    }));
+    it('lists selectors being verified, with their progress and who marked them fixed', () => __awaiter(this, void 0, void 0, function* () {
+        const res = yield list(selector_health_fixture_1.MEMBER_A, '?tab=verifying');
+        (0, chai_1.expect)(names(res)).to.deep.equal([selector_health_fixture_1.SEL.pending]);
+        (0, chai_1.expect)(res.body.items[0].heals).to.equal(1);
+        (0, chai_1.expect)(res.body.items[0].state).to.deep.include({
+            status: 'pending',
+            cleanBuilds: 2,
+            fixedBy: { id: selector_health_fixture_1.USER.priya, name: 'Priya' },
+        });
+    }));
+    it('lists selectors fixed in the period, with or without a heal in it', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?tab=fixed'))).to.deep.equal([selector_health_fixture_1.SEL.fixed]);
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?tab=fixed&days=90'))).to.deep.equal([selector_health_fixture_1.SEL.fixed, selector_health_fixture_1.SEL.fixedOld]);
+        const week = yield list(selector_health_fixture_1.ADMIN, '?tab=fixed&days=7');
+        (0, chai_1.expect)(names(week)).to.deep.equal([selector_health_fixture_1.SEL.fixed]);
+        (0, chai_1.expect)(week.body.items[0]).to.deep.include({
+            heals: 0,
+            sessions: 0,
+            lastHealedAt: null,
+            suggestion: null,
+        });
+    }));
+    it('names nobody for an action by a user who is gone', () => __awaiter(this, void 0, void 0, function* () {
+        const fixed = (yield list(selector_health_fixture_1.ADMIN, '?tab=fixed')).body.items[0];
+        (0, chai_1.expect)(fixed.state.fixedBy).to.deep.equal({ id: selector_health_fixture_1.USER.gone, name: null });
+    }));
+    it('lists muted selectors with who muted them and why, only those a member can see', () => __awaiter(this, void 0, void 0, function* () {
+        const res = yield list(selector_health_fixture_1.MEMBER_A, '?tab=muted');
+        (0, chai_1.expect)(names(res)).to.deep.equal([selector_health_fixture_1.SEL.muted]);
+        (0, chai_1.expect)(res.body.items[0].state).to.deep.include({
+            status: 'muted',
+            mutedBy: { id: selector_health_fixture_1.USER.priya, name: 'Priya' },
+            muteReason: 'Screen being redesigned',
+        });
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?tab=muted'))).to.deep.equal([selector_health_fixture_1.SEL.muted, selector_health_fixture_1.SEL.mutedB]);
+    }));
+    it('searches a status tab by selector', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)(names(yield list(selector_health_fixture_1.ADMIN, '?tab=muted&q=team-b'))).to.deep.equal([selector_health_fixture_1.SEL.mutedB]);
+    }));
+    it('tells a caller without the sessions scope that they cannot act', () => __awaiter(this, void 0, void 0, function* () {
+        (0, chai_1.expect)((yield list(selector_health_fixture_1.READ_ONLY_A)).body.canAct).to.equal(false);
+    }));
+});

package/lib/test/unit/selector-state-service.spec.js

@@ -23,14 +23,18 @@ const SocketEvents_1 = require("../../src/enums/SocketEvents");
  * the resolved value explicitly.
  */
 function buildPrismaStub() {
-    return {
+    const stub = {
         selectorState: {
             findUnique: sinon_1.default.stub(),
             upsert: sinon_1.default.stub(),
             update: sinon_1.default.stub(),
             delete: sinon_1.default.stub(),
         },
+        selectorEvent: { create: sinon_1.default.stub().resolves({}) },
     };
+    // A transaction runs its callback against the same tables, as Prisma's does.
+    stub.$transaction = sinon_1.default.stub().callsFake((fn) => fn(stub));
+    return stub;
 }
 function buildSocketStub() {
     return {
@@ -410,4 +414,73 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(result).to.equal(null);
         }));
     });
+    describe('what each change records', () => {
+        const ctx = { strategy: STRATEGY, selector: SELECTOR, apiKeyId: API_KEY_ID, userId: 'user-1' };
+        const recorded = () => prismaStub.selectorEvent.create.firstCall.args[0].data;
+        it('records who marked it fixed, in the same transaction as the status', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'pending', fixed_at: new Date() }));
+            yield svc.markFixed(ctx);
+            (0, chai_1.expect)(prismaStub.$transaction.calledOnce).to.equal(true);
+            (0, chai_1.expect)(recorded()).to.deep.equal({
+                original_strategy: STRATEGY,
+                original_selector: SELECTOR,
+                action: 'marked_fixed',
+                user_id: 'user-1',
+                reason: null,
+            });
+            (0, chai_1.expect)(prismaStub.selectorEvent.create.calledAfter(prismaStub.selectorState.upsert)).to.equal(true);
+        }));
+        it('fails the change, and tells nobody, when its record cannot be written', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'pending' }));
+            prismaStub.selectorEvent.create.rejects(new Error('disk full'));
+            let thrown;
+            try {
+                yield svc.markFixed(ctx);
+            }
+            catch (e) {
+                thrown = e;
+            }
+            (0, chai_1.expect)(thrown.message).to.equal('disk full');
+            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+        }));
+        it('records the mute with its reason', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted', muted_at: new Date() }));
+            yield svc.mute(Object.assign(Object.assign({}, ctx), { reason: 'Screen being redesigned' }));
+            (0, chai_1.expect)(recorded()).to.include({
+                action: 'muted',
+                user_id: 'user-1',
+                reason: 'Screen being redesigned',
+            });
+        }));
+        it('records an unmute, and nothing for a selector that is not muted', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted', muted_at: new Date() }));
+            prismaStub.selectorState.delete.resolves(makeRow());
+            yield svc.unmute(ctx);
+            (0, chai_1.expect)(recorded()).to.include({ action: 'unmuted', user_id: 'user-1' });
+            prismaStub.selectorEvent.create.resetHistory();
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'active' }));
+            yield svc.unmute(ctx);
+            (0, chai_1.expect)(prismaStub.selectorEvent.create.called).to.equal(false);
+        }));
+        it('records a cancelled verification', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending', fixed_at: new Date() }));
+            prismaStub.selectorState.delete.resolves(makeRow());
+            yield svc.cancelVerification(ctx);
+            (0, chai_1.expect)(recorded()).to.include({ action: 'verification_cancelled', user_id: 'user-1' });
+        }));
+        it('records a selector breaking again, with nobody as its person', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'resolved', resolved_at: new Date() }));
+            prismaStub.selectorState.update.resolves(makeRow({ status: 'active', regression_count: 1 }));
+            yield svc.onHealRecorded({ strategy: STRATEGY, selector: SELECTOR, sessionId: SESSION_ID });
+            (0, chai_1.expect)(recorded()).to.include({ action: 'broke_again', user_id: null, reason: null });
+        }));
+        it('records nothing for a heal on a selector with no status', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            yield svc.onHealRecorded({ strategy: STRATEGY, selector: SELECTOR, sessionId: SESSION_ID });
+            (0, chai_1.expect)(prismaStub.$transaction.called).to.equal(false);
+            (0, chai_1.expect)(prismaStub.selectorEvent.create.called).to.equal(false);
+        }));
+    });
 });

package/lib/test/unit/selector-verification-job.spec.js

@@ -40,8 +40,12 @@ describe('SelectorVerificationJob.run', () => {
                 findMany: sinon_1.default.stub(),
                 update: sinon_1.default.stub().resolves({}),
             },
+            selectorEvent: { create: sinon_1.default.stub().resolves({}) },
             $queryRaw: sinon_1.default.stub(),
         };
+        prismaStub.$transaction = sinon_1.default
+            .stub()
+            .callsFake((fn) => fn(prismaStub));
         socketStub = { emitToDashboard: sinon_1.default.stub() };
         job = new SelectorVerificationJob_1.SelectorVerificationJob(prismaStub, socketStub);
     });
@@ -203,4 +207,38 @@ describe('SelectorVerificationJob.run', () => {
         yield job.run();
         (0, chai_1.expect)(prismaStub.$queryRaw.called).to.be.false;
     }));
+    it('records the verification, with nobody as its person', () => __awaiter(void 0, void 0, void 0, function* () {
+        prismaStub.selectorState.findMany.resolves([
+            {
+                id: 'r-1',
+                original_strategy: 'xpath',
+                original_selector: '//x',
+                status: 'pending',
+                fixed_at: new Date('2026-04-20T00:00:00Z'),
+                clean_builds_count: 2,
+            },
+        ]);
+        prismaStub.$queryRaw.resolves([
+            { build_id: 'b-1', healed: 0 },
+            { build_id: 'b-2', healed: 0 },
+            { build_id: 'b-3', healed: 0 },
+        ]);
+        prismaStub.selectorState.update.resolves({
+            id: 'r-1',
+            original_strategy: 'xpath',
+            original_selector: '//x',
+            status: 'resolved',
+            clean_builds_count: 3,
+            resolved_at: new Date(),
+        });
+        yield job.run();
+        (0, chai_1.expect)(prismaStub.selectorEvent.create.calledOnce).to.equal(true);
+        (0, chai_1.expect)(prismaStub.selectorEvent.create.firstCall.args[0].data).to.deep.equal({
+            original_strategy: 'xpath',
+            original_selector: '//x',
+            action: 'verified',
+            user_id: null,
+            reason: null,
+        });
+    }));
 });

package/lib/test/unit/session-metrics-parse.spec.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const androidMetrics_1 = require("../../src/services/metrics/androidMetrics");
+const iosMetrics_1 = require("../../src/services/metrics/iosMetrics");
+/**
+ * Recorded on the S9+ (Android 10) with the command androidSampleCommand
+ * builds; the second reading is the first plus 1000 jiffies, 800 of them
+ * idle, and 50 for the app.
+ */
+const FIRST = [
+    'cpu  4842746 1486246 9435122 410569805 191176 0 106298 0 0 0',
+    'MemTotal:        5755748 kB',
+    'MemAvailable:    2839168 kB',
+    'pid=1404',
+    'stat=211391 93546',
+    'VmRSS:\t  334480 kB',
+].join('\n');
+const SECOND = [
+    'cpu  4842846 1486246 9435222 410570595 191186 0 106298 0 0 0',
+    'MemTotal:        5755748 kB',
+    'MemAvailable:    2838144 kB',
+    'pid=1404',
+    'stat=211421 93566',
+    'VmRSS:\t  335504 kB',
+].join('\n');
+/** A reading the test knows is readable. */
+function read(out) {
+    const r = (0, androidMetrics_1.parseAndroidReading)(out);
+    if (!r)
+        throw new Error('unreadable sample');
+    return r;
+}
+describe('session metrics: Android readings', () => {
+    it('reads device CPU jiffies, memory, and the app process', () => {
+        (0, chai_1.expect)((0, androidMetrics_1.parseAndroidReading)(FIRST)).to.deep.equal({
+            cpuTotal: 4842746 + 1486246 + 9435122 + 410569805 + 191176 + 0 + 106298 + 0,
+            cpuIdle: 410569805 + 191176,
+            memTotalKb: 5755748,
+            memAvailableKb: 2839168,
+            pid: 1404,
+            appJiffies: 211391 + 93546,
+            appRssKb: 334480,
+        });
+    });
+    it('reads a device with no app process as device figures only', () => {
+        const out = [FIRST.split('\n')[0], FIRST.split('\n')[1], FIRST.split('\n')[2], 'pid='].join('\n');
+        (0, chai_1.expect)((0, androidMetrics_1.parseAndroidReading)(out)).to.include({ pid: null, appJiffies: null, appRssKb: null });
+    });
+    it('reads output with CRLF line ends', () => {
+        (0, chai_1.expect)((0, androidMetrics_1.parseAndroidReading)(FIRST.replace(/\n/g, '\r\n'))).to.include({
+            pid: 1404,
+            appRssKb: 334480,
+        });
+    });
+    it('gives up on output without the cpu line', () => {
+        (0, chai_1.expect)((0, androidMetrics_1.parseAndroidReading)('MemTotal: 5755748 kB')).to.equal(null);
+    });
+    it('records no CPU on the first sample, only memory', () => {
+        const s = (0, androidMetrics_1.androidSample)(null, read(FIRST), 'com.android.systemui', 1000);
+        (0, chai_1.expect)(s).to.deep.equal({
+            at: 1000,
+            deviceCpuPct: null,
+            deviceMemMb: 2848.2,
+            deviceMemTotalMb: 5620.8,
+            appCpuPct: null,
+            appMemMb: 326.6,
+            appId: 'com.android.systemui',
+        });
+    });
+    it('turns two readings into device and app CPU as shares of the whole device', () => {
+        const s = (0, androidMetrics_1.androidSample)((0, androidMetrics_1.parseAndroidReading)(FIRST), read(SECOND), 'com.android.systemui', 3000);
+        (0, chai_1.expect)(s.deviceCpuPct).to.equal(20);
+        (0, chai_1.expect)(s.appCpuPct).to.equal(5);
+        (0, chai_1.expect)(s.appMemMb).to.equal(327.6);
+    });
+    it('records no app CPU, not a spike, when the app restarted between samples', () => {
+        const restarted = SECOND.replace('pid=1404', 'pid=2210').replace('stat=211421 93566', 'stat=12 8');
+        const s = (0, androidMetrics_1.androidSample)((0, androidMetrics_1.parseAndroidReading)(FIRST), read(restarted), 'com.android.systemui', 3000);
+        (0, chai_1.expect)(s.appCpuPct).to.equal(null);
+        (0, chai_1.expect)(s.deviceCpuPct).to.equal(20);
+        (0, chai_1.expect)(s.appMemMb).to.equal(327.6);
+    });
+    it('names no app when the app has no process', () => {
+        const none = [SECOND.split('\n')[0], SECOND.split('\n')[1], SECOND.split('\n')[2], 'pid='].join('\n');
+        const s = (0, androidMetrics_1.androidSample)((0, androidMetrics_1.parseAndroidReading)(FIRST), read(none), 'com.acme.shop', 3000);
+        (0, chai_1.expect)(s).to.include({ appId: null, appCpuPct: null, appMemMb: null, deviceCpuPct: 20 });
+    });
+});
+describe('session metrics: Android package names', () => {
+    it('accepts package names and nothing else', () => {
+        for (const ok of ['com.acme.shop', 'com.sec.android.app.launcher', 'io.x_y.App2']) {
+            (0, chai_1.expect)((0, androidMetrics_1.isSafePackage)(ok), ok).to.equal(true);
+        }
+        for (const bad of [
+            '',
+            'shop',
+            'com.acme;reboot',
+            '$(id).x',
+            'com.acme shop',
+            'com..x',
+            '1com.x',
+            undefined,
+            42,
+        ]) {
+            (0, chai_1.expect)((0, androidMetrics_1.isSafePackage)(bad), String(bad)).to.equal(false);
+        }
+    });
+    it("reads a session's appPackage from either capability spelling", () => {
+        (0, chai_1.expect)((0, androidMetrics_1.appPackageOf)({ 'appium:appPackage': 'com.a.b' })).to.equal('com.a.b');
+        (0, chai_1.expect)((0, androidMetrics_1.appPackageOf)({ appPackage: 'com.c.d' })).to.equal('com.c.d');
+        (0, chai_1.expect)((0, androidMetrics_1.appPackageOf)({})).to.equal(undefined);
+        (0, chai_1.expect)((0, androidMetrics_1.appPackageOf)(undefined)).to.equal(undefined);
+    });
+    it('builds a device-only command with no package, and refuses anything but a package', () => {
+        (0, chai_1.expect)((0, androidMetrics_1.androidSampleCommand)(null)).to.not.include('pidof');
+        (0, chai_1.expect)((0, androidMetrics_1.androidSampleCommand)('com.acme.shop')).to.include('pidof com.acme.shop');
+        (0, chai_1.expect)(() => (0, androidMetrics_1.androidSampleCommand)('com.acme;reboot')).to.throw(/not a package name/);
+    });
+    it('reads the foreground app from dumpsys, before and after Android 10', () => {
+        (0, chai_1.expect)((0, androidMetrics_1.parseForegroundPackage)('    mResumedActivity: ActivityRecord{c51fd83 u0 com.sec.android.app.launcher/.activities.LauncherActivity t2}')).to.equal('com.sec.android.app.launcher');
+        (0, chai_1.expect)((0, androidMetrics_1.parseForegroundPackage)('  topResumedActivity=ActivityRecord{a1b2c3 u0 com.acme.shop/.MainActivity t12}')).to.equal('com.acme.shop');
+        (0, chai_1.expect)((0, androidMetrics_1.parseForegroundPackage)('nothing resumed')).to.equal(null);
+    });
+});
+describe('session metrics: iPhone sysmontap lines', () => {
+    it('reads device CPU, the load divided over the cores', () => {
+        const line = '{"time":"2026-10-02T11:56:46.322036+05:30","level":"INFO","msg":"received CPU usage data","cpu_count":6,"enabled_cpus":6,"end_time":1301586447413,"cpu_total_load":77.48226950354608}';
+        (0, chai_1.expect)((0, iosMetrics_1.parseSysmontapCpu)(line)).to.equal(12.9);
+    });
+    it('reads nothing from other lines', () => {
+        (0, chai_1.expect)((0, iosMetrics_1.parseSysmontapCpu)('{"level":"WARN","msg":"go-ios agent is not running."}')).to.equal(null);
+        (0, chai_1.expect)((0, iosMetrics_1.parseSysmontapCpu)('not json')).to.equal(null);
+    });
+    it('never reports more than 100%', () => {
+        (0, chai_1.expect)((0, iosMetrics_1.parseSysmontapCpu)('{"enabled_cpus":2,"cpu_total_load":450}')).to.equal(100);
+    });
+});

package/lib/test/unit/session-metrics-route.spec.js

@@ -0,0 +1,140 @@
+"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 express_1 = __importDefault(require("express"));
+const supertest_1 = __importDefault(require("supertest"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+const metricsBody_1 = require("../../src/services/metrics/metricsBody");
+const scratch_database_1 = require("../helpers/scratch-database");
+const row = (at, over = {}) => (Object.assign({ at, device_cpu_pct: 20, device_mem_mb: 2800, device_mem_total: 5620.8, app_cpu_pct: 5, app_mem_mb: 300, app_id: 'com.acme.shop' }, over));
+describe('session metrics: the response', () => {
+    it('says what each platform can record', () => {
+        (0, chai_1.expect)((0, metricsBody_1.seriesFor)('Android')).to.deep.equal({
+            deviceCpu: true,
+            deviceMem: true,
+            appCpu: true,
+            appMem: true,
+        });
+        (0, chai_1.expect)((0, metricsBody_1.seriesFor)('ios')).to.deep.equal({
+            deviceCpu: true,
+            deviceMem: false,
+            appCpu: false,
+            appMem: false,
+        });
+        (0, chai_1.expect)((0, metricsBody_1.seriesFor)('')).to.deep.equal({
+            deviceCpu: false,
+            deviceMem: false,
+            appCpu: false,
+            appMem: false,
+        });
+    });
+    it('passes on whether a running session is being sampled, and nothing for an ended one', () => {
+        (0, chai_1.expect)((0, metricsBody_1.sessionMetricsBody)('android', [], 'off').recording).to.equal('off');
+        (0, chai_1.expect)((0, metricsBody_1.sessionMetricsBody)('android', []).recording).to.equal(null);
+    });
+    it('answers samples in time order, named by the last app recorded', () => {
+        const body = (0, metricsBody_1.sessionMetricsBody)('android', [
+            row(4000, { app_id: null, app_cpu_pct: null, app_mem_mb: null }),
+            row(0, { app_id: 'com.old.app' }),
+            row(2000),
+        ]);
+        (0, chai_1.expect)(body.samples.map((s) => s.t)).to.deep.equal([0, 2000, 4000]);
+        (0, chai_1.expect)(body.appId).to.equal('com.acme.shop');
+        (0, chai_1.expect)(body.intervalMs).to.equal(2000);
+        (0, chai_1.expect)(body.samples[1]).to.deep.equal({
+            t: 2000,
+            deviceCpu: 20,
+            deviceMemMb: 2800,
+            deviceMemTotalMb: 5620.8,
+            appCpu: 5,
+            appMemMb: 300,
+            app: 'com.acme.shop',
+        });
+    });
+    it("names each sample's app, since the foreground app can change", () => {
+        const body = (0, metricsBody_1.sessionMetricsBody)('android', [
+            row(0, { app_id: 'com.a.one' }),
+            row(2000, { app_id: 'com.b.two' }),
+        ]);
+        (0, chai_1.expect)(body.samples.map((s) => s.app)).to.deep.equal(['com.a.one', 'com.b.two']);
+    });
+});
+describe('GET /session/:sessionId/metrics', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    function app() {
+        const a = (0, express_1.default)();
+        a.use((req, _res, next) => {
+            req.auth = {
+                kind: 'user',
+                userId: 'sa',
+                role: 'SUPER_ADMIN',
+                scopes: ['admin', 'devices', 'sessions', 'read'],
+                teamIds: undefined,
+            };
+            next();
+        });
+        dashboard_1.default.register(a);
+        return a;
+    }
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.sessionMetric.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+    }));
+    it("answers a session's samples", () => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.session.create({
+            data: {
+                id: 'metrics-1',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'n',
+                has_live_video: false,
+                device_udid: 'phone-m',
+                device_platform: 'android',
+                device_version: '10',
+            },
+        });
+        yield scratch.db.sessionMetric.createMany({
+            data: [
+                Object.assign({ session_id: 'metrics-1' }, row(2000)),
+                Object.assign({ session_id: 'metrics-1' }, row(0)),
+            ],
+        });
+        const res = yield (0, supertest_1.default)(app()).get('/session/metrics-1/metrics');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body.platform).to.equal('android');
+        (0, chai_1.expect)(res.body.samples.map((s) => s.t)).to.deep.equal([0, 2000]);
+        (0, chai_1.expect)(res.body.series.appMem).to.equal(true);
+    }));
+    it('says a running session nothing samples is not recorded', () => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.session.create({
+            data: {
+                id: 'metrics-2',
+                status: 'running',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'n',
+                has_live_video: false,
+                device_udid: 'sim-1',
+                device_platform: 'ios',
+                device_version: '18.0',
+            },
+        });
+        const res = yield (0, supertest_1.default)(app()).get('/session/metrics-2/metrics');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body.recording).to.equal('off');
+    }));
+});