@xenon-device-management/xenon 2.0.0 → 2.1.0

package/lib/src/sessions/RemoteSession.js

@@ -14,8 +14,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteSession = void 0;
 const axios_1 = __importDefault(require("axios"));
+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 nodeSessionStatus_1 = require("../gateway/nodeSessionStatus");
 const XenonSession_1 = require("./XenonSession");
 class RemoteSession extends XenonSession_1.XenonSession {
     constructor(options) {
@@ -29,8 +32,30 @@ class RemoteSession extends XenonSession_1.XenonSession {
     getType() {
         return SessionType_1.default.REMOTE;
     }
+    /** The WebDriver base URL of the server that runs this session. */
+    getWebDriverUrl() {
+        return this.baseUrl;
+    }
+    /**
+     * What every call about this session carries. A node gets the hub's token
+     * for this session, which it accepts in place of the client's credentials
+     * when its own per-command auth is on (the hub checked those).
+     */
+    callOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).tokenFor(this.sessionId);
+            return token ? { headers: { [hubSessionToken_1.HUB_TOKEN_HEADER]: token } } : {};
+        });
+    }
+    call(config) {
+        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 : {})) }));
+        });
+    }
     getScreenShot() {
-        return (0, axios_1.default)({
+        return this.call({
             method: 'get',
             url: `${this.baseUrl}/session/${this.sessionId}/screenshot`,
         }).then((response) => (response.data ? response.data.value : ''));
@@ -41,7 +66,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
             // Generous timeout on purpose: serialising a deep hierarchy on a slow
             // real device is seconds, not milliseconds, and a truncated read here
             // reads to the caller as "this screen has no elements".
-            const response = yield (0, axios_1.default)({
+            const response = yield this.call({
                 method: 'get',
                 url: `${this.baseUrl}/session/${this.sessionId}/source`,
                 timeout: 60000,
@@ -54,7 +79,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
             var _a, _b, _c, _d, _e, _f, _g;
             logger_1.default.info(`[RemoteSession] stopVideoRecording called for session ${this.sessionId}. isVideoAvailable: ${this.isVideoAvailable}`);
             try {
-                const response = yield (0, axios_1.default)({
+                const response = yield this.call({
                     method: 'post',
                     url: `${this.baseUrl}/session/${this.sessionId}/appium/stop_recording_screen`,
                     data: {},
@@ -67,7 +92,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
                 logger_1.default.warn(`[RemoteSession] stopVideoRecording error: ${err.message}, trying anyway to retrieve video...`);
                 // Even if there's an error, try to get the video data
                 try {
-                    const retryResponse = yield (0, axios_1.default)({
+                    const retryResponse = yield this.call({
                         method: 'post',
                         url: `${this.baseUrl}/session/${this.sessionId}/appium/stop_recording_screen`,
                         data: {},
@@ -88,7 +113,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
             var _a, _b;
             logger_1.default.info(`[RemoteSession] stopPerformanceRecording called for session ${this.sessionId}`);
             try {
-                const response = yield (0, axios_1.default)({
+                const response = yield this.call({
                     method: 'post',
                     url: `${this.baseUrl}/session/${this.sessionId}/execute/sync`,
                     data: {
@@ -112,7 +137,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.default.info(`[RemoteSession] startPerformanceRecording called for session ${this.sessionId}`);
             try {
-                yield (0, axios_1.default)({
+                yield this.call({
                     method: 'post',
                     url: `${this.baseUrl}/session/${this.sessionId}/execute/sync`,
                     data: {
@@ -159,7 +184,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
                 size = '720x1280';
             }
             logger_1.default.info(`[RemoteSession] Starting recording with resolution: ${resolution}, size: ${size}`);
-            return (0, axios_1.default)({
+            return this.call({
                 method: 'post',
                 url: `${this.baseUrl}/session/${this.sessionId}/appium/start_recording_screen`,
                 data: {
@@ -196,9 +221,17 @@ class RemoteSession extends XenonSession_1.XenonSession {
             return null;
         }
     }
+    /**
+     * Whether the node still has this session. The node is asked with its
+     * session-status route (gateway/nodeSessionStatus.ts), which reads Appium's
+     * umbrella and runs no command: a WebDriver probe every ~30 s restarted the
+     * node driver's new-command timeout and Xenon's idle clock there, so an
+     * abandoned session and its phone were kept alive for ever. A node without
+     * the route (an older Xenon) is probed the old way, and the hub says so once.
+     */
     checkHealth() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a;
             if (!this.sessionId) {
                 return {
                     isHealthy: false,
@@ -206,12 +239,86 @@ class RemoteSession extends XenonSession_1.XenonSession {
                     message: 'No session ID assigned',
                 };
             }
+            return (_a = (yield this.askNodeForSession())) !== null && _a !== void 0 ? _a : this.probeWithCommand();
+        });
+    }
+    /**
+     * The node's answer at its session-status route, or null when it has no
+     * such route and the WebDriver probe has to do.
+     */
+    askNodeForSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            let origin;
+            try {
+                origin = new URL(this.baseUrl).origin;
+            }
+            catch (_f) {
+                return null;
+            }
+            const support = typedi_1.Container.get(nodeSessionStatus_1.NodeSessionProbeSupport);
+            if (!support.shouldAsk(origin))
+                return null;
+            let response;
+            try {
+                response = yield this.call({
+                    method: 'get',
+                    url: `${origin}${nodeSessionStatus_1.NODE_SESSION_STATUS_PATH}/${encodeURIComponent(this.sessionId)}`,
+                    timeout: 5000,
+                    validateStatus: () => true,
+                });
+            }
+            catch (err) {
+                const unreachable = (err === null || err === void 0 ? void 0 : err.code) === 'ECONNREFUSED' || (err === null || err === void 0 ? void 0 : err.code) === 'ETIMEDOUT';
+                return {
+                    isHealthy: false,
+                    errorType: unreachable ? XenonSession_1.HealthErrorType.SERVER_UNREACHABLE : XenonSession_1.HealthErrorType.TIMEOUT,
+                    message: `Node session status failed: ${(_b = (_a = err === null || err === void 0 ? void 0 : err.code) !== null && _a !== void 0 ? _a : err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`,
+                };
+            }
+            if (!((_c = response.headers) === null || _c === void 0 ? void 0 : _c[nodeSessionStatus_1.NODE_SESSION_STATUS_HEADER])) {
+                support.unsupported(origin, response.status);
+                return null;
+            }
+            const exists = (_e = (_d = response.data) === null || _d === void 0 ? void 0 : _d.value) === null || _e === void 0 ? void 0 : _e.exists;
+            if (response.status === 200 && typeof exists === 'boolean') {
+                if (exists)
+                    return { isHealthy: true, errorType: XenonSession_1.HealthErrorType.NONE, statusCode: 200 };
+                return {
+                    isHealthy: false,
+                    errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+                    message: 'The node no longer has this session',
+                    statusCode: 404,
+                };
+            }
+            // The node refused the hub's token for it, as the WebDriver probe's
+            // unknown-session answer would.
+            if (response.status === 404) {
+                return {
+                    isHealthy: false,
+                    errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+                    message: "The node refused the hub's token for this session",
+                    statusCode: 404,
+                };
+            }
+            return {
+                isHealthy: false,
+                errorType: XenonSession_1.HealthErrorType.DRIVER_ERROR,
+                message: `Node session status answered ${response.status}`,
+                statusCode: response.status,
+            };
+        });
+    }
+    /** The probe for a node without the session-status route: a WebDriver command. */
+    probeWithCommand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
             // Identify the root Appium URL (strip /wd-internal if present)
             const appiumUrl = this.baseUrl.replace(/\/wd-internal$/, '');
             try {
                 // 1️⃣ Safe, read-only, lightweight probe: GET /session/{id}/timeouts
                 // This is a W3C standard command that all Appium drivers should register.
-                const response = yield (0, axios_1.default)({
+                const response = yield this.call({
                     method: 'get',
                     url: `${this.baseUrl}/session/${this.sessionId}/timeouts`,
                     timeout: 5000,

package/lib/src/sessions/SessionManager.js

@@ -19,13 +19,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SESSION_MANAGER = exports.SessionManager = void 0;
+const os_1 = __importDefault(require("os"));
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
 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 helpers_1 = require("../helpers");
+const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 /**
  * SessionManager with persistence and recovery capabilities.
@@ -81,8 +82,9 @@ let SessionManager = class SessionManager {
      * - Sessions on REMOTE nodes are recovered as RemoteSessions.
      * - Sessions on CLOUD providers are recovered as CloudSessions.
      */
-    recoverActiveSessions(currentNodeId, nodeBasePath) {
-        return __awaiter(this, void 0, void 0, function* () {
+    recoverActiveSessions(currentNodeId_1, nodeBasePath_1) {
+        return __awaiter(this, arguments, void 0, function* (currentNodeId, nodeBasePath, isLocalHost = () => false) {
+            var _a, _b;
             this.log.info('🔄 Attempting to recover active sessions from database...');
             try {
                 // Find all sessions that are still "running" (not ended)
@@ -111,8 +113,13 @@ let SessionManager = class SessionManager {
                             failedCount++;
                             continue;
                         }
-                        // Check if this session was on THE CURRENT NODE (LocalSession)
-                        const isLocalSession = dbSession.node_id === currentNodeId || device.nodeId === currentNodeId;
+                        // Check if this session was on THE CURRENT NODE (LocalSession). The
+                        // node id is new on every boot, so a phone this server drives is
+                        // also known by its host; otherwise a local session from before the
+                        // restart would be rebuilt as a remote one pointing back at this hub.
+                        const isLocalSession = dbSession.node_id === currentNodeId ||
+                            device.nodeId === currentNodeId ||
+                            (!device.cloud && isLocalHost(device.host));
                         if (isLocalSession) {
                             // LocalSessions cannot be recovered - the Appium driver is gone
                             this.log.warn(`⏹️ Session ${dbSession.id}: Was a LocalSession on this node. Marking as failed (driver lost).`);
@@ -144,7 +151,8 @@ let SessionManager = class SessionManager {
                             alwaysMatch: desiredCaps,
                             firstMatch: [{}],
                         });
-                        const baseUrl = (0, helpers_1.nodeUrl)(device, nodeBasePath);
+                        // The node's own base path, which need not be this hub's.
+                        const baseUrl = yield (0, nodeWebDriverUrl_1.nodeWebDriverUrl)(device, nodeBasePath);
                         // Create the appropriate session type
                         let recoveredSession;
                         if (device.cloud) {
@@ -169,8 +177,12 @@ let SessionManager = class SessionManager {
                             });
                             this.log.info(`🌐 Recovered RemoteSession ${dbSession.id} on node ${device.nodeId}`);
                         }
+                        // Its owner, as the row recorded it.
+                        recoveredSession.apiKeyId = (_a = dbSession.api_key_id) !== null && _a !== void 0 ? _a : null;
+                        recoveredSession.userId = (_b = dbSession.user_id) !== null && _b !== void 0 ? _b : null;
                         // Add to in-memory map
                         this.addSession(dbSession.id, recoveredSession);
+                        yield this.adoptHeartbeat(dbSession.id);
                         recoveredCount++;
                     }
                     catch (sessionErr) {
@@ -188,6 +200,37 @@ let SessionManager = class SessionManager {
             }
         });
     }
+    /**
+     * 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
+     * of the process that ran before the restart, so after an outage longer
+     * than 3 heartbeat intervals the orphan sweep (OrphanSweeper, at boot and
+     * on every interval) took it for an orphan: it failed the session recovery
+     * had just rebuilt and freed its phone, while the node kept the session.
+     *
+     * Stamping, rather than handing the sweeps a list of ids to skip, makes the
+     * row say what is true, so every reader of it agrees: both sweeps, and the
+     * heartbeat's own check for rows nobody updates. From here the heartbeat
+     * keeps it fresh, and ends the session if its node no longer has it. A
+     * failed write is logged; the heartbeat's next write repairs it.
+     */
+    adoptHeartbeat(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield prisma_1.prisma.session.update({
+                    where: { id: sessionId },
+                    data: {
+                        last_heartbeat_at: new Date(),
+                        heartbeat_pid: process.pid,
+                        heartbeat_host: os_1.default.hostname(),
+                    },
+                });
+            }
+            catch (err) {
+                this.log.warn(`Could not stamp recovered session ${sessionId}'s heartbeat: ${err.message}`);
+            }
+        });
+    }
     /**
      * Mark a session as failed in the database
      */

package/lib/src/sessions/appiumUmbrella.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppiumUmbrella = void 0;
+const typedi_1 = require("typedi");
+function isUmbrella(driver) {
+    return (!!driver &&
+        typeof driver === 'object' &&
+        typeof driver.sessionExists === 'function');
+}
+let AppiumUmbrella = class AppiumUmbrella {
+    /** Remember the umbrella a create was given. Anything else is ignored. */
+    note(driver) {
+        if (isUmbrella(driver))
+            this.umbrella = driver;
+    }
+    /** Whether Appium has this session now, without sending it a command. */
+    hasSession(sessionId) {
+        if (!sessionId || !this.umbrella)
+            return false;
+        return !!this.umbrella.sessionExists(sessionId);
+    }
+};
+exports.AppiumUmbrella = AppiumUmbrella;
+exports.AppiumUmbrella = AppiumUmbrella = __decorate([
+    (0, typedi_1.Service)()
+], AppiumUmbrella);

package/lib/test/helpers/appium-umbrella.js

@@ -0,0 +1,84 @@
+"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.FAKE_AUTOMATION = void 0;
+exports.appiumDir = appiumDir;
+exports.appiumBaseDriver = appiumBaseDriver;
+exports.quietAppiumLogs = quietAppiumLogs;
+exports.fakeInnerDriverClass = fakeInnerDriverClass;
+exports.umbrellaWith = umbrellaWith;
+const path_1 = __importDefault(require("path"));
+/**
+ * Appium's own umbrella driver (`AppiumDriver`) and base-driver, as installed
+ * with the `appium` devDependency, for specs that run a real Appium 3
+ * `server()` in-process. Xenon's own `@appium/base-driver` is an older copy;
+ * these are the ones Appium runs.
+ */
+function appiumDir() {
+    return path_1.default.dirname(require.resolve('appium/package.json'));
+}
+function appiumBaseDriver() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(require.resolve('@appium/base-driver', { paths: [appiumDir()] }));
+}
+/** Silence Appium's own logger (its HTTP log writes every request) until restore(). */
+function quietAppiumLogs() {
+    appiumBaseDriver();
+    const support = require.resolve('@appium/support', { paths: [appiumDir()] });
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const log = require(require.resolve('@appium/logger', { paths: [support] })).default;
+    const level = log.level;
+    log.level = 'silent';
+    return {
+        restore: () => {
+            log.level = level;
+        },
+    };
+}
+/** The automationName the fake inner driver answers to. */
+exports.FAKE_AUTOMATION = 'XenonTestFake';
+let fakeInnerDriver;
+/**
+ * A driver the umbrella can start a session with: Appium's own BaseDriver,
+ * which validates the capabilities and makes a session id, and nothing more.
+ */
+function fakeInnerDriverClass() {
+    if (!fakeInnerDriver) {
+        const { BaseDriver } = appiumBaseDriver();
+        fakeInnerDriver = class XenonTestFakeDriver extends BaseDriver {
+        };
+    }
+    return fakeInnerDriver;
+}
+/**
+ * Appium's umbrella driver with these plugin classes, which finds the fake
+ * inner driver for `appium:automationName` FAKE_AUTOMATION and, like Appium,
+ * no driver for anything else.
+ */
+function umbrellaWith(plugins) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { AppiumDriver } = require(path_1.default.join(appiumDir(), 'build/lib/appium.js'));
+    const umbrella = new AppiumDriver({});
+    umbrella.pluginClasses = new Map(plugins);
+    umbrella.driverConfig = {
+        findMatchingDriver: (caps) => __awaiter(this, void 0, void 0, function* () {
+            if (caps.automationName !== exports.FAKE_AUTOMATION) {
+                throw new Error(`Could not find a driver for automationName '${caps.automationName}' and platformName ` +
+                    'Android.');
+            }
+            return { driver: fakeInnerDriverClass(), version: '0.0.1', driverName: 'fake' };
+        }),
+    };
+    return umbrella;
+}

package/lib/test/helpers/fake-device-table.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * An in-memory device table to stub `prisma.device` with, so a spec runs the
+ * real PrismaDeviceStore. It follows Prisma's rules: `undefined` leaves a
+ * column alone, `null` clears it, an upsert takes `create` for a new row and
+ * `update` for a known one, and `{ contains }` matches a substring (the store
+ * uses it for a host that isn't a URL).
+ */
+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.fakeDeviceTable = fakeDeviceTable;
+function fakeDeviceTable(seed) {
+    const rows = new Map();
+    const key = (udid, host) => `${udid}|${host}`;
+    const matches = (row, where) => {
+        if (!where)
+            return true;
+        return Object.entries(where).every(([field, cond]) => {
+            var _a;
+            if (field === 'OR')
+                return cond.some((w) => matches(row, w));
+            if (field === 'AND')
+                return cond.every((w) => matches(row, w));
+            if (cond && typeof cond === 'object' && 'in' in cond)
+                return cond.in.includes(row[field]);
+            if (cond && typeof cond === 'object' && 'contains' in cond)
+                return String((_a = row[field]) !== null && _a !== void 0 ? _a : '').includes(cond.contains);
+            return row[field] === cond;
+        });
+    };
+    const write = (row, data) => {
+        for (const [field, value] of Object.entries(data))
+            if (value !== undefined)
+                row[field] = value;
+    };
+    const defaults = () => ({
+        busy: false,
+        userBlocked: false,
+        offline: false,
+        session_id: null,
+        teamId: null,
+        sessionProgress: '',
+        sessionStartTime: 0,
+        totalUtilizationTimeMilliSec: 0,
+        claimSessionId: null,
+        claimedAt: null,
+        nodeBusy: false,
+    });
+    for (const r of seed)
+        rows.set(key(r.udid, r.host), Object.assign(Object.assign({}, defaults()), r));
+    return {
+        row: (udid) => [...rows.values()].find((r) => r.udid === udid),
+        delegate: {
+            findMany: (...args_1) => __awaiter(this, [...args_1], void 0, function* (args = {}) { return [...rows.values()].filter((r) => matches(r, args.where)).map((r) => (Object.assign({}, r))); }),
+            findUnique: (_a) => __awaiter(this, [_a], void 0, function* ({ where }) {
+                const r = rows.get(key(where.udid_host.udid, where.udid_host.host));
+                return r ? Object.assign({}, r) : null;
+            }),
+            upsert: (_a) => __awaiter(this, [_a], void 0, function* ({ where, create, update, }) {
+                const k = key(where.udid_host.udid, where.udid_host.host);
+                const found = rows.get(k);
+                if (found) {
+                    write(found, update);
+                    return Object.assign({}, found);
+                }
+                const created = defaults();
+                write(created, create);
+                rows.set(k, created);
+                return Object.assign({}, created);
+            }),
+            updateMany: (_a) => __awaiter(this, [_a], void 0, function* ({ where, data }) {
+                let count = 0;
+                for (const r of rows.values()) {
+                    if (matches(r, where)) {
+                        write(r, data);
+                        count++;
+                    }
+                }
+                return { count };
+            }),
+            deleteMany: (_a) => __awaiter(this, [_a], void 0, function* ({ where }) {
+                for (const [k, r] of rows)
+                    if (matches(r, where))
+                        rows.delete(k);
+                return { count: 0 };
+            }),
+        },
+    };
+}

package/lib/test/helpers/loki-stores.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLokiStores = useLokiStores;
+const device_store_1 = require("../../src/data-service/device-store");
+// DeviceStoreFactory's cached stores, one per kind.
+const CACHES = ['_deviceStore', '_pendingSessionStore', '_cliArgsStore', '_healEtalonStore'];
+/**
+ * The in-memory (Loki) stores for the enclosing `describe`, however the file
+ * was started.
+ *
+ * DeviceStoreFactory picks Loki only while NODE_ENV is 'test'. `npm run
+ * test:all` sets it; `npx mocha <file>` doesn't, so a spec run on its own got
+ * the Prisma stores, which read and write the developer's
+ * ~/.cache/xenon/xenon.db. This holds NODE_ENV at 'test' and hands the
+ * factory new stores for the suite, then puts both back.
+ *
+ * Call it inside a `describe`, before the hooks that use a store, never at the
+ * top of a file.
+ */
+function useLokiStores() {
+    const factory = device_store_1.DeviceStoreFactory;
+    const saved = {};
+    let previousEnv;
+    before(() => {
+        previousEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = 'test';
+        for (const key of CACHES) {
+            saved[key] = factory[key];
+            factory[key] = undefined;
+        }
+    });
+    after(() => {
+        for (const key of CACHES)
+            factory[key] = saved[key];
+        // Assigning undefined would store the string 'undefined'.
+        if (previousEnv === undefined)
+            delete process.env.NODE_ENV;
+        else
+            process.env.NODE_ENV = previousEnv;
+    });
+}

package/lib/test/helpers/loopbackRequest.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = __importDefault(require("http"));
+const supertest_1 = __importDefault(require("supertest"));
+/**
+ * supertest's `request(app)`, served on 127.0.0.1. Import it in place of
+ * supertest's default export; everything else about a request is unchanged.
+ *
+ * supertest listens on every address (`app.listen(0)`) and then connects to
+ * 127.0.0.1. On macOS the kernel can give that listener a port another socket
+ * still holds on 127.0.0.1, and a connection to 127.0.0.1 goes to that socket.
+ * Another suite running at the same time then answers the request: a stray
+ * 501 or a socket hang-up. Listening on 127.0.0.1 ourselves rules that out,
+ * because the kernel never hands out a port already held there.
+ * (loopbackServers() in loopbackServer.ts does the same for specs that manage
+ * their servers themselves.)
+ *
+ * Binding 127.0.0.1 is asynchronous and supertest picks its URL in the
+ * constructor, so the listen waits until the request is sent (`end()`, which
+ * `await` and `.then()` call). A URL, or a server that is already listening,
+ * is used as supertest would.
+ */
+const { Test } = supertest_1.default;
+// One listen per server, however many requests are sent to it at once. The
+// request that started it closes it, as supertest does.
+const listens = new WeakMap();
+function listenOnLoopback(server) {
+    const pending = listens.get(server);
+    if (pending)
+        return { port: pending, owner: false };
+    const port = new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.removeListener('error', reject);
+            resolve(server.address().port);
+        });
+    });
+    listens.set(server, port);
+    server.once('close', () => listens.delete(server));
+    return { port, owner: true };
+}
+class LoopbackTest extends Test {
+    serverAddress(app, path) {
+        if (app.address())
+            return super.serverAddress(app, path);
+        this.loopbackApp = app;
+        this.loopbackPath = path;
+        return `http://127.0.0.1${path}`; // replaced before the request is sent
+    }
+    end(fn) {
+        const app = this.loopbackApp;
+        if (!app)
+            return super.end(fn);
+        const { port, owner } = listenOnLoopback(app);
+        port.then((p) => {
+            var _a;
+            if (owner)
+                this._server = app;
+            this.url = `http://127.0.0.1:${p}${(_a = this.loopbackPath) !== null && _a !== void 0 ? _a : ''}`;
+            super.end(fn);
+        }, (err) => fn === null || fn === void 0 ? void 0 : fn(err, undefined));
+        return this;
+    }
+}
+const METHODS = http_1.default.METHODS.map((m) => m.toLowerCase());
+function request(app) {
+    const obj = {};
+    for (const method of METHODS) {
+        obj[method] = (path) => new LoopbackTest(app, method, path);
+    }
+    obj.del = obj.delete;
+    return obj;
+}
+exports.default = request;