@xenon-device-management/xenon 2.13.2 → 2.15.0

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 }]);
+    }));
+});