@xenon-device-management/xenon 2.10.1 → 2.11.0

package/lib/test/unit/node-metrics-store.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const NodeMetricsStore_1 = require("../../src/services/metrics/NodeMetricsStore");
+const nodeMetrics_1 = require("../../src/services/metrics/nodeMetrics");
+const types_1 = require("../../src/services/metrics/types");
+const sample = (at) => ({
+    at,
+    deviceCpuPct: 10,
+    deviceMemMb: 100,
+    deviceMemTotalMb: 4000,
+    appCpuPct: null,
+    appMemMb: null,
+    appId: null,
+});
+describe('NodeMetricsStore: a node holds its figures for the hub', () => {
+    let now;
+    let store;
+    beforeEach(() => {
+        now = 1000000;
+        store = new NodeMetricsStore_1.NodeMetricsStore();
+        store.now = () => now;
+    });
+    it('answers every sample without `after`, and only newer ones with it', () => {
+        store.begin('s1', 'Android');
+        [1, 2, 3].forEach((t) => store.add('s1', sample(t)));
+        (0, chai_1.expect)(store.read('s1', null)).to.deep.equal({
+            platform: 'android',
+            state: 'sampling',
+            samples: [sample(1), sample(2), sample(3)],
+        });
+        (0, chai_1.expect)(store.read('s1', 2).samples.map((s) => s.at)).to.deep.equal([3]);
+    });
+    it('drops what the hub has collected', () => {
+        store.begin('s1', 'android');
+        [1, 2, 3].forEach((t) => store.add('s1', sample(t)));
+        store.read('s1', 2);
+        (0, chai_1.expect)(store.read('s1', null).samples.map((s) => s.at)).to.deep.equal([3]);
+    });
+    it('keeps the newest 900 samples', () => {
+        store.begin('s1', 'android');
+        for (let t = 1; t <= types_1.MAX_BUFFERED_SAMPLES + 5; t++)
+            store.add('s1', sample(t));
+        const ats = store.read('s1', null).samples.map((s) => s.at);
+        (0, chai_1.expect)(ats).to.have.length(types_1.MAX_BUFFERED_SAMPLES);
+        (0, chai_1.expect)(ats[0]).to.equal(6);
+    });
+    it('says a sampler that gave up stopped, and an ended session ended', () => {
+        store.begin('s1', 'android');
+        store.gaveUp('s1');
+        (0, chai_1.expect)(store.read('s1', null).state).to.equal('stopped');
+        store.end('s1');
+        (0, chai_1.expect)(store.read('s1', null).state).to.equal('ended');
+    });
+    it('keeps an ended session 10 minutes for the last collection, then forgets it', () => {
+        store.begin('s1', 'android');
+        store.add('s1', sample(1));
+        store.end('s1');
+        now += nodeMetrics_1.KEEP_AFTER_END_MS - 1;
+        (0, chai_1.expect)(store.read('s1', null).samples).to.have.length(1);
+        now += 1;
+        (0, chai_1.expect)(store.read('s1', null)).to.deep.equal({ platform: '', state: 'off', samples: [] });
+    });
+    it('says off for a session it has nothing for', () => {
+        (0, chai_1.expect)(store.read('nope', null)).to.deep.equal({ platform: '', state: 'off', samples: [] });
+        store.add('nope', sample(1));
+        (0, chai_1.expect)(store.read('nope', null).samples).to.deep.equal([]);
+    });
+});

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

@@ -0,0 +1,97 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const nodeSessionMetrics_1 = require("../../src/gateway/nodeSessionMetrics");
+const nodeMetrics_1 = require("../../src/services/metrics/nodeMetrics");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const commandAuth_1 = require("../../src/middleware/commandAuth");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+const ANSWER = { platform: 'android', state: 'sampling', samples: [] };
+describe("a node's session metrics route", () => {
+    let verify;
+    let read;
+    let enforced;
+    const app = () => {
+        const a = (0, express_1.default)();
+        a.get('/xenon/api/node/sessions/:sessionId/metrics', (0, nodeSessionMetrics_1.nodeSessionMetricsHandler)({
+            hubTokens: { verify },
+            enforced: () => enforced,
+            read,
+            logger: quiet,
+        }));
+        return a;
+    };
+    const get = (q = '') => (0, supertest_1.default)(app()).get(`/xenon/api/node/sessions/s1/metrics${q}`);
+    beforeEach(() => {
+        verify = sinon_1.default.stub();
+        read = sinon_1.default.stub().returns(ANSWER);
+        enforced = false;
+    });
+    afterEach(() => sinon_1.default.restore());
+    it('answers the figures, with no credential when per-command auth is off', () => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield get('?after=1500');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body).to.deep.equal({ value: ANSWER });
+        (0, chai_1.expect)(res.headers[nodeMetrics_1.NODE_METRICS_HEADER]).to.equal('1');
+        (0, chai_1.expect)(read.calledOnceWithExactly('s1', 1500)).to.equal(true);
+    }));
+    it("with per-command auth on, answers only the hub's token for that session", () => __awaiter(void 0, void 0, void 0, function* () {
+        enforced = true;
+        verify.withArgs('good', 's1').resolves(true);
+        verify.withArgs('other', 's1').resolves(false);
+        const missing = yield get();
+        const wrong = yield get().set(hubSessionToken_1.HUB_TOKEN_HEADER, 'other');
+        const right = yield get().set(hubSessionToken_1.HUB_TOKEN_HEADER, 'good');
+        (0, chai_1.expect)([missing.status, missing.body]).to.deep.equal([404, commandAuth_1.UNKNOWN_SESSION_BODY]);
+        (0, chai_1.expect)([wrong.status, wrong.body]).to.deep.equal([404, commandAuth_1.UNKNOWN_SESSION_BODY]);
+        (0, chai_1.expect)(right.status).to.equal(200);
+        (0, chai_1.expect)(read.calledOnce).to.equal(true);
+        for (const r of [missing, wrong, right])
+            (0, chai_1.expect)(r.headers[nodeMetrics_1.NODE_METRICS_HEADER]).to.equal('1');
+    }));
+    it("answers 503 when it can't check the hub's token", () => __awaiter(void 0, void 0, void 0, function* () {
+        enforced = true;
+        verify.rejects(new Error('JWKS unreachable'));
+        const res = yield get().set(hubSessionToken_1.HUB_TOKEN_HEADER, 'good');
+        (0, chai_1.expect)([res.status, res.body]).to.deep.equal([503, commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY]);
+        (0, chai_1.expect)(read.called).to.equal(false);
+    }));
+    it('reads anything but a time as no `after`', () => {
+        (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)('1500')).to.equal(1500);
+        (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)('1500.5')).to.equal(1500.5);
+        for (const bad of [undefined, '', 'abc', '-5', '1e3', ['1']]) {
+            (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)(bad), String(bad)).to.equal(null);
+        }
+    });
+    it('exists only on a node', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mount = (hub) => {
+            const a = (0, express_1.default)();
+            const r = express_1.default.Router();
+            (0, nodeSessionMetrics_1.registerNodeSessionMetrics)(r, Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { hub }));
+            a.use('/xenon/api', r);
+            return a;
+        };
+        const onHub = yield (0, supertest_1.default)(mount()).get('/xenon/api/node/sessions/s1/metrics');
+        const onNode = yield (0, supertest_1.default)(mount('http://127.0.0.1:1')).get('/xenon/api/node/sessions/s1/metrics');
+        (0, chai_1.expect)(onHub.status).to.equal(404);
+        (0, chai_1.expect)(onHub.headers[nodeMetrics_1.NODE_METRICS_HEADER]).to.equal(undefined);
+        (0, chai_1.expect)(onNode.headers[nodeMetrics_1.NODE_METRICS_HEADER]).to.equal('1');
+    }));
+});

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

@@ -0,0 +1,55 @@
+"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 typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const NodeDevices_1 = __importDefault(require("../../src/device-managers/NodeDevices"));
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * A session's sampling stops however the session ends on this server, its
+ * dashboard on or off: on a node that ends the figures it holds for the hub.
+ */
+describe('session sampling stops however a session ends', function () {
+    this.timeout(30000);
+    (0, scratch_database_1.useScratchDatabase)();
+    let restore;
+    let stop;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(SessionMetricsService_1.SessionMetricsService);
+        stop = sinon_1.default.stub().resolves();
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, { stop });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    it('at shutdown', () => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'onSessionStopped').resolves();
+        yield typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService).stopSessionForShutdown('s-down', 'shutdown');
+        (0, chai_1.expect)(stop.calledWith('s-down')).to.equal(true);
+    }));
+    it('when the driver shuts down unexpectedly on a node', () => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.stub(NodeDevices_1.default.prototype, 'unblockDevice').resolves();
+        const plugin = { pluginArgs: { hub: 'http://hub:4723' } };
+        yield plugin_1.XenonPlugin.prototype.onUnexpectedShutdown.call(plugin, { sessionId: 's-crash', caps: {} }, null);
+        (0, chai_1.expect)(stop.calledWith('s-crash')).to.equal(true);
+    }));
+});

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

@@ -32,6 +32,23 @@ class FakeSampler {
         });
     }
 }
+class FakeStore {
+    constructor() {
+        this.calls = [];
+    }
+    begin(id, platform) {
+        this.calls.push(`begin ${id} ${platform}`);
+    }
+    add(id, s) {
+        this.calls.push(`add ${id} ${s.at}`);
+    }
+    gaveUp(id) {
+        this.calls.push(`gaveUp ${id}`);
+    }
+    end(id) {
+        this.calls.push(`end ${id}`);
+    }
+}
 class TestMetrics extends SessionMetricsService_1.SessionMetricsService {
     constructor() {
         super(...arguments);
@@ -40,6 +57,19 @@ class TestMetrics extends SessionMetricsService_1.SessionMetricsService {
         this.failWrites = 0;
         this.samplers = [];
         this.caps = [];
+        this.store = new FakeStore();
+        this.collected = [];
+        this.collectorState = 'sampling';
+    }
+    nodeStore() {
+        return this.store;
+    }
+    collectorFor(source, hooks, after) {
+        this.collected.push({ source, after });
+        const f = new FakeSampler(hooks);
+        f.state = () => this.collectorState;
+        this.samplers.push(f);
+        return f;
     }
     context() {
         return {
@@ -159,6 +189,73 @@ describe('SessionMetricsService', () => {
         m.start({ sessionId: 's2', device: phone({ nodeId: 'node-2' }), capabilities: {} });
         (0, chai_1.expect)(m.samplers).to.deep.equal([]);
     });
+    it('on a node, holds the figures for the hub instead of writing them', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.args = { hub: 'http://hub:4723' };
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        const hooks = m.samplers[0].hooks;
+        [1, 2].forEach((t) => hooks.onSample(sample(t)));
+        hooks.onGiveUp('adb gone');
+        yield clock.tickAsync(types_1.FLUSH_INTERVAL_MS * 2);
+        yield m.stop('s1');
+        (0, chai_1.expect)(m.written).to.deep.equal([]);
+        (0, chai_1.expect)(m.store.calls).to.deep.equal([
+            'begin s1 android',
+            'add s1 1',
+            'add s1 2',
+            'gaveUp s1',
+            'end s1',
+        ]);
+        (0, chai_1.expect)(m.samplers[0].stopped).to.equal(true);
+    }));
+    it('on a node with sessionMetrics off, holds nothing', () => {
+        m.args = { hub: 'http://hub:4723', sessionMetrics: false };
+        m.start({ sessionId: 's1', device: phone(), capabilities: {} });
+        (0, chai_1.expect)(m.samplers).to.have.length(0);
+        (0, chai_1.expect)(m.store.calls).to.deep.equal([]);
+    });
+    const source = {
+        nodeOrigin: () => 'http://node',
+        nodeMetrics: () => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'refused' }); }),
+    };
+    it("on a hub, collects a node's phone from the node, never a cloud phone or without a session", () => {
+        const nodePhone = phone({ nodeId: 'node-2', host: 'http://node:4723' });
+        (0, chai_1.expect)(m.appliesTo(nodePhone, source)).to.equal(true);
+        (0, chai_1.expect)(m.appliesTo(nodePhone)).to.equal(false);
+        (0, chai_1.expect)(m.appliesTo(Object.assign(Object.assign({}, nodePhone), { cloud: 'browserstack' }), source)).to.equal(false);
+        (0, chai_1.expect)(m.appliesTo(phone({ nodeId: 'node-2', platform: 'ios', realDevice: false }), source)).to.equal(false);
+        m.args = { sessionMetrics: false };
+        (0, chai_1.expect)(m.appliesTo(nodePhone, source)).to.equal(false);
+        m.args = { hub: 'http://hub:4723' };
+        (0, chai_1.expect)(m.appliesTo(nodePhone, source)).to.equal(false);
+    });
+    it('collects from the node, from where it left off, and writes the figures as its own', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({
+            sessionId: 's1',
+            device: phone({ nodeId: 'node-2' }),
+            capabilities: {},
+            source,
+            after: 40,
+        });
+        (0, chai_1.expect)(m.collected).to.deep.equal([{ source, after: 40 }]);
+        m.samplers[0].hooks.onSample(sample(41));
+        yield m.stop('s1');
+        (0, chai_1.expect)(m.written).to.deep.equal([{ sessionId: 's1', ats: [41] }]);
+    }));
+    it("says what the node says about a running session's sampling", () => {
+        m.start({ sessionId: 's1', device: phone({ nodeId: 'node-2' }), capabilities: {}, source });
+        (0, chai_1.expect)(m.recordingState('s1')).to.equal('sampling');
+        m.collectorState = 'off';
+        (0, chai_1.expect)(m.recordingState('s1')).to.equal('off');
+    });
+    it('writes the samples a sampler gives while it stops: the collector asks the node one last time', () => __awaiter(void 0, void 0, void 0, function* () {
+        m.start({ sessionId: 's1', device: phone({ nodeId: 'node-2' }), capabilities: {}, source });
+        const last = m.samplers[0];
+        last.stop = () => __awaiter(void 0, void 0, void 0, function* () {
+            last.hooks.onSample(sample(99));
+        });
+        yield m.stop('s1');
+        (0, chai_1.expect)(m.written).to.deep.equal([{ sessionId: 's1', ats: [99] }]);
+    }));
 });
 /** The real Android wiring, down to the adb process it runs. */
 class WiredMetrics extends SessionMetricsService_1.SessionMetricsService {

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

@@ -0,0 +1,94 @@
+"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 typedi_1 = require("typedi");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * After a hub restart, a node session whose figures the hub was collecting
+ * goes on being collected, from the newest sample the hub stored: the node's
+ * memory fills the gap.
+ */
+describe('a hub restart resumes collecting a node session’s figures', function () {
+    this.timeout(30000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let restore;
+    let start;
+    let savedStore;
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(SessionMetricsService_1.SessionMetricsService);
+        start = sinon_1.default.stub();
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, { start });
+        savedStore = device_store_1.DeviceStoreFactory._deviceStore;
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        yield scratch.db.sessionMetric.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+        yield scratch.db.device.create({
+            data: {
+                udid: 'node-phone',
+                host: 'http://127.0.0.1:1',
+                nodeId: 'node-2',
+                platform: 'android',
+                name: 'S9',
+                sdk: '10',
+                busy: true,
+                userBlocked: false,
+                offline: false,
+            },
+        });
+        const row = (id, profiled) => scratch.db.session.create({
+            data: {
+                id,
+                device_udid: 'node-phone',
+                device_platform: 'android',
+                device_version: '10',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-2',
+                has_live_video: false,
+                status: 'running',
+                is_profiling_available: profiled,
+            },
+        });
+        yield row('collected', true);
+        yield row('fresh', true);
+        yield row('never', false);
+        yield scratch.db.sessionMetric.createMany({
+            data: [100, 200].map((at) => ({ session_id: 'collected', at })),
+        });
+    }));
+    afterEach(() => {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        device_store_1.DeviceStoreFactory._deviceStore = savedStore;
+        sinon_1.default.restore();
+        restore();
+    });
+    it('resumes each from its newest stored sample, and never one the hub did not collect', () => __awaiter(this, void 0, void 0, function* () {
+        yield new SessionManager_1.SessionManager().recoverActiveSessions('hub-1', '/wd/hub');
+        const byId = new Map(start.getCalls().map((c) => [c.args[0].sessionId, c.args[0]]));
+        (0, chai_1.expect)(Array.from(byId.keys()).sort()).to.deep.equal(['collected', 'fresh']);
+        (0, chai_1.expect)(byId.get('collected').after).to.equal(200);
+        (0, chai_1.expect)(byId.get('fresh').after).to.equal(null);
+        (0, chai_1.expect)(typeof byId.get('collected').source.nodeMetrics).to.equal('function');
+    }));
+});