@xenon-device-management/xenon 2.16.0 → 2.17.0

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

@@ -0,0 +1,340 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const NodeDeviceLogStore_1 = require("../../src/services/logcat/NodeDeviceLogStore");
+const NodeDeviceLogsCollector_1 = require("../../src/services/logcat/NodeDeviceLogsCollector");
+const nodeDeviceLogs_1 = require("../../src/services/logcat/nodeDeviceLogs");
+const deviceLogBook_1 = require("../../src/services/logcat/deviceLogBook");
+const scratch_database_1 = require("../helpers/scratch-database");
+const fake_logcat_1 = require("../helpers/fake-logcat");
+const driver_log_1 = require("../helpers/driver-log");
+const quiet = { info: () => undefined, warn: () => undefined, debug: () => undefined };
+/** A node's service: its own phone's log stream fake, its rows held in `store`. */
+class NodeSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    constructor(logcat, store, unclaimed = 60000) {
+        super();
+        this.logcat = logcat;
+        this.store = store;
+        this.unclaimed = unclaimed;
+        this.writes = 0;
+    }
+    context() {
+        return {
+            pluginArgs: { bindHostOrIp: '127.0.0.1', hub: 'http://127.0.0.1:4724' },
+            port: 4725,
+            nodeId: 'node-1',
+        };
+    }
+    streams() {
+        return this.logcat;
+    }
+    readClock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return deviceLogBook_1.UNKNOWN_CLOCK;
+        });
+    }
+    nodeStore() {
+        return this.store;
+    }
+    unclaimedMs() {
+        return this.unclaimed;
+    }
+    writeLines() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.writes += 1;
+        });
+    }
+}
+/** A hub's service: no phone of its own here; it asks a node every 20 ms. */
+class HubSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    context() {
+        return { pluginArgs: { bindHostOrIp: '127.0.0.1' }, port: 4724, nodeId: 'hub-1' };
+    }
+    collectorFor(source, onLines, storedTail) {
+        return new NodeDeviceLogsCollector_1.NodeDeviceLogsCollector({
+            source,
+            onLines,
+            storedTail,
+            support: new nodeDeviceLogs_1.NodeDeviceLogsSupport(),
+            logger: quiet,
+            intervalMs: 20,
+        });
+    }
+}
+/** The phone as the node files it, and as the hub has it from the node's report. */
+const NODE_PHONE = {
+    udid: 'phone-1',
+    platform: 'android',
+    host: 'http://127.0.0.1:4725',
+    nodeId: 'node-1',
+};
+/** The node as the hub's collector sees it: the node's own store, behind its route. */
+const nodeAt = (store, sessionId) => ({
+    nodeOrigin: () => 'http://127.0.0.1:4725',
+    nodeDeviceLogs: (after) => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'answer', answer: store.read(sessionId, after) }); }),
+});
+const row = (n) => ({
+    message: `line ${n}`,
+    timestamp: new Date(1700000000000 + n),
+});
+describe('A node records its phone’s device log for its hub', function () {
+    this.timeout(60000);
+    let logcat;
+    let store;
+    beforeEach(() => {
+        logcat = new fake_logcat_1.FakeLogcatStreams();
+        store = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+    });
+    afterEach(() => logcat.cleanup());
+    it('holds the lines for the hub, whatever its dashboard setting, and writes none', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const since = Date.now() - 60000;
+        yield logs.start({ sessionId: 'n1', device: NODE_PHONE, since });
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since - 600000, 'before the session'));
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 1000, 'first'));
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 2000, 'FATAL EXCEPTION: main', 'E', 'AndroidRuntime'));
+        yield (0, fake_logcat_1.settle)();
+        const held = store.read('n1', null);
+        (0, chai_1.expect)(held.state).to.equal('recording');
+        (0, chai_1.expect)(held.lines.map((l) => l.seq)).to.deep.equal([1, 2]);
+        (0, chai_1.expect)(held.lines[1].message).to.match(/ E AndroidRuntime: FATAL EXCEPTION: main$/);
+        (0, chai_1.expect)(held.lines[1].timestamp).to.equal(since + 2000);
+        yield logs.stop('n1');
+        (0, chai_1.expect)(store.read('n1', 2).state).to.equal('ended');
+        (0, chai_1.expect)(logs.writes).to.equal(0);
+    }));
+    it('holds an iPhone’s lines from its driver’s log, for the hub', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const driverLog = new driver_log_1.TestDriverLog();
+        const iphone = Object.assign(Object.assign({}, NODE_PHONE), { udid: '00008110-000A', platform: 'ios', realDevice: true });
+        yield logs.start({
+            sessionId: 'n-ios',
+            device: iphone,
+            since: Date.now() - 1000,
+            driverLog,
+        });
+        driverLog.line('Oct  5 20:31:07 iPhone Shop[4127] <Error>: payment failed');
+        const held = store.read('n-ios', null);
+        (0, chai_1.expect)(held.state).to.equal('recording');
+        (0, chai_1.expect)(held.lines.map((l) => l.message)).to.deep.equal([
+            'Oct  5 20:31:07 iPhone Shop[4127] <Error>: payment failed',
+        ]);
+        (0, chai_1.expect)(logs.writes).to.equal(0);
+        yield logs.stop('n-ios');
+        (0, chai_1.expect)(store.read('n-ios', 1).state).to.equal('ended');
+    }));
+    it('keeps the session’s line limit, so a hub is sent no more than its own phone’s session keeps', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store);
+        const since = Date.now() - 60000;
+        yield logs.start({ sessionId: 'n2', device: NODE_PHONE, since });
+        for (let i = 0; i < deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 5; i++) {
+            logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 1000 + i, `line ${i}`));
+        }
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(since + 30000, 'the end', 'E', 'AndroidRuntime'));
+        const held = () => store.entries.get('n2').lines.length;
+        yield (0, fake_logcat_1.until)(() => held() === deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 2, 20000);
+        yield logs.stop('n2');
+        let after = null;
+        const all = [];
+        for (;;) {
+            const page = store.read('n2', after);
+            all.push(...page.lines.map((l) => l.message));
+            if (!page.more)
+                break;
+            after = page.lines[page.lines.length - 1].seq;
+        }
+        // The limit, a note that only errors are kept from there, the error, and
+        // a note that the 5 other lines were left out.
+        (0, chai_1.expect)(all).to.have.length(deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 3);
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT]).to.contain('only errors are kept');
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 1]).to.match(/ E AndroidRuntime: the end$/);
+        (0, chai_1.expect)(all[deviceLogBook_1.DEVICE_LOG_LINE_LIMIT + 2]).to.contain('5 device log lines were left out');
+    }));
+    it('stops recording a session no hub has asked about', () => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        yield logs.start({ sessionId: 'n3', device: NODE_PHONE, since: Date.now() });
+        (0, chai_1.expect)((_a = logcat.getMultiplexer(NODE_PHONE.udid)) === null || _a === void 0 ? void 0 : _a.clientCount).to.equal(1);
+        yield (0, fake_logcat_1.until)(() => !logs.isRecording('n3'));
+        (0, chai_1.expect)((_c = (_b = logcat.getMultiplexer(NODE_PHONE.udid)) === null || _b === void 0 ? void 0 : _b.clientCount) !== null && _c !== void 0 ? _c : 0).to.equal(0);
+        (0, chai_1.expect)(store.read('n3', null)).to.deep.equal({ state: 'off', lines: [], more: false });
+        // Ending it later does nothing more.
+        yield logs.stop('n3');
+        (0, chai_1.expect)(store.read('n3', null).state).to.equal('off');
+    }));
+    it('records to the end once a hub has asked', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        const since = Date.now() - 1000;
+        yield logs.start({ sessionId: 'n4', device: NODE_PHONE, since });
+        store.read('n4', null);
+        yield new Promise((r) => setTimeout(r, 80));
+        (0, chai_1.expect)(logs.isRecording('n4')).to.equal(true);
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'still here'));
+        yield (0, fake_logcat_1.settle)();
+        (0, chai_1.expect)(store.read('n4', null).lines.map((l) => l.message)).to.have.length(1);
+        yield logs.stop('n4');
+    }));
+    it('keeps a session that ended before any hub asked, for the hub’s last ask', () => __awaiter(this, void 0, void 0, function* () {
+        const logs = new NodeSideDeviceLogs(logcat, store, 30);
+        const since = Date.now() - 1000;
+        yield logs.start({ sessionId: 'n5', device: NODE_PHONE, since });
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'a short session'));
+        yield (0, fake_logcat_1.settle)();
+        yield logs.stop('n5');
+        yield new Promise((r) => setTimeout(r, 80));
+        const held = store.read('n5', null);
+        (0, chai_1.expect)(held.state).to.equal('ended');
+        (0, chai_1.expect)(held.lines).to.have.length(1);
+    }));
+});
+describe('A hub writes a node session’s device log', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let node;
+    let count = 0;
+    let sessionId;
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        count += 1;
+        sessionId = `hub-dl-${count}`;
+        node = new NodeDeviceLogStore_1.NodeDeviceLogStore();
+        node.begin(sessionId);
+        yield scratch.db.session.create({
+            data: {
+                id: sessionId,
+                device_udid: NODE_PHONE.udid,
+                device_platform: 'android',
+                device_version: '10',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+            },
+        });
+    }));
+    const stored = () => scratch.db.log.findMany({
+        where: { session_id: sessionId, log_type: 'DEVICE' },
+        orderBy: { createdAt: 'asc' },
+    });
+    it('collects only a node’s phone, through its session, and never a cloud provider’s', () => {
+        const hub = new HubSideDeviceLogs();
+        const source = nodeAt(node, sessionId);
+        (0, chai_1.expect)(hub.appliesTo(NODE_PHONE, source)).to.equal(true);
+        (0, chai_1.expect)(hub.appliesTo(NODE_PHONE)).to.equal(false);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { cloud: 'browserstack' }), source)).to.equal(false);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { platform: 'ios' }), source)).to.equal(true);
+        (0, chai_1.expect)(hub.appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { platform: 'windows' }), source)).to.equal(false);
+        // A node never collects from another server.
+        (0, chai_1.expect)(new NodeSideDeviceLogs(new fake_logcat_1.FakeLogcatStreams(), node).appliesTo(Object.assign(Object.assign({}, NODE_PHONE), { nodeId: 'node-2', host: 'http://10.0.0.9:4725' }), source)).to.equal(false);
+    });
+    it('writes the lines as the node gives them, in its order, and the last ones at the end', () => __awaiter(this, void 0, void 0, function* () {
+        const hub = new HubSideDeviceLogs();
+        node.add(sessionId, [row(1), row(2)]);
+        yield hub.start({ sessionId, device: NODE_PHONE, source: nodeAt(node, sessionId) });
+        yield (0, fake_logcat_1.until)(() => node.claimed(sessionId));
+        yield new Promise((r) => setTimeout(r, 50));
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+        // The node's last lines, then its session ends before the hub's.
+        node.add(sessionId, [row(3), row(4)]);
+        node.end(sessionId);
+        yield hub.stop(sessionId);
+        const rows = yield stored();
+        (0, chai_1.expect)(rows.map((r) => r.message)).to.deep.equal(['line 1', 'line 2', 'line 3', 'line 4']);
+        // Each line keeps the node's time; each row its own `createdAt`, in order.
+        (0, chai_1.expect)(rows.map((r) => r.timestamp.getTime())).to.deep.equal([1, 2, 3, 4].map((n) => row(n).timestamp.getTime()));
+        const created = rows.map((r) => r.createdAt.getTime());
+        (0, chai_1.expect)(created.every((t, i) => i === 0 || t > created[i - 1]), String(created)).to.equal(true);
+    }));
+    it('goes on after a restart after the newest line stored, without writing it twice', () => __awaiter(this, void 0, void 0, function* () {
+        // Before the restart the hub wrote lines 1 to 3, the last two from an
+        // answer whose lines the node still holds: it drops them only when the
+        // next ask names them.
+        const later = Date.now() + 60000;
+        yield scratch.db.log.createMany({
+            data: [1, 2, 3].map((n) => ({
+                session_id: sessionId,
+                log_type: 'DEVICE',
+                message: row(n).message,
+                timestamp: row(n).timestamp,
+                createdAt: new Date(later + n),
+            })),
+        });
+        node.add(sessionId, [1, 2, 3, 4, 5].map(row));
+        node.read(sessionId, 1);
+        const hub = new HubSideDeviceLogs();
+        yield hub.start({
+            sessionId,
+            device: NODE_PHONE,
+            source: nodeAt(node, sessionId),
+            resume: true,
+        });
+        node.end(sessionId);
+        yield hub.stop(sessionId);
+        const rows = yield stored();
+        (0, chai_1.expect)(rows.map((r) => r.message)).to.deep.equal([1, 2, 3, 4, 5].map((n) => `line ${n}`));
+        (0, chai_1.expect)(rows[3].createdAt.getTime()).to.be.greaterThan(later + 3);
+    }));
+    it('a second stop waits for the first one’s last lines', () => __awaiter(this, void 0, void 0, function* () {
+        // A node slow to answer: the first stop is still in its last ask.
+        const slow = nodeAt(node, sessionId);
+        const source = {
+            nodeOrigin: slow.nodeOrigin,
+            nodeDeviceLogs: (after) => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((r) => setTimeout(r, 50));
+                return slow.nodeDeviceLogs(after);
+            }),
+        };
+        const hub = new HubSideDeviceLogs();
+        node.add(sessionId, [row(1)]);
+        yield hub.start({ sessionId, device: NODE_PHONE, source });
+        yield (0, fake_logcat_1.until)(() => node.claimed(sessionId));
+        node.add(sessionId, [row(2)]);
+        node.end(sessionId);
+        const first = hub.stop(sessionId);
+        // The failure analysis, after a second ending's stop, reads them all.
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+        yield first;
+    }));
+    it('takes the node’s last lines though the session ends while collection resumes', () => __awaiter(this, void 0, void 0, function* () {
+        class SlowToResume extends HubSideDeviceLogs {
+            storedTail(id) {
+                const _super = Object.create(null, {
+                    storedTail: { get: () => super.storedTail }
+                });
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield new Promise((r) => setTimeout(r, 50));
+                    return _super.storedTail.call(this, id);
+                });
+            }
+        }
+        const hub = new SlowToResume();
+        node.add(sessionId, [row(1), row(2)]);
+        node.end(sessionId);
+        void hub.start({
+            sessionId,
+            device: NODE_PHONE,
+            source: nodeAt(node, sessionId),
+            resume: true,
+        });
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)((yield stored()).map((r) => r.message)).to.deep.equal(['line 1', 'line 2']);
+    }));
+    it('collects nothing from a node that doesn’t record the session', () => __awaiter(this, void 0, void 0, function* () {
+        const hub = new HubSideDeviceLogs();
+        node.forget(sessionId);
+        yield hub.start({ sessionId, device: NODE_PHONE, source: nodeAt(node, sessionId) });
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)(yield stored()).to.deep.equal([]);
+    }));
+});

package/lib/test/unit/session-device-logs-lifecycle.spec.js

@@ -0,0 +1,137 @@
+"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 SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * A session's device log stops however the session ends on this server, its
+ * dashboard on or off: on a node that ends the lines it holds for the hub.
+ */
+describe('a session’s device log stops however the 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, SessionDeviceLogs_1.SessionDeviceLogs);
+        stop = sinon_1.default.stub().resolves();
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, { stop: sinon_1.default.stub().resolves() });
+        typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, { 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);
+    }));
+});
+/**
+ * After a hub restart, a node session's device log goes on being collected
+ * where the hub records sessions: after the newest line it stored.
+ */
+describe('a hub restart resumes collecting a node session’s device log', function () {
+    this.timeout(30000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let restore;
+    let start;
+    let savedStore;
+    let savedArgs;
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(SessionMetricsService_1.SessionMetricsService, SessionDeviceLogs_1.SessionDeviceLogs);
+        start = sinon_1.default.stub().resolves();
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, { start: sinon_1.default.stub() });
+        typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, { start });
+        savedArgs = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs;
+        savedStore = device_store_1.DeviceStoreFactory._deviceStore;
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+        const phone = (udid, extra) => scratch.db.device.create({
+            data: Object.assign({ udid, host: 'http://127.0.0.1:1', nodeId: 'node-2', platform: 'android', name: udid, sdk: '10', busy: true, userBlocked: false, offline: false }, extra),
+        });
+        yield phone('node-phone', {});
+        yield phone('cloud-phone', {
+            cloud: JSON.stringify('browserstack'),
+            host: 'https://hub.example.com',
+        });
+        for (const [id, udid, desired] of [
+            ['on-node', 'node-phone', '{}'],
+            ['logs-off', 'node-phone', JSON.stringify({ 'xe:save_device_logs': false })],
+            ['in-cloud', 'cloud-phone', '{}'],
+        ]) {
+            yield scratch.db.session.create({
+                data: {
+                    id,
+                    device_udid: udid,
+                    device_platform: 'android',
+                    device_version: '10',
+                    desired_capabilities: desired,
+                    session_capabilities: '{}',
+                    node_id: 'node-2',
+                    has_live_video: false,
+                    status: 'running',
+                },
+            });
+        }
+    }));
+    afterEach(() => {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        device_store_1.DeviceStoreFactory._deviceStore = savedStore;
+        typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs = savedArgs;
+        sinon_1.default.restore();
+        restore();
+    });
+    const recover = (enableDashboard) => __awaiter(this, void 0, void 0, function* () {
+        typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { enableDashboard });
+        yield new SessionManager_1.SessionManager().recoverActiveSessions('hub-1', '/wd/hub');
+        // The device log is resumed without waiting on it.
+        yield new Promise((r) => setImmediate(r));
+    });
+    it('resumes a node session’s, through the node, never a cloud provider’s nor one turned off', () => __awaiter(this, void 0, void 0, function* () {
+        yield recover(true);
+        (0, chai_1.expect)(start.getCalls().map((c) => c.args[0].sessionId)).to.deep.equal(['on-node']);
+        const args = start.firstCall.args[0];
+        (0, chai_1.expect)(args.resume).to.equal(true);
+        (0, chai_1.expect)(typeof args.source.nodeDeviceLogs).to.equal('function');
+    }));
+    it('resumes none on a hub with its dashboard off, which records no device logs', () => __awaiter(this, void 0, void 0, function* () {
+        yield recover(false);
+        (0, chai_1.expect)(start.called).to.equal(false);
+    }));
+});