@xenon-device-management/xenon 2.10.1 → 2.11.1

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

@@ -0,0 +1,279 @@
+"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 RemoteSession_1 = require("../../src/sessions/RemoteSession");
+const CloudSession_1 = require("../../src/sessions/CloudSession");
+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("doesn't wait on a last ask when the node already wasn't answering", () => __awaiter(void 0, void 0, void 0, function* () {
+        // A dark node's sessions are ended one after another by the heartbeat;
+        // each would wait up to 5 s more for an answer that won't come.
+        replies = [{ kind: 'unavailable', reason: 'ECONNREFUSED' }];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(10000);
+        yield c.stop();
+        (0, chai_1.expect)(asked).to.have.length(1);
+    }));
+    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('keeps only well-formed samples: one bad sample would block every later write', () => {
+        const bad = [
+            null,
+            'x',
+            Object.assign(Object.assign({}, sample(5)), { at: '6' }),
+            Object.assign(Object.assign({}, sample(7)), { at: Number.NaN }),
+            Object.assign(Object.assign({}, sample(8)), { deviceCpuPct: '12' }),
+            Object.assign(Object.assign({}, sample(9)), { appId: 3 }),
+        ];
+        const reply = (0, nodeMetrics_1.readNodeMetricsReply)(200, h, {
+            value: {
+                platform: 'android',
+                state: 'sampling',
+                samples: [sample(1), ...bad, Object.assign(Object.assign({}, sample(2)), { extra: 1 })],
+            },
+        });
+        (0, chai_1.expect)(reply).to.deep.equal({
+            kind: 'answer',
+            answer: { platform: 'android', state: 'sampling', samples: [sample(1), sample(2)] },
+        });
+    });
+    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',
+        });
+    });
+});
+describe('nodeMetricsSourceOf: only a session a node runs is collected from', () => {
+    const options = (cloud) => ({
+        sessionId: 's1',
+        device: { udid: 'p1', host: 'http://node:4723', platform: 'android', cloud },
+        sessionResponse: {},
+        xenonOption: {},
+        baseUrl: 'http://node:4723/wd/hub',
+    });
+    it("takes a node's session, never a cloud provider's or this server's own", () => {
+        const remote = new RemoteSession_1.RemoteSession(options());
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(remote)).to.equal(remote);
+        // Both inherit nodeMetrics from RemoteSession; neither runs on a node.
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(new CloudSession_1.CloudSession(options('browserstack')))).to.equal(undefined);
+        const local = Object.assign(Object.create(RemoteSession_1.RemoteSession.prototype), {
+            getType: () => 'local',
+        });
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(local)).to.equal(undefined);
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)({ nodeOrigin: () => 'x', nodeMetrics: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) })).to.equal(undefined);
+    });
+});

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,98 @@
+"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);
+        // A 400-digit number is Infinity: it would drop every sample the node holds.
+        for (const bad of [undefined, '', 'abc', '-5', '1e3', ['1'], '9'.repeat(400)]) {
+            (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 {