@xenon-device-management/xenon 2.13.2 → 2.14.0

package/lib/test/unit/recording-options.spec.js

@@ -0,0 +1,181 @@
+"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 plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const concurrency_gate_1 = require("../../src/services/recording/concurrency-gate");
+const config_1 = require("../../src/config");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * `maxConcurrentRecordings` and `recordingsAssetsPath` are declared in
+ * schema.json, so Appium accepts them in a config file, but nothing read them:
+ * only the XENON_MAX_CONCURRENT_RECORDINGS and XENON_RECORDINGS_ASSETS_PATH
+ * environment variables reached src/config.ts. The option now wins, the
+ * variable is the fallback, and both are applied at boot before anything that
+ * reads them (the artifact store, the concurrency gate).
+ */
+describe('the recording options', () => {
+    let saved;
+    let env;
+    let statics;
+    beforeEach(() => {
+        saved = { max: config_1.config.maxConcurrentRecordings, path: config_1.config.recordingsAssetsPath };
+        env = {
+            max: process.env.XENON_MAX_CONCURRENT_RECORDINGS,
+            path: process.env.XENON_RECORDINGS_ASSETS_PATH,
+        };
+        delete process.env.XENON_MAX_CONCURRENT_RECORDINGS;
+        delete process.env.XENON_RECORDINGS_ASSETS_PATH;
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        (0, config_1.updateConfig)({ maxConcurrentRecordings: saved.max, recordingsAssetsPath: saved.path });
+        for (const [name, value] of [
+            ['XENON_MAX_CONCURRENT_RECORDINGS', env.max],
+            ['XENON_RECORDINGS_ASSETS_PATH', env.path],
+        ]) {
+            if (value === undefined)
+                delete process.env[name];
+            else
+                process.env[name] = value;
+        }
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    /**
+     * Boots as far as the database step and says what the options were when it
+     * began: the artifact store is built there from `recordingsAssetsPath`.
+     */
+    function seenAtDatabaseStep(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seen = {};
+            const boot = ServerManager_1.ServerManager.prototype;
+            sinon_1.default.stub(boot, 'resolvePluginArgs').resolves(pluginArgs);
+            sinon_1.default.stub(logger_1.default, 'banner');
+            sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+            sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').resolves();
+            sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(() => __awaiter(this, void 0, void 0, function* () {
+                seen.max = config_1.config.maxConcurrentRecordings;
+                seen.path = config_1.config.recordingsAssetsPath;
+                throw new Error('boot stopped by the test');
+            }));
+            yield typedi_1.Container.get(ServerManager_1.ServerManager)
+                .updateServer({}, null, { port: 4723 })
+                .catch((err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+            return seen;
+        });
+    }
+    describe('applied at boot', () => {
+        it('takes the maxConcurrentRecordings option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const seen = yield seenAtDatabaseStep({ maxConcurrentRecordings: 2 });
+            (0, chai_1.expect)(seen.max).to.equal(2);
+        }));
+        it('takes the recordingsAssetsPath option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const seen = yield seenAtDatabaseStep({ recordingsAssetsPath: '/srv/xenon/recordings' });
+            (0, chai_1.expect)(seen.path).to.equal('/srv/xenon/recordings');
+        }));
+        it('falls back to the environment variables when the options are not set', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.XENON_MAX_CONCURRENT_RECORDINGS = '7';
+            process.env.XENON_RECORDINGS_ASSETS_PATH = '/mnt/recordings';
+            const seen = yield seenAtDatabaseStep({});
+            (0, chai_1.expect)(seen).to.deep.equal({ max: 7, path: '/mnt/recordings' });
+        }));
+        it('lets the option win over the environment variable', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.XENON_MAX_CONCURRENT_RECORDINGS = '7';
+            process.env.XENON_RECORDINGS_ASSETS_PATH = '/mnt/recordings';
+            const seen = yield seenAtDatabaseStep({
+                maxConcurrentRecordings: 3,
+                recordingsAssetsPath: '/srv/xenon/recordings',
+            });
+            (0, chai_1.expect)(seen).to.deep.equal({ max: 3, path: '/srv/xenon/recordings' });
+        }));
+        it('keeps the default cap of 4 when neither is set', () => __awaiter(void 0, void 0, void 0, function* () {
+            const seen = yield seenAtDatabaseStep({});
+            (0, chai_1.expect)(seen.max).to.equal(4);
+        }));
+        it('ignores a cap that is not a whole number of at least 1', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const bad of [0, -2, 2.5, NaN, '3', null]) {
+                const seen = yield seenAtDatabaseStep({ maxConcurrentRecordings: bad });
+                (0, chai_1.expect)(seen.max, `option ${JSON.stringify(bad)}`).to.equal(4);
+                sinon_1.default.restore();
+            }
+        }));
+        it('ignores an environment cap that is not a whole number of at least 1', () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.XENON_MAX_CONCURRENT_RECORDINGS = 'many';
+            const seen = yield seenAtDatabaseStep({});
+            (0, chai_1.expect)(seen.max).to.equal(4);
+        }));
+        it('ignores a blank recordingsAssetsPath', () => __awaiter(void 0, void 0, void 0, function* () {
+            const seen = yield seenAtDatabaseStep({ recordingsAssetsPath: '   ' });
+            (0, chai_1.expect)(seen.path).to.equal(saved.path);
+        }));
+    });
+    describe('the concurrency gate', () => {
+        it('reads the cap when it admits, not when it is built', () => {
+            (0, config_1.updateConfig)({ maxConcurrentRecordings: 4 });
+            const gate = new concurrency_gate_1.ConcurrencyGate();
+            (0, config_1.updateConfig)({ maxConcurrentRecordings: 1 });
+            (0, chai_1.expect)(gate.getLimit()).to.equal(1);
+            (0, chai_1.expect)(gate.tryAcquire(['r1'])).to.equal(true);
+            (0, chai_1.expect)(gate.tryAcquire(['r2'])).to.equal(false);
+        });
+        it('keeps an explicit limit over the configured one', () => {
+            (0, config_1.updateConfig)({ maxConcurrentRecordings: 4 });
+            (0, chai_1.expect)(new concurrency_gate_1.ConcurrencyGate(2).getLimit()).to.equal(2);
+        });
+    });
+});
+describe('resolving the recording options', () => {
+    describe('maxConcurrentRecordings', () => {
+        it('takes the option, then the variable, then 4', () => {
+            (0, chai_1.expect)((0, config_1.resolveMaxConcurrentRecordings)(2, '7')).to.equal(2);
+            (0, chai_1.expect)((0, config_1.resolveMaxConcurrentRecordings)(undefined, '7')).to.equal(7);
+            (0, chai_1.expect)((0, config_1.resolveMaxConcurrentRecordings)(undefined, undefined)).to.equal(4);
+        });
+        it('passes over a value that is not a whole number of at least 1', () => {
+            for (const bad of [0, -1, 1.5, NaN, Infinity, '2', null, {}]) {
+                (0, chai_1.expect)((0, config_1.resolveMaxConcurrentRecordings)(bad, '7'), JSON.stringify(bad)).to.equal(7);
+            }
+            for (const bad of ['', ' ', '0', '-3', '2.5', 'many', 'NaN']) {
+                (0, chai_1.expect)((0, config_1.resolveMaxConcurrentRecordings)(undefined, bad), JSON.stringify(bad)).to.equal(4);
+            }
+        });
+    });
+    describe('recordingsAssetsPath', () => {
+        it('takes the option, then the variable, then the default folder', () => {
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)('/a', '/b')).to.equal('/a');
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)(undefined, '/b')).to.equal('/b');
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)(undefined, undefined)).to.match(/\.cache\/xenon\/assets\/sessions\/recordings$/);
+        });
+        it('counts a blank value as unset', () => {
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)('  ', '/b')).to.equal('/b');
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)(undefined, '')).to.match(/recordings$/);
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)(42, undefined)).to.match(/recordings$/);
+        });
+        it('trims what it is given', () => {
+            (0, chai_1.expect)((0, config_1.resolveRecordingsAssetsPath)(' /a ', undefined)).to.equal('/a');
+        });
+    });
+});

package/lib/test/unit/self-healing-boot.spec.js

@@ -0,0 +1,75 @@
+"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 plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * The self-healing value saved on the Settings page is read once at boot, so a
+ * restart doesn't put the server back on the option it was started with. It
+ * has to be loaded once the database is ready (migrations ran) and before the
+ * first route can answer or the first command arrive.
+ */
+describe('loading the saved self-healing setting, at boot', () => {
+    let statics;
+    beforeEach(() => {
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    it('runs once the database is ready, before routes are registered', () => __awaiter(void 0, void 0, void 0, function* () {
+        const steps = [];
+        const step = (name) => () => {
+            steps.push(name);
+            return Promise.resolve();
+        };
+        const boot = ServerManager_1.ServerManager.prototype;
+        sinon_1.default.stub(boot, 'resolvePluginArgs').resolves({});
+        sinon_1.default.stub(logger_1.default, 'banner');
+        sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+        sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').callsFake(step('database config'));
+        sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(step('database and migrations'));
+        // The real one kills every go-ios process on the machine.
+        sinon_1.default.stub(boot, 'reapLeftoverGoIos').callsFake(step('reap'));
+        sinon_1.default.stub(SelfHealingSwitch_1.SelfHealingSwitch.prototype, 'load').callsFake(step('self-healing setting'));
+        sinon_1.default.stub(boot, 'registerRoutes').callsFake(() => {
+            steps.push('routes');
+            throw new Error('boot stopped by the test');
+        });
+        yield typedi_1.Container.get(ServerManager_1.ServerManager)
+            .updateServer({}, null, { port: 4723 })
+            .then(() => chai_1.expect.fail('the stubbed routes step should have stopped the boot'), (err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+        (0, chai_1.expect)(steps).to.deep.equal([
+            'database config',
+            'database and migrations',
+            'reap',
+            'self-healing setting',
+            'routes',
+        ]);
+    }));
+});

package/lib/test/unit/self-healing-setting.spec.js

@@ -0,0 +1,272 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+const PluginContext_1 = require("../../src/PluginContext");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const web_config_service_1 = require("../../src/data-service/web-config-service");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const logger_1 = __importDefault(require("../../src/logger"));
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * The Settings page's "AI self-healing" toggle used to do nothing: POST /config
+ * stored only the fields its table knew, GET /config never sent the switch back
+ * (so the page always showed Enabled), and CommandInterceptor read the copy of
+ * the plugin options the server started with, which nothing updates.
+ *
+ * It follows the other lab settings now: a value saved in the dashboard wins
+ * over the startup option, which wins over the default, and applies to the very
+ * next command without a restart. The interceptor runs on every command, so it
+ * reads an in-memory value (SelfHealingSwitch), never the database.
+ */
+describe('the AI self-healing switch', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let context;
+    let startedWith;
+    let restoreContainer;
+    let healingSwitch;
+    const startup = (over = {}) => {
+        context.pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), over);
+        return context.pluginArgs;
+    };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        startedWith = context.pluginArgs;
+        restoreContainer = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+        // A switch of its own, as at boot, so no saved value leaks in from another spec.
+        typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+        healingSwitch = typedi_1.Container.get(SelfHealingSwitch_1.SelfHealingSwitch);
+        yield scratch.db.webConfig.deleteMany({});
+    }));
+    afterEach(() => {
+        context.pluginArgs = startedWith;
+        restoreContainer();
+        sinon_1.default.restore();
+    });
+    function app() {
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use((req, _res, next) => {
+            req.auth = {
+                kind: 'user-session',
+                userId: 'usr_x',
+                role: 'SUPER_ADMIN',
+                scopes: 'admin,devices,sessions,read',
+                rateLimit: 1000,
+            };
+            next();
+        });
+        dashboard_1.default.register(a);
+        return a;
+    }
+    const save = (body) => (0, loopbackRequest_1.default)(app()).post('/config').send(body).timeout(5000);
+    const read = () => (0, loopbackRequest_1.default)(app()).get('/config').timeout(5000);
+    describe('as the Settings page saves and reads it', () => {
+        it('is kept: what POST /config saves, GET /config sends back', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            const saved = yield save({ enableSelfHealing: false });
+            (0, chai_1.expect)(saved.status).to.equal(200);
+            const shown = yield read();
+            (0, chai_1.expect)(shown.status).to.equal(200);
+            (0, chai_1.expect)(shown.body.enableSelfHealing).to.equal(false);
+            (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({
+                enableSelfHealing: false,
+            });
+        }));
+        it('can be turned back on', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            yield save({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(true);
+        }));
+        it('is on, and says so, when nothing was saved and the server was started with nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            const shown = yield read();
+            (0, chai_1.expect)(shown.body.enableSelfHealing).to.equal(true);
+            (0, chai_1.expect)(shown.body.defaults.enableSelfHealing).to.equal(true);
+        }));
+        it('shows the option the server started with when nothing was saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup({ enableSelfHealing: false });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(false);
+        }));
+        it('shows a saved value over the option the server started with', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(true);
+        }));
+        it('is saved on its own, without touching the other settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            yield save({ buildCleanupDays: 7 });
+            yield save({ enableSelfHealing: false });
+            (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({
+                buildCleanupDays: 7,
+                enableSelfHealing: false,
+            });
+        }));
+        for (const bad of ['false', 'no', 0, 1, null, {}, []]) {
+            it(`refuses ${JSON.stringify(bad)} with a 400 naming the setting, and saves nothing`, () => __awaiter(void 0, void 0, void 0, function* () {
+                startup();
+                const refused = yield save({ enableSelfHealing: bad, buildCleanupDays: 9 });
+                (0, chai_1.expect)(refused.status).to.equal(400);
+                (0, chai_1.expect)(refused.body).to.include({ error: 'invalid_setting', field: 'enableSelfHealing' });
+                (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({});
+            }));
+        }
+    });
+    describe('on a running interceptor', () => {
+        const noSuchElement = () => Object.assign(new Error('NoSuchElement: An element could not be located'), {
+            name: 'NoSuchElementError',
+        });
+        let attemptHealing;
+        let pluginArgs;
+        beforeEach(() => {
+            pluginArgs = startup();
+            attemptHealing = sinon_1.default.stub().resolves(null);
+            typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, { attemptHealing });
+        });
+        /** A findElement the driver answers with NoSuchElement, as a broken selector does. */
+        function findMissing(sessionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let thrown;
+                try {
+                    yield typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(() => __awaiter(this, void 0, void 0, function* () {
+                        throw noSuchElement();
+                    }), { sessionId }, 'findElement', ['xpath', '//android.widget.Button[@text="Gone"]', sessionId], pluginArgs, false);
+                }
+                catch (err) {
+                    thrown = err;
+                }
+                return thrown;
+            });
+        }
+        it('heals a missing element while the switch is on, as it always did', () => __awaiter(void 0, void 0, void 0, function* () {
+            const thrown = yield findMissing('sess-on');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+            // Nothing healed it, so the test still sees its own NoSuchElement.
+            (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+        }));
+        it('stops healing for the next command once off is saved, with no restart', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield findMissing('sess-1');
+            (0, chai_1.expect)(attemptHealing.callCount).to.equal(1);
+            (0, chai_1.expect)((yield save({ enableSelfHealing: false })).status).to.equal(200);
+            const thrown = yield findMissing('sess-1');
+            (0, chai_1.expect)(attemptHealing.callCount).to.equal(1);
+            // The failure reaches the test untouched, which is the point of turning it off.
+            (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+        }));
+        it('heals again once on is saved after off', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield save({ enableSelfHealing: false });
+            yield findMissing('sess-2');
+            (0, chai_1.expect)(attemptHealing.called).to.equal(false);
+            yield save({ enableSelfHealing: true });
+            yield findMissing('sess-2');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+        }));
+        it('does not read the database for a command', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield save({ enableSelfHealing: false });
+            const reads = sinon_1.default.spy(typedi_1.Container.get(web_config_service_1.WebConfigService), 'getConfig');
+            yield findMissing('sess-3');
+            yield findMissing('sess-3');
+            (0, chai_1.expect)(reads.called).to.equal(false);
+        }));
+        it('follows the startup option when nothing is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginArgs = startup({ enableSelfHealing: false });
+            yield findMissing('sess-4');
+            (0, chai_1.expect)(attemptHealing.called).to.equal(false);
+        }));
+        it('lets a saved on beat a startup off', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginArgs = startup({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            yield findMissing('sess-5');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+        }));
+        it("still hands a session's own healing tiers to the healing it runs", () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns({
+                getCapabilities: () => ({ 'xe:options': { healingTiers: [1, 2] } }),
+            });
+            const driver = { sessionId: 'sess-6' };
+            yield typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor)
+                .handle(() => __awaiter(void 0, void 0, void 0, function* () {
+                throw noSuchElement();
+            }), driver, 'findElement', ['id', 'gone', 'sess-6'], pluginArgs, false)
+                .catch(() => undefined);
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+            (0, chai_1.expect)(attemptHealing.firstCall.args).to.deep.equal(['sess-6', driver, 'id', 'gone', [1, 2]]);
+        }));
+        describe('and what it learns from a found element', () => {
+            let learn;
+            beforeEach(() => {
+                sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'afterSessionCommand').resolves();
+                learn = sinon_1.default.stub(CommandInterceptor_1.CommandInterceptor.prototype, 'triggerLearning');
+            });
+            const afterFind = () => typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).runPostCommandHooks('sess-7', 'findElement', {}, ['id', 'there'], { ELEMENT: 'el-1' }, pluginArgs);
+            it('learns the selector while the switch is on', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield afterFind();
+                (0, chai_1.expect)(learn.calledOnce).to.equal(true);
+            }));
+            it('learns nothing once off is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield save({ enableSelfHealing: false });
+                yield afterFind();
+                (0, chai_1.expect)(learn.called).to.equal(false);
+            }));
+        });
+    });
+    describe('at boot', () => {
+        it('is the saved value, over the startup option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pluginArgs = startup({ enableSelfHealing: true });
+            yield scratch.db.webConfig.create({
+                data: { id: 'enableSelfHealing', name: 'enableSelfHealing', value: 'false' },
+            });
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled(pluginArgs)).to.equal(false);
+        }));
+        it('is the startup option when nothing is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled(startup({ enableSelfHealing: false }))).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled(startup({ enableSelfHealing: true }))).to.equal(true);
+        }));
+        it('is on when neither was set', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled({})).to.equal(true);
+        }));
+        it('is the startup option, and says so once, when the saved value cannot be read', () => __awaiter(void 0, void 0, void 0, function* () {
+            const warn = sinon_1.default.stub(logger_1.default, 'warn');
+            sinon_1.default.stub(typedi_1.Container.get(web_config_service_1.WebConfigService), 'getConfig').rejects(new Error('db is down'));
+            yield healingSwitch.load();
+            const off = startup({ enableSelfHealing: false });
+            const on = startup({ enableSelfHealing: true });
+            (0, chai_1.expect)(healingSwitch.isEnabled(off)).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled(on)).to.equal(true);
+            // However many commands follow, it is said once, at the load.
+            (0, chai_1.expect)(warn.calledOnce).to.equal(true);
+            (0, chai_1.expect)(String(warn.firstCall.args[0])).to.match(/self-healing/i);
+            (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include('db is down');
+        }));
+        it('uses the startup option until it has loaded', () => {
+            (0, chai_1.expect)(healingSwitch.isEnabled({ enableSelfHealing: false })).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled({ enableSelfHealing: true })).to.equal(true);
+        });
+    });
+});