@xenon-device-management/xenon 2.0.0 → 2.1.0

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

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

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

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

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

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