@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/test/unit/ws-upgrade-routing-appium-server.spec.js

@@ -0,0 +1,500 @@
+"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 http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const ws_1 = __importStar(require("ws"));
+const socket_io_client_1 = require("socket.io-client");
+const commandCaller_1 = require("../../src/middleware/commandCaller");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const h264StreamWs_1 = require("../../src/app/ws/h264StreamWs");
+const logcatWs_1 = require("../../src/app/ws/logcatWs");
+const H264Multiplexer_1 = require("../../src/device-managers/android/H264Multiplexer");
+const LogcatMultiplexer_1 = require("../../src/device-managers/android/LogcatMultiplexer");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const config_1 = require("../../src/config");
+const LIVE_SESSION = 'live-session';
+const OWNERS = { [LIVE_SESSION]: 'alice' };
+const DRIVER_LOGCAT = `/ws/session/${LIVE_SESSION}/appium/device/logcat`;
+const H264_URL = '/xenon/api/control/DEV-1/stream/h264?ticket=t-h264';
+const LOGCAT_URL = '/xenon/api/control/DEV-1/logcat?ticket=t-logcat';
+/** Longer than engine.io's 1 s destroyUpgradeTimeout, so a hang is told apart from it. */
+const HANG_MS = 2500;
+function nativelyUsesUpgradeListener() {
+    return typeof http_1.default.createServer().shouldUpgradeCallback !== 'undefined';
+}
+function appiumBaseDriver() {
+    const appiumDir = path_1.default.dirname(require.resolve('appium/package.json'));
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(require.resolve('@appium/base-driver', { paths: [appiumDir] }));
+}
+/**
+ * Open a WebSocket and report how the server answered: open (with the first
+ * message, if one arrives promptly), an HTTP answer, a close without one (and
+ * how long it took), or nothing at all.
+ */
+function connect(port, urlPath, headers = {}) {
+    return new Promise((resolve) => {
+        const started = Date.now();
+        const ws = new ws_1.default(`ws://127.0.0.1:${port}${urlPath}`, { headers });
+        let settled = false;
+        const settle = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(hang);
+            resolve(outcome);
+            ws.terminate();
+        };
+        const hang = setTimeout(() => settle({ kind: 'hang' }), HANG_MS);
+        ws.on('open', () => {
+            const wait = setTimeout(() => settle({ kind: 'open' }), 300);
+            ws.once('message', (data) => {
+                clearTimeout(wait);
+                settle({ kind: 'open', firstMessage: data });
+            });
+        });
+        ws.on('unexpected-response', (req, res) => {
+            var _a;
+            settle({ kind: 'http', status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0 });
+            req.destroy();
+        });
+        ws.on('error', (err) => settle({ kind: 'closed', message: err.message, ms: Date.now() - started }));
+    });
+}
+describe("Xenon's and Appium's WebSockets on Appium 3's own server()", () => {
+    const quiet = {
+        debug: () => undefined,
+        info: () => undefined,
+        warn: () => undefined,
+        error: () => undefined,
+    };
+    let server;
+    let socketServer;
+    let sockets;
+    let clients;
+    let enabled;
+    let warnings;
+    /** URL of every upgrade each WebSocket server was asked to take, in order. */
+    let taken;
+    let bidiConnections;
+    let driverConnections;
+    let h264Redeemed;
+    let logcatRedeemed;
+    let wssNames;
+    function booted() {
+        if (!server)
+            throw new Error('boot() first');
+        return server;
+    }
+    function port() {
+        return booted().address().port;
+    }
+    function boot(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseDriver = appiumBaseDriver();
+            const credentials = { 'alice-token': 'alice', 'bob-token': 'bob' };
+            const verifier = new commandCaller_1.CommandCallerVerifier({
+                verifyKeyPair: sinon_1.default.stub().callsFake((_ak, token) => __awaiter(this, void 0, void 0, function* () {
+                    return credentials[token]
+                        ? {
+                            row: { id: 'k', userId: credentials[token], scopes: 'sessions', expiresAt: null },
+                            user: { id: credentials[token], role: 'MEMBER', status: 'ACTIVE' },
+                        }
+                        : null;
+                })),
+                verifyBearer: sinon_1.default.stub().resolves(null),
+            });
+            const deps = {
+                enabled: () => enabled,
+                authDisabled: () => false,
+                verifier,
+                ownerOf: (id) => __awaiter(this, void 0, void 0, function* () { var _a; return (_a = OWNERS[id]) !== null && _a !== void 0 ? _a : null; }),
+                ownersOf: (ids) => __awaiter(this, void 0, void 0, function* () { return new Map(ids.map((id) => { var _a; return [id, (_a = OWNERS[id]) !== null && _a !== void 0 ? _a : null]; })); }),
+                logger: {
+                    info: () => undefined,
+                    warn: (m) => warnings.push(m),
+                    error: () => undefined,
+                },
+            };
+            // A fake driver that, like UiAutomator2, registers a per-session WebSocket
+            // with the server when its session starts.
+            const driverWss = new ws_1.WebSocketServer({ noServer: true });
+            wssNames.set(driverWss, 'driver');
+            driverWss.on('connection', (ws, req) => {
+                driverConnections.push(String(req.url));
+                ws.on('error', () => undefined);
+            });
+            const driver = {
+                log: quiet,
+                protocol: 'W3C',
+                sessionExists: (id) => id === LIVE_SESSION,
+                proxyActive: () => false,
+                canProxy: () => false,
+                proxyRouteIsAvoided: () => false,
+                executeCommand: (command) => __awaiter(this, void 0, void 0, function* () {
+                    if (command === 'createSession') {
+                        yield booted().addWebSocketHandler(DRIVER_LOGCAT, driverWss);
+                        return [LIVE_SESSION, {}];
+                    }
+                    return null;
+                }),
+            };
+            const h264Mux = new H264Multiplexer_1.H264Multiplexer();
+            h264Mux.setConfig({ type: 'config', data: Buffer.from([0, 0, 0, 1, 0x67]), ptsMs: 0 });
+            const logcatMux = new LogcatMultiplexer_1.LogcatMultiplexer();
+            logcatMux.push({ ts: 1, pid: 1, tid: 1, level: 'I', tag: 'T', message: 'hello' });
+            const createServer = http_1.default.createServer;
+            const forced = opts.upgrades === 'listener' ? sinon_1.default.stub(http_1.default, 'createServer') : undefined;
+            forced === null || forced === void 0 ? void 0 : forced.callsFake(((app) => {
+                const s = createServer(app);
+                if (typeof s.shouldUpgradeCallback === 'undefined') {
+                    s.shouldUpgradeCallback = () => true;
+                }
+                return s;
+            }));
+            try {
+                server = yield baseDriver.server({
+                    routeConfiguringFunction: baseDriver.routeConfiguringFunction(driver),
+                    port: 0,
+                    hostname: '127.0.0.1',
+                    basePath: '/wd/hub',
+                    cliArgs: { basePath: '/wd/hub' },
+                    serverUpdaters: [
+                        (app, httpServer, cliArgs) => {
+                            // ServerManager.updateServer, in its order.
+                            (0, registerCommandAuth_1.registerCommandAuth)(app, cliArgs, deps);
+                            (0, registerCommandAuth_1.registerSessionUpgradeGuard)(httpServer, app, cliArgs, deps);
+                            if (opts.role === 'hub') {
+                                socketServer = new SocketServer_1.SocketServer();
+                                socketServer.initialize(httpServer);
+                            }
+                            (0, h264StreamWs_1.attachH264Ws)(httpServer, {
+                                redeem: (ticket, udid) => __awaiter(this, void 0, void 0, function* () {
+                                    h264Redeemed.push(`${udid}:${ticket}`);
+                                    return { actorId: 'alice' };
+                                }),
+                                startStream: () => __awaiter(this, void 0, void 0, function* () { return h264Mux; }),
+                            });
+                            (0, logcatWs_1.attachLogcatWs)(httpServer, {
+                                redeem: (ticket, udid) => __awaiter(this, void 0, void 0, function* () {
+                                    logcatRedeemed.push(`${udid}:${ticket}`);
+                                    return { actorId: 'alice' };
+                                }),
+                                authorize: () => __awaiter(this, void 0, void 0, function* () { return true; }),
+                                startStream: () => __awaiter(this, void 0, void 0, function* () { return ({ mux: logcatMux }); }),
+                            });
+                        },
+                    ],
+                });
+            }
+            finally {
+                forced === null || forced === void 0 ? void 0 : forced.restore();
+            }
+            booted().on('connection', (socket) => {
+                sockets.add(socket);
+                socket.on('close', () => sockets.delete(socket));
+            });
+            // Appium's main adds its BiDi handler right after server() resolves.
+            const bidi = new ws_1.WebSocketServer({ noServer: true });
+            wssNames.set(bidi, 'bidi');
+            bidi.on('connection', (ws, req) => {
+                bidiConnections.push(String(req.url));
+                ws.on('error', () => undefined);
+            });
+            yield booted().addWebSocketHandler('/wd/hub/bidi', bidi);
+            yield booted().addWebSocketHandler('/wd/hub/bidi/:sessionId', bidi);
+            if (socketServer) {
+                const engine = socketServer.io.engine;
+                const handleUpgrade = engine.handleUpgrade;
+                sinon_1.default.stub(engine, 'handleUpgrade').callsFake(function (...args) {
+                    var _a;
+                    taken.push({ by: 'socket.io', url: String((_a = args[0]) === null || _a === void 0 ? void 0 : _a.url) });
+                    return handleUpgrade.apply(this, args);
+                });
+            }
+        });
+    }
+    function createSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, loopbackRequest_1.default)(booted())
+                .post('/wd/hub/session')
+                .send({ capabilities: { alwaysMatch: { platformName: 'Fake' } } })
+                .expect(200);
+        });
+    }
+    function connectSocketIo(transports) {
+        const client = (0, socket_io_client_1.io)(`http://127.0.0.1:${port()}`, {
+            path: '/socket.io',
+            transports,
+            reconnection: false,
+            forceNew: true,
+        });
+        clients.push(client);
+        return client;
+    }
+    // Appium's HTTP logger writes every request to stdout; quiet it here only.
+    let appiumLog;
+    let appiumLogLevel;
+    let authDisabled = false;
+    before(() => {
+        appiumBaseDriver();
+        const support = require.resolve('@appium/support', {
+            paths: [path_1.default.dirname(require.resolve('appium/package.json'))],
+        });
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const log = require(require.resolve('@appium/logger', { paths: [support] })).default;
+        appiumLog = log;
+        appiumLogLevel = log.level;
+        log.level = 'silent';
+        // socket.io's handshake: an auth-disabled hub admits every dashboard.
+        authDisabled = config_1.config.authDisabled;
+        config_1.config.authDisabled = true;
+    });
+    after(() => {
+        if (appiumLog && appiumLogLevel)
+            appiumLog.level = appiumLogLevel;
+        config_1.config.authDisabled = authDisabled;
+    });
+    beforeEach(() => {
+        enabled = false;
+        warnings = [];
+        taken = [];
+        bidiConnections = [];
+        driverConnections = [];
+        h264Redeemed = [];
+        logcatRedeemed = [];
+        sockets = new Set();
+        clients = [];
+        wssNames = new Map();
+        // Record which WebSocket server each upgrade is handed to. The h264 and
+        // logcat servers are created inside attach*Ws, so they are named by the
+        // path they are asked to take.
+        const handleUpgrade = ws_1.WebSocketServer.prototype.handleUpgrade;
+        sinon_1.default.stub(ws_1.WebSocketServer.prototype, 'handleUpgrade').callsFake(function (...args) {
+            var _a, _b;
+            const url = String((_a = args[0]) === null || _a === void 0 ? void 0 : _a.url);
+            const by = (_b = wssNames.get(this)) !== null && _b !== void 0 ? _b : (/\/stream\/h264/.test(url) ? 'h264' : /\/logcat\?/.test(url) ? 'logcat' : 'unknown');
+            taken.push({ by, url });
+            return handleUpgrade.apply(this, args);
+        });
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        for (const c of clients)
+            c.close();
+        sinon_1.default.restore();
+        const s = server;
+        server = undefined;
+        const io = socketServer === null || socketServer === void 0 ? void 0 : socketServer.io;
+        socketServer = undefined;
+        if (!s)
+            return;
+        for (const socket of sockets)
+            socket.destroy();
+        s.closeAllConnections();
+        if (io) {
+            // socket.io's close() also closes the http.Server, and Appium's close()
+            // calls process.exit() when its shutdown timer runs out. Close only
+            // socket.io's own side here.
+            io.httpServer = undefined;
+            yield new Promise((resolve) => io.close(() => resolve()));
+        }
+        // Appium replaces close() with a graceful one that calls process.exit()
+        // if connections outlive its shutdown timeout. Use http.Server's own.
+        yield new Promise((resolve) => http_1.default.Server.prototype.close.call(s, () => resolve()));
+    }));
+    for (const upgrades of ['native', 'listener']) {
+        const how = upgrades === 'listener' || nativelyUsesUpgradeListener()
+            ? 'its upgrade listener (Node >= 22.21 / 24.9)'
+            : 'its Express upgrade middleware (Node < 22.21)';
+        describe(`Appium taking upgrades with ${how} [${upgrades}]`, () => {
+            describe('on a hub (socket.io attached)', () => {
+                beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                    yield boot({ upgrades, role: 'hub' });
+                }));
+                it("hands an H.264 upgrade with a ticket to Xenon's H.264 handler, which streams", () => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a;
+                    const outcome = yield connect(port(), H264_URL);
+                    (0, chai_1.expect)(outcome.kind).to.equal('open');
+                    (0, chai_1.expect)((_a = outcome.firstMessage) === null || _a === void 0 ? void 0 : _a[0], 'the config frame').to.equal(0);
+                    (0, chai_1.expect)(h264Redeemed).to.deep.equal(['DEV-1:t-h264']);
+                    (0, chai_1.expect)(taken).to.deep.equal([{ by: 'h264', url: H264_URL }]);
+                }));
+                it("hands a logcat upgrade with a ticket to Xenon's logcat handler, which streams", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const outcome = yield connect(port(), LOGCAT_URL);
+                    (0, chai_1.expect)(outcome.kind).to.equal('open');
+                    (0, chai_1.expect)(JSON.parse(String(outcome.firstMessage)).message).to.equal('hello');
+                    (0, chai_1.expect)(logcatRedeemed).to.deep.equal(['DEV-1:t-logcat']);
+                    (0, chai_1.expect)(taken).to.deep.equal([{ by: 'logcat', url: LOGCAT_URL }]);
+                }));
+                it('connects socket.io over the websocket transport, with no polling fallback', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const client = connectSocketIo(['websocket']);
+                    yield new Promise((resolve, reject) => {
+                        client.once('connect', () => resolve());
+                        client.once('connect_error', (err) => reject(err));
+                    });
+                    (0, chai_1.expect)(client.io.engine.transport.name).to.equal('websocket');
+                    (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['socket.io']);
+                }));
+                it("upgrades the dashboard's default socket.io client from polling to websocket", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const client = connectSocketIo(['polling', 'websocket']);
+                    yield new Promise((resolve, reject) => {
+                        client.once('connect_error', (err) => reject(err));
+                        client.io.engine.once('upgrade', () => resolve());
+                        setTimeout(() => { var _a, _b; return reject(new Error(`still on ${(_b = (_a = client.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.name}`)); }, HANG_MS);
+                    });
+                    (0, chai_1.expect)(client.io.engine.transport.name).to.equal('websocket');
+                    (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['socket.io']);
+                }));
+                it("hands a BiDi upgrade to Appium's BiDi handler", () => __awaiter(void 0, void 0, void 0, function* () {
+                    (0, chai_1.expect)((yield connect(port(), `/wd/hub/bidi/${LIVE_SESSION}`)).kind).to.equal('open');
+                    (0, chai_1.expect)(bidiConnections).to.deep.equal([`/wd/hub/bidi/${LIVE_SESSION}`]);
+                    (0, chai_1.expect)(taken).to.deep.equal([{ by: 'bidi', url: `/wd/hub/bidi/${LIVE_SESSION}` }]);
+                }));
+                it("hands a driver's session socket, added in createSession, to the driver", () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield createSession();
+                    (0, chai_1.expect)((yield connect(port(), DRIVER_LOGCAT)).kind).to.equal('open');
+                    (0, chai_1.expect)(driverConnections).to.deep.equal([DRIVER_LOGCAT]);
+                    (0, chai_1.expect)(taken).to.deep.equal([{ by: 'driver', url: DRIVER_LOGCAT }]);
+                }));
+                it('gives an unknown session socket to Appium, which closes it at once', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const outcome = yield connect(port(), '/wd/hub/ws/session/x/appium/device/logcat');
+                    (0, chai_1.expect)(outcome.kind).to.equal('closed');
+                    // At once, not after engine.io's 1 s timer for upgrades it doesn't own.
+                    (0, chai_1.expect)(outcome.ms).to.be.below(800);
+                    (0, chai_1.expect)(taken).to.deep.equal([]);
+                }));
+                it('gives exactly one handler each socket, all on one server', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield createSession();
+                    const client = connectSocketIo(['websocket']);
+                    yield new Promise((resolve, reject) => {
+                        client.once('connect', () => resolve());
+                        client.once('connect_error', (err) => reject(err));
+                    });
+                    for (const url of [H264_URL, LOGCAT_URL, `/wd/hub/bidi/${LIVE_SESSION}`, DRIVER_LOGCAT]) {
+                        (0, chai_1.expect)((yield connect(port(), url)).kind, url).to.equal('open');
+                    }
+                    (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal([
+                        'socket.io',
+                        'h264',
+                        'logcat',
+                        'bidi',
+                        'driver',
+                    ]);
+                }));
+                describe('with XENON_REQUIRE_COMMAND_AUTH on', () => {
+                    beforeEach(() => {
+                        enabled = true;
+                    });
+                    it('refuses a BiDi upgrade without credentials with 404, before Appium sees it', () => __awaiter(void 0, void 0, void 0, function* () {
+                        (0, chai_1.expect)(yield connect(port(), `/wd/hub/bidi/${LIVE_SESSION}`)).to.deep.equal({
+                            kind: 'http',
+                            status: 404,
+                        });
+                        (0, chai_1.expect)(taken).to.deep.equal([]);
+                        (0, chai_1.expect)(warnings).to.have.length(1);
+                    }));
+                    it("lets the owner's BiDi and driver sockets through to Appium", () => __awaiter(void 0, void 0, void 0, function* () {
+                        yield createSession();
+                        const alice = { 'x-xenon-access-key': 'ak', 'x-xenon-token': 'alice-token' };
+                        (0, chai_1.expect)((yield connect(port(), `/wd/hub/bidi/${LIVE_SESSION}`, alice)).kind).to.equal('open');
+                        (0, chai_1.expect)((yield connect(port(), DRIVER_LOGCAT, alice)).kind).to.equal('open');
+                        (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['bidi', 'driver']);
+                    }));
+                    it("refuses another user's driver socket with 404", () => __awaiter(void 0, void 0, void 0, function* () {
+                        yield createSession();
+                        const bob = { 'x-xenon-access-key': 'ak', 'x-xenon-token': 'bob-token' };
+                        (0, chai_1.expect)(yield connect(port(), DRIVER_LOGCAT, bob)).to.deep.equal({
+                            kind: 'http',
+                            status: 404,
+                        });
+                        (0, chai_1.expect)(driverConnections).to.deep.equal([]);
+                    }));
+                    it('answers an unknown session socket 404, as for any session the caller does not own', () => __awaiter(void 0, void 0, void 0, function* () {
+                        (0, chai_1.expect)(yield connect(port(), '/wd/hub/ws/session/x/appium/device/logcat')).to.deep.equal({ kind: 'http', status: 404 });
+                    }));
+                    it("leaves Xenon's ticketed sockets and socket.io alone", () => __awaiter(void 0, void 0, void 0, function* () {
+                        (0, chai_1.expect)((yield connect(port(), H264_URL)).kind).to.equal('open');
+                        (0, chai_1.expect)((yield connect(port(), LOGCAT_URL)).kind).to.equal('open');
+                        const client = connectSocketIo(['websocket']);
+                        yield new Promise((resolve, reject) => {
+                            client.once('connect', () => resolve());
+                            client.once('connect_error', (err) => reject(err));
+                        });
+                        (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['h264', 'logcat', 'socket.io']);
+                        (0, chai_1.expect)(warnings).to.deep.equal([]);
+                    }));
+                });
+            });
+            describe('on a node (no socket.io)', () => {
+                beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                    yield boot({ upgrades, role: 'node' });
+                }));
+                it("hands H.264 and logcat upgrades to Xenon's handlers", () => __awaiter(void 0, void 0, void 0, function* () {
+                    (0, chai_1.expect)((yield connect(port(), H264_URL)).kind).to.equal('open');
+                    (0, chai_1.expect)((yield connect(port(), LOGCAT_URL)).kind).to.equal('open');
+                    (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['h264', 'logcat']);
+                }));
+                it("hands BiDi and a driver's session socket to Appium", () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield createSession();
+                    (0, chai_1.expect)((yield connect(port(), `/wd/hub/bidi/${LIVE_SESSION}`)).kind).to.equal('open');
+                    (0, chai_1.expect)((yield connect(port(), DRIVER_LOGCAT)).kind).to.equal('open');
+                    (0, chai_1.expect)(taken.map((t) => t.by)).to.deep.equal(['bidi', 'driver']);
+                }));
+                it('gives an unknown upgrade to Appium, which closes it at once', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const outcome = yield connect(port(), '/nowhere');
+                    (0, chai_1.expect)(outcome.kind).to.equal('closed');
+                    (0, chai_1.expect)(outcome.ms).to.be.below(800);
+                }));
+            });
+        });
+    }
+});