@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/test/unit/json-logging-option.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
+const plugin_1 = require("../../src/plugin");
+const logger_1 = require("../../src/logger");
+/* eslint-disable @typescript-eslint/no-var-requires -- Appium's internals have no type exports */
+const appiumSchema = require('appium/build/lib/schema/schema');
+/* eslint-enable @typescript-eslint/no-var-requires */
+const xenonSchema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'schema.json'), 'utf8'));
+/**
+ * XENON_JSON_LOGGING turns JSON log lines on. The plugin overwrote it with its
+ * own default, `enableJsonLogging: false`, so the variable never worked. The
+ * rule now: the option when it is set (either way), else the variable, else
+ * off. For that the option has to be absent when nobody set it, so schema.json
+ * gives it no default for Appium to fill in.
+ */
+describe('JSON logging', () => {
+    let savedFlag;
+    let savedEnv;
+    beforeEach(() => {
+        savedFlag = logger_1.XenonLogger.isJsonLogging;
+        savedEnv = process.env.XENON_JSON_LOGGING;
+    });
+    afterEach(() => {
+        logger_1.XenonLogger.isJsonLogging = savedFlag;
+        if (savedEnv === undefined)
+            delete process.env.XENON_JSON_LOGGING;
+        else
+            process.env.XENON_JSON_LOGGING = savedEnv;
+    });
+    /** The logger as it stands once the plugin is built the way Appium builds it. */
+    function loggingAfterBuilding(cliArgs, env) {
+        // The environment is read when the logger loads; this is that read.
+        logger_1.XenonLogger.isJsonLogging = env === 'true';
+        new plugin_1.XenonPlugin('xenon', cliArgs);
+        return logger_1.XenonLogger.isJsonLogging;
+    }
+    it('is on when only the environment variable asks for it', () => {
+        (0, chai_1.expect)(loggingAfterBuilding({}, 'true')).to.equal(true);
+    });
+    it('is off when nothing asks for it', () => {
+        (0, chai_1.expect)(loggingAfterBuilding({})).to.equal(false);
+    });
+    it('is on when only the option asks for it', () => {
+        (0, chai_1.expect)(loggingAfterBuilding({ enableJsonLogging: true })).to.equal(true);
+    });
+    it('lets an option set to false win over the environment variable', () => {
+        (0, chai_1.expect)(loggingAfterBuilding({ enableJsonLogging: false }, 'true')).to.equal(false);
+    });
+    it('lets an option set to true win over a variable that is not "true"', () => {
+        (0, chai_1.expect)(loggingAfterBuilding({ enableJsonLogging: true }, 'false')).to.equal(true);
+    });
+    describe("Appium's defaults for an option nobody set", () => {
+        before(() => {
+            appiumSchema.resetSchema();
+            appiumSchema.registerSchema('plugin', 'xenon', xenonSchema);
+            appiumSchema.finalizeSchema();
+        });
+        after(() => appiumSchema.resetSchema());
+        it('leave enableJsonLogging absent, so the variable can be told from a choice', () => {
+            // What Appium's main does: CLI args, then the file, then schema defaults.
+            const defaults = appiumSchema.getDefaultsForSchema(false);
+            const server = lodash_1.default.defaultsDeep({}, { plugin: { xenon: { maxSessions: 8 } } }, defaults);
+            (0, chai_1.expect)(server.plugin.xenon).to.not.have.property('enableJsonLogging');
+        });
+    });
+});

package/lib/test/unit/lab-settings.spec.js

@@ -0,0 +1,218 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const labSettings_1 = require("../../src/services/settings/labSettings");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+/**
+ * The one rule for the settings the dashboard can change: a value saved there,
+ * else the plugin option the server started with, else the default.
+ */
+describe('lab settings', () => {
+    describe('the defaults', () => {
+        it('are the ones schema.json declares, which Appium fills in', () => {
+            (0, chai_1.expect)((0, labSettings_1.settingsDefaults)()).to.deep.equal({
+                enableSelfHealing: true,
+                healthCheckIntervalMs: 300000,
+                buildCleanupDays: 30,
+                buildCleanupMaxCount: 100,
+                buildCleanupSchedule: '0 0 * * *',
+                deleteBuildAssets: true,
+            });
+        });
+        it('are what the plugin merges under its options', () => {
+            for (const [key, value] of Object.entries((0, labSettings_1.settingsDefaults)())) {
+                (0, chai_1.expect)(IPluginArgs_1.DefaultPluginArgs[key], key).to.equal(value);
+            }
+        });
+    });
+    describe('the settings in effect', () => {
+        it('are the defaults when nothing is saved and nothing was set at startup', () => {
+            const _a = (0, labSettings_1.effectiveSettings)({}, {}), { healthCheckSchedule } = _a, rest = __rest(_a, ["healthCheckSchedule"]);
+            (0, chai_1.expect)(rest).to.deep.equal((0, labSettings_1.settingsDefaults)());
+            (0, chai_1.expect)(healthCheckSchedule).to.equal(undefined);
+        });
+        it('take the startup option over the default', () => {
+            const s = (0, labSettings_1.effectiveSettings)({
+                buildCleanupDays: 7,
+                buildCleanupMaxCount: 20,
+                buildCleanupSchedule: '30 1 * * *',
+                deleteBuildAssets: false,
+                enableSelfHealing: false,
+                healthCheckIntervalMs: 600000,
+                healthCheckSchedule: '0 * * * *',
+            }, {});
+            (0, chai_1.expect)(s).to.deep.equal({
+                enableSelfHealing: false,
+                buildCleanupDays: 7,
+                buildCleanupMaxCount: 20,
+                buildCleanupSchedule: '30 1 * * *',
+                deleteBuildAssets: false,
+                healthCheckIntervalMs: 600000,
+                healthCheckSchedule: '0 * * * *',
+            });
+        });
+        it('take a saved value over the startup option', () => {
+            const s = (0, labSettings_1.effectiveSettings)({
+                buildCleanupDays: 7,
+                buildCleanupMaxCount: 20,
+                buildCleanupSchedule: '30 1 * * *',
+                deleteBuildAssets: false,
+                healthCheckIntervalMs: 600000,
+            }, {
+                buildCleanupDays: 14,
+                buildCleanupMaxCount: 50,
+                buildCleanupSchedule: '0 4 * * 0',
+                deleteBuildAssets: true,
+                healthCheckIntervalMs: 120000,
+            });
+            (0, chai_1.expect)(s).to.include({
+                buildCleanupDays: 14,
+                buildCleanupMaxCount: 50,
+                buildCleanupSchedule: '0 4 * * 0',
+                deleteBuildAssets: true,
+                healthCheckIntervalMs: 120000,
+            });
+        });
+        it('take each setting from its own source', () => {
+            const s = (0, labSettings_1.effectiveSettings)({ buildCleanupDays: 7, buildCleanupMaxCount: 20 }, { buildCleanupDays: 14 });
+            (0, chai_1.expect)(s.buildCleanupDays).to.equal(14);
+            (0, chai_1.expect)(s.buildCleanupMaxCount).to.equal(20);
+        });
+        it('take a self-healing switch saved off over a startup on, and saved on over a startup off', () => {
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ enableSelfHealing: true }, { enableSelfHealing: false })
+                .enableSelfHealing).to.equal(false);
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ enableSelfHealing: false }, { enableSelfHealing: true })
+                .enableSelfHealing).to.equal(true);
+        });
+        it('take the self-healing switch from the startup option, else on', () => {
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ enableSelfHealing: false }, {}).enableSelfHealing).to.equal(false);
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({}, {}).enableSelfHealing).to.equal(true);
+        });
+        it('skip a self-healing switch that is not a boolean, taking the next source', () => {
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ enableSelfHealing: false }, { enableSelfHealing: 'true' })
+                .enableSelfHealing).to.equal(false);
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ enableSelfHealing: 'false' }, {}).enableSelfHealing).to.equal(true);
+        });
+        it('keep a deleteBuildAssets saved as false over a startup true', () => {
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ deleteBuildAssets: true }, { deleteBuildAssets: false })
+                .deleteBuildAssets).to.equal(false);
+        });
+        it('skip a saved value that could not work, taking the next source', () => {
+            const s = (0, labSettings_1.effectiveSettings)({ buildCleanupDays: 7, buildCleanupMaxCount: 20, buildCleanupSchedule: '30 1 * * *' }, {
+                buildCleanupDays: 0,
+                buildCleanupMaxCount: NaN,
+                buildCleanupSchedule: 'nightly',
+                healthCheckIntervalMs: -5,
+            });
+            (0, chai_1.expect)(s).to.include({
+                buildCleanupDays: 7,
+                buildCleanupMaxCount: 20,
+                buildCleanupSchedule: '30 1 * * *',
+                healthCheckIntervalMs: 300000,
+            });
+        });
+        it('skip a startup value that could not work, taking the default', () => {
+            const s = (0, labSettings_1.effectiveSettings)({ buildCleanupDays: 0, buildCleanupSchedule: 'nightly' }, {});
+            (0, chai_1.expect)(s.buildCleanupDays).to.equal(30);
+            (0, chai_1.expect)(s.buildCleanupSchedule).to.equal('0 0 * * *');
+        });
+        it('let a health schedule that was cleared in the dashboard stay cleared', () => {
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ healthCheckSchedule: '0 * * * *' }, { healthCheckSchedule: '' })
+                .healthCheckSchedule).to.equal(undefined);
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ healthCheckSchedule: '0 * * * *' }, {}).healthCheckSchedule).to.equal('0 * * * *');
+            (0, chai_1.expect)((0, labSettings_1.effectiveSettings)({ healthCheckSchedule: '0 * * * *' }, { healthCheckSchedule: '*/10 * * * *' }).healthCheckSchedule).to.equal('*/10 * * * *');
+        });
+    });
+    describe('whether self-healing runs (what the command interceptor asks)', () => {
+        it('is the saved value, else the startup option, else on', () => {
+            (0, chai_1.expect)((0, labSettings_1.selfHealingEnabled)(true, false)).to.equal(false);
+            (0, chai_1.expect)((0, labSettings_1.selfHealingEnabled)(false, true)).to.equal(true);
+            (0, chai_1.expect)((0, labSettings_1.selfHealingEnabled)(false, undefined)).to.equal(false);
+            (0, chai_1.expect)((0, labSettings_1.selfHealingEnabled)(undefined, undefined)).to.equal(true);
+        });
+        it('agrees with the settings in effect for every combination', () => {
+            for (const startup of [true, false, undefined, 'false', null]) {
+                for (const saved of [true, false, undefined]) {
+                    (0, chai_1.expect)((0, labSettings_1.selfHealingEnabled)(startup, saved), `startup ${String(startup)}, saved ${String(saved)}`).to.equal((0, labSettings_1.effectiveSettings)({ enableSelfHealing: startup }, { enableSelfHealing: saved })
+                        .enableSelfHealing);
+                }
+            }
+        });
+    });
+    describe('a cron expression', () => {
+        for (const ok of [
+            '0 0 * * *',
+            '*/15 * * * *',
+            '0 2 * * 0',
+            '0 */12 * * *',
+            '30 1 1 jan *',
+            '*/5 * * * * *',
+        ]) {
+            it(`accepts ${JSON.stringify(ok)}`, () => (0, chai_1.expect)((0, labSettings_1.isValidCron)(ok)).to.equal(true));
+        }
+        for (const bad of [
+            '',
+            'nightly',
+            '0 0 * *',
+            '60 * * * *',
+            '0 0 31 2 *',
+            '* * * * * * *',
+            '2030-01-01',
+            'Jan 1 2030 10:00:00',
+            null,
+            42,
+            undefined,
+        ]) {
+            it(`refuses ${JSON.stringify(bad)}`, () => (0, chai_1.expect)((0, labSettings_1.isValidCron)(bad)).to.equal(false));
+        }
+    });
+    describe('an update', () => {
+        it('is accepted when every cleanup field is sound, or none is sent', () => {
+            (0, chai_1.expect)((0, labSettings_1.validateSettingsUpdate)({})).to.equal(null);
+            (0, chai_1.expect)((0, labSettings_1.validateSettingsUpdate)({
+                buildCleanupDays: 14,
+                buildCleanupMaxCount: 50,
+                buildCleanupSchedule: '0 2 * * *',
+                deleteBuildAssets: false,
+            })).to.equal(null);
+        });
+        it('is not held to a rule for the settings the cleanup job does not act on', () => {
+            (0, chai_1.expect)((0, labSettings_1.validateSettingsUpdate)({
+                healthCheckIntervalMs: 300000,
+                aiProvider: 'gemini',
+            })).to.equal(null);
+        });
+        it('accepts the self-healing switch as true or false, and refuses anything else', () => {
+            var _a;
+            (0, chai_1.expect)((0, labSettings_1.validateSettingsUpdate)({ enableSelfHealing: true })).to.equal(null);
+            (0, chai_1.expect)((0, labSettings_1.validateSettingsUpdate)({ enableSelfHealing: false })).to.equal(null);
+            for (const bad of ['true', 0, null, {}]) {
+                (0, chai_1.expect)((_a = (0, labSettings_1.validateSettingsUpdate)({ enableSelfHealing: bad })) === null || _a === void 0 ? void 0 : _a.field).to.equal('enableSelfHealing');
+            }
+        });
+        it('names the field a refused value was sent for', () => {
+            var _a, _b, _c, _d, _e;
+            (0, chai_1.expect)((_a = (0, labSettings_1.validateSettingsUpdate)({ buildCleanupDays: 0 })) === null || _a === void 0 ? void 0 : _a.field).to.equal('buildCleanupDays');
+            (0, chai_1.expect)((_b = (0, labSettings_1.validateSettingsUpdate)({ buildCleanupMaxCount: 1.5 })) === null || _b === void 0 ? void 0 : _b.field).to.equal('buildCleanupMaxCount');
+            (0, chai_1.expect)((_c = (0, labSettings_1.validateSettingsUpdate)({ buildCleanupSchedule: 'x' })) === null || _c === void 0 ? void 0 : _c.field).to.equal('buildCleanupSchedule');
+            (0, chai_1.expect)((_d = (0, labSettings_1.validateSettingsUpdate)({ deleteBuildAssets: 1 })) === null || _d === void 0 ? void 0 : _d.field).to.equal('deleteBuildAssets');
+            (0, chai_1.expect)((_e = (0, labSettings_1.validateSettingsUpdate)({ enableSelfHealing: 'yes' })) === null || _e === void 0 ? void 0 : _e.field).to.equal('enableSelfHealing');
+        });
+        it('treats a field sent as null as sent', () => {
+            var _a;
+            (0, chai_1.expect)((_a = (0, labSettings_1.validateSettingsUpdate)({ buildCleanupDays: null })) === null || _a === void 0 ? void 0 : _a.field).to.equal('buildCleanupDays');
+        });
+    });
+});

package/lib/test/unit/lease/lease-override.spec.js

@@ -26,14 +26,31 @@ describe('canOverrideLease — who may use a lease they did not create', () => {
             (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'api-key', scopes: 'admin', user: null })).to.equal(false);
         });
     });
-    describe('a session token (the user themselves, like a dashboard cookie)', () => {
-        it('is allowed for an ADMIN or SUPER_ADMIN', () => {
-            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', user: user('ADMIN') })).to.equal(true);
-            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', user: user('SUPER_ADMIN') })).to.equal(true);
+    // A session token carries the scopes of the credential that minted it, and
+    // is judged by them like a key. By role alone, an ADMIN's key without the
+    // admin scope minted itself a token that could override.
+    describe("a session token (judged by its scopes and its user's role now)", () => {
+        // resolveActor's rule (a SUPER_ADMIN, or a credential with `admin`), on
+        // the user's role now: the scope is fixed at mint, so an ADMIN's token
+        // also needs the role to still be ADMIN, which notices a demotion.
+        it("is allowed for an ADMIN's or SUPER_ADMIN's token carrying the admin scope", () => {
+            for (const role of ['ADMIN', 'SUPER_ADMIN']) {
+                (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'admin,sessions', user: user(role) })).to.equal(true);
+            }
+        });
+        // As their key pair overrides, and their Bearer token in per-command auth.
+        it("is allowed for a SUPER_ADMIN's token without the admin scope", () => {
+            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'sessions', user: user('SUPER_ADMIN') })).to.equal(true);
+        });
+        it('is refused for a token with the admin scope whose user is now a member', () => {
+            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'admin,sessions', user: user('MEMBER') })).to.equal(false);
+        });
+        it("is refused for an ADMIN's token without the admin scope", () => {
+            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'sessions', user: user('ADMIN') })).to.equal(false);
         });
         it('is refused for a member, or a user who is not active', () => {
-            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', user: user('MEMBER') })).to.equal(false);
-            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', user: null })).to.equal(false);
+            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'sessions', user: user('MEMBER') })).to.equal(false);
+            (0, chai_1.expect)((0, leaseOverride_1.canOverrideLease)({ kind: 'session-token', scopes: 'admin', user: null })).to.equal(false);
         });
     });
     it('is allowed with auth disabled, where every caller is a SUPER_ADMIN', () => {

package/lib/test/unit/lease/session-lease-proof.spec.js

@@ -83,8 +83,11 @@ const sessionCaps = (xenonOptions, extra = {}) => ({
 const key = (accessKey) => ({ accessKey, token: 'tk' });
 const ownerKey = key('ak_owner');
 const otherKey = key('ak_other');
-// A session token names its user in `sub`; the fake verifier echoes it back.
-const sessionToken = (sub) => ({ sessionToken: `jwt:${sub}` });
+// A session token names its user in `sub` and carries the scopes of the
+// credential that minted it; the fake verifier echoes both back.
+const sessionToken = (sub, scopes = 'sessions') => ({
+    sessionToken: `jwt:${sub}|${scopes}`,
+});
 const keys = {
     ak_owner: { id: 'key_owner', userId: 'usr_owner', scopes: 'sessions', teamId: null },
     ak_other: { id: 'key_other', userId: 'usr_other', scopes: 'sessions', teamId: null },
@@ -174,7 +177,10 @@ describe('createSession — a lease-bound session proves it holds the lease', ()
             findById: (id) => __awaiter(void 0, void 0, void 0, function* () { return roles[id] ? { id, role: roles[id], status: 'ACTIVE' } : null; }),
         });
         typedi_1.Container.set(JwtKeyService_1.JwtKeyService, {
-            verify: (t) => __awaiter(void 0, void 0, void 0, function* () { return ({ sub: t.replace(/^jwt:/, ''), teamId: null }); }),
+            verify: (t) => __awaiter(void 0, void 0, void 0, function* () {
+                const [sub, scopes] = t.replace(/^jwt:/, '').split('|');
+                return { sub, teamId: null, scopes };
+            }),
         });
         teamRows = sinon_1.default.stub(prisma_1.prisma.teamMember, 'findMany').resolves([]);
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
@@ -331,8 +337,14 @@ describe('createSession — a lease-bound session proves it holds the lease', ()
         it("is allowed to a SUPER_ADMIN's key", () => __awaiter(void 0, void 0, void 0, function* () {
             (0, chai_1.expect)(yield allowed(sessionCaps(key('ak_super')))).to.equal(true);
         }));
+        // A session token minted from the dashboard carries the admin's admin
+        // scope; one minted with an ADMIN's narrower key doesn't, and overrides
+        // no more than that key does.
         it('is allowed to an ADMIN presenting a session token, as on the dashboard', () => __awaiter(void 0, void 0, void 0, function* () {
-            (0, chai_1.expect)(yield allowed(sessionCaps(sessionToken('usr_admin')))).to.equal(true);
+            (0, chai_1.expect)(yield allowed(sessionCaps(sessionToken('usr_admin', 'admin,sessions')))).to.equal(true);
+        }));
+        it("is refused to an ADMIN's session token minted without the admin scope", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield refusal(sessionCaps(sessionToken('usr_admin', 'sessions')))).to.equal(REFUSED);
         }));
         it('is refused to a member presenting a session token', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, chai_1.expect)(yield refusal(sessionCaps(sessionToken('usr_other')))).to.equal(REFUSED);

package/lib/test/unit/max-sessions.spec.js

@@ -0,0 +1,240 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = __importDefault(require("chai"));
+const sinon_1 = __importDefault(require("sinon"));
+const DeviceUtils = __importStar(require("../../src/device-utils"));
+const db_1 = require("../../src/data-service/db");
+const device_service_1 = require("../../src/data-service/device-service");
+const deviceClaims_1 = require("../../src/data-service/deviceClaims");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const test_container_1 = require("../helpers/test-container");
+const loki_stores_1 = require("../helpers/loki-stores");
+const scratch_database_1 = require("../helpers/scratch-database");
+const expect = chai_1.default.expect;
+/**
+ * `maxSessions` holds new sessions back once that many Appium sessions run.
+ *
+ * It compared the number of busy phones with `===`, so once the count was past
+ * the limit nothing was held back any more, and it counted every busy phone: a
+ * live preview, a recording, or an SDK lease nobody had started a session on
+ * used up a slot that no Appium session was using. What it counts now is the
+ * phones running a session, or being given one.
+ */
+describe('maxSessions', () => {
+    describe('which phones count', () => {
+        const base = { busy: true };
+        it('counts a session being created (a claim with no session id yet)', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { claimedAt: Date.now() }))).to.equal(true);
+        });
+        it('counts a session that is running', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { claimedAt: 1, claimSessionId: 'sess-1', session_id: 'sess-1' }))).to.equal(true);
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { session_id: 'sess-1' }))).to.equal(true);
+        });
+        it('does not count a live preview or a recording', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { session_id: 'manual_u1_phone-1' }))).to.equal(false);
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { session_id: 'manual_phone-1' }))).to.equal(false);
+        });
+        it('does not count a phone an SDK lease holds that has no session on it', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign({}, base))).to.equal(false);
+        });
+        it('counts a session started on a leased phone', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { claimSessionId: 'sess-2', claimedAt: 1 }))).to.equal(true);
+        });
+        it('does not count a phone that is not busy', () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)({ busy: false })).to.equal(false);
+            expect((0, deviceClaims_1.countsTowardMaxSessions)({ busy: false, session_id: 'sess-1' })).to.equal(false);
+        });
+        it("counts a node's phone the node reports busy, unless the node says it is a preview", () => {
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { nodeBusy: true }))).to.equal(true);
+            expect((0, deviceClaims_1.countsTowardMaxSessions)(Object.assign(Object.assign({}, base), { nodeBusy: true, nodeHold: 'manual_u1_phone-1' }))).to.equal(false);
+        });
+    });
+    describe('the limit itself', () => {
+        it('is the setting when it is a positive number', () => {
+            expect((0, deviceClaims_1.sessionCap)(8)).to.equal(8);
+            expect((0, deviceClaims_1.sessionCap)(1)).to.equal(1);
+        });
+        it('is no limit when it is unset, zero, negative or not a number', () => {
+            for (const value of [undefined, null, 0, -1, NaN, Infinity, '8']) {
+                expect((0, deviceClaims_1.sessionCap)(value), String(value)).to.equal(undefined);
+            }
+        });
+    });
+    describe('allocation', () => {
+        (0, loki_stores_1.useLokiStores)();
+        const scratch = (0, scratch_database_1.useScratchDatabase)();
+        const sandbox = sinon_1.default.createSandbox();
+        const HOST = 'http://127.0.0.1:4723';
+        const pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, {
+            iosDeviceType: 'both',
+            androidDeviceType: 'both',
+        });
+        const phone = (udid, over = {}) => (Object.assign({ udid, name: udid, platform: 'android', sdk: '13', host: HOST, busy: false, offline: false, userBlocked: false, state: 'device', deviceType: 'emulator', realDevice: false, systemPort: 57000, totalUtilizationTimeMilliSec: 0, sessionStartTime: 0 }, over));
+        // New each time: allocation pins the phone it picked into the caps it is given.
+        const caps = () => ({
+            alwaysMatch: { platformName: 'android' },
+            firstMatch: [{}],
+        });
+        const row = (udid) => __awaiter(void 0, void 0, void 0, function* () { return (yield db_1.XenonDatabase.DeviceModel).findOne({ udid }); });
+        /** Asks for a phone, waiting `ms` at most. Resolves to the udid, or null when held back. */
+        const ask = (ms = 400) => DeviceUtils.allocateDeviceForSession(caps(), ms, 50, pluginArgs).then((d) => d.udid, () => null);
+        const withCap = (maxSessions) => (0, test_container_1.createTestXenonManager)(Object.assign({}, pluginArgs, { maxSessions, platform: 'android' }));
+        before(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, test_container_1.resetTestContainer)();
+            yield (0, test_container_1.setupTestContainer)();
+        }));
+        after(() => (0, test_container_1.resetTestContainer)());
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+            yield scratch.db.lease.deleteMany({});
+            sandbox.stub(DeviceUtils, 'setUtilizationTime').resolves();
+        }));
+        afterEach(() => sandbox.restore());
+        const running = (n) => Array.from({ length: n }, (_, i) => phone(`running-${i}`, {
+            busy: true,
+            session_id: `sess-${i}`,
+            claimSessionId: `sess-${i}`,
+            claimedAt: 1,
+        }));
+        it('allocates while fewer sessions run than the limit', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)([...running(1), phone('free-1')]);
+            expect(yield ask()).to.equal('free-1');
+        }));
+        it('holds a session back at the limit', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)([...running(2), phone('free-1')]);
+            expect(yield ask()).to.equal(null);
+            expect((yield row('free-1')).busy).to.equal(false);
+        }));
+        it('still holds it back when more sessions run than the limit, which `===` let through', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)([...running(3), phone('free-1')]);
+            expect(yield ask()).to.equal(null);
+            expect((yield row('free-1')).busy).to.equal(false);
+        }));
+        it('gives the phone once a session ends', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)([...running(2), phone('free-1')]);
+            const waiting = ask(2000);
+            yield new Promise((r) => setTimeout(r, 150));
+            (yield db_1.XenonDatabase.DeviceModel)
+                .chain()
+                .find({ udid: 'running-0' })
+                .update((d) => Object.assign(d, {
+                busy: false,
+                session_id: null,
+                claimSessionId: null,
+                claimedAt: null,
+            }));
+            expect(yield waiting).to.be.oneOf(['free-1', 'running-0']);
+        }));
+        it('does not count live previews: they are not sessions', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)([
+                phone('preview-1', { busy: true, session_id: 'manual_u1_preview-1' }),
+                phone('preview-2', { busy: true, session_id: 'manual_u1_preview-2' }),
+                phone('free-1'),
+            ]);
+            expect(yield ask()).to.equal('free-1');
+        }));
+        it('does not count a leased phone no session is running on', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(1);
+            yield (0, device_service_1.addNewDevice)([phone('leased-1', { busy: true }), phone('free-1')]);
+            yield scratch.db.lease.create({
+                data: {
+                    tokenHash: 'h',
+                    deviceUdid: 'leased-1',
+                    deviceHost: HOST,
+                    actorId: 'key_owner',
+                    status: 'active',
+                    expiresAt: Date.now() + 600000,
+                    lastHeartbeatAt: Date.now(),
+                    allocatedPorts: '{}',
+                    capabilityBag: '{}',
+                },
+            });
+            expect(yield ask()).to.equal('free-1');
+        }));
+        it('counts a session started on a leased phone', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(1);
+            yield (0, device_service_1.addNewDevice)([
+                phone('leased-1', {
+                    busy: true,
+                    session_id: 'sess-l',
+                    claimSessionId: 'sess-l',
+                    claimedAt: 1,
+                }),
+                phone('free-1'),
+            ]);
+            expect(yield ask()).to.equal(null);
+        }));
+        it('counts a session still being created', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(1);
+            yield (0, device_service_1.addNewDevice)([
+                phone('pending-1', { busy: true, claimedAt: Date.now() }),
+                phone('free-1'),
+            ]);
+            expect(yield ask()).to.equal(null);
+        }));
+        it('holds back exactly the sessions over the limit when many ask at once', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(2);
+            yield (0, device_service_1.addNewDevice)(Array.from({ length: 6 }, (_, i) => phone(`free-${i}`)));
+            const got = yield Promise.all(Array.from({ length: 5 }, () => ask(300)));
+            const given = got.filter((udid) => udid !== null);
+            expect(given, JSON.stringify(got)).to.have.length(2);
+            expect(new Set(given).size).to.equal(2);
+        }));
+        it('has no limit when the setting is not a positive number', () => __awaiter(void 0, void 0, void 0, function* () {
+            withCap(0);
+            yield (0, device_service_1.addNewDevice)([...running(3), phone('free-1')]);
+            expect(yield ask()).to.equal('free-1');
+        }));
+    });
+});