@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/src/sessions/RemoteSession.js

@@ -18,7 +18,9 @@ const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../logger"));
 const SessionType_1 = __importDefault(require("../enums/SessionType"));
 const hubSessionToken_1 = require("../gateway/hubSessionToken");
+const outboundProxy_1 = require("../helpers/outboundProxy");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
 const nodeSessionStatus_1 = require("../gateway/nodeSessionStatus");
 const XenonSession_1 = require("./XenonSession");
 class RemoteSession extends XenonSession_1.XenonSession {
@@ -52,7 +54,8 @@ class RemoteSession extends XenonSession_1.XenonSession {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const options = yield this.callOptions();
-            return (0, axios_1.default)(Object.assign(Object.assign(Object.assign({}, config), options), { headers: Object.assign(Object.assign({}, ((_a = config.headers) !== null && _a !== void 0 ? _a : {})), ((_b = options.headers) !== null && _b !== void 0 ? _b : {})) }));
+            const request = Object.assign(Object.assign({}, config), options);
+            return (0, axios_1.default)(Object.assign(Object.assign(Object.assign({}, (request.proxy === undefined ? proxyFor(config.url) : {})), request), { headers: Object.assign(Object.assign({}, ((_a = config.headers) !== null && _a !== void 0 ? _a : {})), ((_b = options.headers) !== null && _b !== void 0 ? _b : {})) }));
         });
     }
     getScreenShot() {
@@ -233,6 +236,14 @@ class RemoteSession extends XenonSession_1.XenonSession {
     }
     /** The node's CPU and memory for this session newer than `after` (NodeMetricsCollector). */
     nodeMetrics(after) {
+        return this.askNode('metrics', after, nodeMetrics_1.readNodeMetricsReply);
+    }
+    /** The node's device log lines for this session after line `after` (NodeDeviceLogsCollector). */
+    nodeDeviceLogs(after) {
+        return this.askNode('device-logs', after, nodeDeviceLogs_1.readNodeDeviceLogsReply);
+    }
+    /** One of the node's routes about this session, `/xenon/api/node/sessions/<id>/<what>?after=`. */
+    askNode(what, after, read) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             const origin = this.nodeOrigin();
@@ -241,12 +252,12 @@ class RemoteSession extends XenonSession_1.XenonSession {
             try {
                 const response = yield this.call({
                     method: 'get',
-                    url: `${origin}${nodeSessionStatus_1.NODE_SESSION_STATUS_PATH}/${encodeURIComponent(this.sessionId)}/metrics`,
+                    url: `${origin}${nodeSessionStatus_1.NODE_SESSION_STATUS_PATH}/${encodeURIComponent(this.sessionId)}/${what}`,
                     params: after === null ? undefined : { after },
                     timeout: 5000,
                     validateStatus: () => true,
                 });
-                return (0, nodeMetrics_1.readNodeMetricsReply)(response.status, (_a = response.headers) !== null && _a !== void 0 ? _a : {}, response.data);
+                return read(response.status, (_a = response.headers) !== null && _a !== void 0 ? _a : {}, response.data);
             }
             catch (err) {
                 return { kind: 'unavailable', reason: String((_c = (_b = err === null || err === void 0 ? void 0 : err.code) !== null && _b !== void 0 ? _b : err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : err) };
@@ -392,7 +403,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
                     logger_1.default.warn(`[RemoteSession] Session ${this.sessionId} probe returned 404. Performing server status fallback...`);
                     // Fallback: Verify Appium server is alive
                     try {
-                        const statusRes = yield axios_1.default.get(`${appiumUrl}/status`, { timeout: 3000 });
+                        const statusRes = yield axios_1.default.get(`${appiumUrl}/status`, Object.assign({ timeout: 3000 }, proxyFor(`${appiumUrl}/status`)));
                         if (statusRes.status === 200) {
                             // If server is alive but we got a raw 404 with no specific error,
                             // it's likely the session is gone in Appium 2 (where /sessions list check is unsupported).
@@ -438,3 +449,11 @@ class RemoteSession extends XenonSession_1.XenonSession {
     }
 }
 exports.RemoteSession = RemoteSession;
+function proxyFor(url) {
+    try {
+        return url ? (0, outboundProxy_1.axiosProxyConfig)(url) : {};
+    }
+    catch (_a) {
+        return {};
+    }
+}

package/lib/src/sessions/SessionManager.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_MANAGER = exports.SessionManager = exports.HUB_RESTART_CATEGORY = void 0;
+exports.SESSION_MANAGER = exports.SessionManager = void 0;
 const os_1 = __importDefault(require("os"));
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
@@ -59,15 +59,14 @@ const logger_1 = __importDefault(require("../logger"));
 const RemoteSession_1 = require("./RemoteSession");
 const CloudSession_1 = require("./CloudSession");
 const device_store_1 = require("../data-service/device-store");
+const PluginContext_1 = require("../PluginContext");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
-/**
- * The `failure_category` of a session a restart ended: one still running at
- * boot that couldn't be picked up again. The failure analysis writes every
- * other category (`ANALYSIS_CATEGORIES`).
- */
-exports.HUB_RESTART_CATEGORY = 'HUB_RESTART';
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
+// A session still running at boot that can't be picked up again is filed
+// under it; the failure analysis also writes it for a shutdown's drain.
+const failureCategories_1 = require("../dashboard/services/failureCategories");
 /**
  * SessionManager with persistence and recovery capabilities.
  *
@@ -124,7 +123,7 @@ let SessionManager = class SessionManager {
      */
     recoverActiveSessions(currentNodeId_1, nodeBasePath_1) {
         return __awaiter(this, arguments, void 0, function* (currentNodeId, nodeBasePath, isLocalHost = () => false) {
-            var _a, _b;
+            var _a, _b, _c;
             this.log.info('🔄 Attempting to recover active sessions from database...');
             try {
                 // Find all sessions that are still "running" (not ended)
@@ -228,6 +227,13 @@ let SessionManager = class SessionManager {
                         if (!device.cloud && dbSession.is_profiling_available) {
                             yield this.resumeNodeMetrics(dbSession.id, device, recoveredSession, sessionResponse);
                         }
+                        // Its device log too, where the hub records sessions (the dashboard
+                        // on) and the session didn't turn it off, after the newest line stored.
+                        if (!device.cloud &&
+                            ((_c = typedi_2.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _c === void 0 ? void 0 : _c.enableDashboard) &&
+                            xenonCapabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS] !== false) {
+                            yield this.resumeNodeDeviceLogs(dbSession.id, device, recoveredSession);
+                        }
                         recoveredCount++;
                     }
                     catch (sessionErr) {
@@ -269,6 +275,24 @@ let SessionManager = class SessionManager {
             }
         });
     }
+    /** Goes on collecting a node session's device log after a hub restart. */
+    resumeNodeDeviceLogs(sessionId, device, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Loaded here: SessionDeviceLogs imports the device managers.
+                const { SessionDeviceLogs } = yield Promise.resolve().then(() => __importStar(require('../services/logcat/SessionDeviceLogs')));
+                void typedi_2.Container.get(SessionDeviceLogs).start({
+                    sessionId,
+                    device,
+                    source: (0, nodeDeviceLogs_1.nodeDeviceLogsSourceOf)(session),
+                    resume: true,
+                });
+            }
+            catch (err) {
+                this.log.warn(`Session ${sessionId}: device log 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
@@ -312,7 +336,7 @@ let SessionManager = class SessionManager {
                         status: 'failed',
                         endTime: new Date(),
                         failure_reason: reason,
-                        failure_category: exports.HUB_RESTART_CATEGORY,
+                        failure_category: failureCategories_1.HUB_RESTART_CATEGORY,
                     },
                 });
             }

package/lib/test/helpers/driver-log.js

@@ -0,0 +1,38 @@
+"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 });
+exports.TestDriverLog = void 0;
+const line_consuming_log_1 = require("appium-xcuitest-driver/build/lib/device/log/line-consuming-log");
+const quietLog = { debug() { }, info() { }, warn() { }, error() { } };
+/**
+ * The XCUITest driver's own log class, as an iPhone's (`IOSDeviceLog`) and a
+ * simulator's (`IOSSimulatorLog`) `logs.syslog` extend it, with `line()` in
+ * place of a device: what Xenon reads is what the driver keeps.
+ */
+class TestDriverLog extends line_consuming_log_1.LineConsumingLog {
+    constructor() {
+        super({ log: quietLog });
+    }
+    startCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    stopCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    get isCapturing() {
+        return true;
+    }
+    /** A line from the device, as the driver's capture hands it on. */
+    line(message) {
+        this.broadcast(message);
+    }
+}
+exports.TestDriverLog = TestDriverLog;

package/lib/test/helpers/fake-http-proxy.js

@@ -0,0 +1,106 @@
+"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 });
+exports.startFakeProxy = startFakeProxy;
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+/**
+ * An HTTP proxy on 127.0.0.1 that forwards what it is sent and notes it: a
+ * request in absolute form (http-proxy-agent, axios) is passed on to its
+ * target, a CONNECT (https-proxy-agent, so WebSockets) becomes a tunnel, or
+ * is refused with `refuseConnect`. A spec can then tell a call that went
+ * through the proxy from one that went straight to the target.
+ */
+function startFakeProxy() {
+    return __awaiter(this, arguments, void 0, function* (opts = {}) {
+        const seen = [];
+        const authorizations = [];
+        const sockets = new Set();
+        const resolve = (host) => { var _a, _b; return (_b = (_a = opts.hosts) === null || _a === void 0 ? void 0 : _a[host]) !== null && _b !== void 0 ? _b : host; };
+        const server = http_1.default.createServer((req, res) => {
+            var _a, _b;
+            seen.push(`${req.method} ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            let target;
+            try {
+                target = new URL((_b = req.url) !== null && _b !== void 0 ? _b : '');
+            }
+            catch (_c) {
+                res.writeHead(400).end();
+                return;
+            }
+            const upstream = http_1.default.request(Object.assign(Object.assign({}, urlParts(target)), { hostname: resolve(target.hostname), method: req.method, headers: req.headers }), (answer) => {
+                var _a;
+                res.writeHead((_a = answer.statusCode) !== null && _a !== void 0 ? _a : 502, answer.headers);
+                answer.pipe(res);
+            });
+            upstream.on('error', () => res.writeHead(502).end());
+            req.pipe(upstream);
+        });
+        server.on('connect', (req, client, head) => {
+            var _a;
+            seen.push(`CONNECT ${req.url}`);
+            authorizations.push(String((_a = req.headers['proxy-authorization']) !== null && _a !== void 0 ? _a : ''));
+            if (opts.ignoreConnect) {
+                sockets.add(client);
+                client.on('error', () => client.destroy());
+                return;
+            }
+            if (opts.refuseConnect) {
+                client.end('HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n');
+                return;
+            }
+            const [host, port] = String(req.url).split(':');
+            const upstream = net_1.default.connect(Number(port), resolve(host), () => {
+                client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+                if (head.length)
+                    upstream.write(head);
+                upstream.pipe(client);
+                client.pipe(upstream);
+            });
+            sockets.add(upstream).add(client);
+            const drop = () => {
+                upstream.destroy();
+                client.destroy();
+            };
+            upstream.on('error', drop);
+            client.on('error', drop);
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: `http://127.0.0.1:${port}`,
+            seen,
+            authorizations,
+            close: () => new Promise((resolve) => {
+                var _a;
+                for (const socket of sockets)
+                    socket.destroy();
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+function urlParts(url) {
+    return {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port,
+        path: `${url.pathname}${url.search}`,
+    };
+}

package/lib/test/helpers/fake-logcat.js

@@ -0,0 +1,80 @@
+"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 });
+exports.until = exports.settle = exports.FakeLogcatStreams = void 0;
+exports.lineAt = lineAt;
+exports.fakeProc = fakeProc;
+const stream_1 = require("stream");
+const LogcatStreamService_1 = require("../../src/device-managers/android/LogcatStreamService");
+const PackageResolver_1 = require("../../src/services/logcat/PackageResolver");
+const pad = (n, w = 2) => String(n).padStart(w, '0');
+/** A threadtime line logged at `at` by this machine's local clock. */
+function lineAt(at, msg, level = 'I', tag = 'Tag', pid = 4127) {
+    const t = new Date(at);
+    return (`${pad(t.getMonth() + 1)}-${pad(t.getDate())} ${pad(t.getHours())}:${pad(t.getMinutes())}:` +
+        `${pad(t.getSeconds())}.${pad(t.getMilliseconds(), 3)}  ${pid}  ${pid} ${level} ${tag}: ${msg}\n`);
+}
+/** An `adb logcat` child whose output the test writes. */
+function fakeProc() {
+    const stdout = new stream_1.PassThrough();
+    const handlers = {};
+    return {
+        stdout,
+        killed: false,
+        on(ev, cb) {
+            (handlers[ev] || (handlers[ev] = [])).push(cb);
+        },
+        /** The process ends, as when the phone restarts or is unplugged. */
+        exit() {
+            stdout.end();
+            (handlers.close || []).forEach((h) => h());
+        },
+        kill() {
+            this.killed = true;
+        },
+    };
+}
+/** The real stream service, its `adb logcat` children fake. */
+class FakeLogcatStreams extends LogcatStreamService_1.LogcatStreamService {
+    constructor() {
+        super(...arguments);
+        this.procs = [];
+    }
+    spawnLogcat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proc = fakeProc();
+            this.procs.push(proc);
+            return proc;
+        });
+    }
+    makeResolver() {
+        return new PackageResolver_1.PackageResolver(() => __awaiter(this, void 0, void 0, function* () { return '  PID NAME\n 4127 com.example.app\n'; }));
+    }
+    get proc() {
+        return this.procs[this.procs.length - 1];
+    }
+}
+exports.FakeLogcatStreams = FakeLogcatStreams;
+/** Lets readline, the stream's package lookups and the mux deliver what was written. */
+const settle = () => __awaiter(void 0, void 0, void 0, function* () {
+    for (let i = 0; i < 5; i++)
+        yield new Promise((r) => setImmediate(r));
+});
+exports.settle = settle;
+const until = (check_1, ...args_1) => __awaiter(void 0, [check_1, ...args_1], void 0, function* (check, ms = 2000) {
+    const end = Date.now() + ms;
+    while (!check()) {
+        if (Date.now() > end)
+            throw new Error('timed out');
+        yield new Promise((r) => setTimeout(r, 5));
+    }
+});
+exports.until = until;

package/lib/test/helpers/hub-node-pair.js

@@ -0,0 +1,227 @@
+"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 });
+exports.NODE_ID = void 0;
+exports.useHubAndNode = useHubAndNode;
+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 typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("./loopbackRequest"));
+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 nodeSessionDeviceLogs_1 = require("../../src/gateway/nodeSessionDeviceLogs");
+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("./container-registration");
+const appium_umbrella_1 = require("./appium-umbrella");
+exports.NODE_ID = 'node-1';
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+/**
+ * A hub and a node in one process, for what a hub collects from a node about
+ * a session it runs: the node in Appium 3's own server() (Appium's umbrella
+ * with Xenon's plugin, the production node gateway, and the node's
+ * session-status, metrics and device-log routes), with per-command auth on,
+ * so every ask carries the hub's session token. The hub serves only its
+ * public keys: the spec plays the hub's side through the session's
+ * RemoteSession.
+ *
+ * Call it inside a `describe`, after useScratchDatabase(). `services` are the
+ * container ids the spec replaces in its own `beforeEach`; they are put back
+ * after each test.
+ */
+function useHubAndNode(scratch, services = []) {
+    const servers = [];
+    let dirs;
+    let hubKeys;
+    let appiumLogs;
+    let restore;
+    let saved;
+    let authDisabledBefore;
+    let commandAuthBefore;
+    let nodeOrigin = '';
+    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-hub-node-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, ...services);
+        // 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;
+    function boot() {
+        return __awaiter(this, arguments, void 0, function* (nodeArgs = {}) {
+            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);
+            const hubUrl = `http://127.0.0.1:${port(hubServer)}`;
+            const pluginArgs = Object.assign(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { hub: hubUrl, bindHostOrIp: '127.0.0.1', enableDashboard: false, deviceAvailabilityTimeoutMs: 1000, deviceAvailabilityQueryIntervalMs: 100 }), nodeArgs);
+            const 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);
+                        (0, nodeSessionDeviceLogs_1.registerNodeSessionDeviceLogs)(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), exports.NODE_ID, '/node');
+            yield scratch.db.device.create({
+                data: {
+                    udid: 'phone-1',
+                    host: nodeOrigin,
+                    nodeId: exports.NODE_ID,
+                    platform: 'android',
+                    name: 'phone-1',
+                    sdk: '14',
+                    busy: false,
+                    userBlocked: false,
+                    offline: false,
+                },
+            });
+        });
+    }
+    function nodeSession() {
+        return __awaiter(this, arguments, void 0, function* (caps = {}) {
+            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: Object.assign({ platformName: 'Android', 'appium:automationName': appium_umbrella_1.FAKE_AUTOMATION, 'appium:newCommandTimeout': 0, 'appium:udid': 'phone-1', 'xe:options': { recordVideo: false } }, caps),
+                    firstMatch: [{}],
+                },
+            });
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            return res.body.value.sessionId;
+        });
+    }
+    const hubSide = (sessionId) => new RemoteSession_1.RemoteSession({
+        sessionId,
+        device: { udid: 'phone-1', host: nodeOrigin, nodeId: exports.NODE_ID, platform: 'android' },
+        sessionResponse: {},
+        xenonOption: {},
+        baseUrl: `${nodeOrigin}/node`,
+    });
+    function deleteOnNode(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).tokenFor(sessionId);
+            const res = yield (0, loopbackRequest_1.default)(nodeOrigin)
+                .delete(`/node/session/${sessionId}`)
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, token);
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+        });
+    }
+    return {
+        get nodeOrigin() {
+            return nodeOrigin;
+        },
+        boot,
+        nodeSession,
+        hubSide,
+        deleteOnNode,
+    };
+}