@xenon-device-management/xenon 2.0.0 → 2.1.0

package/lib/test/unit/upgrade-router.spec.js

@@ -0,0 +1,446 @@
+"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 });
+const chai_1 = require("chai");
+const events_1 = require("events");
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const ws_1 = __importStar(require("ws"));
+const upgradeRouter_1 = require("../../src/app/ws/upgradeRouter");
+const h264StreamWs_1 = require("../../src/app/ws/h264StreamWs");
+const H264Multiplexer_1 = require("../../src/device-managers/android/H264Multiplexer");
+const commandCaller_1 = require("../../src/middleware/commandCaller");
+const sessionUpgradeGuard_1 = require("../../src/middleware/sessionUpgradeGuard");
+/**
+ * The upgrade router (src/app/ws/upgradeRouter.ts) on its own: which handler
+ * each upgrade reaches, what it adds to a server, and its copy of Appium's
+ * upgrade listener for Node < 22.21, checked against Appium's own dispatch.
+ * ws-upgrade-routing-appium-server.spec.ts runs it inside Appium's server().
+ */
+/** base-driver's own upgrade dispatch (tryHandleWebSocketUpgrade), from Appium's install. */
+function appiumDispatch() {
+    const appiumDir = path_1.default.dirname(require.resolve('appium/package.json'));
+    const baseDriverDir = path_1.default.dirname(require.resolve('@appium/base-driver/package.json', { paths: [appiumDir] }));
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(path_1.default.join(baseDriverDir, 'build/lib/express/middleware'));
+}
+function silentAppiumLog() {
+    appiumDispatch();
+    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;
+    const level = log.level;
+    log.level = 'silent';
+    return () => {
+        log.level = level;
+    };
+}
+const quiet = () => ({
+    infos: [],
+    warns: [],
+    errors: [],
+    info(m) {
+        this.infos.push(m);
+    },
+    warn(m) {
+        this.warns.push(m);
+    },
+    error(m) {
+        this.errors.push(m);
+    },
+});
+function connect(port, urlPath) {
+    return new Promise((resolve) => {
+        const ws = new ws_1.default(`ws://127.0.0.1:${port}${urlPath}`);
+        ws.on('open', () => {
+            resolve({ kind: 'open' });
+            ws.terminate();
+        });
+        ws.on('unexpected-response', (req, res) => {
+            var _a;
+            resolve({ kind: 'http', status: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0 });
+            req.destroy();
+        });
+        ws.on('error', () => resolve({ kind: 'closed' }));
+    });
+}
+function listen(server) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sockets = new Set();
+        server.on('connection', (s) => {
+            sockets.add(s);
+            s.on('close', () => sockets.delete(s));
+        });
+        yield new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+        return {
+            port: server.address().port,
+            shut: () => __awaiter(this, void 0, void 0, function* () {
+                for (const s of sockets)
+                    s.destroy();
+                server.closeAllConnections();
+                yield new Promise((resolve) => server.close(() => resolve()));
+            }),
+        };
+    });
+}
+describe('upgrade router', () => {
+    describe("its copy of Appium's upgrade dispatch, against Appium's own", () => {
+        let restoreLog;
+        before(() => {
+            restoreLog = silentAppiumLog();
+        });
+        after(() => restoreLog());
+        /** Which handler each dispatch picks, or whether it threw. */
+        function outcome(dispatch, url, upgrade, patterns) {
+            const mapping = {};
+            for (const p of patterns) {
+                mapping[p] = { handleUpgrade: sinon_1.default.stub(), emit: sinon_1.default.stub(), name: p };
+            }
+            const req = { url, headers: upgrade === undefined ? {} : { upgrade } };
+            try {
+                const handled = dispatch(req, mapping);
+                const by = patterns.filter((p) => mapping[p].handleUpgrade.called);
+                return `${handled}:${by.join(',')}`;
+            }
+            catch (error) {
+                return `threw ${error.name}`;
+            }
+        }
+        const PATTERNS = [
+            '/wd/hub/bidi',
+            '/wd/hub/bidi/:sessionId',
+            '/ws/session/abc-123/appium/device/logcat',
+            '/ws/session/abc-123/appium/device/syslog',
+        ];
+        const CASES = [
+            ['/wd/hub/bidi', 'websocket'],
+            ['/wd/hub/bidi/', 'websocket'],
+            ['/wd/hub/bidi/abc-123', 'websocket'],
+            ['/wd/hub/bidi/abc-123/', 'websocket'],
+            ['/WD/HUB/BIDI/abc-123', 'websocket'],
+            ['/wd/hub/bidi/abc-123?x=1', 'websocket'],
+            ['/wd/hub/bidi/abc-123/extra', 'websocket'],
+            ['/wd/hub/bidi//', 'websocket'],
+            ['/wd/hub/./bidi/abc-123', 'websocket'],
+            ['/wd/hub/x/../bidi/abc-123', 'websocket'],
+            ['/wd/hub/%2e%2e/wd/hub/bidi/abc', 'websocket'],
+            ['/wd/hub/bidi/a%20b', 'websocket'],
+            ['/wd/hub/bidi/%E0%A4%A', 'websocket'],
+            ['/wd/hub/bidi/abc-123', 'WebSocket'],
+            ['/wd/hub/bidi/abc-123', 'h2c'],
+            ['/wd/hub/bidi/abc-123', undefined],
+            ['http://example.com/wd/hub/bidi/abc-123', 'websocket'],
+            ['/ws/session/abc-123/appium/device/logcat', 'websocket'],
+            ['/ws/session/ABC-123/appium/device/logcat', 'websocket'],
+            ['/ws/session/abc-123/appium/device/logcat/', 'websocket'],
+            ['/ws/session/abc-123/appium/device/syslog', 'websocket'],
+            ['/ws/session/other/appium/device/logcat', 'websocket'],
+            ['/xenon/api/control/u1/stream/h264?ticket=t', 'websocket'],
+            ['/socket.io/?EIO=4&transport=websocket', 'websocket'],
+            ['', 'websocket'],
+        ];
+        for (const [url, upgrade] of CASES) {
+            it(`picks the same handler for ${JSON.stringify(url)} (Upgrade: ${upgrade})`, () => {
+                const logger = quiet();
+                const theirs = outcome((req, mapping) => appiumDispatch().tryHandleWebSocketUpgrade(req, {}, Buffer.alloc(0), mapping), url, upgrade, PATTERNS);
+                const ours = outcome((req, mapping) => (0, upgradeRouter_1.dispatchToAppiumHandlers)(req, {}, Buffer.alloc(0), mapping, logger), url, upgrade, PATTERNS);
+                (0, chai_1.expect)(ours).to.equal(theirs);
+            });
+        }
+        it('takes the first matching handler, in registration order, as Appium does', () => {
+            const first = { handleUpgrade: sinon_1.default.stub(), emit: sinon_1.default.stub() };
+            const second = { handleUpgrade: sinon_1.default.stub(), emit: sinon_1.default.stub() };
+            const handled = (0, upgradeRouter_1.dispatchToAppiumHandlers)({ url: '/wd/hub/bidi/s1', headers: { upgrade: 'websocket' } }, {}, Buffer.alloc(0), { '/wd/hub/bidi/:id': first, '/wd/hub/bidi/s1': second }, quiet());
+            (0, chai_1.expect)(handled).to.equal(true);
+            (0, chai_1.expect)(first.handleUpgrade.calledOnce).to.equal(true);
+            (0, chai_1.expect)(second.handleUpgrade.called).to.equal(false);
+        });
+        it('emits connection on the handler, with the request, as Appium does', () => {
+            const ws = {};
+            const wss = {
+                handleUpgrade: sinon_1.default.stub().callsFake((_r, _s, _h, cb) => cb(ws)),
+                emit: sinon_1.default.stub(),
+            };
+            const req = { url: '/wd/hub/bidi', headers: { upgrade: 'websocket' } };
+            (0, upgradeRouter_1.dispatchToAppiumHandlers)(req, {}, Buffer.alloc(0), { '/wd/hub/bidi': wss }, quiet());
+            (0, chai_1.expect)(wss.emit.calledOnceWithExactly('connection', ws, req)).to.equal(true);
+        });
+        it('skips a pattern in syntax it does not speak, and says so once', () => {
+            (0, chai_1.expect)((0, upgradeRouter_1.appiumPatternMatcher)('/ws/{:optional}')).to.equal(null);
+            (0, chai_1.expect)((0, upgradeRouter_1.appiumPatternMatcher)('/ws/*rest')).to.equal(null);
+            const logger = quiet();
+            const wss = { handleUpgrade: sinon_1.default.stub(), emit: sinon_1.default.stub() };
+            for (let i = 0; i < 2; i++) {
+                (0, upgradeRouter_1.dispatchToAppiumHandlers)({ url: '/ws/x', headers: { upgrade: 'websocket' } }, {}, Buffer.alloc(0), { '/ws/*rest': wss }, logger);
+            }
+            (0, chai_1.expect)(wss.handleUpgrade.called).to.equal(false);
+            (0, chai_1.expect)(logger.warns).to.have.length(1);
+        });
+        it('matches literal text literally, regex characters included', () => {
+            const matches = (0, upgradeRouter_1.appiumPatternMatcher)('/base.path/bidi/:id');
+            (0, chai_1.expect)(matches === null || matches === void 0 ? void 0 : matches('/base.path/bidi/s1')).to.equal(true);
+            (0, chai_1.expect)(matches === null || matches === void 0 ? void 0 : matches('/basexpath/bidi/s1')).to.equal(false);
+        });
+    });
+    describe('what it adds to a server', () => {
+        function fakeServer(opts) {
+            const server = new events_1.EventEmitter();
+            if (opts.callback)
+                server.shouldUpgradeCallback = () => true;
+            for (let i = 0; i < opts.listeners; i++)
+                server.on('upgrade', () => undefined);
+            return server;
+        }
+        it('adds nothing when Appium already listens (Node >= 22.21 / 24.9)', () => {
+            const server = fakeServer({ callback: true, listeners: 1 });
+            const router = new upgradeRouter_1.UpgradeRouter(server, quiet());
+            (0, chai_1.expect)(router.appiumPath).to.equal('appium-listener');
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(1);
+        });
+        it("adds Appium's listener when this Node has no shouldUpgradeCallback (Node < 22.21)", () => {
+            const server = fakeServer({ callback: false, listeners: 0 });
+            const router = new upgradeRouter_1.UpgradeRouter(server, quiet());
+            (0, chai_1.expect)(router.appiumPath).to.equal('router-listener');
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(1);
+        });
+        it('adds it on Node < 22.21 even when another listener is already there', () => {
+            // Node hands no upgrade to Appium's Express middleware once any listener exists.
+            const server = fakeServer({ callback: false, listeners: 1 });
+            (0, chai_1.expect)(new upgradeRouter_1.UpgradeRouter(server, quiet()).appiumPath).to.equal('router-listener');
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(2);
+        });
+        it('adds a listener to a server with none, or no Node would emit upgrade at all', () => {
+            const server = fakeServer({ callback: true, listeners: 0 });
+            (0, chai_1.expect)(new upgradeRouter_1.UpgradeRouter(server, quiet()).appiumPath).to.equal('router-listener');
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(1);
+        });
+        it('installs once per server', () => {
+            const server = http_1.default.createServer();
+            const router = (0, upgradeRouter_1.upgradeRouterFor)(server);
+            const emit = server.emit;
+            const listeners = server.listenerCount('upgrade');
+            (0, chai_1.expect)((0, upgradeRouter_1.upgradeRouterFor)(server)).to.equal(router);
+            (0, chai_1.expect)(server.emit).to.equal(emit);
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(listeners);
+        });
+        it('leaves every other event alone', () => {
+            const server = fakeServer({ callback: true, listeners: 1 });
+            new upgradeRouter_1.UpgradeRouter(server, quiet());
+            const seen = [];
+            server.on('request', (a) => seen.push(a));
+            (0, chai_1.expect)(server.emit('request', 'r')).to.equal(true);
+            (0, chai_1.expect)(seen).to.deep.equal(['r']);
+        });
+    });
+    describe('on a real server', () => {
+        let shut;
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.restore();
+            yield (shut === null || shut === void 0 ? void 0 : shut());
+            shut = undefined;
+        }));
+        /** A server shaped like Appium's on Node >= 22.21: its listener, destroying what it can't place. */
+        function appiumLikeServer(mapping) {
+            const server = http_1.default.createServer();
+            if (typeof server.shouldUpgradeCallback === 'undefined')
+                server.shouldUpgradeCallback = () => true;
+            server.webSocketsMapping = mapping;
+            const appiumSaw = [];
+            server.on('upgrade', (req, socket, head) => {
+                appiumSaw.push(String(req.url));
+                if (!(0, upgradeRouter_1.dispatchToAppiumHandlers)(req, socket, head, server.webSocketsMapping, quiet())) {
+                    socket.destroy();
+                }
+            });
+            return { server: server, appiumSaw };
+        }
+        it("gives a route's upgrades to the route alone, and every other upgrade to the listeners", () => __awaiter(void 0, void 0, void 0, function* () {
+            const bidi = new ws_1.WebSocketServer({ noServer: true });
+            const { server, appiumSaw } = appiumLikeServer({ '/bidi/:id': bidi });
+            const xenon = new ws_1.WebSocketServer({ noServer: true });
+            const routed = [];
+            (0, upgradeRouter_1.upgradeRouterFor)(server).add({
+                name: 'test',
+                matches: (req) => String(req.url).startsWith('/xenon/'),
+                handle: (req, socket, head) => {
+                    routed.push(String(req.url));
+                    xenon.handleUpgrade(req, socket, head, () => undefined);
+                },
+            });
+            const listening = yield listen(server);
+            shut = listening.shut;
+            (0, chai_1.expect)(yield connect(listening.port, '/xenon/x')).to.deep.equal({ kind: 'open' });
+            (0, chai_1.expect)(yield connect(listening.port, '/bidi/s1')).to.deep.equal({ kind: 'open' });
+            (0, chai_1.expect)(routed).to.deep.equal(['/xenon/x']);
+            (0, chai_1.expect)(appiumSaw).to.deep.equal(['/bidi/s1']);
+        }));
+        it('adopts the upgrade listener an attach adds, and calls it only for its own path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { server, appiumSaw } = appiumLikeServer({});
+            const adoptedSaw = [];
+            const wss = new ws_1.WebSocketServer({ noServer: true });
+            const result = (0, upgradeRouter_1.upgradeRouterFor)(server).adopt('adopted', (req) => String(req.url).startsWith('/mine/'), () => {
+                server.on('upgrade', (req, socket, head) => {
+                    adoptedSaw.push(String(req.url));
+                    // Like engine.io: anything not its own is ended.
+                    if (!String(req.url).startsWith('/mine/'))
+                        return socket.end();
+                    wss.handleUpgrade(req, socket, head, () => undefined);
+                });
+                return 'attached';
+            });
+            (0, chai_1.expect)(result).to.equal('attached');
+            (0, chai_1.expect)(server.listenerCount('upgrade')).to.equal(1); // Appium's, not the adopted one
+            const listening = yield listen(server);
+            shut = listening.shut;
+            (0, chai_1.expect)(yield connect(listening.port, '/mine/x')).to.deep.equal({ kind: 'open' });
+            (0, chai_1.expect)(yield connect(listening.port, '/other')).to.deep.equal({ kind: 'closed' });
+            (0, chai_1.expect)(adoptedSaw).to.deep.equal(['/mine/x']);
+            (0, chai_1.expect)(appiumSaw).to.deep.equal(['/other']);
+        }));
+        it('adds no route when the attach adds no listener', () => {
+            const { server } = appiumLikeServer({});
+            const router = (0, upgradeRouter_1.upgradeRouterFor)(server);
+            router.adopt('nothing', () => true, () => undefined);
+            (0, chai_1.expect)(router.routeFor({ url: '/anything' })).to.equal(undefined);
+        });
+        it("closes the socket and keeps the process up when a route's handler throws", () => __awaiter(void 0, void 0, void 0, function* () {
+            const { server } = appiumLikeServer({});
+            const router = (0, upgradeRouter_1.upgradeRouterFor)(server);
+            const errors = sinon_1.default.stub(router.logger, 'error');
+            router.add({
+                name: 'broken',
+                matches: () => true,
+                handle: () => {
+                    throw new Error('boom');
+                },
+            });
+            const listening = yield listen(server);
+            shut = listening.shut;
+            (0, chai_1.expect)(yield connect(listening.port, '/x')).to.deep.equal({ kind: 'closed' });
+            (0, chai_1.expect)(errors.calledOnce).to.equal(true);
+            (0, chai_1.expect)(String(errors.firstCall.args[0])).to.match(/broken.*boom/);
+        }));
+        it('closes the socket and keeps the process up on a malformed udid in a Xenon path', () => __awaiter(void 0, void 0, void 0, function* () {
+            // parseH264WsPath decodes the udid, and decodeURIComponent throws on a
+            // malformed escape. Out of a plain `upgrade` listener that ended the process.
+            const { server } = appiumLikeServer({});
+            const redeem = sinon_1.default.stub().resolves({ actorId: 'a' });
+            (0, h264StreamWs_1.attachH264Ws)(server, { redeem, startStream: () => __awaiter(void 0, void 0, void 0, function* () { return new H264Multiplexer_1.H264Multiplexer(); }) });
+            sinon_1.default.stub((0, upgradeRouter_1.upgradeRouterFor)(server).logger, 'error');
+            const listening = yield listen(server);
+            shut = listening.shut;
+            (0, chai_1.expect)(yield connect(listening.port, '/xenon/api/control/%E0%A4%A/stream/h264?ticket=t')).to.deep.equal({ kind: 'closed' });
+            (0, chai_1.expect)(yield connect(listening.port, '/xenon/api/control/ok/stream/h264?ticket=t')).to.deep.equal({ kind: 'open' });
+            (0, chai_1.expect)(redeem.callCount).to.equal(1);
+        }));
+        it("closes the socket and keeps the process up when Appium's own dispatch throws", () => __awaiter(void 0, void 0, void 0, function* () {
+            // path-to-regexp decodes a matched parameter; a malformed escape throws
+            // out of Appium's listener on Node >= 22.21.
+            const restoreLog = silentAppiumLog();
+            try {
+                const server = http_1.default.createServer();
+                if (typeof server.shouldUpgradeCallback === 'undefined')
+                    server.shouldUpgradeCallback = () => true;
+                const mapping = { '/bidi/:id': new ws_1.WebSocketServer({ noServer: true }) };
+                server.on('upgrade', (req, socket, head) => {
+                    if (!appiumDispatch().tryHandleWebSocketUpgrade(req, socket, head, mapping))
+                        socket.destroy();
+                });
+                sinon_1.default.stub((0, upgradeRouter_1.upgradeRouterFor)(server).logger, 'error');
+                const listening = yield listen(server);
+                shut = listening.shut;
+                (0, chai_1.expect)(yield connect(listening.port, '/bidi/%E0%A4%A')).to.deep.equal({ kind: 'closed' });
+                (0, chai_1.expect)(yield connect(listening.port, '/bidi/s1')).to.deep.equal({ kind: 'open' });
+            }
+            finally {
+                restoreLog();
+            }
+        }));
+        for (const order of ['guard first', 'router first']) {
+            it(`keeps the session guard in front of Appium, and out of Xenon's way (${order})`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const bidi = new ws_1.WebSocketServer({ noServer: true });
+                const { server, appiumSaw } = appiumLikeServer({ '/bidi/:id': bidi });
+                const ownerOf = sinon_1.default.stub().resolves('alice');
+                const guard = (0, sessionUpgradeGuard_1.createSessionUpgradeGuard)('', {
+                    enabled: () => true,
+                    authDisabled: () => false,
+                    verifier: new commandCaller_1.CommandCallerVerifier({
+                        verifyKeyPair: sinon_1.default.stub().resolves(null),
+                        verifyBearer: sinon_1.default.stub().resolves(null),
+                    }),
+                    ownerOf,
+                    ownersOf: () => __awaiter(void 0, void 0, void 0, function* () { return new Map(); }),
+                    logger: { info: () => undefined, warn: () => undefined, error: () => undefined },
+                });
+                const route = {
+                    name: 'xenon',
+                    matches: (req) => String(req.url).startsWith('/xenon/'),
+                    handle: (req, socket, head) => new ws_1.WebSocketServer({ noServer: true }).handleUpgrade(req, socket, head, () => undefined),
+                };
+                if (order === 'guard first') {
+                    (0, sessionUpgradeGuard_1.guardUpgradeEvents)(server, guard);
+                    (0, upgradeRouter_1.upgradeRouterFor)(server).add(route);
+                }
+                else {
+                    (0, upgradeRouter_1.upgradeRouterFor)(server).add(route);
+                    (0, sessionUpgradeGuard_1.guardUpgradeEvents)(server, guard);
+                }
+                const listening = yield listen(server);
+                shut = listening.shut;
+                (0, chai_1.expect)(yield connect(listening.port, '/bidi/s1')).to.deep.equal({
+                    kind: 'http',
+                    status: 404,
+                });
+                (0, chai_1.expect)(yield connect(listening.port, '/xenon/x')).to.deep.equal({ kind: 'open' });
+                (0, chai_1.expect)(appiumSaw).to.deep.equal([]);
+            }));
+        }
+    });
+});

package/lib/test/unit/users-router.test.js

@@ -16,7 +16,7 @@ require("reflect-metadata");
 const chai_1 = require("chai");
 const sinon_1 = __importDefault(require("sinon"));
 const express_1 = __importDefault(require("express"));
-const supertest_1 = __importDefault(require("supertest"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
 const users_1 = require("../../src/app/routers/users");
 const typedi_1 = require("typedi");
 const UserService_1 = require("../../src/services/UserService");
@@ -36,7 +36,7 @@ describe('/users router', () => {
     it('GET /users returns the listUsers result, filtered by caller role', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(typedi_1.Container.get(UserService_1.UserService), 'listUsers').resolves([{ id: 'u1' }]);
         const app = appWithAuth({ userId: 'admin', role: 'ADMIN' });
-        const r = yield (0, supertest_1.default)(app).get('/users');
+        const r = yield (0, loopbackRequest_1.default)(app).get('/users');
         (0, chai_1.expect)(r.status).to.equal(200);
         (0, chai_1.expect)(r.body[0].id).to.equal('u1');
     }));
@@ -50,23 +50,26 @@ describe('/users router', () => {
             accessKey: 'xen_NEW0000NEW00',
         });
         const app = appWithAuth({ userId: 'admin', role: 'ADMIN' });
-        const r = yield (0, supertest_1.default)(app)
+        const r = yield (0, loopbackRequest_1.default)(app)
             .post('/users')
             .send({ email: 'new@x.local', name: 'New', role: 'MEMBER' });
         (0, chai_1.expect)(r.status).to.equal(201);
         (0, chai_1.expect)(r.body.id).to.equal('new-user');
         (0, chai_1.expect)(r.body.temporaryPassword).to.match(/^[A-Za-z0-9_-]{12,}$/);
+        // The admin hands the new user their key; the logger's redaction of
+        // accessKey must not reach a response.
+        (0, chai_1.expect)(r.body.accessKey).to.equal('xen_NEW0000NEW00');
     }));
     it('POST /users — ADMIN cannot create an ADMIN', () => __awaiter(void 0, void 0, void 0, function* () {
         const app = appWithAuth({ userId: 'admin', role: 'ADMIN' });
-        const r = yield (0, supertest_1.default)(app)
+        const r = yield (0, loopbackRequest_1.default)(app)
             .post('/users')
             .send({ email: 'wannabe@x.local', name: 'Wannabe', role: 'ADMIN' });
         (0, chai_1.expect)(r.status).to.equal(403);
     }));
     it('PATCH /users/:id — refuses self role-change', () => __awaiter(void 0, void 0, void 0, function* () {
         const app = appWithAuth({ userId: 'me', role: 'SUPER_ADMIN' });
-        const r = yield (0, supertest_1.default)(app).patch('/users/me').send({ role: 'MEMBER' });
+        const r = yield (0, loopbackRequest_1.default)(app).patch('/users/me').send({ role: 'MEMBER' });
         (0, chai_1.expect)(r.status).to.equal(400);
         (0, chai_1.expect)(r.body.error).to.match(/role-change yourself/);
     }));
@@ -80,7 +83,7 @@ describe('/users router', () => {
             status: 'ACTIVE',
         });
         const app = appWithAuth({ userId: 'admin', role: 'ADMIN' });
-        const r = yield (0, supertest_1.default)(app).patch('/users/t1').send({ email: 'evil@x.local', name: 'NewName' });
+        const r = yield (0, loopbackRequest_1.default)(app).patch('/users/t1').send({ email: 'evil@x.local', name: 'NewName' });
         (0, chai_1.expect)(r.status).to.equal(200);
         const passedPatch = update.firstCall.args[1];
         (0, chai_1.expect)(passedPatch).to.not.have.property('email');
@@ -88,7 +91,7 @@ describe('/users router', () => {
     }));
     it('DELETE /users/:id — refuses self-delete', () => __awaiter(void 0, void 0, void 0, function* () {
         const app = appWithAuth({ userId: 'me', role: 'SUPER_ADMIN' });
-        const r = yield (0, supertest_1.default)(app).delete('/users/me');
+        const r = yield (0, loopbackRequest_1.default)(app).delete('/users/me');
         (0, chai_1.expect)(r.status).to.equal(400);
         (0, chai_1.expect)(r.body.error).to.match(/delete yourself/);
     }));
@@ -98,7 +101,7 @@ describe('/users router', () => {
             .resolves({ id: 'last-sa', role: 'SUPER_ADMIN' });
         sinon_1.default.stub(prisma_1.prisma.user, 'count').resolves(0);
         const app = appWithAuth({ userId: 'me', role: 'SUPER_ADMIN' });
-        const r = yield (0, supertest_1.default)(app).delete('/users/last-sa');
+        const r = yield (0, loopbackRequest_1.default)(app).delete('/users/last-sa');
         (0, chai_1.expect)(r.status).to.equal(400);
         (0, chai_1.expect)(r.body.error).to.match(/last active super-admin/);
     }));

package/lib/test/unit/verify-credential.spec.js

@@ -23,6 +23,7 @@ const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
 const UserService_1 = require("../../src/services/UserService");
 const ApiKeyService_1 = require("../../src/services/ApiKeyService");
 const verifyCredential_1 = require("../../src/middleware/verifyCredential");
+const container_registration_1 = require("../helpers/container-registration");
 /**
  * The credential checks authMiddleware applies to the header pair and to a
  * Bearer JWT, pulled out so the WebDriver per-command check verifies exactly
@@ -36,7 +37,9 @@ describe('verifyCredential', () => {
     let dir;
     let keys;
     const active = { id: 'u1', role: 'MEMBER', status: 'ACTIVE' };
+    let restoreContainer;
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        restoreContainer = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, UserService_1.UserService, ApiKeyService_1.ApiKeyService);
         dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-verify-cred-'));
         keys = new JwtKeyService_1.JwtKeyService();
         yield keys.init(dir);
@@ -46,7 +49,7 @@ describe('verifyCredential', () => {
     }));
     afterEach(() => {
         sinon_1.default.restore();
-        typedi_1.Container.reset();
+        restoreContainer();
         fs_1.default.rmSync(dir, { recursive: true, force: true });
     });
     describe('verifyBearerCredential', () => {

package/lib/test/unit/webdriver-info-route.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const config_1 = require("../../src/config");
+const index_1 = require("../../src/app/index");
+const PluginContext_1 = require("../../src/PluginContext");
+/**
+ * GET /xenon/api/webdriver: where this server's WebDriver API lives. A hub
+ * asks a node before sending it a session or a command, because a phone's
+ * `host` names only the node's origin and the two need not share a base path.
+ * The hub holds no credentials for the node, so the answer needs no login;
+ * the base path is part of every client's URL anyway.
+ *
+ * Driven through the real /xenon/api stack (createRouter + authMiddleware).
+ */
+describe('GET /xenon/api/webdriver', () => {
+    let app;
+    let savedAuthDisabled;
+    let savedBasePath;
+    before(() => {
+        app = (0, express_1.default)();
+        app.use('/xenon', (0, index_1.createRouter)({ bindHostOrIp: '127.0.0.1', enableDashboard: false }));
+    });
+    beforeEach(() => {
+        savedAuthDisabled = config_1.config.authDisabled;
+        config_1.config.authDisabled = false;
+        savedBasePath = typedi_1.Container.get(PluginContext_1.PluginContext).nodeBasePath;
+    });
+    afterEach(() => {
+        config_1.config.authDisabled = savedAuthDisabled;
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeBasePath = savedBasePath;
+    });
+    it("answers this server's base path, normalised as Appium does, without a login", () => __awaiter(void 0, void 0, void 0, function* () {
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeBasePath = 'wd/hub/';
+        const res = yield (0, loopbackRequest_1.default)(app).get('/xenon/api/webdriver');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.body).to.deep.equal({ basePath: '/wd/hub' });
+    }));
+    it("answers Appium 3's default, no base path, as an empty one", () => __awaiter(void 0, void 0, void 0, function* () {
+        typedi_1.Container.get(PluginContext_1.PluginContext).nodeBasePath = '';
+        const res = yield (0, loopbackRequest_1.default)(app).get('/xenon/api/webdriver');
+        (0, chai_1.expect)(res.body).to.deep.equal({ basePath: '' });
+    }));
+    it('while the rest of /xenon/api still needs one', () => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield (0, loopbackRequest_1.default)(app).get('/xenon/api/cliArgs');
+        (0, chai_1.expect)(res.status).to.equal(401);
+    }));
+});