@xenon-device-management/xenon 2.16.0 → 2.17.1

package/lib/src/sessions/sessionMemory.js

@@ -1,13 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forgetSessionMemory = forgetSessionMemory;
 const typedi_1 = require("typedi");
 const OmniVisionService_1 = require("../services/omni-vision/OmniVisionService");
 const AutowaitService_1 = require("../services/autowait/AutowaitService");
+const IOSStreamService_1 = __importDefault(require("../device-managers/ios/IOSStreamService"));
+const logger_1 = __importDefault(require("../logger"));
 /**
  * Drop what this server keeps in memory for a session's commands: the
- * elements its finds and heals found in screenshots (OmniVisionService) and
- * its autowait settings (AutowaitService). Called however the session ends
+ * elements its finds and heals found in screenshots (OmniVisionService), its
+ * autowait settings (AutowaitService), and a simulator's live preview of its
+ * picture (IOSStreamService). Called however the session ends
  * here: the test's delete (SessionLifecycleService.deleteSession), Appium's
  * new-command timeout or a crash (XenonPlugin.onUnexpectedShutdown), the idle
  * release (releaseBlockedDevices), a stale heartbeat (OrphanSweeper) and a
@@ -22,4 +28,7 @@ function forgetSessionMemory(sessionId) {
         return;
     typedi_1.Container.get(OmniVisionService_1.OmniVisionService).forgetSession(sessionId);
     typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(sessionId);
+    typedi_1.Container.get(IOSStreamService_1.default)
+        .endSimulatorPreviews(sessionId)
+        .catch((err) => { var _a; return logger_1.default.warn(`Ending the simulator preview of ${sessionId} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); });
 }

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,
+    };
+}

package/lib/test/unit/UserService.test.js

@@ -26,6 +26,14 @@ describe('UserService', () => {
             (0, chai_1.expect)(yield svc.verifyPassword('correct-horse-staple', hash)).to.be.true;
             (0, chai_1.expect)(yield svc.verifyPassword('wrong', hash)).to.be.false;
         }));
+        // Written by the native `bcrypt` 5 that hashed passwords through 2.17, at
+        // its cost of 12: every stored password is one of these.
+        it('verifies a password stored before 2.18', () => __awaiter(void 0, void 0, void 0, function* () {
+            const stored = '$2b$12$5kTngvxC6mQpOaiVCcexfuHPHKvxQMKz/IFm3Gxzia4Sb3lzK85dC';
+            const svc = new UserService_1.UserService();
+            (0, chai_1.expect)(yield svc.verifyPassword('signed-in-before-2.18', stored)).to.be.true;
+            (0, chai_1.expect)(yield svc.verifyPassword('signed-in-before-2.17', stored)).to.be.false;
+        }));
         it('rejects passwords shorter than 8 characters', () => __awaiter(void 0, void 0, void 0, function* () {
             const svc = new UserService_1.UserService();
             let err;

package/lib/test/unit/boot-device-sync.spec.js

@@ -0,0 +1,195 @@
+"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 __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) {
+        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 net_1 = __importDefault(require("net"));
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const async_wait_until_1 = __importDefault(require("async-wait-until"));
+const prisma_1 = require("../../src/prisma");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const device_store_1 = require("../../src/data-service/device-store");
+const deviceUtils = __importStar(require("../../src/device-utils"));
+const helpers = __importStar(require("../../src/helpers"));
+const NodeDevices_1 = __importDefault(require("../../src/device-managers/NodeDevices"));
+const device_managers_1 = require("../../src/device-managers");
+const iOSTracker_1 = require("../../src/device-managers/iOSTracker");
+const localDeviceHosts_1 = require("../../src/device-managers/localDeviceHosts");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const container_registration_1 = require("../helpers/container-registration");
+const fake_device_table_1 = require("../helpers/fake-device-table");
+/**
+ * Appium opens its port only once every plugin's updateServer has finished,
+ * so a start must not wait long on another server. Seen with 2.17.0: a hub
+ * whose database still listed its own phones under its old DHCP address
+ * (http://192.168.0.104:4723, now .102) asked that address whether it was a
+ * live node, and a host that drops packets takes four 30 s timeouts to give
+ * up, so the port opened 2 min 4 s after the plugin loaded. A node whose hub
+ * doesn't answer waited the same way before reporting its phones.
+ */
+const IP = '192.168.0.102';
+const HUB = `http://${IP}:4723`;
+const NODE = `http://${IP}:4725`;
+const phone = (udid, host, over = {}) => (Object.assign({ udid,
+    host, name: udid, platform: 'android', deviceType: 'real', realDevice: true, state: 'device', sdk: '14' }, over));
+/** A promise this test settles when it chooses, as a host that drops packets never does. */
+const deferred = () => {
+    let resolve;
+    const promise = new Promise((r) => (resolve = r));
+    return { promise, resolve };
+};
+/** Whether a promise settles within a time no probe of another server can beat. */
+const settlesSoon = (p) => Promise.race([
+    p.then(() => true),
+    new Promise((r) => setTimeout(() => r(false), 1000)),
+]);
+describe('A start never waits on another server', () => {
+    let table;
+    let discover;
+    let restoreContainer;
+    let savedStore;
+    const seed = (rows) => {
+        table = (0, fake_device_table_1.fakeDeviceTable)(rows);
+        for (const m of Object.keys(table.delegate)) {
+            sinon_1.default.stub(prisma_1.prisma.device, m).callsFake(table.delegate[m]);
+        }
+        const settings = (0, fake_device_table_1.fakeDeviceSettingTable)();
+        for (const m of Object.keys(settings.delegate)) {
+            sinon_1.default.stub(prisma_1.prisma.deviceSetting, m).callsFake(settings.delegate[m]);
+        }
+    };
+    const boot = (port, args) => typedi_1.Container.get(ServerManager_1.ServerManager).syncDevicesAtBoot((0, localDeviceHosts_1.localDeviceHosts)({ bindHostOrIp: IP }, port), args);
+    beforeEach(() => {
+        discover = () => __awaiter(void 0, void 0, void 0, function* () { return []; });
+        restoreContainer = (0, container_registration_1.saveRegistrations)(device_managers_1.XenonManager, SocketServer_1.SocketServer, NotificationService_1.NotificationService, iOSTracker_1.IosTracker);
+        typedi_1.Container.set({
+            id: device_managers_1.XenonManager,
+            value: { getDevices: (known) => discover(known) },
+        });
+        typedi_1.Container.set({
+            id: SocketServer_1.SocketServer,
+            value: {
+                emitToDashboard: () => undefined,
+                emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+                hasScopedDashboard: () => false,
+            },
+        });
+        typedi_1.Container.set({ id: NotificationService_1.NotificationService, value: { dispatchEvent: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }) } });
+        sinon_1.default.stub(prisma_1.prisma.lease, 'findMany').resolves([]);
+        savedStore = device_store_1.DeviceStoreFactory._deviceStore;
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+    });
+    afterEach(() => {
+        device_store_1.DeviceStoreFactory._deviceStore = savedStore;
+        sinon_1.default.restore();
+        restoreContainer();
+    });
+    describe('on a hub, a row whose server never answers', () => {
+        // Takes the connection and never answers, as a host past a dropped route
+        // looks to the client: nothing but the timeout ends the request.
+        let silent;
+        let sockets;
+        let silentHost;
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            sockets = [];
+            silent = net_1.default.createServer((s) => {
+                sockets.push(s);
+            });
+            yield new Promise((r) => silent.listen(0, '127.0.0.1', r));
+            silentHost = `http://127.0.0.1:${silent.address().port}`;
+            // The real probe, with a limit this test can wait for.
+            sinon_1.default.stub(deviceUtils.BOOT_PROBE, 'timeoutMs').value(300);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            sockets.forEach((s) => s.destroy());
+            yield new Promise((r) => silent.close(() => r()));
+        }));
+        it('is asked once, briefly, and gone before the port opens', () => __awaiter(void 0, void 0, void 0, function* () {
+            seed([phone('old-row', silentHost)]);
+            discover = () => __awaiter(void 0, void 0, void 0, function* () { return [phone('own-phone', HUB)]; });
+            (0, chai_1.expect)(yield settlesSoon(boot(4723, {}))).to.equal(true);
+            (0, chai_1.expect)(table.row('own-phone')).to.include({ host: HUB });
+            (0, chai_1.expect)(table.row('old-row')).to.equal(undefined);
+            (0, chai_1.expect)(sockets).to.have.length(1);
+        }));
+    });
+    it('a node opens while its hub never answers, and reports its phones once it does', () => __awaiter(void 0, void 0, void 0, function* () {
+        seed([]);
+        discover = () => __awaiter(void 0, void 0, void 0, function* () { return [phone('node-phone', NODE)]; });
+        const hubAnswer = deferred();
+        const alive = sinon_1.default.stub(helpers, 'isXenonRunning').returns(hubAnswer.promise);
+        const post = sinon_1.default.stub(NodeDevices_1.default.prototype, 'postDevicesToHub').resolves();
+        (0, chai_1.expect)(yield settlesSoon(boot(4725, { hub: HUB }))).to.equal(true);
+        (0, chai_1.expect)(table.row('node-phone')).to.include({ host: NODE });
+        (0, chai_1.expect)(alive.calledWith(HUB)).to.equal(true);
+        (0, chai_1.expect)(post.called).to.equal(false);
+        hubAnswer.resolve(true);
+        yield (0, async_wait_until_1.default)(() => post.called, { timeout: 2000 });
+        (0, chai_1.expect)(post.firstCall.args[1]).to.equal('add');
+        (0, chai_1.expect)(post.firstCall.args[0].map((d) => d.udid)).to.deep.equal(['node-phone']);
+    }));
+    it("a node's report that fails is logged, and never fails the start", () => __awaiter(void 0, void 0, void 0, function* () {
+        seed([]);
+        sinon_1.default.stub(deviceUtils, 'reportDevicesToHub').rejects(new Error('hub refused'));
+        const warn = sinon_1.default.spy(typedi_1.Container.get(ServerManager_1.ServerManager).logger, 'warn');
+        const unhandled = sinon_1.default.spy();
+        process.on('unhandledRejection', unhandled);
+        try {
+            yield boot(4725, { hub: HUB });
+            yield (0, async_wait_until_1.default)(() => warn.called, { timeout: 2000 });
+            (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include('hub refused');
+            yield new Promise((r) => setImmediate(r));
+            (0, chai_1.expect)(unhandled.called).to.equal(false);
+        }
+        finally {
+            process.off('unhandledRejection', unhandled);
+        }
+    }));
+});

package/lib/test/unit/dashboard-events-device-logs.spec.js

@@ -175,6 +175,21 @@ describe('EventManager: an Android session’s device log', () => {
         (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].driverLog).to.equal(driverLog);
         (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].appUnderTest).to.equal('com.example.shop');
     }));
+    it("collects a node session's from the node, through the session", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { device } = stubSessionStart();
+        const session = {
+            getId: () => 's-logs-node',
+            getType: () => 'remote',
+            getCapabilities: () => ({ platformName: 'Android' }),
+            getLiveVideoUrl: () => null,
+            nodeOrigin: () => 'http://node:4723',
+            nodeDeviceLogs: () => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'refused' }); }),
+            apiKeyId: null,
+            userId: null,
+        };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({}), session, Object.assign(Object.assign({}, device), { host: 'http://node:4723' }));
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].source).to.equal(session);
+    }));
     it('writes it to the end when the session stops, even one no longer in memory', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns(undefined);
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({ getDevices: () => __awaiter(void 0, void 0, void 0, function* () { return []; }) });

package/lib/test/unit/hub-node-gateway-appium-server.spec.js

@@ -67,6 +67,7 @@ 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 event_manager_1 = require("../../src/dashboard/event-manager");
+const deviceService = __importStar(require("../../src/data-service/device-service"));
 const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
 const internalCall_1 = require("../../src/gateway/internalCall");
 const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
@@ -657,6 +658,26 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
             (0, chai_1.expect)(nodeRequests).to.have.length(1);
             (0, chai_1.expect)(nodeRequests[0].headers[internalCall_1.INTERNAL_CALL_HEADER]).to.equal(undefined);
         }));
+        it('is never logged as one of the session’s commands, though forwarded', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const before = sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'beforeSessionCommand').resolves(true);
+            const after = sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'afterSessionCommand').resolves();
+            const touched = sinon_1.default.stub(deviceService, 'updateCmdExecutedTime').resolves();
+            yield (0, loopbackRequest_1.default)(hubUrl)
+                .get(`/wd/hub/wd-internal/session/${id}/url`)
+                .set((0, internalCall_1.internalCallHeaders)())
+                .expect(200);
+            (0, chai_1.expect)(node.commands).to.deep.equal(['getUrl']);
+            (0, chai_1.expect)(before.called, 'the dashboard’s before hook').to.equal(false);
+            (0, chai_1.expect)(after.called, 'the dashboard’s after hook').to.equal(false);
+            (0, chai_1.expect)(touched.called, 'counted as the session’s activity').to.equal(false);
+            // The test's own command is, as before.
+            yield (0, loopbackRequest_1.default)(hubUrl).get(`/wd/hub/session/${id}/url`).expect(200);
+            (0, chai_1.expect)(before.callCount).to.equal(1);
+            (0, chai_1.expect)(after.callCount).to.equal(1);
+            (0, chai_1.expect)(touched.calledOnceWith(id)).to.equal(true);
+        }));
     });
     describe('per-command auth on a remote session (at the hub)', () => {
         it('lets the owner through to the node', () => __awaiter(this, void 0, void 0, function* () {