@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/test/unit/device-access-lease.spec.js

@@ -0,0 +1,270 @@
+"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 deviceAccessPolicy_1 = require("../../src/services/device-access/deviceAccessPolicy");
+const deviceAccessGuard_1 = require("../../src/middleware/deviceAccessGuard");
+const ticketActorAccess_1 = require("../../src/services/device-access/ticketActorAccess");
+const streamStartConflict_1 = require("../../src/app/routers/streamStartConflict");
+const busy_precheck_1 = require("../../src/services/recording/busy-precheck");
+// A phone an SDK lease holds is its lease holder's. The guard used to read
+// only `busy` and `session_id`: a freshly leased phone (busy, no session) was
+// refused to everyone but admins, its holder included, and a leased phone
+// whose `busy` had been cleared (a lease-bound session's release, the idle
+// sweeper) was open to anyone.
+const UDID = 'DEV-1';
+const HOST = 'http://hub:4723';
+const ALICE = 'usr_alice';
+const ALICE_KEY = 'key_alice';
+const BOB = 'usr_bob';
+const BOB_KEY = 'key_bob';
+const aliceLease = { actorId: ALICE_KEY, holderUserId: ALICE };
+function input(over = {}) {
+    return Object.assign({ udid: UDID, busy: true, sessionId: null, sessionOwnerUserId: null, actorUserId: BOB, actorApiKeyId: BOB_KEY, isAdmin: false, lease: aliceLease }, over);
+}
+describe('device access on a leased phone', () => {
+    describe('evaluateDeviceAccess', () => {
+        it('lets the lease holder through by the key that created it', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ actorUserId: 'usr_other', actorApiKeyId: ALICE_KEY }))).to.deep.equal({ allow: true });
+        });
+        it('lets the lease holder through with any credential of theirs', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ actorUserId: ALICE, actorApiKeyId: undefined }))).to.deep.equal({ allow: true });
+        });
+        it('lets a user through on a lease made with their bearer token (actorId is the user id)', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({
+                actorUserId: ALICE,
+                actorApiKeyId: undefined,
+                lease: { actorId: ALICE, holderUserId: ALICE },
+            }))).to.deep.equal({ allow: true });
+        });
+        it('refuses anyone else, naming the lease holder', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input())).to.deep.equal({
+                allow: false,
+                code: 'device_held_by_another_user',
+                holderId: ALICE,
+                heldBy: 'lease',
+            });
+        });
+        it("refuses anyone else even when the phone's busy flag was cleared", () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ busy: false })).allow).to.equal(false);
+        });
+        it('lets the owner of the session running on the leased phone drive it', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ sessionId: 'sess-1', sessionOwnerUserId: BOB }))).to.deep.equal({ allow: true });
+        });
+        it("doesn't let a manual hold on a leased phone stand in for the lease", () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ sessionId: `manual_${BOB}_${UDID}` })).allow).to.equal(false);
+        });
+        it('fails closed when the holder cannot be resolved', () => {
+            const d = (0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ lease: { actorId: 'key_gone', holderUserId: null } }));
+            (0, chai_1.expect)(d).to.deep.equal({
+                allow: false,
+                code: 'device_held_by_another_user',
+                holderId: '',
+                heldBy: 'lease',
+            });
+        });
+        it('still allows an admin', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ isAdmin: true }))).to.deep.equal({ allow: true });
+        });
+        it('leaves an unleased phone to the rules it had', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ lease: null, busy: false }))).to.deep.equal({
+                allow: true,
+            });
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.evaluateDeviceAccess)(input({ lease: null, sessionId: 'sess-1', sessionOwnerUserId: ALICE }))
+                .allow).to.equal(false);
+        });
+        it('isLeaseHolder needs a lease', () => {
+            (0, chai_1.expect)((0, deviceAccessPolicy_1.isLeaseHolder)(null, ALICE, ALICE_KEY)).to.equal(false);
+        });
+    });
+    describe('deviceAccessGuard', () => {
+        function appFor(opts) {
+            var _a;
+            const app = (0, express_1.default)();
+            app.use(express_1.default.json());
+            app.use((req, _res, next) => {
+                var _a;
+                req.auth = {
+                    kind: 'api-key',
+                    userId: opts.actorUserId,
+                    role: (_a = opts.role) !== null && _a !== void 0 ? _a : 'MEMBER',
+                    scopes: 'devices',
+                    rateLimit: 100,
+                };
+                if (opts.apiKeyId)
+                    req.apiKey = { id: opts.apiKeyId };
+                next();
+            });
+            const router = express_1.default.Router();
+            router.use((0, deviceAccessGuard_1.deviceAccessGuard)({
+                findDevice: () => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    return ({
+                        udid: UDID,
+                        host: HOST,
+                        busy: (_a = opts.busy) !== null && _a !== void 0 ? _a : true,
+                        session_id: null,
+                    });
+                }),
+                resolveSessionOwner: () => __awaiter(this, void 0, void 0, function* () { return null; }),
+                describeHolder: (id) => __awaiter(this, void 0, void 0, function* () { return (id === ALICE ? 'alice@example.com' : null); }),
+                findActiveLease: (_a = opts.leaseLookup) !== null && _a !== void 0 ? _a : ((udid, host) => __awaiter(this, void 0, void 0, function* () { var _a; return (udid === UDID && host === HOST ? ((_a = opts.lease) !== null && _a !== void 0 ? _a : null) : null); })),
+                resolveLeaseHolder: () => __awaiter(this, void 0, void 0, function* () { var _a; return (_a = opts.leaseHolder) !== null && _a !== void 0 ? _a : null; }),
+            }));
+            router.post('/:udid/tap', (_req, res) => res.json({ reached: true }));
+            router.get('/:udid/clipboard', (_req, res) => res.json({ reached: true }));
+            app.use('/control', router);
+            return app;
+        }
+        it('lets the lease holder control the phone they just leased', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor({ actorUserId: ALICE, lease: { actorId: ALICE_KEY }, leaseHolder: ALICE })).post(`/control/${UDID}/tap`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.reached).to.equal(true);
+        }));
+        it('refuses another member with a message about the lease', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor({ actorUserId: BOB, lease: { actorId: ALICE_KEY }, leaseHolder: ALICE })).post(`/control/${UDID}/tap`);
+            (0, chai_1.expect)(res.status).to.equal(409);
+            (0, chai_1.expect)(res.body.error).to.equal('device_held_by_another_user');
+            (0, chai_1.expect)(res.body.message).to.match(/leased by alice@example\.com/);
+            (0, chai_1.expect)(res.body.holder.userId).to.equal(ALICE);
+        }));
+        it('refuses another member on a leased phone whose busy flag was cleared', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor({
+                actorUserId: BOB,
+                busy: false,
+                lease: { actorId: ALICE_KEY },
+                leaseHolder: ALICE,
+            })).get(`/control/${UDID}/clipboard`);
+            (0, chai_1.expect)(res.status).to.equal(409);
+        }));
+        it('answers 503 when it cannot tell whether a lease holds the phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor({
+                actorUserId: BOB,
+                leaseLookup: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('db down');
+                }),
+            })).post(`/control/${UDID}/tap`);
+            (0, chai_1.expect)(res.status).to.equal(503);
+            (0, chai_1.expect)(res.body.error).to.equal('device_ownership_unavailable');
+        }));
+        it('does not look leases up for an admin', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor({
+                actorUserId: BOB,
+                role: 'SUPER_ADMIN',
+                leaseLookup: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('an admin should not need this');
+                }),
+            })).post(`/control/${UDID}/tap`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+        }));
+    });
+    describe('the logcat ticket authorizer', () => {
+        const authorize = (0, ticketActorAccess_1.makeTicketActorAuthorizer)({
+            findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: UDID, host: HOST, busy: true, session_id: null }); }),
+            resolveSessionOwner: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            findActiveLease: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: ALICE_KEY }); }),
+            resolveLeaseHolder: () => __awaiter(void 0, void 0, void 0, function* () { return ALICE; }),
+        });
+        it('lets the lease holder read the leased phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield authorize(UDID, { actorId: ALICE })).to.equal(true);
+        }));
+        it('refuses anyone else', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield authorize(UDID, { actorId: BOB })).to.equal(false);
+        }));
+    });
+    describe('stream/start', () => {
+        const start = (over = {}) => (0, streamStartConflict_1.decideStreamStartConflict)(Object.assign({ udid: UDID, busy: true, sessionId: null, hasLiveManualStream: false, sessionOwnerUserId: null, actorUserId: ALICE, isAdmin: false }, over));
+        it('lets the lease holder preview their leased phone (busy, no session)', () => {
+            (0, chai_1.expect)(start({ leaseHolder: true })).to.deep.equal({ action: 'proceed' });
+        });
+        it('still refuses a busy phone with no holder on record to anyone else', () => {
+            (0, chai_1.expect)(start().action).to.equal('deny');
+        });
+        it("doesn't let a lease stand in for someone else's session on the phone", () => {
+            (0, chai_1.expect)(start({ leaseHolder: true, sessionId: 'sess-9', sessionOwnerUserId: BOB }).action).to.equal('deny');
+        });
+        function appFor(actorUserId, role = 'MEMBER', leased = true) {
+            const app = (0, express_1.default)();
+            app.use((req, _res, next) => {
+                req.auth = { kind: 'api-key', userId: actorUserId, role, scopes: 'devices' };
+                next();
+            });
+            const router = express_1.default.Router();
+            router.use((0, deviceAccessGuard_1.deviceAccessGuard)({
+                findDevice: () => __awaiter(this, void 0, void 0, function* () { return ({ udid: UDID, host: HOST, busy: false, session_id: null }); }),
+                resolveSessionOwner: () => __awaiter(this, void 0, void 0, function* () { return null; }),
+                describeHolder: () => __awaiter(this, void 0, void 0, function* () { return 'alice@example.com'; }),
+                findActiveLease: () => __awaiter(this, void 0, void 0, function* () {
+                    if (role === 'SUPER_ADMIN')
+                        throw new Error('an admin should not need this');
+                    return leased ? { actorId: ALICE_KEY } : null;
+                }),
+                resolveLeaseHolder: () => __awaiter(this, void 0, void 0, function* () { return ALICE; }),
+            }));
+            router.post('/:udid/stream/start', (_req, res) => res.json({ reached: true }));
+            app.use('/control', router);
+            return app;
+        }
+        it('refuses a stranger before the handler (and before a hub forwards it)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor(BOB)).post(`/control/${UDID}/stream/start`);
+            (0, chai_1.expect)(res.status).to.equal(409);
+            (0, chai_1.expect)(res.body.message).to.match(/leased by/);
+        }));
+        it('passes the lease holder on to the handler', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor(ALICE)).post(`/control/${UDID}/stream/start`);
+            (0, chai_1.expect)(res.body.reached).to.equal(true);
+        }));
+        it('leaves an unleased phone to stream/start, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor(BOB, 'MEMBER', false)).post(`/control/${UDID}/stream/start`);
+            (0, chai_1.expect)(res.body.reached).to.equal(true);
+        }));
+        it('passes an admin without looking leases up', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield (0, loopbackRequest_1.default)(appFor(BOB, 'SUPER_ADMIN')).post(`/control/${UDID}/stream/start`);
+            (0, chai_1.expect)(res.body.reached).to.equal(true);
+        }));
+    });
+    describe('recordings (BusyPrecheck)', () => {
+        const precheck = (row, lease) => new busy_precheck_1.BusyPrecheck({ findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return (Object.assign({ udid: UDID, host: HOST }, row)); }) }, { isRecording: () => __awaiter(void 0, void 0, void 0, function* () { return false; }) }, {
+            find: () => __awaiter(void 0, void 0, void 0, function* () {
+                if (lease instanceof Error)
+                    throw lease;
+                return lease;
+            }),
+            holderOf: () => __awaiter(void 0, void 0, void 0, function* () { return ALICE; }),
+        });
+        it("refuses a stranger's recording of a leased phone, busy or not", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield precheck({ busy: false }, { actorId: ALICE_KEY }).findBusy([UDID], BOB)).to.deep.equal([{ udid: UDID, reason: 'leased' }]);
+        }));
+        it('lets the lease holder record their leased phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield precheck({ busy: true }, { actorId: ALICE_KEY }).findBusy([UDID], ALICE)).to.deep.equal([]);
+        }));
+        it('still refuses the holder while a session runs on it, as for any session', () => __awaiter(void 0, void 0, void 0, function* () {
+            const busy = yield precheck({ busy: true, session_id: 'sess-1' }, { actorId: ALICE_KEY }).findBusy([UDID], ALICE);
+            (0, chai_1.expect)(busy).to.deep.equal([{ udid: UDID, reason: 'automation', sessionId: 'sess-1' }]);
+        }));
+        it('fails the start when it cannot tell whether a lease holds the phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            let thrown;
+            try {
+                yield precheck({ busy: false }, new Error('db down')).findBusy([UDID], BOB);
+            }
+            catch (e) {
+                thrown = e;
+            }
+            (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.message).to.equal('db down');
+        }));
+    });
+});

package/lib/test/unit/device-offline-webhook.spec.js

@@ -0,0 +1,81 @@
+"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 typedi_1 = require("typedi");
+const device_service_1 = require("../../src/data-service/device-service");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const container_registration_1 = require("../helpers/container-registration");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * The `device_offline` webhook carries the device's name and platform, as its
+ * documented payload says (src/services/webhookEvents.ts). Every caller of
+ * `removeDevice` holds only a udid and a host, so the event used to carry just
+ * those two and `{{name}}` stayed unfilled in a template.
+ */
+describe('device_offline: what the event carries', () => {
+    (0, loki_stores_1.useLokiStores)();
+    let restore;
+    let dispatch;
+    const HOST = 'http://127.0.0.1:4723';
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(NotificationService_1.NotificationService, SocketServer_1.SocketServer);
+        dispatch = sinon_1.default.stub().resolves();
+        typedi_1.Container.set({ id: NotificationService_1.NotificationService, value: { dispatchEvent: dispatch } });
+        typedi_1.Container.set({
+            id: SocketServer_1.SocketServer,
+            value: {
+                emitToDashboard: () => undefined,
+                emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+                hasScopedDashboard: () => false,
+            },
+        });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    const phone = () => ({
+        udid: 'R58M123',
+        name: 'Galaxy S9+',
+        platform: 'android',
+        sdk: '10',
+        host: HOST,
+        busy: false,
+        offline: false,
+        userBlocked: false,
+        deviceType: 'real',
+        realDevice: true,
+    });
+    it('names the device and its platform, though the caller passed only a udid and a host', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, device_service_1.addNewDevice)([phone()]);
+        dispatch.resetHistory();
+        yield (0, device_service_1.removeDevice)([{ udid: 'R58M123', host: HOST }]);
+        (0, chai_1.expect)(dispatch.calledOnce).to.equal(true);
+        (0, chai_1.expect)(dispatch.firstCall.args[0]).to.equal('device_offline');
+        (0, chai_1.expect)(dispatch.firstCall.args[1]).to.include({
+            udid: 'R58M123',
+            host: HOST,
+            name: 'Galaxy S9+',
+            platform: 'android',
+        });
+    }));
+    it('still reports a device the store no longer knows, by its udid and host', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, device_service_1.removeDevice)([{ udid: 'gone-1', host: HOST }]);
+        (0, chai_1.expect)(dispatch.firstCall.args[1]).to.deep.include({ udid: 'gone-1', host: HOST });
+    }));
+});

package/lib/test/unit/device-setting-columns.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const client_1 = require("../../src/generated/client");
+const deviceFieldOwners_1 = require("../../src/data-service/deviceFieldOwners");
+const deviceSettings_1 = require("../../src/data-service/deviceSettings");
+/**
+ * The settings a phone keeps when its Device row goes (deviceSettings.ts) are
+ * the Device columns placed as `setting` in deviceFieldOwners.ts, and the
+ * DeviceSetting table has exactly those, besides its key. A setting added to
+ * one and not the other would be lost, or never written.
+ */
+describe('Saved phone settings: the columns', () => {
+    it('DeviceSetting has exactly the setting columns, besides its key', () => {
+        const saved = Object.keys(client_1.Prisma.DeviceSettingScalarFieldEnum).filter((column) => !['udid', 'host', 'updatedAt'].includes(column));
+        (0, chai_1.expect)([...deviceFieldOwners_1.SETTING_FIELDS].sort()).to.deep.equal(saved.sort());
+    });
+    it('are team, tags, maintenance and the reservation', () => {
+        (0, chai_1.expect)([...deviceFieldOwners_1.SETTING_FIELDS].sort()).to.deep.equal([
+            'reservationReason',
+            'reservedBy',
+            'reservedByUserId',
+            'reservedUntil',
+            'tags',
+            'teamId',
+            'userBlocked',
+        ].sort());
+    });
+    it('are never written by a sync or by a node’s report', () => {
+        for (const column of deviceFieldOwners_1.SETTING_FIELDS) {
+            (0, chai_1.expect)(deviceFieldOwners_1.DISCOVERY_FIELDS.has(column), column).to.equal(false);
+            (0, chai_1.expect)(deviceFieldOwners_1.NODE_REPORT_FIELDS.has(column), column).to.equal(false);
+        }
+    });
+    it('pickSettingFields keeps only them', () => {
+        (0, chai_1.expect)((0, deviceFieldOwners_1.pickSettingFields)({ teamId: 't', busy: true, session_id: 's', userBlocked: true })).to.deep.equal({ teamId: 't', userBlocked: true });
+    });
+    it('a new row starts with every one of them, so a cleared one stays cleared', () => {
+        const now = 1000;
+        (0, chai_1.expect)(Object.keys((0, deviceSettings_1.restoredColumns)({}, now)).sort()).to.deep.equal([...deviceFieldOwners_1.SETTING_FIELDS].sort());
+        (0, chai_1.expect)((0, deviceSettings_1.restoredColumns)({}, now)).to.deep.equal({
+            teamId: null,
+            tags: null,
+            userBlocked: false,
+            reservationReason: null,
+            reservedBy: null,
+            reservedByUserId: null,
+            reservedUntil: null,
+        });
+    });
+    it('a reservation only while it holds', () => {
+        const reservation = {
+            reservedBy: 'Dana',
+            reservedByUserId: 'u1',
+            reservationReason: 'release',
+            reservedUntil: 2000,
+        };
+        (0, chai_1.expect)((0, deviceSettings_1.restoredColumns)(reservation, 1999)).to.include(reservation);
+        (0, chai_1.expect)((0, deviceSettings_1.restoredColumns)(reservation, 2000)).to.include({
+            reservedBy: null,
+            reservedByUserId: null,
+            reservationReason: null,
+            reservedUntil: null,
+        });
+    });
+});

package/lib/test/unit/device-settings-loki.spec.js

@@ -0,0 +1,87 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const device_store_1 = require("../../src/data-service/device-store");
+const db_1 = require("../../src/data-service/db");
+const deviceSettings_1 = require("../../src/data-service/deviceSettings");
+const localDeviceHosts_1 = require("../../src/device-managers/localDeviceHosts");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * The in-memory store keeps a phone's settings apart from its row as the
+ * Prisma store does (device-settings-survive.spec.ts runs the real one).
+ */
+const IP = '10.0.0.1';
+const OWN = `http://${IP}:4723`;
+const NODE = `http://${IP}:4725`;
+const local = (0, localDeviceHosts_1.localDeviceHosts)({ bindHostOrIp: IP }, 4723);
+const phone = (udid, host = OWN, over = {}) => (Object.assign({ udid,
+    host, name: udid, platform: 'android', deviceType: 'real', realDevice: true, state: 'device', sdk: '14', busy: false, userBlocked: false, offline: false, totalUtilizationTimeMilliSec: 0, sessionStartTime: 0 }, over));
+describe('Saved phone settings in the in-memory store', () => {
+    (0, loki_stores_1.useLokiStores)();
+    const store = () => device_store_1.DeviceStoreFactory.getStore();
+    const empty = () => __awaiter(void 0, void 0, void 0, function* () {
+        (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+        (yield db_1.XenonDatabase.DeviceSettingsModel).removeDataOnly();
+    });
+    beforeEach(empty);
+    after(empty);
+    const configure = (udid, host = OWN) => store().updateDevice(udid, host, { teamId: 'team-a', tags: ['lab-1'], userBlocked: true });
+    it('a phone removed and added again keeps them', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield store().addDevices([phone('p1')]);
+        yield configure('p1');
+        yield store().removeDevices({ udid: 'p1', host: OWN });
+        const [back] = yield store().addDevices([phone('p1')]);
+        (0, chai_1.expect)(back).to.include({ teamId: 'team-a', userBlocked: true });
+        (0, chai_1.expect)(back.tags).to.deep.equal(['lab-1']);
+    }));
+    it('keeps them across a restart, and saves those kept only on a row', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield store().addDevices([phone('p1'), phone('legacy', OWN, { teamId: 'team-b' })]);
+        yield configure('p1');
+        yield (0, deviceSettings_1.resetDevicesAtBoot)(store(), { removeDevicesFromDatabaseBeforeRunningThePlugin: false }, local);
+        (0, chai_1.expect)(yield store().getAllDevices()).to.deep.equal([]);
+        yield store().addDevices([phone('p1'), phone('legacy')]);
+        (0, chai_1.expect)(yield store().findDevice({ udid: 'p1', host: OWN })).to.include({ teamId: 'team-a' });
+        (0, chai_1.expect)(yield store().findDevice({ udid: 'legacy', host: OWN })).to.include({
+            teamId: 'team-b',
+        });
+    }));
+    it('gives a node’s phone the hub’s settings, never its report’s or another host’s', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield store().addDevices([phone('emulator-5554')]);
+        yield configure('emulator-5554');
+        yield store().addDevices([phone('node-phone', NODE)], { nodeReport: true });
+        yield store().updateDevice('node-phone', NODE, { teamId: 'team-a' });
+        yield store().removeDevices({ udid: 'node-phone', host: NODE });
+        yield store().addDevices([
+            phone('node-phone', NODE, { teamId: 'team-b', userBlocked: true }),
+            phone('emulator-5554', NODE),
+        ], { nodeReport: true });
+        (0, chai_1.expect)(yield store().findDevice({ udid: 'node-phone', host: NODE })).to.include({
+            teamId: 'team-a',
+            userBlocked: false,
+        });
+        const nodeEmulator = yield store().findDevice({ udid: 'emulator-5554', host: NODE });
+        (0, chai_1.expect)((_a = nodeEmulator === null || nodeEmulator === void 0 ? void 0 : nodeEmulator.teamId) !== null && _a !== void 0 ? _a : null).to.equal(null);
+        (0, chai_1.expect)((_b = nodeEmulator === null || nodeEmulator === void 0 ? void 0 : nodeEmulator.userBlocked) !== null && _b !== void 0 ? _b : false).to.equal(false);
+    }));
+    it('lists the saved phones of a udid, and forgets those of the hosts named', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield store().updateDevice('p1', OWN, { userBlocked: true });
+        yield store().updateDevice('p1', NODE, { userBlocked: true });
+        (0, chai_1.expect)(yield store().findSavedPhones('p1')).to.have.deep.members([
+            { udid: 'p1', host: OWN },
+            { udid: 'p1', host: NODE },
+        ]);
+        yield store().forgetSettings([OWN]);
+        (0, chai_1.expect)(yield store().findSavedPhones('p1')).to.deep.equal([{ udid: 'p1', host: NODE }]);
+    }));
+});