@xenon-device-management/xenon 2.9.2 → 2.10.0

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

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

@@ -0,0 +1,248 @@
+"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 });
+const chai_1 = require("chai");
+const events_1 = require("events");
+const sinon_1 = __importDefault(require("sinon"));
+const AndroidMetricsSampler_1 = require("../../src/services/metrics/AndroidMetricsSampler");
+const IOSMetricsSampler_1 = require("../../src/services/metrics/IOSMetricsSampler");
+const types_1 = require("../../src/services/metrics/types");
+const reading = (jiffies, idle, app) => [
+    `cpu  ${jiffies - idle} 0 0 ${idle} 0 0 0 0 0 0`,
+    'MemTotal:        5755748 kB',
+    'MemAvailable:    2839168 kB',
+    'pid=1404',
+    `stat=${app} 0`,
+    'VmRSS:\t  334480 kB',
+].join('\n');
+describe('session metrics: AndroidMetricsSampler', () => {
+    let clock;
+    let samples;
+    let gaveUp;
+    const hooks = () => ({
+        onSample: (s) => samples.push(s),
+        onGiveUp: (r) => gaveUp.push(r),
+    });
+    beforeEach(() => {
+        clock = sinon_1.default.useFakeTimers({ now: 1000000 });
+        samples = [];
+        gaveUp = [];
+    });
+    afterEach(() => clock.restore());
+    it("samples the session's app every 2 s, with CPU from the second sample", () => __awaiter(void 0, void 0, void 0, function* () {
+        const commands = [];
+        let n = 0;
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: 'com.acme.shop',
+            hooks: hooks(),
+            shell: (c) => __awaiter(void 0, void 0, void 0, function* () {
+                commands.push(c);
+                n += 1;
+                return reading(1000 * n, 800 * n, 50 * n);
+            }),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS);
+        yield s.stop();
+        (0, chai_1.expect)(commands).to.have.length(2);
+        (0, chai_1.expect)(commands.every((c) => c.includes('pidof com.acme.shop'))).to.equal(true);
+        (0, chai_1.expect)(samples.map((x) => x.deviceCpuPct)).to.deep.equal([null, 20]);
+        (0, chai_1.expect)(samples.map((x) => x.appCpuPct)).to.deep.equal([null, 5]);
+        (0, chai_1.expect)(samples[1].appId).to.equal('com.acme.shop');
+    }));
+    it('with no appPackage, samples the foreground app, looked up once per 10 s', () => __awaiter(void 0, void 0, void 0, function* () {
+        const commands = [];
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: undefined,
+            hooks: hooks(),
+            shell: (c) => __awaiter(void 0, void 0, void 0, function* () {
+                commands.push(c);
+                return c.startsWith('dumpsys')
+                    ? '  topResumedActivity=ActivityRecord{a1 u0 com.acme.shop/.Main t3}'
+                    : reading(1000, 800, 50);
+            }),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS);
+        yield clock.tickAsync(types_1.FOREGROUND_REFRESH_MS);
+        yield s.stop();
+        const lookups = commands.filter((c) => c.startsWith('dumpsys'));
+        (0, chai_1.expect)(lookups).to.have.length(2);
+        (0, chai_1.expect)(commands.filter((c) => c.includes('pidof com.acme.shop')).length).to.be.greaterThan(2);
+    }));
+    it("never puts an appPackage that isn't a package name into a command", () => __awaiter(void 0, void 0, void 0, function* () {
+        const commands = [];
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: 'com.acme;reboot',
+            hooks: hooks(),
+            shell: (c) => __awaiter(void 0, void 0, void 0, function* () {
+                commands.push(c);
+                return c.startsWith('dumpsys') ? '' : reading(1000, 800, 50);
+            }),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield s.stop();
+        (0, chai_1.expect)(commands.some((c) => c.includes('reboot'))).to.equal(false);
+        (0, chai_1.expect)(samples[0].appId).to.equal(null);
+    }));
+    it('stops itself after 5 failures in a row, and says so once', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calls = 0;
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: 'com.acme.shop',
+            hooks: hooks(),
+            shell: () => __awaiter(void 0, void 0, void 0, function* () {
+                calls += 1;
+                throw new Error('device offline');
+            }),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS * (types_1.MAX_CONSECUTIVE_FAILURES + 3));
+        (0, chai_1.expect)(calls).to.equal(types_1.MAX_CONSECUTIVE_FAILURES);
+        (0, chai_1.expect)(gaveUp).to.deep.equal(['device offline']);
+    }));
+    it('starts counting failures again after a good sample', () => __awaiter(void 0, void 0, void 0, function* () {
+        let n = 0;
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: 'com.acme.shop',
+            hooks: hooks(),
+            shell: () => __awaiter(void 0, void 0, void 0, function* () {
+                n += 1;
+                if (n % 4 === 0)
+                    return reading(1000 * n, 800 * n, 50 * n);
+                throw new Error('flaky');
+            }),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS * 12);
+        yield s.stop();
+        (0, chai_1.expect)(gaveUp).to.deep.equal([]);
+        (0, chai_1.expect)(samples.length).to.equal(3);
+    }));
+    it('reports nothing that was in flight when it stopped', () => __awaiter(void 0, void 0, void 0, function* () {
+        let release = () => undefined;
+        const s = new AndroidMetricsSampler_1.AndroidMetricsSampler({
+            appPackage: 'com.acme.shop',
+            hooks: hooks(),
+            shell: () => new Promise((r) => (release = r)),
+        });
+        s.start();
+        yield clock.tickAsync(0);
+        yield s.stop();
+        release(reading(1000, 800, 50));
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS * 3);
+        (0, chai_1.expect)(samples).to.deep.equal([]);
+    }));
+});
+class FakeChild extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.stdout = new events_1.EventEmitter();
+        this.stderr = new events_1.EventEmitter();
+        this.pid = 4321;
+        this.killed = [];
+    }
+    kill(sig) {
+        this.killed.push(sig);
+        return true;
+    }
+}
+describe('session metrics: IOSMetricsSampler', () => {
+    let clock;
+    let samples;
+    let gaveUp;
+    let children;
+    let envs;
+    let borrows;
+    const line = (load) => JSON.stringify({ msg: 'received CPU usage data', enabled_cpus: 6, cpu_total_load: load }) +
+        '\n';
+    function sampler() {
+        return new IOSMetricsSampler_1.IOSMetricsSampler({
+            udid: 'iphone-1',
+            tunnels: {
+                borrow: () => __awaiter(this, void 0, void 0, function* () {
+                    borrows += 1;
+                    return 12100;
+                }),
+                envFor: () => ({ GO_IOS_AGENT_PORT: '12100' }),
+            },
+            spawnSysmontap: (env) => {
+                envs.push(env);
+                const c = new FakeChild();
+                children.push(c);
+                return c;
+            },
+            hooks: { onSample: (s) => samples.push(s), onGiveUp: (r) => gaveUp.push(r) },
+        });
+    }
+    beforeEach(() => {
+        clock = sinon_1.default.useFakeTimers({ now: 1000000 });
+        samples = [];
+        gaveUp = [];
+        children = [];
+        envs = [];
+        borrows = 0;
+    });
+    afterEach(() => clock.restore());
+    it("runs sysmontap through the phone's tunnel and reports device CPU every 2 s", () => __awaiter(void 0, void 0, void 0, function* () {
+        const s = sampler();
+        s.start();
+        yield clock.tickAsync(0);
+        (0, chai_1.expect)(envs).to.deep.equal([{ GO_IOS_AGENT_PORT: '12100' }]);
+        children[0].stderr.emit('data', line(60) + line(120));
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS);
+        yield s.stop();
+        (0, chai_1.expect)(samples).to.have.length(1);
+        (0, chai_1.expect)(samples[0]).to.include({
+            deviceCpuPct: 20,
+            deviceMemMb: null,
+            appCpuPct: null,
+            appMemMb: null,
+            appId: null,
+        });
+        (0, chai_1.expect)(children[0].killed).to.deep.equal(['SIGTERM']);
+    }));
+    it('reports nothing when no reading came for 4 s', () => __awaiter(void 0, void 0, void 0, function* () {
+        const s = sampler();
+        s.start();
+        yield clock.tickAsync(0);
+        children[0].stdout.emit('data', line(60));
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS * 4);
+        yield s.stop();
+        (0, chai_1.expect)(samples.length).to.be.lessThan(3);
+    }));
+    it('asks for the tunnel again every 30 s', () => __awaiter(void 0, void 0, void 0, function* () {
+        const s = sampler();
+        s.start();
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.TUNNEL_RENEW_MS * 2);
+        yield s.stop();
+        (0, chai_1.expect)(borrows).to.equal(3);
+    }));
+    it('starts sysmontap again when it exits, and gives up after 5 exits with no reading', () => __awaiter(void 0, void 0, void 0, function* () {
+        const s = sampler();
+        s.start();
+        for (let i = 0; i < types_1.MAX_CONSECUTIVE_FAILURES; i += 1) {
+            yield clock.tickAsync(0);
+            children[children.length - 1].emit('exit', 1);
+            yield clock.tickAsync(30000);
+        }
+        (0, chai_1.expect)(children).to.have.length(types_1.MAX_CONSECUTIVE_FAILURES);
+        (0, chai_1.expect)(gaveUp).to.deep.equal(['ios sysmontap kept exiting']);
+    }));
+});