@xenon-device-management/xenon 2.10.1 → 2.11.0

package/lib/src/sessions/SessionManager.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -28,6 +61,7 @@ const CloudSession_1 = require("./CloudSession");
 const device_store_1 = require("../data-service/device-store");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
+const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
 /**
  * SessionManager with persistence and recovery capabilities.
  *
@@ -183,6 +217,11 @@ let SessionManager = class SessionManager {
                         // Add to in-memory map
                         this.addSession(dbSession.id, recoveredSession);
                         yield this.adoptHeartbeat(dbSession.id);
+                        // A node session whose figures the hub was collecting goes on from
+                        // the newest sample stored here; the node's memory fills the gap.
+                        if (!device.cloud && dbSession.is_profiling_available) {
+                            yield this.resumeNodeMetrics(dbSession.id, device, recoveredSession, sessionResponse);
+                        }
                         recoveredCount++;
                     }
                     catch (sessionErr) {
@@ -200,6 +239,30 @@ let SessionManager = class SessionManager {
             }
         });
     }
+    /** Goes on collecting a node session's figures after a hub restart, from the newest stored. */
+    resumeNodeMetrics(sessionId, device, session, capabilities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const newest = yield prisma_1.prisma.sessionMetric.aggregate({
+                    where: { session_id: sessionId },
+                    _max: { at: true },
+                });
+                // Loaded here: SessionMetricsService imports the device managers.
+                const { SessionMetricsService } = yield Promise.resolve().then(() => __importStar(require('../services/metrics/SessionMetricsService')));
+                typedi_2.Container.get(SessionMetricsService).start({
+                    sessionId,
+                    device,
+                    capabilities,
+                    source: (0, nodeMetrics_1.nodeMetricsSourceOf)(session),
+                    after: (_a = newest._max.at) !== null && _a !== void 0 ? _a : null,
+                });
+            }
+            catch (err) {
+                this.log.warn(`Session ${sessionId}: CPU and memory not resumed: ${err.message}`);
+            }
+        });
+    }
     /**
      * A recovered session is this process's from now on: its row's heartbeat
      * is stamped with this process, now. The row still carried the heartbeat

package/lib/test/unit/dashboard-events-metrics.spec.js

@@ -143,4 +143,14 @@ describe('EventManager: CPU and memory sampling', () => {
         yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped('s-metrics-2');
         (0, chai_1.expect)(metrics.stop.calledOnceWithExactly('s-metrics-2')).to.equal(true);
     }));
+    it("hands the service a node's session, to collect its figures from the node", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = startSession();
+        const remote = Object.assign(session, {
+            nodeOrigin: () => 'http://node:4723',
+            nodeMetrics: () => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'refused' }); }),
+        });
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, remote, device);
+        (0, chai_1.expect)(metrics.appliesTo.firstCall.args).to.deep.equal([device, remote]);
+        (0, chai_1.expect)(metrics.start.firstCall.args[0].source).to.equal(remote);
+    }));
 });

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

@@ -0,0 +1,330 @@
+"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 fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const defaultGateway_1 = require("../../src/gateway/defaultGateway");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const nodeSessionStatus_1 = require("../../src/gateway/nodeSessionStatus");
+const nodeSessionMetrics_1 = require("../../src/gateway/nodeSessionMetrics");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const NodeMetricsStore_1 = require("../../src/services/metrics/NodeMetricsStore");
+const NodeMetricsCollector_1 = require("../../src/services/metrics/NodeMetricsCollector");
+const nodeMetrics_1 = require("../../src/services/metrics/nodeMetrics");
+const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const device_managers_1 = require("../../src/device-managers");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const RemoteSession_1 = require("../../src/sessions/RemoteSession");
+const appiumUmbrella_1 = require("../../src/sessions/appiumUmbrella");
+const config_1 = require("../../src/config");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * A hub collects CPU and memory for a session on a node's phone from the
+ * node: against a node in Appium 3's own server() (Appium's umbrella with
+ * Xenon's plugin, the production node gateway, and the node's session-status
+ * and session-metrics routes), with per-command auth on, so every ask carries
+ * the hub's session token. The node's phone sampler is replaced by one the
+ * test drives; everything between it and the hub's writes is the real thing.
+ */
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+const NODE_ID = 'node-1';
+/** The node's sampler service, its phone sampler replaced by one the test drives. */
+class NodeSideMetrics extends SessionMetricsService_1.SessionMetricsService {
+    constructor() {
+        super(...arguments);
+        this.hooks = [];
+        this.stopped = 0;
+    }
+    samplerFor(_id, _d, _c, hooks) {
+        this.hooks.push(hooks);
+        return { start: () => undefined, stop: () => __awaiter(this, void 0, void 0, function* () { return void (this.stopped += 1); }) };
+    }
+}
+/** The hub's sampler service: this hub's own phones are none, it asks the node every 50 ms. */
+class HubSideMetrics extends SessionMetricsService_1.SessionMetricsService {
+    constructor() {
+        super(...arguments);
+        this.written = [];
+    }
+    context() {
+        return {
+            pluginArgs: Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }),
+            port: 4799,
+            nodeId: 'hub-1',
+        };
+    }
+    writeSamples(_id, samples) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.written.push(...samples.map((s) => s.at));
+        });
+    }
+    collectorFor(source, hooks, after) {
+        return new NodeMetricsCollector_1.NodeMetricsCollector({
+            source,
+            hooks,
+            after,
+            support: typedi_1.Container.get(nodeMetrics_1.NodeMetricsSupport),
+            logger: quiet,
+            intervalMs: 50,
+        });
+    }
+}
+const until = (ok_1, ...args_1) => __awaiter(void 0, [ok_1, ...args_1], void 0, function* (ok, ms = 5000) {
+    const end = Date.now() + ms;
+    while (!ok()) {
+        if (Date.now() > end)
+            throw new Error('timed out');
+        yield new Promise((r) => setTimeout(r, 20));
+    }
+});
+const at = (t) => ({
+    at: t,
+    deviceCpuPct: 12,
+    deviceMemMb: 900,
+    deviceMemTotalMb: 4000,
+    appCpuPct: 3,
+    appMemMb: 150,
+    appId: 'com.android.settings',
+});
+describe('a hub collects a node session’s CPU and memory', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const servers = [];
+    let dirs;
+    let hubKeys;
+    let appiumLogs;
+    let restore;
+    let saved;
+    let authDisabledBefore;
+    let commandAuthBefore;
+    let umbrella;
+    let hubUrl;
+    let nodeOrigin;
+    let nodeMetrics;
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+        dirs = [fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-heartbeat-keys-'))];
+        hubKeys = new JwtKeyService_1.JwtKeyService();
+        yield hubKeys.init(dirs[0]);
+    }));
+    after(() => {
+        appiumLogs.restore();
+        for (const dir of dirs)
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, appiumUmbrella_1.AppiumUmbrella, nodeSessionStatus_1.NodeSessionProbeSupport, SessionMetricsService_1.SessionMetricsService, NodeMetricsStore_1.NodeMetricsStore, nodeMetrics_1.NodeMetricsSupport);
+        nodeMetrics = new NodeSideMetrics();
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, nodeMetrics);
+        typedi_1.Container.set(NodeMetricsStore_1.NodeMetricsStore, new NodeMetricsStore_1.NodeMetricsStore());
+        typedi_1.Container.set(nodeMetrics_1.NodeMetricsSupport, new nodeMetrics_1.NodeMetricsSupport());
+        // One process plays both sides: the hub's keys sign, the node checks them.
+        typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
+        typedi_1.Container.set(appiumUmbrella_1.AppiumUmbrella, new appiumUmbrella_1.AppiumUmbrella());
+        typedi_1.Container.set(nodeSessionStatus_1.NodeSessionProbeSupport, new nodeSessionStatus_1.NodeSessionProbeSupport());
+        typedi_1.Container.set(device_managers_1.XenonManager, {
+            getMaxSessionCount: () => undefined,
+            deviceInstances: () => __awaiter(this, void 0, void 0, function* () { return []; }),
+        });
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = {
+            store: device_store_1.DeviceStoreFactory._deviceStore,
+            pending: device_store_1.DeviceStoreFactory._pendingSessionStore,
+            context: Object.assign({}, context),
+        };
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        device_store_1.DeviceStoreFactory._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = false;
+        // Per-command auth on: the node then takes the hub's token and nothing else.
+        commandAuthBefore = process.env.XENON_REQUIRE_COMMAND_AUTH;
+        process.env.XENON_REQUIRE_COMMAND_AUTH = '1';
+        yield scratch.db.pendingSession.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        device_store_1.DeviceStoreFactory._deviceStore = saved.store;
+        device_store_1.DeviceStoreFactory._pendingSessionStore = saved.pending;
+        Object.assign(typedi_1.Container.get(PluginContext_1.PluginContext), saved.context);
+        config_1.config.authDisabled = authDisabledBefore;
+        if (commandAuthBefore === undefined)
+            delete process.env.XENON_REQUIRE_COMMAND_AUTH;
+        else
+            process.env.XENON_REQUIRE_COMMAND_AUTH = commandAuthBefore;
+        sinon_1.default.restore();
+        restore();
+        for (const s of servers.splice(0)) {
+            s.closeAllConnections();
+            yield new Promise((resolve) => http_1.default.Server.prototype.close.call(s, () => resolve()));
+        }
+    }));
+    const port = (s) => s.address().port;
+    /** A hub (its public keys) and a node. */
+    function boot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+            const hubServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction((0, appium_umbrella_1.umbrellaWith)([])),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: '/wd/hub',
+                cliArgs: { basePath: '/wd/hub' },
+                serverUpdaters: [
+                    (app) => {
+                        app.get('/xenon/api/auth/jwks.json', (_req, res) => res.json(hubKeys.jwks()));
+                    },
+                ],
+            });
+            servers.push(hubServer);
+            hubUrl = `http://127.0.0.1:${port(hubServer)}`;
+            const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { hub: hubUrl, bindHostOrIp: '127.0.0.1', enableDashboard: false, deviceAvailabilityTimeoutMs: 1000, deviceAvailabilityQueryIntervalMs: 100 });
+            umbrella = (0, appium_umbrella_1.umbrellaWith)([[plugin_1.XenonPlugin, 'xenon']]);
+            const nodeServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: '/node',
+                cliArgs: { basePath: '/node' },
+                serverUpdaters: [
+                    (app) => {
+                        (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: '/node' }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => true, authDisabled: () => false, logger: quiet }), (0, defaultGateway_1.nodeGatewayOptions)(hubUrl));
+                        // What ServerManager mounts under /xenon/api on a node.
+                        const api = express_1.default.Router();
+                        (0, nodeSessionStatus_1.registerNodeSessionStatus)(api, pluginArgs);
+                        (0, nodeSessionMetrics_1.registerNodeSessionMetrics)(api, pluginArgs);
+                        app.use('/xenon/api', api);
+                    },
+                ],
+            });
+            servers.push(nodeServer);
+            nodeOrigin = `http://127.0.0.1:${port(nodeServer)}`;
+            typedi_1.Container.get(PluginContext_1.PluginContext).setContext(pluginArgs, port(nodeServer), NODE_ID, '/node');
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'phone-1',
+                    host: nodeOrigin,
+                    nodeId: NODE_ID,
+                    platform: 'android',
+                    name: 'phone-1',
+                    sdk: '14',
+                    busy: false,
+                    userBlocked: false,
+                    offline: false,
+                },
+            });
+        });
+    }
+    /** A session on the node, created as the hub creates it. */
+    function nodeSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).createTokenFor({
+                userId: 'alice',
+                udid: 'phone-1',
+                host: nodeOrigin,
+            });
+            const res = yield (0, loopbackRequest_1.default)(nodeOrigin)
+                .post('/node/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, token)
+                .send({
+                capabilities: {
+                    alwaysMatch: {
+                        platformName: 'Android',
+                        'appium:automationName': appium_umbrella_1.FAKE_AUTOMATION,
+                        'appium:newCommandTimeout': 0,
+                        'appium:udid': 'phone-1',
+                        'xe:options': { recordVideo: false },
+                    },
+                    firstMatch: [{}],
+                },
+            });
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            return res.body.value.sessionId;
+        });
+    }
+    /** The hub's object for that session. */
+    const hubSide = (sessionId) => new RemoteSession_1.RemoteSession({
+        sessionId,
+        device: { udid: 'phone-1', host: nodeOrigin, nodeId: NODE_ID, platform: 'android' },
+        sessionResponse: {},
+        xenonOption: {},
+        baseUrl: `${nodeOrigin}/node`,
+    });
+    it("the hub collects a node session's figures as it runs, and the last ones when it ends", () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        // The node samples the session the hub created, its dashboard off.
+        (0, chai_1.expect)(nodeMetrics.hooks).to.have.length(1);
+        nodeMetrics.hooks[0].onSample(at(1000));
+        nodeMetrics.hooks[0].onSample(at(2000));
+        const hub = new HubSideMetrics();
+        const device = {
+            udid: 'phone-1',
+            host: nodeOrigin,
+            nodeId: NODE_ID,
+            platform: 'android',
+            realDevice: true,
+        };
+        hub.start({ sessionId, device, capabilities: {}, source: hubSide(sessionId) });
+        (0, chai_1.expect)(hub.recordingState(sessionId)).to.equal('sampling');
+        // Live: asked with the hub's token (per-command auth is on), every 50 ms here.
+        yield until(() => hub.written.length === 0 &&
+            typedi_1.Container.get(NodeMetricsStore_1.NodeMetricsStore).read(sessionId, null).samples.length === 0);
+        nodeMetrics.hooks[0].onSample(at(3000));
+        const token = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).tokenFor(sessionId);
+        const del = yield (0, loopbackRequest_1.default)(nodeOrigin)
+            .delete(`/node/session/${sessionId}`)
+            .set(hubSessionToken_1.HUB_TOKEN_HEADER, token);
+        (0, chai_1.expect)(del.status, JSON.stringify(del.body)).to.equal(200);
+        (0, chai_1.expect)(nodeMetrics.stopped).to.equal(1);
+        (0, chai_1.expect)(typedi_1.Container.get(NodeMetricsStore_1.NodeMetricsStore).read(sessionId, 2000).state).to.equal('ended');
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)(hub.written).to.deep.equal([1000, 2000, 3000]);
+    }));
+    it("an older node's sessions say they aren't recorded", () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        const hub = new HubSideMetrics();
+        const device = {
+            udid: 'phone-1',
+            host: nodeOrigin,
+            nodeId: NODE_ID,
+            platform: 'android',
+            realDevice: true,
+        };
+        const older = Object.assign(hubSide(sessionId), {
+            nodeMetrics: () => __awaiter(this, void 0, void 0, function* () { return ({ kind: 'unsupported', status: 404 }); }),
+        });
+        hub.start({ sessionId, device, capabilities: {}, source: older });
+        yield until(() => hub.recordingState(sessionId) === 'off');
+    }));
+});

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

@@ -0,0 +1,226 @@
+"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 NodeMetricsCollector_1 = require("../../src/services/metrics/NodeMetricsCollector");
+const nodeMetrics_1 = require("../../src/services/metrics/nodeMetrics");
+const sample = (at) => ({
+    at,
+    deviceCpuPct: 5,
+    deviceMemMb: 1,
+    deviceMemTotalMb: 2,
+    appCpuPct: null,
+    appMemMb: null,
+    appId: null,
+});
+const answer = (state, ats) => ({
+    kind: 'answer',
+    answer: { platform: 'android', state, samples: ats.map(sample) },
+});
+describe('NodeMetricsCollector: the hub collects a node session’s figures', () => {
+    let clock;
+    let replies;
+    let asked;
+    let got;
+    let warned;
+    let support;
+    /** While set, an ask waits on it: a node slow to answer. */
+    let gate;
+    const source = {
+        nodeOrigin: () => 'http://node:4723',
+        nodeMetrics: (after) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            asked.push(after);
+            if (gate)
+                yield gate;
+            return (_a = replies.shift()) !== null && _a !== void 0 ? _a : answer('sampling', []);
+        }),
+    };
+    const make = (after = null) => new NodeMetricsCollector_1.NodeMetricsCollector({
+        source,
+        hooks: { onSample: (s) => got.push(s.at), onGiveUp: () => undefined },
+        support,
+        logger: { info: () => undefined, warn: (m) => warned.push(m) },
+        after,
+    });
+    beforeEach(() => {
+        clock = sinon_1.default.useFakeTimers({ now: 0 });
+        replies = [];
+        asked = [];
+        got = [];
+        warned = [];
+        gate = null;
+        support = new nodeMetrics_1.NodeMetricsSupport();
+        support.now = () => clock.now;
+        support.logger = { warn: (m) => warned.push(m) };
+    });
+    afterEach(() => clock.restore());
+    it('asks every 10 s from the newest sample it has, and passes the samples on', () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [answer('sampling', [1, 2]), answer('sampling', [3])];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(10000);
+        yield clock.tickAsync(10000);
+        (0, chai_1.expect)(asked).to.deep.equal([null, 2]);
+        (0, chai_1.expect)(got).to.deep.equal([1, 2, 3]);
+        (0, chai_1.expect)(c.state()).to.equal('sampling');
+    }));
+    it('starts from the newest sample stored, after a hub restart', () => __awaiter(void 0, void 0, void 0, function* () {
+        const c = make(500);
+        c.start();
+        yield clock.tickAsync(10000);
+        (0, chai_1.expect)(asked).to.deep.equal([500]);
+    }));
+    it('asks once more when the session ends, and takes the last samples', () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [answer('sampling', [1]), answer('ended', [2, 3])];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(10000);
+        yield c.stop();
+        (0, chai_1.expect)(got).to.deep.equal([1, 2, 3]);
+        (0, chai_1.expect)(c.state()).to.equal('stopped');
+        yield clock.tickAsync(30000);
+        (0, chai_1.expect)(asked).to.have.length(2);
+    }));
+    it('stops asking when the node says off, or that its sampler stopped', () => __awaiter(void 0, void 0, void 0, function* () {
+        for (const [state, ats, expected] of [
+            ['off', [], 'off'],
+            ['stopped', [7], 'stopped'],
+        ]) {
+            asked = [];
+            replies = [answer(state, [...ats])];
+            const c = make();
+            c.start();
+            yield clock.tickAsync(30000);
+            (0, chai_1.expect)(asked, state).to.have.length(1);
+            (0, chai_1.expect)(c.state(), state).to.equal(expected);
+            yield c.stop();
+            (0, chai_1.expect)(asked, `${state}: no last ask`).to.have.length(1);
+        }
+    }));
+    it('stops asking a node without the route, says so once, and asks it again later', () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [{ kind: 'unsupported', status: 404 }];
+        const first = make();
+        first.start();
+        yield clock.tickAsync(10000);
+        (0, chai_1.expect)(first.state()).to.equal('off');
+        const second = make();
+        second.start();
+        yield clock.tickAsync(10000);
+        (0, chai_1.expect)(asked).to.have.length(1);
+        (0, chai_1.expect)(second.state()).to.equal('off');
+        (0, chai_1.expect)(warned.filter((m) => m.includes('http://node:4723'))).to.have.length(1);
+        yield clock.tickAsync(10 * 60000);
+        const third = make();
+        third.start();
+        yield clock.tickAsync(10000);
+        (0, chai_1.expect)(asked).to.have.length(2);
+    }));
+    it('keeps the figures it has when the node later says off or refuses: it says stopped', () => __awaiter(void 0, void 0, void 0, function* () {
+        for (const last of [answer('off', []), { kind: 'refused' }]) {
+            asked = [];
+            replies = [answer('sampling', [1]), last];
+            const c = make();
+            c.start();
+            yield clock.tickAsync(20000);
+            (0, chai_1.expect)(asked, last.kind).to.have.length(2);
+            (0, chai_1.expect)(c.state(), last.kind).to.equal('stopped');
+        }
+    }));
+    it("stops asking when the node refuses the hub's token", () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [{ kind: 'refused' }];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(30000);
+        (0, chai_1.expect)(asked).to.have.length(1);
+        (0, chai_1.expect)(c.state()).to.equal('off');
+    }));
+    it('keeps asking an unreachable node, saying so once per outage', () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [
+            { kind: 'unavailable', reason: 'ECONNREFUSED' },
+            { kind: 'unavailable', reason: 'ECONNREFUSED' },
+            answer('sampling', [1]),
+            { kind: 'unavailable', reason: 'timeout' },
+        ];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(40000);
+        (0, chai_1.expect)(asked).to.have.length(4);
+        (0, chai_1.expect)(got).to.deep.equal([1]);
+        (0, chai_1.expect)(warned).to.have.length(2);
+        (0, chai_1.expect)(c.state()).to.equal('sampling');
+    }));
+    it('finishes stopping when the node is unreachable', () => __awaiter(void 0, void 0, void 0, function* () {
+        replies = [{ kind: 'unavailable', reason: 'timeout' }];
+        const c = make();
+        c.start();
+        yield c.stop();
+        (0, chai_1.expect)(asked).to.have.length(1);
+    }));
+    it('never asks twice at once, or takes a sample twice', () => __awaiter(void 0, void 0, void 0, function* () {
+        let release;
+        gate = new Promise((r) => (release = r));
+        replies = [answer('sampling', [1, 2]), answer('sampling', [2, 3])];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(10000); // the first ask, held by the node
+        yield clock.tickAsync(20000); // two more ticks while it is held
+        (0, chai_1.expect)(asked).to.have.length(1);
+        gate = null;
+        release();
+        yield clock.tickAsync(10000); // the first answer arrives; the next ask goes
+        (0, chai_1.expect)(asked).to.deep.equal([null, 2]);
+        (0, chai_1.expect)(got).to.deep.equal([1, 2, 3]);
+    }));
+});
+describe("readNodeMetricsReply: what a node's answer means", () => {
+    const h = { [nodeMetrics_1.NODE_METRICS_HEADER]: '1' };
+    it('reads each answer', () => {
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(404, {}, undefined)).to.deep.equal({
+            kind: 'unsupported',
+            status: 404,
+        });
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(404, h, {})).to.deep.equal({ kind: 'refused' });
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(200, h, {
+            value: { platform: 'ios', state: 'sampling', samples: [sample(1)] },
+        })).to.deep.equal({
+            kind: 'answer',
+            answer: { platform: 'ios', state: 'sampling', samples: [sample(1)] },
+        });
+        // Without the header: an older node only for what an older node answers
+        // (its login's 401, an unknown route's 404, a catch-all's 2xx). A proxy's
+        // 502 or 503 in front of a new node is an outage, not an older node.
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(401, {}, {})).to.deep.equal({ kind: 'unsupported', status: 401 });
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(200, {}, '<html>')).to.deep.equal({
+            kind: 'unsupported',
+            status: 200,
+        });
+        for (const status of [500, 502, 503, 504]) {
+            (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(status, {}, 'Bad Gateway'), String(status)).to.deep.equal({
+                kind: 'unavailable',
+                reason: `answered ${status}`,
+            });
+        }
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(503, h, {})).to.deep.equal({
+            kind: 'unavailable',
+            reason: 'answered 503',
+        });
+        (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(200, h, { value: { state: 'weird', samples: [] } })).to.deep.equal({
+            kind: 'unavailable',
+            reason: 'answered 200',
+        });
+    });
+});