@xenon-device-management/xenon 2.16.0 → 2.17.0

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/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-iphone-readiness.spec.js

@@ -0,0 +1,134 @@
+"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 device_utils_1 = require("../../src/device-utils");
+const device_service_1 = require("../../src/data-service/device-service");
+const device_store_1 = require("../../src/data-service/device-store");
+const localDeviceHosts_1 = require("../../src/device-managers/localDeviceHosts");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const WDAClient_1 = require("../../src/device-managers/ios/WDAClient");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const test_container_1 = require("../helpers/test-container");
+const loki_stores_1 = require("../helpers/loki-stores");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * Before a session, allocation asks the phone's manager whether it is ready.
+ * For an iPhone that asks WebDriverAgent on 127.0.0.1, at the port the phone's
+ * row names, and on no answer starts a go-ios stream for the phone. Both are
+ * this machine's: they say nothing about a phone another server drives.
+ *
+ * A hub ran it for its nodes' iPhones too. With the node on another machine
+ * nothing answered on the hub, its stream found no phone of its own to start,
+ * and every session on the node's iPhone was refused as "unhealthy". With both
+ * on one Mac, the hub started its own WebDriverAgent on the phone the node
+ * drives. The node checks the phone itself when it allocates it.
+ */
+describe("Readiness before a session, on a hub allocating a node's iPhone", function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    (0, loki_stores_1.usePrismaStores)();
+    const NODE_ID = 'node-process';
+    const UDID = '00008110-000A1B2C3D4E5F60';
+    const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { platform: 'ios', iosDeviceType: 'both' });
+    let hubNodeId;
+    let hubOrigin;
+    let verifyWda;
+    let startStream;
+    const iPhone = (over) => (Object.assign({ udid: UDID, name: 'iPhone 14 Plus', platform: 'ios', sdk: '18.0', deviceType: 'real', realDevice: true, state: 'device', busy: false, offline: false, userBlocked: false, wdaLocalPort: 8100, mjpegServerPort: 9100, totalUtilizationTimeMilliSec: 0, sessionStartTime: 0 }, over));
+    const caps = (extra = {}) => ({
+        alwaysMatch: Object.assign({ platformName: 'iOS', 'appium:udid': UDID }, extra),
+        firstMatch: [{}],
+    });
+    const allocate = (extra = {}) => (0, device_utils_1.allocateDeviceForSession)(caps(extra), 1000, 50, pluginArgs);
+    const row = (host) => device_store_1.DeviceStoreFactory.getStore().findDevice({ udid: UDID, host });
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        const { context, xenonManager } = (0, test_container_1.setupTestContainer)(pluginArgs);
+        xenonManager.init();
+        hubNodeId = context.nodeId;
+        hubOrigin = (0, localDeviceHosts_1.serverOrigin)(context.pluginArgs, context.port);
+        yield scratch.db.device.deleteMany({});
+        yield scratch.db.deviceSetting.deleteMany({});
+        verifyWda = sinon_1.default.stub(WDAClient_1.WDAClient.prototype, 'verifyWDAStatus');
+        startStream = sinon_1.default.stub(IOSStreamService_1.default.prototype, 'startStream');
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        yield (0, test_container_1.resetTestContainer)();
+    }));
+    describe('a node on another machine', () => {
+        const NODE = 'http://203.0.113.7:4723';
+        beforeEach(() => {
+            // What the hub's own machine answers: no WebDriverAgent on its
+            // 127.0.0.1, and no row of its own to start a stream from.
+            verifyWda.resolves(false);
+            startStream.rejects(new Error(`Device ${UDID} not found`));
+        });
+        it("allocates the node's iPhone, which the node checks itself", () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield (0, device_service_1.addNewDevice)([iPhone({ host: NODE, nodeId: NODE_ID })]);
+            const device = yield allocate();
+            (0, chai_1.expect)(device).to.include({ udid: UDID, host: NODE });
+            (0, chai_1.expect)((_a = (yield row(NODE))) === null || _a === void 0 ? void 0 : _a.busy).to.equal(true);
+        }));
+        it("never asks the hub's own WebDriverAgent or starts a stream for it", () => __awaiter(this, void 0, void 0, function* () {
+            yield (0, device_service_1.addNewDevice)([iPhone({ host: NODE, nodeId: NODE_ID })]);
+            yield allocate().catch(() => undefined);
+            (0, chai_1.expect)(verifyWda.called, 'verifyWDAStatus called').to.equal(false);
+            (0, chai_1.expect)(startStream.called, 'startStream called').to.equal(false);
+        }));
+    });
+    describe('a node on the same Mac', () => {
+        it("never starts the hub's own stream for the iPhone the node drives", () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const node = `http://${pluginArgs.bindHostOrIp}:4724`;
+            // The hub sees the same iPhone and files it under its own host; the
+            // client asks for the node's.
+            yield (0, device_service_1.addNewDevice)([
+                iPhone({ host: node, nodeId: NODE_ID }),
+                iPhone({ host: hubOrigin, nodeId: hubNodeId, wdaLocalPort: 8101 }),
+            ]);
+            // The hub's stream starts for the udid, and its WebDriverAgent then
+            // answers: a second one beside the node's.
+            verifyWda.callsFake(() => __awaiter(this, void 0, void 0, function* () { return startStream.called; }));
+            startStream.resolves({ wdaPort: 8102, mjpegPort: 9102 });
+            const device = yield allocate({ 'appium:filterByHost': node });
+            (0, chai_1.expect)(device).to.include({ udid: UDID, host: node });
+            (0, chai_1.expect)(startStream.called, 'startStream called').to.equal(false);
+            (0, chai_1.expect)(verifyWda.called, 'verifyWDAStatus called').to.equal(false);
+            (0, chai_1.expect)((_a = (yield row(hubOrigin))) === null || _a === void 0 ? void 0 : _a.busy).to.equal(false);
+        }));
+    });
+    describe("the hub's own iPhone", () => {
+        it('is still checked, and allocated when its WebDriverAgent answers', () => __awaiter(this, void 0, void 0, function* () {
+            yield (0, device_service_1.addNewDevice)([iPhone({ host: hubOrigin, nodeId: hubNodeId })]);
+            verifyWda.resolves(true);
+            const device = yield allocate();
+            (0, chai_1.expect)(device).to.include({ udid: UDID, host: hubOrigin });
+            (0, chai_1.expect)(verifyWda.calledWith(UDID)).to.equal(true);
+        }));
+        it('is still refused, and released, when it is not ready and cannot be recovered', () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield (0, device_service_1.addNewDevice)([iPhone({ host: hubOrigin, nodeId: hubNodeId })]);
+            verifyWda.resolves(false);
+            startStream.rejects(new Error('go-ios could not start'));
+            const error = yield allocate().then(() => null, (e) => e);
+            (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/is unhealthy and could not be autonomously recovered/);
+            (0, chai_1.expect)(startStream.calledWith(UDID)).to.equal(true);
+            (0, chai_1.expect)((_a = (yield row(hubOrigin))) === null || _a === void 0 ? void 0 : _a.busy).to.equal(false);
+        }));
+    });
+});

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

@@ -0,0 +1,194 @@
+"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 typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+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 hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const commandAuth_1 = require("../../src/middleware/commandAuth");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
+const hub_node_pair_1 = require("../helpers/hub-node-pair");
+const fake_logcat_1 = require("../helpers/fake-logcat");
+/**
+ * A hub writes the Device logs of a session on a node's phone, collected from
+ * the node: the node records its phone's log for the session the hub created
+ * (its dashboard off) and holds the lines; the hub asks for them with its
+ * session token (per-command auth is on) and writes them as the session page
+ * reads them. The node's `adb logcat` is fake; everything from it to the
+ * hub's rows is the real thing.
+ */
+const quiet = { info: () => undefined, warn: () => undefined, debug: () => undefined };
+/** The node's service, its phone's log stream fake. */
+class NodeSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    constructor(logcat, unclaimed = 60000) {
+        super();
+        this.logcat = logcat;
+        this.unclaimed = unclaimed;
+    }
+    streams() {
+        return this.logcat;
+    }
+    readClock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return deviceLogBook_1.UNKNOWN_CLOCK;
+        });
+    }
+    unclaimedMs() {
+        return this.unclaimed;
+    }
+}
+/** The hub's service: none of the phones are its own; it asks the node every 50 ms. */
+class HubSideDeviceLogs extends SessionDeviceLogs_1.SessionDeviceLogs {
+    context() {
+        return {
+            pluginArgs: Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }),
+            port: 4799,
+            nodeId: 'hub-1',
+        };
+    }
+    collectorFor(source, onLines, storedTail) {
+        return new NodeDeviceLogsCollector_1.NodeDeviceLogsCollector({
+            source,
+            onLines,
+            storedTail,
+            support: typedi_1.Container.get(nodeDeviceLogs_1.NodeDeviceLogsSupport),
+            logger: quiet,
+            intervalMs: 50,
+        });
+    }
+}
+describe('a hub writes a node session’s device log', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const pair = (0, hub_node_pair_1.useHubAndNode)(scratch, [
+        SessionDeviceLogs_1.SessionDeviceLogs,
+        NodeDeviceLogStore_1.NodeDeviceLogStore,
+        nodeDeviceLogs_1.NodeDeviceLogsSupport,
+    ]);
+    let logcat;
+    beforeEach(() => {
+        logcat = new fake_logcat_1.FakeLogcatStreams();
+        typedi_1.Container.set(NodeDeviceLogStore_1.NodeDeviceLogStore, new NodeDeviceLogStore_1.NodeDeviceLogStore());
+        typedi_1.Container.set(nodeDeviceLogs_1.NodeDeviceLogsSupport, new nodeDeviceLogs_1.NodeDeviceLogsSupport());
+    });
+    afterEach(() => logcat.cleanup());
+    /** Boots the pair, the node's device log service `nodeLogs`; no CPU and memory sampling. */
+    function boot(nodeLogs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, nodeLogs);
+            yield pair.boot({ sessionMetrics: false });
+        });
+    }
+    /** The hub's row for the session, as onSessionStarted writes it. */
+    const hubRow = (sessionId) => scratch.db.session.create({
+        data: {
+            id: sessionId,
+            device_udid: 'phone-1',
+            device_platform: 'android',
+            device_version: '14',
+            desired_capabilities: '{}',
+            session_capabilities: '{}',
+            node_id: hub_node_pair_1.NODE_ID,
+            has_live_video: false,
+            status: 'running',
+        },
+    });
+    /** The session's Device logs as the hub's session page gets them. */
+    const page = (sessionId) => __awaiter(this, void 0, void 0, function* () {
+        const res = yield (0, loopbackRequest_1.default)((0, selector_health_fixture_1.selectorHealthApp)(selector_health_fixture_1.ADMIN)).get(`/session/${sessionId}/logs/device`);
+        (0, chai_1.expect)(res.status, res.text).to.equal(200);
+        return res.body.map((r) => r.message.replace(/^.*?Tag {5}: /, ''));
+    });
+    /** The page, once `ok` holds for it. */
+    const pageOnce = (sessionId, ok) => __awaiter(this, void 0, void 0, function* () {
+        const end = Date.now() + 5000;
+        for (;;) {
+            const rows = yield page(sessionId);
+            if (ok(rows))
+                return rows;
+            if (Date.now() > end)
+                throw new Error(`timed out at ${JSON.stringify(rows)}`);
+            yield new Promise((r) => setTimeout(r, 50));
+        }
+    });
+    const device = () => ({ udid: 'phone-1', host: pair.nodeOrigin, nodeId: hub_node_pair_1.NODE_ID, platform: 'android' });
+    it('writes the lines as the session runs, and the last ones when it ends', () => __awaiter(this, void 0, void 0, function* () {
+        const nodeLogs = new NodeSideDeviceLogs(logcat);
+        yield boot(nodeLogs);
+        const sessionId = yield pair.nodeSession();
+        // The node records the session the hub created, its dashboard off.
+        (0, chai_1.expect)(nodeLogs.isRecording(sessionId)).to.equal(true);
+        yield (0, fake_logcat_1.until)(() => logcat.procs.length === 1);
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now() - 600000, 'before the session'));
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'app started'));
+        yield hubRow(sessionId);
+        const hub = new HubSideDeviceLogs();
+        yield hub.start({ sessionId, device: device(), source: pair.hubSide(sessionId) });
+        // Live: written while the session runs.
+        (0, chai_1.expect)(yield pageOnce(sessionId, (rows) => rows.length > 0)).to.deep.equal(['app started']);
+        // The test's last moments, then the hub's DELETE reaches the node.
+        logcat.proc.stdout.write((0, fake_logcat_1.lineAt)(Date.now(), 'FATAL EXCEPTION: main'));
+        yield (0, fake_logcat_1.until)(() => typedi_1.Container.get(NodeDeviceLogStore_1.NodeDeviceLogStore).read(sessionId, null).lines.length > 0);
+        yield pair.deleteOnNode(sessionId);
+        (0, chai_1.expect)(nodeLogs.isRecording(sessionId)).to.equal(false);
+        yield hub.stop(sessionId);
+        (0, chai_1.expect)(yield page(sessionId)).to.deep.equal(['app started', 'FATAL EXCEPTION: main']);
+    }));
+    it('asks only with the hub’s token for the session', () => __awaiter(this, void 0, void 0, function* () {
+        yield boot(new NodeSideDeviceLogs(logcat));
+        const sessionId = yield pair.nodeSession();
+        const route = `/xenon/api/node/sessions/${sessionId}/device-logs`;
+        const without = yield (0, loopbackRequest_1.default)(pair.nodeOrigin).get(route);
+        const forged = yield (0, loopbackRequest_1.default)(pair.nodeOrigin).get(route).set(hubSessionToken_1.HUB_TOKEN_HEADER, 'forged');
+        (0, chai_1.expect)([without.status, without.body]).to.deep.equal([404, commandAuth_1.UNKNOWN_SESSION_BODY]);
+        (0, chai_1.expect)([forged.status, forged.body]).to.deep.equal([404, commandAuth_1.UNKNOWN_SESSION_BODY]);
+        const asked = yield pair.hubSide(sessionId).nodeDeviceLogs(null);
+        (0, chai_1.expect)(asked).to.deep.equal({
+            kind: 'answer',
+            answer: { state: 'recording', lines: [], more: false },
+        });
+        yield pair.deleteOnNode(sessionId);
+    }));
+    it('records nothing for a session that turned its device log off', () => __awaiter(this, void 0, void 0, function* () {
+        const nodeLogs = new NodeSideDeviceLogs(logcat);
+        yield boot(nodeLogs);
+        const sessionId = yield pair.nodeSession({ 'xe:save_device_logs': false });
+        (0, chai_1.expect)(nodeLogs.isRecording(sessionId)).to.equal(false);
+        (0, chai_1.expect)(logcat.procs).to.have.length(0);
+        (0, chai_1.expect)(yield pair.hubSide(sessionId).nodeDeviceLogs(null)).to.deep.equal({
+            kind: 'answer',
+            answer: { state: 'off', lines: [], more: false },
+        });
+        yield pair.deleteOnNode(sessionId);
+    }));
+    it('stops recording a session its hub doesn’t ask about', () => __awaiter(this, void 0, void 0, function* () {
+        const nodeLogs = new NodeSideDeviceLogs(logcat, 50);
+        yield boot(nodeLogs);
+        const sessionId = yield pair.nodeSession();
+        yield (0, fake_logcat_1.until)(() => !nodeLogs.isRecording(sessionId));
+        (0, chai_1.expect)(yield pair.hubSide(sessionId).nodeDeviceLogs(null)).to.deep.equal({
+            kind: 'answer',
+            answer: { state: 'off', lines: [], more: false },
+        });
+        yield pair.deleteOnNode(sessionId);
+    }));
+});