@xenon-device-management/xenon 2.9.2 → 2.10.1

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

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

@@ -0,0 +1,215 @@
+"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 SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const types_1 = require("../../src/services/metrics/types");
+class FakeSampler {
+    constructor(hooks) {
+        this.hooks = hooks;
+        this.started = false;
+        this.stopped = false;
+    }
+    start() {
+        this.started = true;
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopped = true;
+        });
+    }
+}
+class TestMetrics extends SessionMetricsService_1.SessionMetricsService {
+    constructor() {
+        super(...arguments);
+        this.args = {};
+        this.written = [];
+        this.failWrites = 0;
+        this.samplers = [];
+        this.caps = [];
+    }
+    context() {
+        return {
+            pluginArgs: Object.assign({ bindHostOrIp: '127.0.0.1' }, this.args),
+            port: 4723,
+            nodeId: 'node-1',
+        };
+    }
+    writeSamples(sessionId, samples) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.failWrites > 0) {
+                this.failWrites -= 1;
+                throw new Error('FOREIGN KEY constraint failed');
+            }
+            this.written.push({ sessionId, ats: samples.map((s) => s.at) });
+        });
+    }
+    samplerFor(_id, _d, caps, hooks) {
+        this.caps.push(caps);
+        const f = new FakeSampler(hooks);
+        this.samplers.push(f);
+        return f;
+    }
+}
+const phone = (over = {}) => (Object.assign({ udid: 'phone-1', platform: 'android', realDevice: true, host: 'http://127.0.0.1:4723', nodeId: 'node-1' }, over));
+const sample = (at) => ({
+    at,
+    deviceCpuPct: 10,
+    deviceMemMb: 1,
+    deviceMemTotalMb: 2,
+    appCpuPct: null,
+    appMemMb: null,
+    appId: null,
+});
+describe('SessionMetricsService', () => {
+    let clock;
+    let m;
+    beforeEach(() => {
+        clock = sinon_1.default.useFakeTimers({ now: 1000000 });
+        m = new TestMetrics();
+    });
+    afterEach(() => clock.restore());
+    it("samples this server's Android phones (emulators too) and iPhones, not simulators", () => {
+        (0, chai_1.expect)(m.appliesTo(phone())).to.equal(true);
+        (0, chai_1.expect)(m.appliesTo(phone({ realDevice: false }))).to.equal(true);
+        (0, chai_1.expect)(m.appliesTo(phone({ platform: 'ios' }))).to.equal(true);
+        (0, chai_1.expect)(m.appliesTo(phone({ platform: 'ios', realDevice: false }))).to.equal(false);
+        (0, chai_1.expect)(m.appliesTo(undefined)).to.equal(false);
+    });
+    it("doesn't sample another server's phone, or anything when sessionMetrics is off", () => {
+        (0, chai_1.expect)(m.appliesTo(phone({ nodeId: 'node-2' }))).to.equal(false);
+        m.args = { sessionMetrics: false };
+        (0, chai_1.expect)(m.appliesTo(phone())).to.equal(false);
+    });
+    it('writes the samples every 10 s, and the rest when the session stops', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone(), capabilities: { 'appium:appPackage': 'com.a.b' } });
+        const hooks = m.samplers[0].hooks;
+        (0, chai_1.expect)(m.samplers[0].started).to.equal(true);
+        (0, chai_1.expect)(m.caps).to.deep.equal([{ 'appium:appPackage': 'com.a.b' }]);
+        [1, 2, 3].forEach((t) => hooks.onSample(sample(t)));
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS);
+        [4, 5].forEach((t) => hooks.onSample(sample(t)));
+        yield m.stop('s1');
+        (0, chai_1.expect)(m.written).to.deep.equal([
+            { sessionId: 's1', ats: [1, 2, 3] },
+            { sessionId: 's1', ats: [4, 5] },
+        ]);
+        (0, chai_1.expect)(m.samplers[0].stopped).to.equal(true);
+    }));
+    it('keeps samples whose write failed, in order, for the next write', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        const hooks = m.samplers[0].hooks;
+        m.failWrites = 1;
+        [1, 2].forEach((t) => hooks.onSample(sample(t)));
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS);
+        hooks.onSample(sample(3));
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS);
+        yield m.stop('s1');
+        (0, chai_1.expect)(m.written).to.deep.equal([{ sessionId: 's1', ats: [1, 2, 3] }]);
+    }));
+    it('keeps only the newest samples while writes keep failing', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        const hooks = m.samplers[0].hooks;
+        m.failWrites = 1;
+        for (let t = 1; t <= types_1.MAX_BUFFERED_SAMPLES + 5; t += 1)
+            hooks.onSample(sample(t));
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS);
+        yield m.stop('s1');
+        const ats = m.written[0].ats;
+        (0, chai_1.expect)(ats).to.have.length(types_1.MAX_BUFFERED_SAMPLES);
+        (0, chai_1.expect)(ats[0]).to.equal(6);
+        (0, chai_1.expect)(ats[ats.length - 1]).to.equal(types_1.MAX_BUFFERED_SAMPLES + 5);
+    }));
+    it('drops a sample that arrives after the session stopped', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        const hooks = m.samplers[0].hooks;
+        yield m.stop('s1');
+        hooks.onSample(sample(9));
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS * 2);
+        (0, chai_1.expect)(m.written).to.deep.equal([]);
+    }));
+    it('stops twice, or a session it never sampled, without complaint', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        yield m.stop('s1');
+        yield m.stop('s1');
+        yield m.stop('never-started');
+        (0, chai_1.expect)(m.samplers).to.have.length(1);
+    }));
+    it('says whether it is sampling a session, stopped after giving up, or not at all', () => {
+        (0, chai_1.expect)(m.recordingState('s1')).to.equal('off');
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        (0, chai_1.expect)(m.recordingState('s1')).to.equal('sampling');
+        m.samplers[0].hooks.onGiveUp('device offline');
+        (0, chai_1.expect)(m.recordingState('s1')).to.equal('stopped');
+    });
+    it("doesn't start a sampler for a phone it doesn't apply to", () => {
+        m.start({ sessionId: 's2', device: phone({ nodeId: 'node-2' }), capabilities: {} });
+        (0, chai_1.expect)(m.samplers).to.deep.equal([]);
+    });
+});
+/** The real Android wiring, down to the adb process it runs. */
+class WiredMetrics extends SessionMetricsService_1.SessionMetricsService {
+    constructor() {
+        super(...arguments);
+        this.calls = [];
+    }
+    context() {
+        return { pluginArgs: { bindHostOrIp: '127.0.0.1' }, port: 4723, nodeId: 'node-1' };
+    }
+    writeSamples() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // nothing stored
+        });
+    }
+    adbCommand(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return { path: '/sdk/platform-tools/adb', base: ['-P', '5037', '-s', udid] };
+        });
+    }
+    execAdb(path, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.calls.push([path, ...args]);
+            return args.includes('dumpsys activity activities')
+                ? ''
+                : 'cpu  100 0 0 50 0 0 0 0 0 0\nMemTotal: 1024 kB\nMemAvailable: 512 kB\n';
+        });
+    }
+}
+describe("SessionMetricsService: the Android sampler's adb calls", () => {
+    let clock;
+    beforeEach(() => {
+        clock = sinon_1.default.useFakeTimers({ now: 1000000 });
+    });
+    afterEach(() => clock.restore());
+    it('names the phone in every adb call, so a server with several phones reaches the right one', () => __awaiter(void 0, void 0, void 0, function* () {
+        const m = new WiredMetrics();
+        m.start({ sessionId: 's-adb', device: phone(), capabilities: {} });
+        yield clock.tickAsync(0);
+        yield clock.tickAsync(types_1.SAMPLE_INTERVAL_MS);
+        yield m.stop('s-adb');
+        (0, chai_1.expect)(m.calls.length).to.be.greaterThan(1);
+        for (const call of m.calls) {
+            (0, chai_1.expect)(call.slice(0, 6)).to.deep.equal([
+                '/sdk/platform-tools/adb',
+                '-P',
+                '5037',
+                '-s',
+                'phone-1',
+                'shell',
+            ]);
+        }
+    }));
+});