@xenon-device-management/xenon 2.0.0 → 2.1.0

package/lib/test/unit/session-listing-auth.spec.js

@@ -0,0 +1,345 @@
+"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 });
+const chai_1 = require("chai");
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const commandAuth_1 = require("../../src/middleware/commandAuth");
+const commandCaller_1 = require("../../src/middleware/commandCaller");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * Appium 3's session listing (`GET <basePath>/appium/sessions`) under
+ * XENON_REQUIRE_COMMAND_AUTH.
+ *
+ * Appium answers it for anyone with every live session's id and capabilities,
+ * which is the easiest way to find an id to use. With the setting on, the
+ * answer is filtered: an override admin sees everything, a verified caller sees
+ * the sessions they own, and a caller without valid credentials sees an empty
+ * list in Appium's own shape. Appium still produces the listing; Xenon only
+ * removes entries from it.
+ *
+ * The apps are built as Appium builds its own (middleware, routes, then the
+ * plugin's updater), and the listing route records that it ran.
+ */
+function appiumExpress() {
+    const appiumDir = path_1.default.dirname(require.resolve('appium/package.json'));
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(require.resolve('express', { paths: [appiumDir] }));
+}
+const USERS = {
+    alice: { id: 'alice', role: 'MEMBER', status: 'ACTIVE' },
+    bob: { id: 'bob', role: 'MEMBER', status: 'ACTIVE' },
+    carol: { id: 'carol', role: 'ADMIN', status: 'ACTIVE' },
+    root: { id: 'root', role: 'SUPER_ADMIN', status: 'ACTIVE' },
+};
+// token -> [owner, scopes]
+const KEYS = {
+    'alice-token': ['alice', 'devices,sessions,read'],
+    'bob-token': ['bob', 'devices,sessions,read'],
+    'carol-ordinary': ['carol', 'devices,sessions,read'],
+    'carol-admin': ['carol', 'admin,devices,sessions,read'],
+};
+const JWTS = {
+    'alice-jwt': ['alice', 'devices,sessions,read'],
+    'root-jwt': ['root', 'sessions'],
+};
+const OWNERS = {
+    's-alice': 'alice',
+    's-bob': 'bob',
+    's-anon': null,
+    's-alice-2': 'alice',
+};
+/** What Appium's getAppiumSessions answers: id, creation time, capabilities. */
+const LISTING = [
+    { id: 's-alice', created: 1, capabilities: { platformName: 'Android' } },
+    { id: 's-bob', created: 2, capabilities: { platformName: 'iOS' } },
+    { id: 's-anon', created: 3, capabilities: { platformName: 'Android' } },
+    { id: 's-alice-2', created: 4, capabilities: { platformName: 'iOS' } },
+];
+const ALL_IDS = LISTING.map((s) => s.id);
+const as = (token) => ({
+    'x-xenon-access-key': `ak-${KEYS[token][0]}`,
+    'x-xenon-token': token,
+});
+const bearer = (jwt) => ({ authorization: `Bearer ${jwt}` });
+const idsOf = (res) => res.body.value.map((s) => s.id);
+const shapes = [
+    ['Express 4', () => (0, express_1.default)()],
+    ['Express 5 (Appium 3)', () => appiumExpress()()],
+];
+describe('session listing under per-command auth (GET <basePath>/appium/sessions)', () => {
+    it('is the listing route under the normalised base path', () => {
+        (0, chai_1.expect)((0, registerCommandAuth_1.sessionListingPath)('/wd/hub')).to.equal('/wd/hub/appium/sessions');
+        (0, chai_1.expect)((0, registerCommandAuth_1.sessionListingPath)('wd/hub/')).to.equal('/wd/hub/appium/sessions');
+        (0, chai_1.expect)((0, registerCommandAuth_1.sessionListingPath)('')).to.equal('/appium/sessions');
+        (0, chai_1.expect)((0, registerCommandAuth_1.sessionListingPath)(undefined)).to.equal('/appium/sessions');
+    });
+    for (const [shapeName, makeExpress] of shapes) {
+        describe(shapeName, () => {
+            let enabled;
+            let authDisabled;
+            let verifyKeyPair;
+            let verifyBearer;
+            let ownerOf;
+            let ownersOf;
+            let infos;
+            let warnings;
+            let errors;
+            /** What the listing route answers; a test may swap in an error. */
+            let answer;
+            const loopback = (0, loopbackServer_1.loopbackServers)();
+            afterEach(() => loopback.closeAll());
+            function lab() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const ran = [];
+                    const app = makeExpress();
+                    app.use(express_1.default.json());
+                    app.get('/wd/hub/appium/sessions', (_req, res) => {
+                        ran.push('getAppiumSessions');
+                        res.status(answer.status).json(answer.body);
+                    });
+                    app.get('/wd/hub/status', (_req, res) => {
+                        ran.push('getStatus');
+                        res.json({ value: { ready: true } });
+                    });
+                    const result = (0, registerCommandAuth_1.registerCommandAuth)(app, { basePath: '/wd/hub' }, {
+                        enabled: () => enabled,
+                        authDisabled: () => authDisabled,
+                        verifier: new commandCaller_1.CommandCallerVerifier({ verifyKeyPair, verifyBearer }),
+                        ownerOf,
+                        ownersOf,
+                        logger: {
+                            info: (m) => infos.push(m),
+                            warn: (m) => warnings.push(m),
+                            error: (m) => errors.push(m),
+                        },
+                    });
+                    (0, chai_1.expect)(result.placed, 'placed ahead of the routes').to.equal(true);
+                    // Only what requests log counts below; drop the registration's own line.
+                    infos.splice(0);
+                    return { app: yield loopback.serve(app), ran };
+                });
+            }
+            beforeEach(() => {
+                enabled = true;
+                authDisabled = false;
+                infos = [];
+                warnings = [];
+                errors = [];
+                answer = { status: 200, body: { value: LISTING } };
+                verifyKeyPair = sinon_1.default.stub().callsFake((accessKey, token) => __awaiter(void 0, void 0, void 0, function* () {
+                    const key = KEYS[token];
+                    if (!key || accessKey !== `ak-${key[0]}`)
+                        return null;
+                    return {
+                        row: { id: `key-${token}`, userId: key[0], scopes: key[1], expiresAt: null },
+                        user: USERS[key[0]],
+                    };
+                }));
+                verifyBearer = sinon_1.default.stub().callsFake((jwt) => __awaiter(void 0, void 0, void 0, function* () {
+                    const t = JWTS[jwt];
+                    if (!t)
+                        return null;
+                    return { payload: { sub: t[0], scopes: t[1] }, user: USERS[t[0]] };
+                }));
+                ownerOf = sinon_1.default.stub().callsFake((id) => __awaiter(void 0, void 0, void 0, function* () { return (id in OWNERS ? OWNERS[id] : null); }));
+                ownersOf = sinon_1.default
+                    .stub()
+                    .callsFake((ids) => __awaiter(void 0, void 0, void 0, function* () { return new Map(ids.map((id) => [id, id in OWNERS ? OWNERS[id] : null])); }));
+            });
+            describe('who sees what', () => {
+                it('shows the owner only the sessions they own', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app, ran } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('alice-token'));
+                    (0, chai_1.expect)(res.status).to.equal(200);
+                    (0, chai_1.expect)(res.headers['content-type']).to.equal('application/json; charset=utf-8');
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: [LISTING[0], LISTING[3]] });
+                    (0, chai_1.expect)(ran).to.deep.equal(['getAppiumSessions']);
+                }));
+                it('decides every listed session with one owner lookup, not one per session', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('alice-token')).expect(200);
+                    (0, chai_1.expect)(ownersOf.callCount).to.equal(1);
+                    (0, chai_1.expect)(ownersOf.firstCall.args[0]).to.have.members(ALL_IDS);
+                    (0, chai_1.expect)(ownerOf.called).to.equal(false);
+                }));
+                it('shows the owner their sessions for a Bearer token too', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(bearer('alice-jwt'));
+                    (0, chai_1.expect)(idsOf(res)).to.deep.equal(['s-alice', 's-alice-2']);
+                }));
+                it('shows another user only theirs', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('bob-token'));
+                    (0, chai_1.expect)(idsOf(res)).to.deep.equal(['s-bob']);
+                }));
+                it('logs the filtering at info with the caller and the counts, never the credential', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('bob-token')).expect(200);
+                    (0, chai_1.expect)(infos).to.have.length(1);
+                    (0, chai_1.expect)(infos[0]).to.include('bob');
+                    (0, chai_1.expect)(infos[0]).to.include('1 of 4');
+                    (0, chai_1.expect)(infos[0]).not.to.include('bob-token');
+                    (0, chai_1.expect)(warnings).to.deep.equal([]);
+                }));
+                it('shows an admin-scoped key every session, without looking up owners', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('carol-admin'));
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: LISTING });
+                    (0, chai_1.expect)(ownersOf.called || ownerOf.called).to.equal(false);
+                }));
+                it('shows a SUPER_ADMIN every session', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(bearer('root-jwt'));
+                    (0, chai_1.expect)(idsOf(res)).to.deep.equal(ALL_IDS);
+                }));
+                it("shows an ADMIN's ordinary key only their own sessions, here none", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('carol-ordinary'));
+                    (0, chai_1.expect)(res.status).to.equal(200);
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: [] });
+                }));
+                it('never shows a session nobody owns to anyone but an override admin', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    for (const who of ['alice-token', 'bob-token', 'carol-ordinary']) {
+                        const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as(who));
+                        (0, chai_1.expect)(idsOf(res), who).not.to.include('s-anon');
+                    }
+                    const admin = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('carol-admin'));
+                    (0, chai_1.expect)(idsOf(admin)).to.include('s-anon');
+                }));
+            });
+            describe('callers without valid credentials', () => {
+                it("get an empty list in Appium's normal shape, with no lookups at all", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app, ran } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions');
+                    (0, chai_1.expect)(res.status).to.equal(200);
+                    (0, chai_1.expect)(res.headers['content-type']).to.equal('application/json; charset=utf-8');
+                    (0, chai_1.expect)(res.text).to.equal('{"value":[]}');
+                    (0, chai_1.expect)(ran).to.deep.equal(['getAppiumSessions']);
+                    (0, chai_1.expect)(verifyKeyPair.called || verifyBearer.called).to.equal(false);
+                    (0, chai_1.expect)(ownersOf.called || ownerOf.called).to.equal(false);
+                    (0, chai_1.expect)(warnings).to.have.length(1);
+                    (0, chai_1.expect)(warnings[0]).to.include('no credentials');
+                }));
+                it('get an empty list for credentials that do not verify, logged without the secret', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/appium/sessions')
+                        .set({ 'x-xenon-access-key': 'ak-alice', 'x-xenon-token': 'guessed' });
+                    (0, chai_1.expect)(res.status).to.equal(200);
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: [] });
+                    (0, chai_1.expect)(ownersOf.called).to.equal(false);
+                    (0, chai_1.expect)(warnings).to.have.length(1);
+                    (0, chai_1.expect)(warnings[0]).to.include('invalid credentials');
+                    (0, chai_1.expect)(warnings[0]).not.to.include('guessed');
+                }));
+                it('get the same answer as when no session is running', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app } = yield lab();
+                    const filtered = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions');
+                    answer = { status: 200, body: { value: [] } };
+                    const empty = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('carol-admin'));
+                    (0, chai_1.expect)(filtered.status).to.equal(empty.status);
+                    (0, chai_1.expect)(filtered.headers['content-type']).to.equal(empty.headers['content-type']);
+                    (0, chai_1.expect)(filtered.text).to.equal(empty.text);
+                }));
+                it('are filtered on the path in another letter case and with a trailing slash', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app, ran } = yield lab();
+                    for (const url of ['/WD/HUB/APPIUM/SESSIONS', '/wd/hub/appium/sessions/']) {
+                        const res = yield (0, loopbackRequest_1.default)(app).get(url);
+                        (0, chai_1.expect)(res.status, url).to.equal(200);
+                        (0, chai_1.expect)(res.body, url).to.deep.equal({ value: [] });
+                    }
+                    (0, chai_1.expect)(ran).to.deep.equal(['getAppiumSessions', 'getAppiumSessions']);
+                }));
+            });
+            describe('what it leaves alone', () => {
+                it('does nothing at all when the setting is off (the default)', () => __awaiter(void 0, void 0, void 0, function* () {
+                    enabled = false;
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions');
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: LISTING });
+                    (0, chai_1.expect)(verifyKeyPair.called || verifyBearer.called).to.equal(false);
+                    (0, chai_1.expect)(ownersOf.called || ownerOf.called).to.equal(false);
+                    (0, chai_1.expect)(infos.concat(warnings, errors)).to.deep.equal([]);
+                }));
+                it('does nothing when auth is disabled, even with the setting on', () => __awaiter(void 0, void 0, void 0, function* () {
+                    authDisabled = true;
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions');
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: LISTING });
+                    (0, chai_1.expect)(ownersOf.called).to.equal(false);
+                }));
+                it("passes Appium's error answer through untouched (session_discovery not enabled)", () => __awaiter(void 0, void 0, void 0, function* () {
+                    answer = {
+                        status: 400,
+                        body: {
+                            value: {
+                                error: 'invalid argument',
+                                message: 'Potentially insecure feature session_discovery has not been enabled',
+                                stacktrace: '',
+                            },
+                        },
+                    };
+                    const { app } = yield lab();
+                    for (const headers of [{}, as('alice-token')]) {
+                        const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(headers);
+                        (0, chai_1.expect)(res.status).to.equal(400);
+                        (0, chai_1.expect)(res.body).to.deep.equal(answer.body);
+                    }
+                    (0, chai_1.expect)(ownersOf.called).to.equal(false);
+                }));
+                it('leaves other requests alone', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { app, ran } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/status');
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: { ready: true } });
+                    (0, chai_1.expect)(ran).to.deep.equal(['getStatus']);
+                    (0, chai_1.expect)(warnings).to.deep.equal([]);
+                }));
+            });
+            describe('failing closed', () => {
+                it('answers 503 when the credential check fails, before the listing runs', () => __awaiter(void 0, void 0, void 0, function* () {
+                    verifyKeyPair.rejects(new Error('database is locked'));
+                    const { app, ran } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('alice-token'));
+                    (0, chai_1.expect)(res.status).to.equal(503);
+                    (0, chai_1.expect)(res.body).to.deep.equal(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
+                    (0, chai_1.expect)(ran).to.deep.equal([]);
+                    (0, chai_1.expect)(errors).to.have.length(1);
+                    (0, chai_1.expect)(errors[0]).to.include('database is locked');
+                }));
+                it('answers 503 when the owner lookup fails, never the unfiltered list', () => __awaiter(void 0, void 0, void 0, function* () {
+                    ownersOf.rejects(new Error('database is locked\nSELECT secret FROM ...'));
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('alice-token'));
+                    (0, chai_1.expect)(res.status).to.equal(503);
+                    (0, chai_1.expect)(res.body).to.deep.equal(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
+                    (0, chai_1.expect)(res.text).not.to.include('s-bob');
+                    (0, chai_1.expect)(errors).to.have.length(1);
+                    (0, chai_1.expect)(errors[0]).to.include('database is locked');
+                    (0, chai_1.expect)(errors[0]).not.to.include('SELECT');
+                }));
+                it('drops a listed entry it cannot attribute rather than showing it', () => __awaiter(void 0, void 0, void 0, function* () {
+                    answer = { status: 200, body: { value: [LISTING[0], { created: 5 }, 'junk'] } };
+                    const { app } = yield lab();
+                    const res = yield (0, loopbackRequest_1.default)(app).get('/wd/hub/appium/sessions').set(as('alice-token'));
+                    (0, chai_1.expect)(res.body).to.deep.equal({ value: [LISTING[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);
+    }));
+});