@xenon-device-management/xenon 2.9.2 → 2.10.1

package/lib/test/unit/selector-verification-missed-regression.spec.js

@@ -0,0 +1,132 @@
+"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 scratch_database_1 = require("../helpers/scratch-database");
+const SelectorVerificationJob_1 = require("../../src/services/SelectorVerificationJob");
+const HOUR = 60 * 60 * 1000;
+/**
+ * A heal of a selector someone marked fixed turns it back to "To fix" at once
+ * (SelectorStateService.onHealRecorded, called after the heal is written). That
+ * call can fail, say on a busy database, and nothing tried again: the selector
+ * stayed "being verified", and was even promoted to fixed once three other
+ * builds ran clean. The verification job now catches such a heal.
+ */
+describe('SelectorVerificationJob catches a heal the live check missed', function () {
+    this.timeout(90000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let socket;
+    const now = Date.now();
+    const fixedAt = new Date(now - 48 * HOUR);
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        for (const b of ['mr-b1', 'mr-b2', 'mr-b3', 'mr-b4']) {
+            yield scratch.db.build.create({ data: { id: b, name: b } });
+            yield scratch.db.session.create({
+                data: {
+                    id: `mr-s-${b}`,
+                    build_id: b,
+                    device_udid: 'mr-phone',
+                    device_platform: 'android',
+                    device_version: '14',
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: 'localhost',
+                    has_live_video: false,
+                },
+            });
+        }
+    }));
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.selectorEvent.deleteMany();
+        yield scratch.db.selectorState.deleteMany();
+        yield scratch.db.sessionLog.deleteMany();
+        socket = { emitToDashboard: sinon_1.default.stub() };
+    }));
+    const find = (build, selector, healed, at) => scratch.db.sessionLog.create({
+        data: {
+            session_id: `mr-s-${build}`,
+            command_name: 'findElement',
+            url: '/element',
+            method: 'POST',
+            title: 'Find element',
+            response: '{}',
+            is_healed: healed,
+            original_strategy: 'xpath',
+            original_selector: selector,
+            createdAt: new Date(at),
+        },
+    });
+    const state = (selector, status) => scratch.db.selectorState.create({
+        data: {
+            original_strategy: 'xpath',
+            original_selector: selector,
+            status,
+            fixed_at: fixedAt,
+            resolved_at: status === 'resolved' ? new Date(now - 24 * HOUR) : null,
+            clean_builds_count: status === 'resolved' ? 3 : 0,
+        },
+    });
+    const run = () => new SelectorVerificationJob_1.SelectorVerificationJob(scratch.db, socket).run();
+    const rowOf = (selector) => scratch.db.selectorState.findUniqueOrThrow({
+        where: {
+            original_strategy_original_selector: {
+                original_strategy: 'xpath',
+                original_selector: selector,
+            },
+        },
+    });
+    const actionsOf = (selector) => __awaiter(this, void 0, void 0, function* () {
+        return (yield scratch.db.selectorEvent.findMany({
+            where: { original_selector: selector },
+            orderBy: { createdAt: 'asc' },
+        })).map((e) => e.action);
+    });
+    it('sends a selector being verified back to fix, rather than promoting it', () => __awaiter(this, void 0, void 0, function* () {
+        yield state('//pending/broke', 'pending');
+        // Three clean builds since it was marked fixed, and one that healed.
+        for (const b of ['mr-b1', 'mr-b2', 'mr-b3'])
+            yield find(b, '//pending/broke', false, now - HOUR);
+        yield find('mr-b4', '//pending/broke', true, now - 2 * HOUR);
+        yield run();
+        const row = yield rowOf('//pending/broke');
+        (0, chai_1.expect)(row).to.include({ status: 'active', regression_count: 1, clean_builds_count: 0 });
+        (0, chai_1.expect)(row.fixed_at).to.equal(null);
+        (0, chai_1.expect)(yield actionsOf('//pending/broke')).to.deep.equal(['broke_again']);
+        (0, chai_1.expect)(socket.emitToDashboard.firstCall.args[0]).to.equal('selector_regressed');
+    }));
+    it('sends a fixed selector back to fix', () => __awaiter(this, void 0, void 0, function* () {
+        yield state('//resolved/broke', 'resolved');
+        yield find('mr-b1', '//resolved/broke', true, now - HOUR);
+        yield run();
+        const row = yield rowOf('//resolved/broke');
+        (0, chai_1.expect)(row).to.include({ status: 'active', regression_count: 1 });
+        (0, chai_1.expect)(row.resolved_at).to.equal(null);
+        (0, chai_1.expect)(yield actionsOf('//resolved/broke')).to.deep.equal(['broke_again']);
+    }));
+    it('leaves alone a selector that healed only before it was marked fixed', () => __awaiter(this, void 0, void 0, function* () {
+        yield state('//pending/clean', 'pending');
+        yield state('//resolved/clean', 'resolved');
+        yield find('mr-b1', '//pending/clean', true, fixedAt.getTime() - HOUR);
+        yield find('mr-b1', '//resolved/clean', true, fixedAt.getTime() - HOUR);
+        for (const b of ['mr-b1', 'mr-b2', 'mr-b3'])
+            yield find(b, '//pending/clean', false, now - HOUR);
+        yield run();
+        (0, chai_1.expect)((yield rowOf('//pending/clean')).status).to.equal('resolved');
+        (0, chai_1.expect)((yield rowOf('//resolved/clean')).status).to.equal('resolved');
+        (0, chai_1.expect)(yield actionsOf('//pending/clean')).to.deep.equal(['verified']);
+        (0, chai_1.expect)(yield actionsOf('//resolved/clean')).to.deep.equal([]);
+    }));
+});

package/lib/test/unit/session-log-indexes.spec.js

@@ -0,0 +1,147 @@
+"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 typedi_1 = require("typedi");
+const CleanupService_1 = require("../../src/services/CleanupService");
+const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
+/** The SQL statements `run` makes. */
+function sqlOf(db, run) {
+    return __awaiter(this, void 0, void 0, function* () {
+        db.queries.length = 0;
+        yield run();
+        return db.queries.slice();
+    });
+}
+/** How SQLite reads `table` in these statements: one line per step. */
+function stepsOn(db, table, queries) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const steps = [];
+        for (const q of queries) {
+            if (!q.query.includes(`\`${table}\``))
+                continue;
+            // SQLite plans without looking at the values, and Prisma's logged
+            // parameters aren't JSON, so every placeholder gets null.
+            const placeholders = ((_a = q.query.match(/\?/g)) !== null && _a !== void 0 ? _a : []).length;
+            const plan = yield db.db.$queryRawUnsafe(`EXPLAIN QUERY PLAN ${q.query}`, ...new Array(placeholders).fill(null));
+            steps.push(...plan.map((p) => p.detail).filter((d) => new RegExp(`\\b${table}\\b`).test(d)));
+        }
+        return steps;
+    });
+}
+/** The steps that walk the whole table, or a whole index of it. */
+const scansOf = (table, steps) => steps.filter((s) => new RegExp(`^SCAN (main\\.)?${table}\\b`).test(s));
+const getAs = (auth, path) => () => __awaiter(void 0, void 0, void 0, function* () {
+    const res = yield (0, supertest_1.default)((0, selector_health_fixture_1.selectorHealthApp)(auth)).get(path);
+    (0, chai_1.expect)(res.status, `${path}: ${res.text}`).to.equal(200);
+});
+/**
+ * SessionLog holds every command of every session, so a read that scans it
+ * costs as much as the lab's whole history: on a million commands, the
+ * "To fix" list took 2.5 s and a session's own commands 80 ms. Each read
+ * these pages make must find its rows through an index.
+ */
+describe('SessionLog is read through an index', function () {
+    this.timeout(30000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)({ captureQueries: true });
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        yield (0, selector_health_fixture_1.seedSelectorHealth)(scratch.db);
+    }));
+    const cases = [
+        ['the summary', selector_health_fixture_1.ADMIN, '/healing/summary?windowDays=365&tz=330'],
+        ["a member's summary", selector_health_fixture_1.MEMBER_A, '/healing/summary?windowDays=30'],
+        ['"To fix"', selector_health_fixture_1.ADMIN, '/healing/selectors?tab=fix&days=365'],
+        ['"To fix" with a search', selector_health_fixture_1.ADMIN, '/healing/selectors?tab=fix&days=30&q=confirm'],
+        ['"To fix" on one platform', selector_health_fixture_1.ADMIN, '/healing/selectors?tab=fix&days=30&platform=android'],
+        ['a member\'s "To fix"', selector_health_fixture_1.MEMBER_A, '/healing/selectors?tab=fix&days=30'],
+        ['"Fixed"', selector_health_fixture_1.ADMIN, '/healing/selectors?tab=fixed&days=30'],
+        ['a member\'s "Fixed"', selector_health_fixture_1.MEMBER_A, '/healing/selectors?tab=fixed&days=30'],
+        [
+            'the panel',
+            selector_health_fixture_1.ADMIN,
+            `/healing/selectors/detail?strategy=xpath&selector=${encodeURIComponent(selector_health_fixture_1.SEL.hot)}&days=365`,
+        ],
+        [
+            "a member's panel",
+            selector_health_fixture_1.MEMBER_A,
+            `/healing/selectors/detail?strategy=xpath&selector=${encodeURIComponent(selector_health_fixture_1.SEL.hot)}&days=30`,
+        ],
+        ["a session's commands", selector_health_fixture_1.ADMIN, '/session/sh-s-shared-1/session_log'],
+    ];
+    for (const [name, auth, path] of cases) {
+        it(`reads ${name} without a scan`, () => __awaiter(this, void 0, void 0, function* () {
+            const steps = yield stepsOn(scratch, 'SessionLog', yield sqlOf(scratch, getAs(auth, path)));
+            (0, chai_1.expect)(steps, 'no SessionLog statement was captured').to.not.be.empty;
+            (0, chai_1.expect)(scansOf('SessionLog', steps), steps.join('\n')).to.deep.equal([]);
+        }));
+    }
+});
+/**
+ * A session's device logs (hundreds of lines a session) and the profiling
+ * rows sessions wrote before 2.10 are read by session on every session page,
+ * and deleted by session in cleanup. Neither table had an index on it.
+ */
+describe("A session's logs and profiling are read through an index", function () {
+    this.timeout(30000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)({ captureQueries: true });
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.build.create({ data: { id: 'ix-build', name: 'ix' } });
+        yield scratch.db.session.create({
+            data: {
+                id: 'ix-session',
+                build_id: 'ix-build',
+                device_udid: 'ix-phone',
+                device_platform: 'android',
+                device_version: '14',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'localhost',
+                has_live_video: false,
+            },
+        });
+        yield scratch.db.log.createMany({
+            data: [
+                { session_id: 'ix-session', log_type: 'DEVICE', message: 'I/ActivityManager: start' },
+                { session_id: 'ix-session', log_type: 'DEBUG', message: 'step 1' },
+            ],
+        });
+        yield scratch.db.profiling.create({
+            data: { session_id: 'ix-session', cpu: '12', memory: '200', timestamp: new Date() },
+        });
+    }));
+    const reads = [
+        ['device logs', 'Log', '/session/ix-session/logs/device'],
+        ['debug logs', 'Log', '/session/ix-session/logs/debug'],
+        ['profiling', 'Profiling', '/session/ix-session/profiling'],
+    ];
+    for (const [name, table, path] of reads) {
+        it(`reads a session's ${name} without a scan`, () => __awaiter(this, void 0, void 0, function* () {
+            const steps = yield stepsOn(scratch, table, yield sqlOf(scratch, getAs(selector_health_fixture_1.ADMIN, path)));
+            (0, chai_1.expect)(steps, `no ${table} statement was captured`).to.not.be.empty;
+            (0, chai_1.expect)(scansOf(table, steps), steps.join('\n')).to.deep.equal([]);
+        }));
+    }
+    it("deletes a session's commands, logs and profiling without a scan", () => __awaiter(this, void 0, void 0, function* () {
+        const ran = yield sqlOf(scratch, () => typedi_1.Container.get(CleanupService_1.CleanupService).purgeBuild('ix-build', false));
+        for (const table of ['SessionLog', 'Log', 'Profiling']) {
+            const steps = yield stepsOn(scratch, table, ran);
+            (0, chai_1.expect)(steps, `no ${table} statement was captured`).to.not.be.empty;
+            (0, chai_1.expect)(scansOf(table, steps), `${table}:\n${steps.join('\n')}`).to.deep.equal([]);
+        }
+    }));
+});

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');
+    }));
+});