@xenon-device-management/xenon 2.0.0 → 2.2.0

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

@@ -0,0 +1,591 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const jose = __importStar(require("jose"));
+const typedi_1 = require("typedi");
+const base_driver_1 = require("@appium/base-driver");
+const plugin_1 = require("../../src/plugin");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const insertBeforeRoutes_1 = require("../../src/app/insertBeforeRoutes");
+const defaultGateway_1 = require("../../src/gateway/defaultGateway");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
+const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const SessionOwnerResolver_1 = require("../../src/services/device-access/SessionOwnerResolver");
+const ApiKeyService_1 = require("../../src/services/ApiKeyService");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const device_managers_1 = require("../../src/device-managers");
+const device_store_1 = require("../../src/data-service/device-store");
+const prisma_store_1 = require("../../src/data-service/prisma-store");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const SessionType_1 = __importDefault(require("../../src/enums/SessionType"));
+const deviceUtils = __importStar(require("../../src/device-utils"));
+const leaseToken_1 = require("../../src/services/lease/leaseToken");
+const config_1 = require("../../src/config");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * `POST /session` through a Xenon hub, in Appium 3's own server(): the hub is
+ * Appium's real umbrella driver with Xenon's real plugin, the session gateway
+ * from the production wiring (hubGatewayOptions), the real
+ * SessionLifecycleService and a scratch SQLite database. The node runs the
+ * production node wiring too (nodeGatewayOptions), so the hub's token is
+ * checked by the node's real create layer against the hub's JWKS; what the
+ * node then does with the grant is node-gateway-create-appium-server.spec.ts.
+ * Here a stand-in records it and the node's fake driver answers.
+ */
+const quiet = {
+    debug: () => undefined,
+    info: () => undefined,
+    warn: () => undefined,
+    error: () => undefined,
+};
+const HUB_NODE_ID = 'hub-node-id';
+const SECRETS = ['SECRET-SESSION-JWT', 'SECRET-LEASE-TOKEN'];
+/** Another plugin, ahead of Xenon's in the chain, that can refuse a create. */
+class GatekeeperPlugin {
+    constructor(name) {
+        this.name = name;
+    }
+    createSession(next, _driver, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if ((_b = (_a = args[2]) === null || _a === void 0 ? void 0 : _a.alwaysMatch) === null || _b === void 0 ? void 0 : _b['gatekeeper:refuse']) {
+                throw new ((0, appium_umbrella_1.appiumBaseDriver)().errors.InvalidArgumentError)('refused by another plugin');
+            }
+            return next();
+        });
+    }
+}
+describe('POST /session through a hub, in Appium 3’s own server()', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const servers = [];
+    let keyDir;
+    let hubKeys;
+    let appiumLogs;
+    let restore;
+    let saved;
+    let authDisabledBefore;
+    let gateBefore;
+    let umbrella;
+    let hubUrl;
+    let nodeOrigin;
+    let node;
+    let nodeRequests;
+    let nodeCreates;
+    let nodeRefuses;
+    let keys;
+    let keyIds;
+    let nodeSessions = 0;
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+        keyDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-hub-create-keys-'));
+        hubKeys = new JwtKeyService_1.JwtKeyService();
+        yield hubKeys.init(keyDir);
+    }));
+    after(() => {
+        appiumLogs.restore();
+        fs_1.default.rmSync(keyDir, { recursive: true, force: true });
+    });
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, nodeWebDriverUrl_1.NodeBasePathResolver, SessionOwnerResolver_1.SessionOwnerResolver, device_managers_1.XenonManager);
+        typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
+        typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
+        typedi_1.Container.set(nodeWebDriverUrl_1.NodeBasePathResolver, new nodeWebDriverUrl_1.NodeBasePathResolver());
+        typedi_1.Container.set(SessionOwnerResolver_1.SessionOwnerResolver, new SessionOwnerResolver_1.SessionOwnerResolver());
+        // No adb here: no health check, no extra device info.
+        typedi_1.Container.set(device_managers_1.XenonManager, {
+            getMaxSessionCount: () => undefined,
+            deviceInstances: () => __awaiter(this, void 0, void 0, function* () { return []; }),
+        });
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = {
+            store: device_store_1.DeviceStoreFactory._deviceStore,
+            pending: device_store_1.DeviceStoreFactory._pendingSessionStore,
+            context: Object.assign({}, context),
+        };
+        device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        device_store_1.DeviceStoreFactory._pendingSessionStore = new prisma_store_1.PrismaPendingSessionStore();
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = false;
+        gateBefore = process.env.XENON_REQUIRE_SESSION_TOKEN;
+        delete process.env.XENON_REQUIRE_SESSION_TOKEN;
+        for (const model of [
+            'pendingSession',
+            'lease',
+            'session',
+            'device',
+            'apiKey',
+            'teamMember',
+            'team',
+            'user',
+        ]) {
+            yield scratch.db[model].deleteMany({});
+        }
+        nodeRequests = [];
+        nodeCreates = [];
+        nodeRefuses = false;
+        sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'onSessionStopped').resolves();
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        for (const s of SessionManager_1.SESSION_MANAGER.getAllSessions())
+            SessionManager_1.SESSION_MANAGER.removeSession(s.getId());
+        device_store_1.DeviceStoreFactory._deviceStore = saved.store;
+        device_store_1.DeviceStoreFactory._pendingSessionStore = saved.pending;
+        Object.assign(typedi_1.Container.get(PluginContext_1.PluginContext), saved.context);
+        config_1.config.authDisabled = authDisabledBefore;
+        if (gateBefore === undefined)
+            delete process.env.XENON_REQUIRE_SESSION_TOKEN;
+        else
+            process.env.XENON_REQUIRE_SESSION_TOKEN = gateBefore;
+        sinon_1.default.restore();
+        restore();
+        for (const s of servers.splice(0)) {
+            s.closeAllConnections();
+            yield new Promise((resolve) => http_1.default.Server.prototype.close.call(s, () => resolve()));
+        }
+    }));
+    const port = (s) => s.address().port;
+    /** A fake node driver: a session is whatever it is asked to create. */
+    function fakeNodeDriver() {
+        const commands = [];
+        const sessions = new Set();
+        const driver = {
+            log: quiet,
+            protocol: 'W3C',
+            sessionExists: (id) => sessions.has(id),
+            proxyActive: () => false,
+            canProxy: () => false,
+            proxyRouteIsAvoided: () => false,
+            executeCommand: (command) => __awaiter(this, void 0, void 0, function* () {
+                commands.push(command);
+                if (command === 'createSession') {
+                    const id = `node-session-${++nodeSessions}`;
+                    sessions.add(id);
+                    return [id, { platformName: 'Android' }];
+                }
+                return null;
+            }),
+        };
+        return { commands, driver };
+    }
+    function boot() {
+        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            var _a, _b;
+            const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+            const hubBase = (_a = opts.hubBase) !== null && _a !== void 0 ? _a : '/wd/hub';
+            const nodeBase = (_b = opts.nodeBase) !== null && _b !== void 0 ? _b : '/node';
+            umbrella = (0, appium_umbrella_1.umbrellaWith)([
+                [plugin_1.XenonPlugin, 'xenon'],
+                [GatekeeperPlugin, 'gatekeeper'],
+            ]);
+            const hubServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: hubBase,
+                cliArgs: { basePath: hubBase },
+                serverUpdaters: [
+                    (app) => {
+                        app.get('/xenon/api/auth/jwks.json', (_req, res) => res.json(hubKeys.jwks()));
+                        (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: hubBase }, (0, registerCommandAuth_1.commandAuthDeps)({
+                            enabled: () => false,
+                            authDisabled: () => false,
+                            logger: quiet,
+                        }), (0, defaultGateway_1.hubGatewayOptions)({
+                            basePath: hubBase,
+                            isLocalHost: (host) => host === hubUrl,
+                            nodeId: () => HUB_NODE_ID,
+                            dashboard: () => false,
+                        }));
+                    },
+                ],
+            });
+            servers.push(hubServer);
+            hubUrl = `http://127.0.0.1:${port(hubServer)}`;
+            typedi_1.Container.get(PluginContext_1.PluginContext).setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1', enableDashboard: false, deviceAvailabilityTimeoutMs: 1000, deviceAvailabilityQueryIntervalMs: 100 }), port(hubServer), HUB_NODE_ID, hubBase);
+            node = fakeNodeDriver();
+            // The node's own create layer, from the production wiring; its lifecycle
+            // is a stand-in that records the grant (see the node's own spec).
+            const nodeLifecycle = {
+                prepareSession: (caps, opts) => __awaiter(this, void 0, void 0, function* () {
+                    nodeCreates.push({ caps: JSON.parse(JSON.stringify(caps)), grant: opts === null || opts === void 0 ? void 0 : opts.hubGrant });
+                    if (nodeRefuses)
+                        throw new base_driver_1.errors.InvalidArgumentError('the node refused');
+                    return { remote: false };
+                }),
+                completeRemoteSession: () => __awaiter(this, void 0, void 0, function* () {
+                    throw new Error('a node never forwards a create');
+                }),
+                releaseAllocation: () => __awaiter(this, void 0, void 0, function* () { return undefined; }),
+            };
+            const nodeOptions = (0, defaultGateway_1.nodeGatewayOptions)(hubUrl);
+            const nodeServer = yield baseDriver.server({
+                routeConfiguringFunction: baseDriver.routeConfiguringFunction(node.driver),
+                port: 0,
+                hostname: '127.0.0.1',
+                basePath: nodeBase,
+                cliArgs: { basePath: nodeBase },
+                serverUpdaters: [
+                    (app) => {
+                        (0, insertBeforeRoutes_1.insertBeforeRoutes)(app, '/', (req, _res, next) => {
+                            if (!req.url.startsWith('/xenon/')) {
+                                nodeRequests.push({
+                                    method: req.method,
+                                    url: req.url,
+                                    headers: Object.assign({}, req.headers),
+                                    body: req.body,
+                                });
+                            }
+                            next();
+                        });
+                        app.get(nodeWebDriverUrl_1.WEBDRIVER_INFO_PATH, (0, nodeWebDriverUrl_1.webdriverInfoHandler)(() => nodeBase));
+                        (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: nodeBase }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => false, authDisabled: () => false, logger: quiet }), Object.assign(Object.assign({}, nodeOptions), { create: Object.assign(Object.assign({}, nodeOptions.create), { lifecycle: () => nodeLifecycle }) }));
+                    },
+                ],
+            });
+            servers.push(nodeServer);
+            nodeOrigin = `http://127.0.0.1:${port(nodeServer)}`;
+        });
+    }
+    /** alice (team A) and bob (team B), members with an ordinary sessions key each. */
+    function seedUsers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            keys = {};
+            keyIds = {};
+            for (const [id, team] of [
+                ['alice', 'team-a'],
+                ['bob', 'team-b'],
+            ]) {
+                yield scratch.db.team.create({ data: { id: team, name: team } });
+                yield scratch.db.user.create({
+                    data: {
+                        id,
+                        email: `${id}@xenon.test`,
+                        name: id,
+                        passwordHash: 'x',
+                        accessKey: `ak-${id}`,
+                        role: 'MEMBER',
+                    },
+                });
+                yield scratch.db.teamMember.create({ data: { teamId: team, userId: id } });
+                const key = yield typedi_1.Container.get(ApiKeyService_1.ApiKeyService).create({
+                    name: id,
+                    scopes: ['sessions'],
+                    userId: id,
+                });
+                keys[id] = key.raw;
+                keyIds[id] = key.id;
+            }
+        });
+    }
+    function phone(udid_1, where_1) {
+        return __awaiter(this, arguments, void 0, function* (udid, where, extra = {}) {
+            yield scratch.db.device.create({
+                data: Object.assign({ udid, host: where === 'node' ? nodeOrigin : hubUrl, nodeId: where === 'node' ? 'node-1' : HUB_NODE_ID, platform: 'android', name: udid, sdk: '14', busy: false, userBlocked: false, offline: false }, extra),
+            });
+        });
+    }
+    const row = (udid) => scratch.db.device.findFirst({ where: { udid } });
+    function capsFor(who, xeOptions = {}, alwaysMatch = {}) {
+        return {
+            capabilities: {
+                alwaysMatch: Object.assign({ platformName: 'Android', 'appium:automationName': appium_umbrella_1.FAKE_AUTOMATION, 'appium:newCommandTimeout': 0, 
+                    // No video: it would start Xenon's real capture pipeline for the phone.
+                    'xe:options': Object.assign({ accessKey: `ak-${who}`, token: keys[who], recordVideo: false }, xeOptions) }, alwaysMatch),
+                firstMatch: [{}],
+            },
+        };
+    }
+    const creates = () => nodeRequests.filter((r) => r.method === 'POST' && /\/session$/.test(r.url));
+    const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
+    describe('a node’s phone', () => {
+        it('is created on the node and answered by the hub; Appium’s createSession never runs', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('node-phone', 'node');
+            const umbrellaCommands = sinon_1.default.spy(umbrella, 'executeCommand');
+            const pluginCreate = sinon_1.default.spy(plugin_1.XenonPlugin.prototype, 'createSession');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('alice'));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            const sessionId = res.body.value.sessionId;
+            (0, chai_1.expect)(sessionId).to.match(/^node-session-/);
+            // The node's capabilities, plus the `desired` ones finalizeSession adds,
+            // as a session created through Appium's route always had.
+            (0, chai_1.expect)(res.body.value.capabilities.platformName).to.equal('Android');
+            (0, chai_1.expect)(res.body.value.capabilities.desired['appium:udid']).to.equal('node-phone');
+            (0, chai_1.expect)(JSON.stringify(res.body)).to.not.include(keys.alice);
+            // Appium never saw it: no umbrella command, no plugin, no promoted plugin.
+            (0, chai_1.expect)(umbrellaCommands.called).to.equal(false);
+            (0, chai_1.expect)(pluginCreate.called).to.equal(false);
+            (0, chai_1.expect)(umbrella.sessionlessPlugins).to.deep.equal([]);
+            (0, chai_1.expect)(Object.keys(umbrella.sessionPlugins)).to.deep.equal([]);
+            (0, chai_1.expect)(Object.keys(umbrella.sessions)).to.deep.equal([]);
+            // The node created it, under its own base path.
+            (0, chai_1.expect)(node.commands).to.deep.equal(['createSession']);
+            (0, chai_1.expect)(creates().map((r) => r.url)).to.deep.equal(['/node/session']);
+            // The hub's record of it.
+            (0, chai_1.expect)(yield row('node-phone')).to.include({ busy: true, session_id: sessionId });
+            const live = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+            (0, chai_1.expect)(live === null || live === void 0 ? void 0 : live.getType()).to.equal(SessionType_1.default.REMOTE);
+            (0, chai_1.expect)(live.userId).to.equal('alice');
+            (0, chai_1.expect)(yield scratch.db.pendingSession.count()).to.equal(0);
+            // Its commands then go through the gateway to the node.
+            yield (0, loopbackRequest_1.default)(hubUrl).get(`/wd/hub/session/${sessionId}/url`).expect(200);
+            (0, chai_1.expect)(node.commands).to.deep.equal(['createSession', 'getUrl']);
+            (0, chai_1.expect)(umbrellaCommands.called).to.equal(false);
+        }));
+        it('the node gets the hub’s token for the verified owner, never the client’s credentials', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('node-phone', 'node');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post('/wd/hub/session')
+                .set('x-xenon-access-key', 'ak-alice')
+                .set('x-xenon-token', keys.alice)
+                .set('authorization', 'Bearer SECRET-SESSION-JWT')
+                .set('cookie', 'xenon_dashboard_session=SECRET-LEASE-TOKEN')
+                .send(capsFor('alice', { sessionToken: SECRETS[0], leaseToken: SECRETS[1], buildId: 'b-1' }));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            const [sent] = creates();
+            const everything = JSON.stringify({ headers: sent.headers, body: sent.body });
+            for (const secret of [...SECRETS, keys.alice])
+                (0, chai_1.expect)(everything).to.not.include(secret);
+            for (const header of ['x-xenon-access-key', 'x-xenon-token', 'authorization', 'cookie']) {
+                (0, chai_1.expect)(sent.headers[header], header).to.equal(undefined);
+            }
+            // Options that are not secrets still travel.
+            (0, chai_1.expect)(sent.body.capabilities.alwaysMatch['xe:options']).to.deep.equal({
+                recordVideo: false,
+                buildId: 'b-1',
+            });
+            const claims = jose.decodeJwt(String(sent.headers[hubSessionToken_1.HUB_TOKEN_HEADER]));
+            (0, chai_1.expect)(claims).to.include({
+                aud: hubSessionToken_1.HUB_CREATE_AUDIENCE,
+                sub: 'alice',
+                udid: 'node-phone',
+                host: nodeOrigin,
+            });
+            // The node's real create layer checked it against the hub's keys.
+            (0, chai_1.expect)(nodeCreates).to.have.length(1);
+            (0, chai_1.expect)(nodeCreates[0].grant).to.deep.equal({
+                userId: 'alice',
+                udid: 'node-phone',
+                host: nodeOrigin,
+            });
+            (0, chai_1.expect)(JSON.stringify(nodeCreates[0].caps)).to.not.include(keys.alice);
+        }));
+        it('a node that refuses it: the hub answers the error and frees the phone', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('node-phone', 'node');
+            nodeRefuses = true;
+            const res = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('alice'));
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body.value.message).to.include('invalid argument');
+            (0, chai_1.expect)(yield row('node-phone')).to.include({ busy: false, session_id: null });
+            (0, chai_1.expect)(SessionManager_1.SESSION_MANAGER.getAllSessions()).to.deep.equal([]);
+            (0, chai_1.expect)(yield scratch.db.pendingSession.count()).to.equal(0);
+        }));
+    });
+    describe('the hub’s own phone', () => {
+        it('is allocated once, in the gateway, and created by Appium through the plugin', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('hub-phone', 'hub');
+            const lifecycle = typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService);
+            const allocate = sinon_1.default.spy(deviceUtils, 'allocateDeviceForSession');
+            const prepare = sinon_1.default.spy(lifecycle, 'prepareSession');
+            const completeLocal = sinon_1.default.spy(lifecycle, 'completeLocalSession');
+            const fallback = sinon_1.default.spy(lifecycle, 'createSession');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('alice'));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            const sessionId = res.body.value.sessionId;
+            (0, chai_1.expect)(Object.keys(umbrella.sessions)).to.deep.equal([sessionId]);
+            (0, chai_1.expect)(allocate.callCount, 'allocations').to.equal(1);
+            (0, chai_1.expect)(prepare.callCount).to.equal(1);
+            (0, chai_1.expect)(completeLocal.callCount).to.equal(1);
+            (0, chai_1.expect)(fallback.called, 'the plugin’s own allocation').to.equal(false);
+            (0, chai_1.expect)(yield row('hub-phone')).to.include({ busy: true, session_id: sessionId });
+            (0, chai_1.expect)(yield scratch.db.pendingSession.count()).to.equal(0);
+            (0, chai_1.expect)(creates(), 'the node').to.deep.equal([]);
+            // The driver never saw the credentials.
+            const inner = umbrella.sessions[sessionId];
+            (0, chai_1.expect)(JSON.stringify(inner.originalCaps)).to.not.include(keys.alice);
+            yield (0, loopbackRequest_1.default)(hubUrl).delete(`/wd/hub/session/${sessionId}`).expect(200);
+            (0, chai_1.expect)(yield row('hub-phone')).to.include({ busy: false, session_id: null });
+        }));
+        it('is freed when Appium rejects the create after the plugin (no such driver)', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('hub-phone', 'hub');
+            const lookup = sinon_1.default.spy(umbrella.driverConfig, 'findMatchingDriver');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post('/wd/hub/session')
+                .send(capsFor('alice', {}, { 'appium:automationName': 'NoSuchDriver' }));
+            (0, chai_1.expect)(res.status).to.equal(500);
+            // Appium looked for the driver, after Xenon's plugin, and found none.
+            (0, chai_1.expect)(lookup.calledOnce).to.equal(true);
+            (0, chai_1.expect)(yield lookup.firstCall.returnValue.catch((e) => e.message)).to.include('NoSuchDriver');
+            yield settle();
+            (0, chai_1.expect)(yield row('hub-phone')).to.include({ busy: false, session_id: null });
+            (0, chai_1.expect)(yield scratch.db.pendingSession.count()).to.equal(0);
+            (0, chai_1.expect)(Object.keys(umbrella.sessions)).to.deep.equal([]);
+        }));
+        it('is freed when Appium rejects the create before the plugin runs', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('hub-phone', 'hub');
+            const pluginCreate = sinon_1.default.spy(plugin_1.XenonPlugin.prototype, 'createSession');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post('/wd/hub/session')
+                .send(capsFor('alice', {}, { 'gatekeeper:refuse': true }));
+            (0, chai_1.expect)(res.status).to.equal(400);
+            (0, chai_1.expect)(res.body.value.message).to.include('refused by another plugin');
+            (0, chai_1.expect)(pluginCreate.called, 'Xenon’s plugin').to.equal(false);
+            yield settle();
+            (0, chai_1.expect)(yield row('hub-phone')).to.include({ busy: false, session_id: null });
+            (0, chai_1.expect)(yield scratch.db.pendingSession.count()).to.equal(0);
+        }));
+    });
+    describe('a lease through the hub', () => {
+        const LEASE_TOKEN = 'SECRET-LEASE-TOKEN';
+        function leaseNodePhone() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield phone('node-phone', 'node', { busy: true });
+                yield scratch.db.lease.create({
+                    data: {
+                        id: 'lse_1',
+                        tokenHash: (0, leaseToken_1.hashToken)(LEASE_TOKEN),
+                        deviceUdid: 'node-phone',
+                        deviceHost: nodeOrigin,
+                        actorId: keyIds.alice,
+                        status: 'active',
+                        expiresAt: Date.now() + 600000,
+                        lastHeartbeatAt: Date.now(),
+                        allocatedPorts: '{}',
+                        capabilityBag: '{}',
+                    },
+                });
+            });
+        }
+        it('its token opens the leased node phone; the node gets neither the lease id nor its token', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield leaseNodePhone();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post('/wd/hub/session')
+                .send(capsFor('bob', { leaseId: 'lse_1', leaseToken: LEASE_TOKEN }));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            const [sent] = creates();
+            const body = JSON.stringify(sent.body);
+            (0, chai_1.expect)(body).to.not.include(LEASE_TOKEN);
+            (0, chai_1.expect)(body).to.not.include('lse_1');
+            (0, chai_1.expect)(sent.body.capabilities.alwaysMatch['appium:udid']).to.equal('node-phone');
+            (0, chai_1.expect)(nodeCreates[0].grant).to.deep.include({ userId: 'bob', udid: 'node-phone' });
+            (0, chai_1.expect)(yield row('node-phone')).to.include({ session_id: res.body.value.sessionId });
+        }));
+        it('without its token or its creator, is refused at the hub; the node sees nothing', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield leaseNodePhone();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post('/wd/hub/session')
+                .send(capsFor('bob', { leaseId: 'lse_1' }));
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body.value.message).to.include('lease lse_1 is not active');
+            (0, chai_1.expect)(creates()).to.deep.equal([]);
+            (0, chai_1.expect)(yield row('node-phone')).to.include({ busy: true, session_id: null });
+        }));
+    });
+    describe('a team-scoped member through the hub', () => {
+        it('reaches their team’s node phone, and another team’s member does not', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            yield seedUsers();
+            yield phone('team-a-phone', 'node', { teamId: 'team-a' });
+            const refused = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('bob'));
+            (0, chai_1.expect)(refused.status).to.equal(500);
+            (0, chai_1.expect)(refused.body.value.message).to.include('No device matching request');
+            (0, chai_1.expect)(creates(), 'the node, for bob').to.deep.equal([]);
+            (0, chai_1.expect)(yield row('team-a-phone')).to.include({ busy: false, session_id: null });
+            const allowed = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('alice'));
+            (0, chai_1.expect)(allowed.status, JSON.stringify(allowed.body)).to.equal(200);
+            (0, chai_1.expect)(nodeCreates.map((c) => c.grant.userId)).to.deep.equal(['alice']);
+        }));
+    });
+    describe('base paths', () => {
+        it('a hub at the root creates on a node under its own base path', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ hubBase: '', nodeBase: '/node' });
+            yield seedUsers();
+            yield phone('node-phone', 'node');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl).post('/session').send(capsFor('alice'));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            (0, chai_1.expect)(creates().map((r) => r.url)).to.deep.equal(['/node/session']);
+        }));
+        it('a node at the root is created at /session', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ hubBase: '/wd/hub', nodeBase: '' });
+            yield seedUsers();
+            yield phone('node-phone', 'node');
+            const res = yield (0, loopbackRequest_1.default)(hubUrl).post('/wd/hub/session').send(capsFor('alice'));
+            (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+            (0, chai_1.expect)(creates().map((r) => r.url)).to.deep.equal(['/session']);
+        }));
+    });
+});