@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/test/unit/session-locator.spec.js

@@ -0,0 +1,250 @@
+"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 express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const SessionType_1 = __importDefault(require("../../src/enums/SessionType"));
+const sessionLocator_1 = require("../../src/gateway/sessionLocator");
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * Where a session runs, as the hub's gateway asks it: SESSION_MANAGER for a
+ * live session, the database after a restart, and never a routing table of
+ * its own. And where a node's WebDriver API lives, which a node says itself.
+ */
+const NODE = 'http://10.0.0.7:4725';
+function fakeSession(type, url, host = NODE) {
+    return {
+        getType: () => type,
+        getWebDriverUrl: () => url,
+        getDevice: () => ({ udid: 'u1', host }),
+    };
+}
+describe('SessionLocator', () => {
+    let live;
+    let rows;
+    let devices;
+    let findOpenSession;
+    let findDevice;
+    let webDriverUrlOf;
+    function locator(maxRemembered) {
+        return new sessionLocator_1.SessionLocator({
+            getSession: (id) => live[id],
+            findOpenSession,
+            findDevice,
+            isLocalDevice: (device) => device.host === 'http://10.0.0.1:4724',
+            webDriverUrlOf,
+            maxRemembered,
+        });
+    }
+    beforeEach(() => {
+        live = {};
+        rows = {};
+        devices = {};
+        findOpenSession = sinon_1.default.spy((id) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = rows[id]) !== null && _a !== void 0 ? _a : null; }));
+        findDevice = sinon_1.default.spy((udid) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = devices[udid]) !== null && _a !== void 0 ? _a : null; }));
+        webDriverUrlOf = sinon_1.default.spy((device) => __awaiter(void 0, void 0, void 0, function* () { return `${device.host}/node-base`; }));
+    });
+    it('answers a live local session from SESSION_MANAGER, with no lookup', () => __awaiter(void 0, void 0, void 0, function* () {
+        live.s = fakeSession(SessionType_1.default.LOCAL, 'http://10.0.0.1:4724/wd/hub/wd-internal');
+        (0, chai_1.expect)(yield locator().locate('s')).to.deep.equal({ kind: 'local' });
+        (0, chai_1.expect)(findOpenSession.called).to.equal(false);
+    }));
+    it('answers a live remote session with its node URL and the session', () => __awaiter(void 0, void 0, void 0, function* () {
+        live.s = fakeSession(SessionType_1.default.REMOTE, `${NODE}/wd/hub`);
+        const location = yield locator().locate('s');
+        (0, chai_1.expect)(location).to.include({ kind: 'remote', url: `${NODE}/wd/hub`, cloud: false });
+        (0, chai_1.expect)(location.session).to.equal(live.s);
+        (0, chai_1.expect)(findOpenSession.called).to.equal(false);
+    }));
+    it('marks a cloud session, which gets no hub token', () => __awaiter(void 0, void 0, void 0, function* () {
+        live.s = fakeSession(SessionType_1.default.CLOUD, 'https://cloud.example/wd/hub', 'https://cloud.example');
+        (0, chai_1.expect)(yield locator().locate('s')).to.include({ kind: 'remote', cloud: true });
+    }));
+    it('never routes a session back to this server’s own phone', () => __awaiter(void 0, void 0, void 0, function* () {
+        live.s = fakeSession(SessionType_1.default.REMOTE, 'http://10.0.0.1:4724/wd/hub', 'http://10.0.0.1:4724');
+        (0, chai_1.expect)(yield locator().locate('s')).to.deep.equal({ kind: 'local' });
+    }));
+    it('after a restart, routes an open session from its row and its phone’s row', () => __awaiter(void 0, void 0, void 0, function* () {
+        rows.s = { device_udid: 'u1', node_id: 'node-1' };
+        devices.u1 = { udid: 'u1', host: NODE, nodeId: 'node-1' };
+        (0, chai_1.expect)(yield locator().locate('s')).to.deep.equal({
+            kind: 'remote',
+            url: `${NODE}/node-base`,
+            cloud: false,
+        });
+        (0, chai_1.expect)(findDevice.firstCall.args).to.deep.equal(['u1', 'node-1']);
+    }));
+    it('remembers the database’s answer, which cannot change, until forgotten', () => __awaiter(void 0, void 0, void 0, function* () {
+        rows.s = { device_udid: 'u1', node_id: null };
+        devices.u1 = { udid: 'u1', host: NODE };
+        const l = locator();
+        yield l.locate('s');
+        yield l.locate('s');
+        (0, chai_1.expect)(findOpenSession.callCount).to.equal(1);
+        l.forget('s');
+        yield l.locate('s');
+        (0, chai_1.expect)(findOpenSession.callCount).to.equal(2);
+    }));
+    it('answers local for a session nobody here knows, so Appium gives its own answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const l = locator();
+        (0, chai_1.expect)(yield l.locate('nobody')).to.deep.equal({ kind: 'local' });
+        yield l.locate('nobody');
+        (0, chai_1.expect)(findOpenSession.callCount).to.equal(1);
+    }));
+    it('answers local for an open session on this server’s own phone', () => __awaiter(void 0, void 0, void 0, function* () {
+        rows.s = { device_udid: 'u1', node_id: null };
+        devices.u1 = { udid: 'u1', host: 'http://10.0.0.1:4724' };
+        (0, chai_1.expect)(yield locator().locate('s')).to.deep.equal({ kind: 'local' });
+        (0, chai_1.expect)(webDriverUrlOf.called).to.equal(false);
+    }));
+    it('bounds what it remembers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const l = locator(2);
+        yield l.locate('a');
+        yield l.locate('b');
+        yield l.locate('c');
+        yield l.locate('a');
+        (0, chai_1.expect)(findOpenSession.callCount).to.equal(4);
+    }));
+    it('lets a database error through for the gateway to answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const l = new sessionLocator_1.SessionLocator({
+            getSession: () => undefined,
+            findOpenSession: () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error('database is locked');
+            }),
+            findDevice,
+            isLocalDevice: () => false,
+            webDriverUrlOf,
+        });
+        let thrown;
+        try {
+            yield l.locate('s');
+        }
+        catch (err) {
+            thrown = err;
+        }
+        (0, chai_1.expect)(thrown.message).to.equal('database is locked');
+    }));
+    describe('sessionRowsFrom (Prisma)', () => {
+        it('reads only an open session, and prefers the phone on the session’s node', () => __awaiter(void 0, void 0, void 0, function* () {
+            const db = {
+                session: { findFirst: sinon_1.default.stub().resolves({ device_udid: 'u1', node_id: 'n1' }) },
+                device: {
+                    findFirst: sinon_1.default
+                        .stub()
+                        .callsFake((_a) => __awaiter(void 0, [_a], void 0, function* ({ where }) { return where.nodeId ? { udid: 'u1', host: NODE, nodeId: 'n1' } : { udid: 'u1', host: 'x' }; })),
+                },
+            };
+            const rowsFrom = (0, sessionLocator_1.sessionRowsFrom)(db);
+            (0, chai_1.expect)(yield rowsFrom.findOpenSession('s')).to.deep.equal({
+                device_udid: 'u1',
+                node_id: 'n1',
+            });
+            (0, chai_1.expect)(db.session.findFirst.firstCall.args[0].where).to.deep.equal({
+                id: 's',
+                endTime: null,
+            });
+            (0, chai_1.expect)(yield rowsFrom.findDevice('u1', 'n1')).to.include({ host: NODE });
+            (0, chai_1.expect)(yield rowsFrom.findDevice('u1', null)).to.include({ host: 'x' });
+        }));
+    });
+});
+describe('NodeBasePathResolver', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let restore;
+    let hits;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(nodeWebDriverUrl_1.NodeBasePathResolver);
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        hits = 0;
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        restore();
+        yield loopback.closeAll();
+    }));
+    function node(basePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = (0, express_1.default)();
+            if (basePath !== undefined) {
+                app.get(nodeWebDriverUrl_1.WEBDRIVER_INFO_PATH, (req, res, next) => {
+                    hits++;
+                    (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => basePath)(req, res, next);
+                });
+            }
+            const server = yield loopback.serve(app);
+            return `http://127.0.0.1:${server.address().port}`;
+        });
+    }
+    it('the node says its base path, normalised as Appium does', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node('node/base/');
+        const res = yield (0, loopbackRequest_1.default)(origin).get(nodeWebDriverUrl_1.WEBDRIVER_INFO_PATH).expect(200);
+        (0, chai_1.expect)(res.body).to.deep.equal({ basePath: '/node/base' });
+    }));
+    it('uses the base path the node says, however the hub’s differs', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node('');
+        (0, chai_1.expect)(yield typedi_1.Container.get(nodeWebDriverUrl_1.NodeBasePathResolver).resolve(origin, '/wd/hub')).to.equal('');
+    }));
+    it('falls back to the hub’s own for a node that does not say (an older Xenon)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node(undefined);
+        (0, chai_1.expect)(yield typedi_1.Container.get(nodeWebDriverUrl_1.NodeBasePathResolver).resolve(origin, 'wd/hub')).to.equal('/wd/hub');
+    }));
+    it('falls back to the hub’s own for a node that cannot be reached', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node('/x');
+        yield loopback.closeAll();
+        (0, chai_1.expect)(yield typedi_1.Container.get(nodeWebDriverUrl_1.NodeBasePathResolver).resolve(origin, '/wd/hub')).to.equal('/wd/hub');
+    }));
+    it('asks once for concurrent callers, and again only after the answer expires', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node('/node');
+        const resolver = typedi_1.Container.get(nodeWebDriverUrl_1.NodeBasePathResolver);
+        let now = 1000;
+        resolver.now = () => now;
+        const answers = yield Promise.all([
+            resolver.resolve(origin, '/wd/hub'),
+            resolver.resolve(origin, '/wd/hub'),
+        ]);
+        (0, chai_1.expect)(answers).to.deep.equal(['/node', '/node']);
+        (0, chai_1.expect)(hits).to.equal(1);
+        now += nodeWebDriverUrl_1.BASE_PATH_TTL_MS - 1;
+        yield resolver.resolve(origin, '/wd/hub');
+        (0, chai_1.expect)(hits).to.equal(1);
+        now += 2;
+        yield resolver.resolve(origin, '/wd/hub');
+        (0, chai_1.expect)(hits).to.equal(2);
+    }));
+    it('asks again soon after a fallback', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node(undefined);
+        const resolver = typedi_1.Container.get(nodeWebDriverUrl_1.NodeBasePathResolver);
+        let now = 1000;
+        resolver.now = () => now;
+        yield resolver.resolve(origin, '/wd/hub');
+        now += nodeWebDriverUrl_1.FALLBACK_TTL_MS + 1;
+        const lookUp = sinon_1.default.spy(resolver, 'lookUp');
+        yield resolver.resolve(origin, '/wd/hub');
+        (0, chai_1.expect)(lookUp.callCount).to.equal(1);
+    }));
+    it('nodeWebDriverUrl: a node’s origin plus its own base path', () => __awaiter(void 0, void 0, void 0, function* () {
+        const origin = yield node('/node');
+        (0, chai_1.expect)(yield (0, nodeWebDriverUrl_1.nodeWebDriverUrl)({ udid: 'u', host: `${origin}/` }, '/wd/hub')).to.equal(`${origin}/node`);
+    }));
+    it('nodeWebDriverUrl: a cloud provider’s own URL, with no lookup', () => __awaiter(void 0, void 0, void 0, function* () {
+        const url = yield (0, nodeWebDriverUrl_1.nodeWebDriverUrl)({ udid: 'u', host: 'https://cloud.example', cloud: 'pCloudy' }, '/wd/hub');
+        (0, chai_1.expect)(url).to.equal('https://cloud.example/wd/hub');
+        (0, chai_1.expect)(hits).to.equal(0);
+    }));
+});

package/lib/test/unit/session-node-calls.spec.js

@@ -0,0 +1,174 @@
+"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 express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const RemoteSession_1 = require("../../src/sessions/RemoteSession");
+const CloudSession_1 = require("../../src/sessions/CloudSession");
+const LocalSession_1 = require("../../src/sessions/LocalSession");
+const XenonSession_1 = require("../../src/sessions/XenonSession");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const internalCall_1 = require("../../src/gateway/internalCall");
+const nodeSessionStatus_1 = require("../../src/gateway/nodeSessionStatus");
+const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * The calls a session object makes about its session over HTTP.
+ *
+ * A RemoteSession's go to the node, with the hub's session token for that
+ * session, so a node with per-command auth on accepts them (the heartbeat's
+ * probe among them). A cloud provider is not a Xenon node and never gets one.
+ * A LocalSession's go to this server's own `/wd-internal` path with the
+ * per-process secret, never through an HTTP proxy, and its heartbeat asks the
+ * in-process driver instead of sending a command.
+ */
+describe('session calls to the server that runs the session', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let seen;
+    let port;
+    let restore;
+    const env = Object.assign({}, process.env);
+    const device = { udid: 'u1', host: 'http://10.0.0.7:4725', platform: 'android' };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        seen = [];
+        const app = (0, express_1.default)();
+        app.use(express_1.default.json());
+        app.all('*', (req, res) => {
+            seen.push({ method: req.method, url: req.originalUrl, headers: req.headers });
+            res.json({ value: req.path.endsWith('/source') ? '<hierarchy/>' : 'ok' });
+        });
+        const server = yield loopback.serve(app);
+        port = server.address().port;
+        restore = (0, container_registration_1.saveRegistrations)(hubSessionToken_1.HubSessionTokenIssuer, nodeSessionStatus_1.NodeSessionProbeSupport);
+        const probes = new nodeSessionStatus_1.NodeSessionProbeSupport();
+        probes.logger = { warn: () => undefined };
+        typedi_1.Container.set(nodeSessionStatus_1.NodeSessionProbeSupport, probes);
+        const issuer = new hubSessionToken_1.HubSessionTokenIssuer();
+        issuer.useSigner({ sign: (claims) => __awaiter(void 0, void 0, void 0, function* () { return `hub-token-for-${claims.sid}`; }) });
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, issuer);
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        process.env = Object.assign({}, env);
+        sinon_1.default.restore();
+        restore();
+        yield loopback.closeAll();
+    }));
+    function remote(Type = RemoteSession_1.RemoteSession) {
+        return new Type({
+            sessionId: 's-1',
+            device,
+            sessionResponse: {},
+            xenonOption: {},
+            baseUrl: `http://127.0.0.1:${port}/node-base`,
+        });
+    }
+    describe('RemoteSession (hub to node)', () => {
+        it('sends the hub’s session token on every call, the heartbeat probe included', () => __awaiter(void 0, void 0, void 0, function* () {
+            const session = remote();
+            yield session.getScreenShot();
+            yield session.getPageSource();
+            yield session.startVideoRecording({ resolution: '720x1280' });
+            yield session.stopVideoRecording();
+            yield session.startPerformanceRecording();
+            yield session.stopPerformanceRecording();
+            const health = yield session.checkHealth();
+            (0, chai_1.expect)(health.isHealthy).to.equal(true);
+            (0, chai_1.expect)(seen.map((r) => `${r.method} ${r.url}`)).to.deep.equal([
+                'GET /node-base/session/s-1/screenshot',
+                'GET /node-base/session/s-1/source',
+                'POST /node-base/session/s-1/appium/start_recording_screen',
+                'POST /node-base/session/s-1/appium/stop_recording_screen',
+                'POST /node-base/session/s-1/execute/sync',
+                'POST /node-base/session/s-1/execute/sync',
+                // This node has no session-status route (no NODE_SESSION_STATUS_HEADER
+                // on its answer), so the heartbeat falls back to the WebDriver probe.
+                'GET /xenon/api/node/sessions/s-1',
+                'GET /node-base/session/s-1/timeouts',
+            ]);
+            for (const r of seen)
+                (0, chai_1.expect)(r.headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal('hub-token-for-s-1');
+            for (const r of seen)
+                (0, chai_1.expect)(r.headers[internalCall_1.INTERNAL_CALL_HEADER]).to.equal(undefined);
+        }));
+        it('goes without a token when the hub cannot sign one', () => __awaiter(void 0, void 0, void 0, function* () {
+            typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).useSigner({
+                sign: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('JWT key service not initialized');
+                }),
+            });
+            sinon_1.default.stub(typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).logger, 'warn');
+            yield remote().getPageSource();
+            (0, chai_1.expect)(seen).to.have.length(1);
+            (0, chai_1.expect)(seen[0].headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+        }));
+        it('says the node’s WebDriver URL it was made with', () => {
+            (0, chai_1.expect)(remote().getWebDriverUrl()).to.equal(`http://127.0.0.1:${port}/node-base`);
+        });
+    });
+    describe('CloudSession (hub to a cloud provider)', () => {
+        it('never sends a hub token to a cloud provider', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield remote(CloudSession_1.CloudSession).getPageSource();
+            yield remote(CloudSession_1.CloudSession).checkHealth();
+            (0, chai_1.expect)(seen).to.have.length(2);
+            for (const r of seen)
+                (0, chai_1.expect)(r.headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+        }));
+    });
+    describe('LocalSession (this server)', () => {
+        function local(driver = {}) {
+            return new LocalSession_1.LocalSession({
+                sessionId: 's-1',
+                device: Object.assign(Object.assign({}, device), { host: `http://127.0.0.1:${port}` }),
+                sessionResponse: {},
+                xenonOption: {},
+                driver: Object.assign({ opts: { address: '0.0.0.0', port, basePath: '/wd/hub' }, sessions: {} }, driver),
+            });
+        }
+        it('falls back to /wd-internal with the secret, and never through a proxy', () => __awaiter(void 0, void 0, void 0, function* () {
+            // A proxy in the environment would receive the secret; it must be skipped.
+            process.env.HTTP_PROXY = 'http://127.0.0.1:1';
+            process.env.http_proxy = 'http://127.0.0.1:1';
+            delete process.env.NO_PROXY;
+            delete process.env.no_proxy;
+            const session = local();
+            (0, chai_1.expect)(yield session.getPageSource()).to.equal('<hierarchy/>');
+            yield session.stopVideoRecording();
+            (0, chai_1.expect)(seen.map((r) => `${r.method} ${r.url}`)).to.deep.equal([
+                'GET /wd/hub/wd-internal/session/s-1/source',
+                'POST /wd/hub/wd-internal/session/s-1/appium/stop_recording_screen',
+            ]);
+            const secret = (0, internalCall_1.internalCallHeaders)()[internalCall_1.INTERNAL_CALL_HEADER];
+            for (const r of seen) {
+                (0, chai_1.expect)(r.headers[internalCall_1.INTERNAL_CALL_HEADER]).to.equal(secret);
+                (0, chai_1.expect)(r.headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+            }
+        }));
+        it('checks its health in process: no command, so no new-command timeout is reset', () => __awaiter(void 0, void 0, void 0, function* () {
+            const exists = sinon_1.default.stub().returns(true);
+            const healthy = yield local({ sessionExists: exists }).checkHealth();
+            (0, chai_1.expect)(healthy).to.deep.include({ isHealthy: true, errorType: XenonSession_1.HealthErrorType.NONE });
+            exists.returns(false);
+            const gone = yield local({ sessionExists: exists }).checkHealth();
+            (0, chai_1.expect)(gone).to.deep.include({
+                isHealthy: false,
+                errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+            });
+            (0, chai_1.expect)(exists.alwaysCalledWith('s-1')).to.equal(true);
+            (0, chai_1.expect)(seen).to.deep.equal([]);
+        }));
+    });
+});

package/lib/test/unit/session-owner-resolver.spec.js

@@ -139,3 +139,110 @@ describe('SessionOwnerResolver.displayName', () => {
         (0, chai_1.expect)(db.calls.user).to.equal(1);
     }));
 });
+// Prisma-shaped findMany delegates over fixed tables, recording each query so
+// "one query for the whole list" is observable.
+function tableDb(opts) {
+    const queries = [];
+    const pick = (rows, where) => rows.filter((row) => where.id.in.includes(row.id));
+    return {
+        queries,
+        session: {
+            findUnique: () => __awaiter(this, void 0, void 0, function* () {
+                throw new Error('ownersOf must not look sessions up one by one');
+            }),
+            findMany: (_a) => __awaiter(this, [_a], void 0, function* ({ where }) {
+                queries.push({ table: 'session', ids: [...where.id.in] });
+                return pick(opts.sessions, where);
+            }),
+        },
+        apiKey: {
+            findUnique: () => __awaiter(this, void 0, void 0, function* () {
+                throw new Error('ownersOf must not look keys up one by one');
+            }),
+            findMany: (_a) => __awaiter(this, [_a], void 0, function* ({ where }) {
+                var _b;
+                queries.push({ table: 'apiKey', ids: [...where.id.in] });
+                return pick((_b = opts.apiKeys) !== null && _b !== void 0 ? _b : [], where);
+            }),
+        },
+    };
+}
+describe('SessionOwnerResolver.ownersOf', () => {
+    it("resolves every session's owner with one query, by ownerOf's rule", () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({
+            sessions: [
+                { id: 's1', api_key_id: 'k1', user_id: 'usr_direct' },
+                { id: 's2', api_key_id: null, user_id: null },
+            ],
+        });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        const owners = yield r.ownersOf(['s1', 's2', 's-missing']);
+        (0, chai_1.expect)([...owners.entries()]).to.deep.equal([
+            ['s1', 'usr_direct'],
+            ['s2', null],
+            ['s-missing', null],
+        ]);
+        (0, chai_1.expect)(db.queries).to.deep.equal([{ table: 'session', ids: ['s1', 's2', 's-missing'] }]);
+    }));
+    it('takes the ApiKey hop in one more query, only for rows written before user_id', () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({
+            sessions: [
+                { id: 's1', api_key_id: 'k1', user_id: null },
+                { id: 's2', api_key_id: 'k2', user_id: null },
+                { id: 's3', api_key_id: 'k1', user_id: 'usr_direct' },
+            ],
+            apiKeys: [
+                { id: 'k1', userId: 'usr_legacy_1' },
+                { id: 'k2', userId: 'usr_legacy_2' },
+            ],
+        });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        const owners = yield r.ownersOf(['s1', 's2', 's3']);
+        (0, chai_1.expect)(owners.get('s1')).to.equal('usr_legacy_1');
+        (0, chai_1.expect)(owners.get('s2')).to.equal('usr_legacy_2');
+        (0, chai_1.expect)(owners.get('s3')).to.equal('usr_direct');
+        (0, chai_1.expect)(db.queries).to.have.length(2);
+        (0, chai_1.expect)(db.queries[1].table).to.equal('apiKey');
+        (0, chai_1.expect)(db.queries[1].ids).to.have.members(['k1', 'k2']);
+    }));
+    it('agrees with ownerOf and shares its cache of resolved owners', () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({ sessions: [{ id: 's1', api_key_id: null, user_id: 'usr_a' }] });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        (0, chai_1.expect)((yield r.ownersOf(['s1'])).get('s1')).to.equal('usr_a');
+        // Resolved above, so ownerOf answers from the cache; its findUnique would throw.
+        (0, chai_1.expect)(yield r.ownerOf('s1')).to.equal('usr_a');
+        // And a cached owner is not queried again.
+        yield r.ownersOf(['s1']);
+        (0, chai_1.expect)(db.queries).to.have.length(1);
+    }));
+    it('does not cache an unresolved owner', () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({ sessions: [] });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        yield r.ownersOf(['s1']);
+        yield r.ownersOf(['s1']);
+        (0, chai_1.expect)(db.queries).to.have.length(2);
+    }));
+    it('makes no query for an empty list, and asks for a repeated id once', () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({ sessions: [{ id: 's1', api_key_id: null, user_id: 'usr_a' }] });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        (0, chai_1.expect)((yield r.ownersOf([])).size).to.equal(0);
+        (0, chai_1.expect)(db.queries).to.deep.equal([]);
+        yield r.ownersOf(['s1', 's1']);
+        (0, chai_1.expect)(db.queries).to.deep.equal([{ table: 'session', ids: ['s1'] }]);
+    }));
+    it('lets a failed query reject, so the caller can fail closed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const db = tableDb({ sessions: [] });
+        db.session.findMany = () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new Error('database is locked');
+        });
+        const r = new SessionOwnerResolver_1.SessionOwnerResolver(db);
+        let caught;
+        try {
+            yield r.ownersOf(['s1']);
+        }
+        catch (err) {
+            caught = err;
+        }
+        (0, chai_1.expect)(caught === null || caught === void 0 ? void 0 : caught.message).to.equal('database is locked');
+    }));
+});

package/lib/test/unit/session-recovery-routing.spec.js

@@ -0,0 +1,118 @@
+"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 express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const localDeviceHosts_1 = require("../../src/device-managers/localDeviceHosts");
+const SessionType_1 = __importDefault(require("../../src/enums/SessionType"));
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * After a hub restart, SessionManager rebuilds the sessions still running on
+ * nodes from the database, and the session gateway routes them from there.
+ * A recovered session must point at its node's own base path, and a session
+ * that ran on the hub's own phone (its driver died with the hub) must never be
+ * rebuilt as a remote session pointing back at the hub.
+ */
+describe('recovering remote sessions after a hub restart', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let restore;
+    let savedStore;
+    let nodeOrigin;
+    const HUB = 'http://10.0.0.1:4724';
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(nodeWebDriverUrl_1.NodeBasePathResolver);
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        savedStore = device_store_1.DeviceStoreFactory._deviceStore;
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+        const node = (0, express_1.default)();
+        node.get('/xenon/api/webdriver', (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => '/node-base'));
+        const server = yield loopback.serve(node);
+        nodeOrigin = `http://127.0.0.1:${server.address().port}`;
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        device_store_1.DeviceStoreFactory._deviceStore = savedStore;
+        restore();
+        yield loopback.closeAll();
+    }));
+    function running(id, udid, host, nodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({
+                data: { udid, host, nodeId, platform: 'android', busy: true, session_id: id },
+            });
+            yield scratch.db.session.create({
+                data: {
+                    id,
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: nodeId,
+                    has_live_video: false,
+                    device_udid: udid,
+                    device_platform: 'android',
+                    device_version: '14',
+                },
+            });
+        });
+    }
+    it("rebuilds a node's session under the node's own base path", () => __awaiter(this, void 0, void 0, function* () {
+        yield running('on-node', 'phone-n', nodeOrigin, 'node-1');
+        const manager = new SessionManager_1.SessionManager();
+        const recovered = yield manager.recoverActiveSessions('hub-new-id', '/wd/hub', (h) => h === HUB);
+        (0, chai_1.expect)(recovered).to.equal(1);
+        const session = manager.getSession('on-node');
+        (0, chai_1.expect)(session.getType()).to.equal(SessionType_1.default.REMOTE);
+        (0, chai_1.expect)(session.getWebDriverUrl()).to.equal(`${nodeOrigin}/node-base`);
+    }));
+    describe("the hub's boot", () => {
+        const hubHosts = { origin: HUB, hosts: new Set([HUB]) };
+        it("keeps a node's phone, so the session on it is recovered rather than failed", () => __awaiter(this, void 0, void 0, function* () {
+            yield running('on-node', 'phone-n', nodeOrigin, 'node-1');
+            yield running('on-hub', 'phone-h', HUB, 'hub-old-id');
+            // What ServerManager does at boot, in order: clear, then recover.
+            const cleared = (0, localDeviceHosts_1.devicesClearedAtBoot)({ hub: undefined }, hubHosts);
+            yield device_store_1.DeviceStoreFactory.getStore().clearStorage(cleared);
+            const left = yield scratch.db.device.findMany({ select: { udid: true } });
+            (0, chai_1.expect)(left.map((d) => d.udid)).to.deep.equal(['phone-n']);
+            const manager = new SessionManager_1.SessionManager();
+            const recovered = yield manager.recoverActiveSessions('hub-new-id', '/wd/hub', (h) => h === HUB);
+            (0, chai_1.expect)(recovered).to.equal(1);
+            (0, chai_1.expect)(manager.getSession('on-node')).to.not.equal(undefined);
+            const hubRow = yield scratch.db.session.findUnique({ where: { id: 'on-hub' } });
+            (0, chai_1.expect)(hubRow === null || hubRow === void 0 ? void 0 : hubRow.status).to.equal('failed');
+        }));
+        it('a node still clears every phone it has, as before', () => {
+            (0, chai_1.expect)((0, localDeviceHosts_1.devicesClearedAtBoot)({ hub: 'http://hub:4724' }, hubHosts)).to.equal(undefined);
+        });
+    });
+    it("marks a session on the hub's own phone failed, though its node id changed with the restart", () => __awaiter(this, void 0, void 0, function* () {
+        yield running('on-hub', 'phone-h', HUB, 'hub-old-id');
+        const manager = new SessionManager_1.SessionManager();
+        const recovered = yield manager.recoverActiveSessions('hub-new-id', '/wd/hub', (h) => h === HUB);
+        (0, chai_1.expect)(recovered).to.equal(0);
+        (0, chai_1.expect)(manager.getSession('on-hub')).to.equal(undefined);
+        const row = yield scratch.db.session.findUnique({ where: { id: 'on-hub' } });
+        (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.status).to.equal('failed');
+    }));
+});