@xenon-device-management/xenon 2.0.0 → 2.1.0

package/lib/test/unit/session-create-layer.spec.js

@@ -0,0 +1,255 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const express_1 = __importDefault(require("express"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const base_driver_1 = require("@appium/base-driver");
+const sessionCreate_1 = require("../../src/gateway/sessionCreate");
+const createHandoff_1 = require("../../src/gateway/createHandoff");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+/**
+ * `POST <basePath>/session` in the session gateway: allocation happens here,
+ * before Appium's route. A remote phone's session is created on its node and
+ * answered here; a local phone's allocation goes on to the plugin through the
+ * request's async context, and is given back if nothing takes it.
+ *
+ * Appium's route is stood in for by a plain route, and the plugin by a
+ * function that takes the handoff, the way XenonPlugin.createSession does.
+ */
+describe('the session gateway’s create layer', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+    let lifecycle;
+    let routeHits;
+    let pluginTakes;
+    let base;
+    const grant = { userId: 'alice', udid: 'phone-1', host: 'http://node:4725' };
+    const caps = () => ({
+        capabilities: { alwaysMatch: { platformName: 'Android' }, firstMatch: [{}] },
+    });
+    beforeEach(() => {
+        routeHits = [];
+        pluginTakes = true;
+        lifecycle = {
+            prepareSession: sinon_1.default.stub().resolves({ remote: false, device: { udid: 'phone-1' } }),
+            completeRemoteSession: sinon_1.default
+                .stub()
+                .resolves({ protocol: 'W3C', value: ['node-s1', { platformName: 'Android' }, 'W3C'] }),
+            releaseAllocation: sinon_1.default.stub().resolves(),
+        };
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        yield loopback.closeAll();
+    }));
+    function serve() {
+        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            var _a;
+            const basePath = (_a = opts.basePath) !== null && _a !== void 0 ? _a : '/wd/hub';
+            const app = (0, express_1.default)();
+            app.use(express_1.default.json());
+            app.use(`${basePath}/session`, (0, sessionCreate_1.createSessionCreateLayer)({
+                lifecycle: () => lifecycle,
+                hubGrants: opts.hubGrants,
+                authDisabled: () => !!opts.authDisabled,
+                logger: quiet,
+            }));
+            if (opts.beforeRoute)
+                app.use(opts.beforeRoute);
+            // Appium's route, with the plugin inside it.
+            app.post(`${basePath}/session`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const hit = { headers: Object.assign({}, req.headers), body: req.body };
+                routeHits.push(hit);
+                yield new Promise((resolve) => setTimeout(resolve, 1));
+                if (pluginTakes)
+                    hit.took = (_a = (0, createHandoff_1.currentCreateHandoff)()) === null || _a === void 0 ? void 0 : _a.take();
+                res.json({ value: { sessionId: 'local-s1', capabilities: {} } });
+            }));
+            app.all('*', (_req, res) => res.status(404).json({ value: { error: 'unknown command' } }));
+            const server = yield loopback.serve(app);
+            base = `http://127.0.0.1:${server.address().port}`;
+            return base;
+        });
+    }
+    describe('what it handles', () => {
+        it('only a POST of exactly the create path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base).get('/wd/hub/session').expect(404);
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session/abc/url').send({}).expect(404);
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/sessionx').send(caps()).expect(404);
+            (0, chai_1.expect)(lifecycle.prepareSession.called).to.equal(false);
+        }));
+        it('a body without a capabilities object goes straight on, for Appium to answer', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send({ desiredCapabilities: {} }).expect(200);
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send({ capabilities: 'no' }).expect(200);
+            (0, chai_1.expect)(lifecycle.prepareSession.called).to.equal(false);
+        }));
+        it('matches the path as the router does: letter case, a trailing slash, any base path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve({ basePath: '' });
+            yield (0, loopbackRequest_1.default)(base).post('/SESSION/').send(caps()).expect(200);
+            (0, chai_1.expect)(lifecycle.prepareSession.calledOnce).to.equal(true);
+        }));
+        it('fills in an omitted firstMatch, as the plugin used to', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .send({ capabilities: { alwaysMatch: { platformName: 'Android' } } })
+                .expect(200);
+            (0, chai_1.expect)(lifecycle.prepareSession.firstCall.args[0].firstMatch).to.deep.equal([{}]);
+            (0, chai_1.expect)(routeHits[0].body.capabilities.firstMatch).to.deep.equal([{}]);
+        }));
+    });
+    describe('a remote phone', () => {
+        beforeEach(() => lifecycle.prepareSession.resolves({ remote: true }));
+        it('is created on its node and answered here, as Appium answers a new session', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            const res = yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps());
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.headers['content-type']).to.equal('application/json; charset=utf-8');
+            (0, chai_1.expect)(res.body).to.deep.equal({
+                value: { capabilities: { platformName: 'Android' }, sessionId: 'node-s1' },
+            });
+            (0, chai_1.expect)(routeHits, 'Appium’s route').to.deep.equal([]);
+            (0, chai_1.expect)(lifecycle.completeRemoteSession.calledOnce).to.equal(true);
+        }));
+        it('a failure is answered as Appium answers the error', () => __awaiter(void 0, void 0, void 0, function* () {
+            lifecycle.completeRemoteSession.rejects(new base_driver_1.errors.SessionNotCreatedError('node said no'));
+            yield serve();
+            const res = yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps());
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body.value.error).to.equal('session not created');
+            (0, chai_1.expect)(res.body.value.message).to.include('node said no');
+            (0, chai_1.expect)(routeHits).to.deep.equal([]);
+        }));
+    });
+    describe('a refusal before any phone is allocated', () => {
+        it('is answered as Appium answers the error, and Appium never sees the request', () => __awaiter(void 0, void 0, void 0, function* () {
+            lifecycle.prepareSession.rejects(new base_driver_1.errors.InvalidArgumentError('session rejected: no'));
+            yield serve();
+            const res = yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps());
+            (0, chai_1.expect)(res.status).to.equal(400);
+            (0, chai_1.expect)(res.body.value).to.include({ error: 'invalid argument' });
+            (0, chai_1.expect)(res.body.value.message).to.include('session rejected: no');
+            (0, chai_1.expect)(routeHits).to.deep.equal([]);
+        }));
+        it('a plain error is an unknown error', () => __awaiter(void 0, void 0, void 0, function* () {
+            lifecycle.prepareSession.rejects(new Error('No device matching request.'));
+            yield serve();
+            const res = yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps());
+            (0, chai_1.expect)(res.status).to.equal(500);
+            (0, chai_1.expect)(res.body.value.error).to.equal('unknown error');
+        }));
+    });
+    describe('a local phone', () => {
+        it('its allocation reaches the plugin through Appium’s route, and is not given back', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps()).expect(200);
+            (0, chai_1.expect)(routeHits[0].took).to.deep.equal({ remote: false, device: { udid: 'phone-1' } });
+            (0, chai_1.expect)(lifecycle.prepareSession.calledOnce).to.equal(true);
+            (0, chai_1.expect)(lifecycle.releaseAllocation.called).to.equal(false);
+        }));
+        it('is given back once when Appium answers without the plugin taking it', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginTakes = false;
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps()).expect(200);
+            yield new Promise((resolve) => setImmediate(resolve));
+            (0, chai_1.expect)(lifecycle.releaseAllocation.callCount).to.equal(1);
+            (0, chai_1.expect)(lifecycle.releaseAllocation.firstCall.args[0].device.udid).to.equal('phone-1');
+        }));
+        it('is given back, and Appium never called, when the client left while it waited', () => __awaiter(void 0, void 0, void 0, function* () {
+            let allocated;
+            lifecycle.prepareSession.callsFake(() => new Promise((resolve) => {
+                allocated = () => resolve({ remote: false, device: { udid: 'phone-1' } });
+            }));
+            yield serve();
+            const req = (0, loopbackRequest_1.default)(base).post('/wd/hub/session').send(caps()).timeout(50);
+            yield req.then(() => undefined, () => undefined);
+            // The server sees the connection close, then the phone turns up.
+            yield new Promise((resolve) => setTimeout(resolve, 20));
+            allocated();
+            yield new Promise((resolve) => setTimeout(resolve, 20));
+            (0, chai_1.expect)(lifecycle.releaseAllocation.callCount).to.equal(1);
+            (0, chai_1.expect)(routeHits).to.deep.equal([]);
+        }));
+    });
+    describe('on a node: the hub’s token', () => {
+        it('a valid one is the grant the node allocates by; the header goes no further', () => __awaiter(void 0, void 0, void 0, function* () {
+            const verifyCreate = sinon_1.default.stub().resolves(grant);
+            yield serve({ hubGrants: { verifyCreate } });
+            yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'good-token')
+                .send(caps())
+                .expect(200);
+            (0, chai_1.expect)(verifyCreate.calledOnceWith('good-token')).to.equal(true);
+            (0, chai_1.expect)(lifecycle.prepareSession.firstCall.args[1]).to.deep.equal({ hubGrant: grant });
+            (0, chai_1.expect)(routeHits[0].headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+        }));
+        it('an invalid one is refused, and nothing is allocated', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve({ hubGrants: { verifyCreate: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) } });
+            const res = yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'forged')
+                .send(caps());
+            (0, chai_1.expect)(res.status).to.equal(400);
+            (0, chai_1.expect)(res.body.value.error).to.equal('invalid argument');
+            (0, chai_1.expect)(res.body.value.message).to.include('session rejected');
+            (0, chai_1.expect)(lifecycle.prepareSession.called).to.equal(false);
+            (0, chai_1.expect)(routeHits).to.deep.equal([]);
+        }));
+        it('one that cannot be checked is a 503, and nothing is allocated', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve({
+                hubGrants: {
+                    verifyCreate: () => __awaiter(void 0, void 0, void 0, function* () {
+                        throw new hubSessionToken_1.HubTokenUnavailableError('hub down');
+                    }),
+                },
+            });
+            const res = yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'token')
+                .send(caps());
+            (0, chai_1.expect)(res.status).to.equal(503);
+            (0, chai_1.expect)(res.body.value.error).to.equal('unknown error');
+            (0, chai_1.expect)(lifecycle.prepareSession.called).to.equal(false);
+        }));
+        it('with auth disabled it is not checked, only removed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const verifyCreate = sinon_1.default.stub().resolves(null);
+            yield serve({ hubGrants: { verifyCreate }, authDisabled: true });
+            yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'anything')
+                .send(caps())
+                .expect(200);
+            (0, chai_1.expect)(verifyCreate.called).to.equal(false);
+            (0, chai_1.expect)(lifecycle.prepareSession.firstCall.args[1]).to.deep.equal({});
+            (0, chai_1.expect)(routeHits[0].headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+        }));
+        it('a hub, which checks no hub tokens, ignores and removes one', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield serve();
+            yield (0, loopbackRequest_1.default)(base)
+                .post('/wd/hub/session')
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'anything')
+                .send(caps())
+                .expect(200);
+            (0, chai_1.expect)(lifecycle.prepareSession.firstCall.args[1]).to.deep.equal({});
+            (0, chai_1.expect)(routeHits[0].headers[hubSessionToken_1.HUB_TOKEN_HEADER]).to.equal(undefined);
+        }));
+    });
+});

package/lib/test/unit/session-credential-strip.spec.js

@@ -54,12 +54,15 @@ const PluginContext_1 = require("../../src/PluginContext");
 const ApiKeyService_1 = require("../../src/services/ApiKeyService");
 const UserService_1 = require("../../src/services/UserService");
 const JwtKeyService_1 = require("../../src/services/token/JwtKeyService");
+const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
 const pendingSessions = __importStar(require("../../src/data-service/pending-sessions-service"));
 const deviceService = __importStar(require("../../src/data-service/device-service"));
 const deviceUtils = __importStar(require("../../src/device-utils"));
 const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
 const config_1 = require("../../src/config");
+const prisma_1 = require("../../src/prisma");
 const container_registration_1 = require("../helpers/container-registration");
+const loki_stores_1 = require("../helpers/loki-stores");
 /**
  * createSession end to end: the credentials a session presents in
  * `xe:options` (or its alias `xenon:options`) are read once, then taken out of
@@ -85,6 +88,10 @@ const caps = (always, firstMatch = [{}]) => ({
 });
 const leaked = (value) => SECRETS.filter((s) => JSON.stringify(value !== null && value !== void 0 ? value : null).includes(s));
 describe('createSession — credentials never reach the driver or storage', () => {
+    // The in-memory stores, also when this file runs on its own: without
+    // NODE_ENV=test the factory handed out the Prisma stores, which are the
+    // developer's ~/.cache/xenon/xenon.db.
+    (0, loki_stores_1.useLokiStores)();
     let svc;
     let device;
     let context;
@@ -125,7 +132,7 @@ describe('createSession — credentials never reach the driver or storage', () =
         context.pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, { bindHostOrIp: '127.0.0.1' });
         context.nodeId = 'node-hub';
         device = { udid: 'u1', host: 'h1', platform: 'android', nodeId: 'node-hub', teamId: null };
-        restore = (0, container_registration_1.saveRegistrations)(ApiKeyService_1.ApiKeyService, UserService_1.UserService, JwtKeyService_1.JwtKeyService);
+        restore = (0, container_registration_1.saveRegistrations)(ApiKeyService_1.ApiKeyService, UserService_1.UserService, JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer);
         typedi_1.Container.set(ApiKeyService_1.ApiKeyService, {
             verifyPair: sinon_1.default
                 .stub()
@@ -142,6 +149,8 @@ describe('createSession — credentials never reach the driver or storage', () =
                 return { sub: t.slice('jwt:'.length), teamId: null };
             }),
         });
+        // The owner's teams: none, and not read from the developer's database.
+        sinon_1.default.stub(prisma_1.prisma.teamMember, 'findMany').resolves([]);
         seen = {};
         sinon_1.default.stub(pendingSessions, 'addNewPendingSession').callsFake((c) => __awaiter(void 0, void 0, void 0, function* () {
             seen.pending = JSON.parse(JSON.stringify(c));
@@ -246,32 +255,39 @@ describe('createSession — credentials never reach the driver or storage', () =
         }));
     });
     describe('when the device is on another node', () => {
+        let grants;
         beforeEach(() => {
             sinon_1.default.stub(svc, 'finalizeSession').callsFake((...args) => __awaiter(void 0, void 0, void 0, function* () {
                 seen.sessionResponse = { desired: JSON.parse(JSON.stringify(args[2])) };
             }));
-            sinon_1.default.stub(svc, 'forwardSessionRequest').callsFake((_d, c) => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(svc, 'forwardSessionRequest').callsFake((_d, c, t) => __awaiter(void 0, void 0, void 0, function* () {
                 seen.forwarded = JSON.parse(JSON.stringify(c));
+                seen.hubToken = t;
                 return { protocol: 'W3C', value: ['sess-1', {}, 'W3C'] };
             }));
+            grants = sinon_1.default.stub().resolves('HUB-CREATE-TOKEN');
+            typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, {
+                createTokenFor: grants,
+                forget: () => undefined,
+            });
         });
-        it('a peer Xenon node gets them, since it authenticates the session itself', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('a peer Xenon node never gets them: it gets the hub’s token for the verified owner', () => __awaiter(void 0, void 0, void 0, function* () {
             device.nodeId = 'node-peer';
             yield create(caps({ 'xe:options': { accessKey: KEY, token: TOKEN, sessionToken: JWT } }));
-            (0, chai_1.expect)(seen.forwarded.alwaysMatch['xe:options']).to.deep.equal({
-                accessKey: KEY,
-                token: TOKEN,
-                sessionToken: JWT,
-            });
+            (0, chai_1.expect)(leaked(seen.forwarded), 'forwarded').to.deep.equal([]);
+            (0, chai_1.expect)(seen.hubToken).to.equal('HUB-CREATE-TOKEN');
+            (0, chai_1.expect)(grants.firstCall.args[0]).to.deep.equal({ userId: 'usr_key', udid: 'u1', host: 'h1' });
             for (const where of ['pending', 'sent', 'sessionResponse']) {
                 (0, chai_1.expect)(leaked(seen[where]), where).to.deep.equal([]);
             }
         }));
-        it('a cloud provider never does', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('a cloud provider gets neither', () => __awaiter(void 0, void 0, void 0, function* () {
             device.nodeId = undefined;
             device.cloud = true;
             yield create(caps({ 'xe:options': { accessKey: KEY, token: TOKEN, sessionToken: JWT } }));
             (0, chai_1.expect)(leaked(seen.forwarded)).to.deep.equal([]);
+            (0, chai_1.expect)(seen.hubToken).to.equal(null);
+            (0, chai_1.expect)(grants.called).to.equal(false);
         }));
     });
 });

package/lib/test/unit/session-credentials.spec.js

@@ -100,50 +100,3 @@ describe('takeSessionCredentials', () => {
         (0, chai_1.expect)(() => (0, sessionCredentials_1.takeSessionCredentials)({ alwaysMatch: null, firstMatch: 'x' })).to.not.throw();
     });
 });
-describe('capsWithCredentials — the copy a peer Xenon node gets', () => {
-    // A peer node re-runs createSession: it authenticates and attributes the
-    // session and checks the lease itself, so it needs what the hub read. It
-    // takes the credentials out again before its own driver sees them.
-    const take = (caps) => ({ caps, credentials: (0, sessionCredentials_1.takeSessionCredentials)(caps) });
-    it('puts every credential back, so the node reads the same ones the hub did', () => {
-        const { caps, credentials } = take({
-            alwaysMatch: {
-                'xenon:options': { leaseId: 'lse_1', accessKey: 'ak_old', token: 'tk_old' },
-                'xe:options': { token: SECRETS.token, sessionToken: SECRETS.sessionToken },
-            },
-            firstMatch: [{}],
-        });
-        const forwarded = (0, sessionCredentials_1.capsWithCredentials)(caps, credentials);
-        (0, chai_1.expect)((0, sessionCredentials_1.takeSessionCredentials)(JSON.parse(JSON.stringify(forwarded)))).to.deep.equal(credentials);
-    });
-    it('writes them into the namespace that wins, in the bucket it is in', () => {
-        const { caps, credentials } = take({
-            alwaysMatch: { 'xenon:options': { leaseId: 'lse_1', leaseToken: SECRETS.leaseToken } },
-            firstMatch: [{ 'xe:options': { accessKey: SECRETS.accessKey, token: SECRETS.token } }],
-        });
-        const forwarded = (0, sessionCredentials_1.capsWithCredentials)(caps, credentials);
-        (0, chai_1.expect)(forwarded.firstMatch[0]['xe:options']).to.deep.equal({
-            accessKey: SECRETS.accessKey,
-            token: SECRETS.token,
-            leaseToken: SECRETS.leaseToken,
-        });
-        (0, chai_1.expect)(forwarded.alwaysMatch['xenon:options']).to.deep.equal({ leaseId: 'lse_1' });
-    });
-    it('does not modify the caps it copies', () => {
-        const { caps, credentials } = take({
-            alwaysMatch: { 'xe:options': Object.assign({ leaseId: 'lse_1' }, SECRETS) },
-            firstMatch: [{}],
-        });
-        const before = JSON.stringify(caps);
-        (0, sessionCredentials_1.capsWithCredentials)(caps, credentials);
-        (0, chai_1.expect)(JSON.stringify(caps)).to.equal(before);
-        (0, chai_1.expect)(leaks(caps)).to.deep.equal([]);
-    });
-    it('returns the caps unchanged when there is nothing to put back', () => {
-        const { caps, credentials } = take({
-            alwaysMatch: { 'xe:options': { leaseId: 'lse_1' } },
-            firstMatch: [{}],
-        });
-        (0, chai_1.expect)((0, sessionCredentials_1.capsWithCredentials)(caps, credentials)).to.equal(caps);
-    });
-});