@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/test/unit/emulator-boot.spec.js

@@ -0,0 +1,91 @@
+"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 appium_adb_1 = require("appium-adb");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+/**
+ * `emulators` lists Android emulators (AVDs) for the server to boot at
+ * startup, with the launch options each one needs. It used to boot them only
+ * when `platform` was exactly an Android one, so with the default `both` it
+ * booted nothing, and schema.json described it as an allow-list that
+ * discovery never applied. Discovery is not filtered by it: a booted emulator
+ * is found like any other.
+ */
+describe('booting the configured emulators', () => {
+    afterEach(() => sinon_1.default.restore());
+    function args(over) {
+        return Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), over);
+    }
+    function fakeAdb(launch) {
+        const launchAVD = sinon_1.default.stub().callsFake(launch !== null && launch !== void 0 ? launch : (() => __awaiter(this, void 0, void 0, function* () { return undefined; })));
+        const createADB = sinon_1.default.stub(appium_adb_1.ADB, 'createADB').resolves({ launchAVD });
+        return { launchAVD, createADB };
+    }
+    const boot = (pluginArgs) => typedi_1.Container.get(ServerManager_1.ServerManager).bootEmulators(pluginArgs);
+    const EMULATORS = [
+        { avdName: 'Pixel_7', args: ['-no-snapshot-load'] },
+        { avdName: 'Pixel_Tablet' },
+    ];
+    it('boots them when the platform is android', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD } = fakeAdb();
+        yield boot(args({ platform: 'android', emulators: EMULATORS }));
+        (0, chai_1.expect)(launchAVD.args.map((a) => a[0])).to.have.members(['Pixel_7', 'Pixel_Tablet']);
+    }));
+    it('boots them when the platform is both, the default', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD } = fakeAdb();
+        yield boot(args({ platform: 'both', emulators: EMULATORS }));
+        (0, chai_1.expect)(launchAVD.args.map((a) => a[0])).to.have.members(['Pixel_7', 'Pixel_Tablet']);
+    }));
+    it("passes each emulator's own launch options on", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD } = fakeAdb();
+        yield boot(args({ platform: 'both', emulators: EMULATORS }));
+        const pixel = launchAVD.args.find((a) => a[0] === 'Pixel_7');
+        (0, chai_1.expect)(pixel === null || pixel === void 0 ? void 0 : pixel[1]).to.include({ avdName: 'Pixel_7' });
+        (0, chai_1.expect)(pixel === null || pixel === void 0 ? void 0 : pixel[1].args).to.deep.equal(['-no-snapshot-load']);
+    }));
+    it('boots nothing for an iOS-only server', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD, createADB } = fakeAdb();
+        yield boot(args({ platform: 'ios', emulators: EMULATORS }));
+        (0, chai_1.expect)(createADB.called).to.equal(false);
+        (0, chai_1.expect)(launchAVD.called).to.equal(false);
+    }));
+    it('boots nothing when only real Android devices are wanted', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD } = fakeAdb();
+        yield boot(args({ platform: 'both', androidDeviceType: 'real', emulators: EMULATORS }));
+        (0, chai_1.expect)(launchAVD.called).to.equal(false);
+    }));
+    it('boots nothing when none is listed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD, createADB } = fakeAdb();
+        yield boot(args({ platform: 'both', emulators: [] }));
+        (0, chai_1.expect)(createADB.called).to.equal(false);
+        (0, chai_1.expect)(launchAVD.called).to.equal(false);
+    }));
+    it('does not stop the server from starting when one emulator will not boot', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { launchAVD } = fakeAdb((avd) => __awaiter(void 0, void 0, void 0, function* () {
+            if (avd === 'Pixel_7')
+                throw new Error('Emulator is not ready');
+        }));
+        yield boot(args({ platform: 'both', emulators: EMULATORS }));
+        (0, chai_1.expect)(launchAVD.args.map((a) => a[0])).to.have.members(['Pixel_7', 'Pixel_Tablet']);
+    }));
+    it('does not stop the server from starting when there is no Android SDK', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(appium_adb_1.ADB, 'createADB').rejects(new Error('ANDROID_HOME is not set'));
+        yield boot(args({ platform: 'both', emulators: EMULATORS }));
+    }));
+});

package/lib/test/unit/hub-node-gateway-appium-server.spec.js

@@ -126,6 +126,8 @@ function fakeDriver(name) {
             }
             if (command === 'stopRecordingScreen')
                 return 'node-video.mp4';
+            if (command === 'execute')
+                return { ranOn: name, script: args[0] };
             if (command === 'deleteSession') {
                 sessions.delete(args[0]);
                 return null;
@@ -178,6 +180,9 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
         typedi_1.Container.set(SessionOwnerResolver_1.SessionOwnerResolver, new SessionOwnerResolver_1.SessionOwnerResolver());
         savedStore = device_store_1.DeviceStoreFactory._deviceStore;
         device_store_1.DeviceStoreFactory._deviceStore = new prisma_store_1.PrismaDeviceStore();
+        // A dashboard-on hub logs each forwarded command against its session.
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.log.deleteMany({});
         yield scratch.db.session.deleteMany({});
         yield scratch.db.device.deleteMany({});
         nodeRequests = [];
@@ -418,6 +423,49 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
             (0, chai_1.expect)(hub.commands).to.deep.equal([]);
         }));
     });
+    describe('xenon: execute scripts for a node’s phone', () => {
+        // With the hub's dashboard on, its before-hook used to take every
+        // `xenon:`/`xe:` script as a dashboard command and answer `{ value: null }`
+        // itself, so autowait, Omni-Vision and network-capture scripts for a node's
+        // phone never reached the node.
+        const execute = (id, script, args = [{}]) => (0, loopbackRequest_1.default)(hubUrl).post(`/wd/hub/session/${id}/execute/sync`).send({ script, args });
+        it('forwards Xenon’s scripts other than session details to the node, which answers them', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const scripts = [
+                'xenon: setAutowaitProperties',
+                'xe: smartTap',
+                'xenon: assertVisualState',
+                'xenon: addMock',
+                'xenon: notACommand',
+            ];
+            for (const script of scripts) {
+                const res = yield execute(id, script);
+                (0, chai_1.expect)(res.status, script).to.equal(200);
+                (0, chai_1.expect)(res.body.value, script).to.deep.equal({ ranOn: 'node', script });
+            }
+            (0, chai_1.expect)(node.commands).to.deep.equal(scripts.map(() => 'execute'));
+            (0, chai_1.expect)(hub.commands).to.deep.equal([]);
+        }));
+        it('answers a session-details command on the hub, from its own record; the node never sees it', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const res = yield execute(id, 'xenon: setSessionName', ['Checkout']);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body).to.deep.equal({ value: { recorded: true } });
+            (0, chai_1.expect)(node.commands).to.deep.equal([]);
+            (0, chai_1.expect)(hub.commands).to.deep.equal([]);
+            const row = yield scratch.db.session.findUnique({ where: { id } });
+            (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.name).to.equal('Checkout');
+        }));
+        it('with the hub’s dashboard off, sends a session-details command on to the node', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: false });
+            const { id } = yield remoteSession();
+            const res = yield execute(id, 'xenon: setSessionName', ['Checkout']);
+            (0, chai_1.expect)(res.body.value).to.deep.equal({ ranOn: 'node', script: 'xenon: setSessionName' });
+            (0, chai_1.expect)(node.commands).to.deep.equal(['execute']);
+        }));
+    });
     describe('DELETE of a remote session', () => {
         it('runs the session lifecycle with the forward as its driver step', () => __awaiter(this, void 0, void 0, function* () {
             yield boot({ nodeAuth: true });

package/lib/test/unit/hub-node-same-host.spec.js

@@ -133,6 +133,11 @@ describe('A hub and a node on one machine keep to their own phones', () => {
         for (const m of Object.keys(table.delegate)) {
             sinon_1.default.stub(prisma_1.prisma.device, m).callsFake(table.delegate[m]);
         }
+        // The phones' saved settings (deviceSettings.ts), so none reach a database.
+        const settings = (0, fake_device_table_1.fakeDeviceSettingTable)();
+        for (const m of Object.keys(settings.delegate)) {
+            sinon_1.default.stub(prisma_1.prisma.deviceSetting, m).callsFake(settings.delegate[m]);
+        }
     };
     beforeEach(() => {
         discover = () => __awaiter(void 0, void 0, void 0, function* () { return []; });

package/lib/test/unit/iphone-ipad-only.spec.js

@@ -0,0 +1,132 @@
+"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 prisma_store_1 = require("../../src/data-service/prisma-store");
+const device_utils_1 = require("../../src/device-utils");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * `appium:iPhoneOnly` / `appium:iPadOnly` become a device filter in
+ * getDeviceFiltersFromCapability, but the Prisma store, the one a running
+ * server uses, never applied it: a session asking for an iPad could be given
+ * an iPhone. These run the real store against a real (scratch) database, from
+ * the capability to the rows that come back.
+ *
+ * A real iPhone's name is whatever its owner typed ("QA-Phone-3"), so the
+ * family is read from what the phone reports (its model, then its form
+ * factor), and only from its name for a row written before those existed.
+ */
+const HOST = 'http://127.0.0.1:4723';
+const row = (udid, over) => (Object.assign({ udid, host: HOST, platform: 'ios', deviceType: 'real', realDevice: true, busy: false, userBlocked: false }, over));
+const DEVICES = [
+    // Simulators: the name is the marketing name, and the form factor comes from it.
+    row('sim-iphone', {
+        name: 'iPhone 16 Pro',
+        deviceType: 'simulator',
+        realDevice: false,
+        formFactor: 'phone',
+        marketingName: 'iPhone 16 Pro',
+    }),
+    row('sim-ipad', {
+        name: 'iPad Pro 13-inch (M4)',
+        deviceType: 'simulator',
+        realDevice: false,
+        formFactor: 'tablet',
+        marketingName: 'iPad Pro 13-inch (M4)',
+    }),
+    row('sim-tv', {
+        name: 'Apple TV 4K',
+        deviceType: 'simulator',
+        realDevice: false,
+        formFactor: 'tv',
+        marketingName: 'Apple TV 4K',
+    }),
+    // Real phones, named by their owners.
+    row('real-iphone', {
+        name: 'QA-Phone-3',
+        model: 'iPhone17,3',
+        formFactor: 'phone',
+        marketingName: 'iPhone 16',
+    }),
+    row('real-ipad-named-iphone', {
+        name: 'iPhone spare',
+        model: 'iPad13,4',
+        formFactor: 'tablet',
+        marketingName: 'iPad Pro 11-inch (3rd generation)',
+    }),
+    // Rows written before the identity columns: only the name is known.
+    row('old-iphone', { name: 'iPhone 13' }),
+    row('old-ipad', { name: 'iPad (9th generation)' }),
+    row('old-unnamed', { name: 'unknown' }),
+    // Android: never an iPhone or an iPad, whatever its form factor.
+    row('pixel', {
+        name: 'Pixel 7',
+        platform: 'android',
+        formFactor: 'phone',
+        model: 'Pixel 7',
+    }),
+    row('pixel-tablet', {
+        name: 'Pixel Tablet',
+        platform: 'android',
+        formFactor: 'tablet',
+        model: 'Pixel Tablet',
+    }),
+];
+describe('appium:iPhoneOnly and appium:iPadOnly', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.device.deleteMany({});
+        for (const d of DEVICES)
+            yield scratch.db.device.create({ data: d });
+    }));
+    /** The udids a session with these capabilities may be given. */
+    function allocatable(caps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filter = (0, device_utils_1.getDeviceFiltersFromCapability)(caps, IPluginArgs_1.DefaultPluginArgs);
+            const found = yield new prisma_store_1.PrismaDeviceStore().getDevices(filter);
+            return found.map((d) => d.udid).sort();
+        });
+    }
+    it('iPhoneOnly gets iPhones: by model, by form factor, and by name for an old row', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, chai_1.expect)(yield allocatable({ platformName: 'iOS', 'appium:iPhoneOnly': true })).to.deep.equal([
+            'old-iphone',
+            'real-iphone',
+            'sim-iphone',
+        ]);
+    }));
+    it('iPadOnly gets iPads, including one named for an iPhone', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, chai_1.expect)(yield allocatable({ platformName: 'iOS', 'appium:iPadOnly': true })).to.deep.equal([
+            'old-ipad',
+            'real-ipad-named-iphone',
+            'sim-ipad',
+        ]);
+    }));
+    it('gives an iPad when both are asked for, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, chai_1.expect)(yield allocatable({
+            platformName: 'iOS',
+            'appium:iPhoneOnly': true,
+            'appium:iPadOnly': true,
+        })).to.deep.equal(['old-ipad', 'real-ipad-named-iphone', 'sim-ipad']);
+    }));
+    it('never gives an Android phone, even when the platform is not named', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ids = yield allocatable({ 'appium:iPadOnly': true });
+        (0, chai_1.expect)(ids).to.not.include.members(['pixel-tablet']);
+        const phones = yield allocatable({ 'appium:iPhoneOnly': true });
+        (0, chai_1.expect)(phones).to.not.include.members(['pixel']);
+    }));
+    it('filters nothing without either capability', () => __awaiter(void 0, void 0, void 0, function* () {
+        const all = yield allocatable({ platformName: 'iOS' });
+        (0, chai_1.expect)(all).to.include.members(['sim-iphone', 'sim-ipad', 'real-iphone', 'old-unnamed']);
+        (0, chai_1.expect)(all).to.not.include.members(['pixel', 'pixel-tablet']);
+    }));
+});

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/allocate-lease-branch.spec.js

@@ -41,6 +41,7 @@ describe('allocateDeviceForSession — lease-bound session', () => {
     let device;
     let lease;
     let restore;
+    let updateDevice;
     const allocate = (proof, callerTeamIds) => (0, device_utils_1.allocateDeviceForSession)(leaseCaps(), 1000, 100, IPluginArgs_1.DefaultPluginArgs, callerTeamIds, proof);
     const refusedWith = (proof, callerTeamIds) => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -71,8 +72,10 @@ describe('allocateDeviceForSession — lease-bound session', () => {
         const noAuth = { nodePairAuth: () => __awaiter(void 0, void 0, void 0, function* () { return ({ accessKey: '', token: '' }); }) };
         restore = (0, container_registration_1.saveRegistrations)(LeaseService_1.LeaseService);
         typedi_1.Container.set(LeaseService_1.LeaseService, new LeaseService_1.LeaseService(db, {}, {}, noAuth));
+        updateDevice = sinon_1.default.stub().resolves();
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
             findDevice: sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return device; })),
+            updateDevice,
         });
     });
     afterEach(() => {
@@ -94,6 +97,25 @@ describe('allocateDeviceForSession — lease-bound session', () => {
             (0, chai_1.expect)(got.udid).to.equal('u1');
         }));
     });
+    describe('the idle sweeper reads the session, not the lease', () => {
+        // It used to read the server-wide newCommandTimeoutSec and the lease's
+        // creation time, so a leased session was ended a minute after the lease
+        // was taken, whatever the session asked for.
+        it("records the session's newCommandTimeout and its start", () => __awaiter(void 0, void 0, void 0, function* () {
+            const caps = leaseCaps();
+            caps.alwaysMatch['appium:newCommandTimeout'] = 120;
+            const before = Date.now();
+            yield (0, device_utils_1.allocateDeviceForSession)(caps, 1000, 100, IPluginArgs_1.DefaultPluginArgs, undefined, Object.assign(Object.assign({}, NOBODY), { leaseToken: TOKEN }));
+            const [udid, host, written] = updateDevice.firstCall.args;
+            (0, chai_1.expect)([udid, host]).to.deep.equal(['u1', 'h1']);
+            (0, chai_1.expect)(written.newCommandTimeout).to.equal(120);
+            (0, chai_1.expect)(written.lastCmdExecutedAt).to.be.at.least(before);
+        }));
+        it("falls back to the server's newCommandTimeoutSec", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield allocate(Object.assign(Object.assign({}, NOBODY), { leaseToken: TOKEN }));
+            (0, chai_1.expect)(updateDevice.firstCall.args[2].newCommandTimeout).to.equal(IPluginArgs_1.DefaultPluginArgs.newCommandTimeoutSec);
+        }));
+    });
     describe("someone else's lease id is refused, as if it were not active", () => {
         it('with no credentials and no token', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, chai_1.expect)(yield refusal(NOBODY)).to.equal(REFUSED);