@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/test/unit/heal-report.spec.js

@@ -0,0 +1,71 @@
+"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 });
+const chai_1 = require("chai");
+const http_1 = __importDefault(require("http"));
+const healReport_1 = require("../../src/gateway/healReport");
+/**
+ * How a node hands a heal back to its hub on the answer to the hub's command
+ * (healReport.ts): what goes on the answer, and what the hub accepts off it.
+ */
+describe('A heal reported to the hub', () => {
+    const answer = () => new http_1.default.ServerResponse(new http_1.default.IncomingMessage(null));
+    const heal = (selector) => ({
+        originalSelector: selector,
+        originalStrategy: 'xpath',
+        healedSelector: "//*[@text='Anmelden']",
+        healedStrategy: 'xpath',
+        confidence: 0.82,
+        tier: 2,
+    });
+    it('goes on the answer and comes off it whole, whatever its characters', () => {
+        const res = answer();
+        const sent = heal("//*[@text='Ünïcödé “quotes”']");
+        (0, chai_1.expect)((0, healReport_1.runReportingHeals)(res, () => (0, healReport_1.reportHeal)(sent))).to.equal('reported');
+        const headers = { [healReport_1.HEAL_REPORT_HEADER]: String(res.getHeader(healReport_1.HEAL_REPORT_HEADER)) };
+        (0, chai_1.expect)((0, healReport_1.takeHealReport)(headers)).to.deep.equal(sent);
+        (0, chai_1.expect)(headers, 'taken off the headers').to.not.have.property(healReport_1.HEAL_REPORT_HEADER);
+    });
+    it('is not sent for a command that did not come from a hub', () => {
+        (0, chai_1.expect)((0, healReport_1.reportHeal)(heal('//a'))).to.equal('not-from-hub');
+    });
+    it('is not sent when too long for the hub to read, so the command still answers', () => {
+        const res = answer();
+        const reported = (0, healReport_1.runReportingHeals)(res, () => (0, healReport_1.reportHeal)(heal(`//${'x'.repeat(10000)}`)));
+        (0, chai_1.expect)(reported).to.equal('too-long');
+        (0, chai_1.expect)(res.getHeader(healReport_1.HEAL_REPORT_HEADER)).to.equal(undefined);
+    });
+    it('is not put on an answer that has closed, by work the command left running', () => __awaiter(void 0, void 0, void 0, function* () {
+        const res = answer();
+        let release;
+        const gate = new Promise((resolve) => (release = resolve));
+        // Async work started during the command keeps its context after it.
+        const lingering = (0, healReport_1.runReportingHeals)(res, () => __awaiter(void 0, void 0, void 0, function* () {
+            yield gate;
+            return (0, healReport_1.reportHeal)(heal('//late'));
+        }));
+        res.emit('close');
+        release();
+        (0, chai_1.expect)(yield lingering).to.equal('not-from-hub');
+    }));
+    it('is ignored when it is not one', () => {
+        const notJson = { [healReport_1.HEAL_REPORT_HEADER]: 'not base64 json' };
+        const notAHeal = {
+            [healReport_1.HEAL_REPORT_HEADER]: Buffer.from('{"originalSelector":1}').toString('base64url'),
+        };
+        (0, chai_1.expect)((0, healReport_1.takeHealReport)(notJson)).to.equal(undefined);
+        (0, chai_1.expect)((0, healReport_1.takeHealReport)(notAHeal)).to.equal(undefined);
+        (0, chai_1.expect)((0, healReport_1.takeHealReport)({})).to.equal(undefined);
+    });
+});

package/lib/test/unit/healing-instrumentation.spec.js

@@ -187,7 +187,11 @@ describe('HealingOrchestrator instrumentation', () => {
         (0, chai_1.expect)(mockSpan.end.calledOnce).to.equal(true);
     }));
     it('marks span ERROR and ends on context-collection failure (driver throws)', () => __awaiter(void 0, void 0, void 0, function* () {
-        const orch = makeOrchestratorWithProviders([]);
+        // A tier to run, or nothing is collected at all; it never runs here.
+        const heal = sinon_1.default.stub().resolves(null);
+        const orch = makeOrchestratorWithProviders([
+            { name: 'p1', tier: types_1.HealingTier.TIER_1_RECOVERY, heal },
+        ]);
         const driver = {
             getPageSource: () => __awaiter(void 0, void 0, void 0, function* () {
                 throw new Error('disconnected');
@@ -198,6 +202,7 @@ describe('HealingOrchestrator instrumentation', () => {
         (0, chai_1.expect)(result).to.equal(null);
         (0, chai_1.expect)(mockSpan.addEvent.calledWith('context_collection_failed')).to.equal(true);
         (0, chai_1.expect)(mockSpan.end.calledOnce).to.equal(true);
+        (0, chai_1.expect)(heal.called).to.equal(false);
     }));
     it('does not put the original selector text on span attributes (cardinality discipline)', () => __awaiter(void 0, void 0, void 0, function* () {
         const provider = {

package/lib/test/unit/healing-tier-gate.spec.js

@@ -51,54 +51,84 @@ describe('filterProvidersByTier (§2.7 healing-tier gate)', () => {
         const result = (0, HealingOrchestrator_1.filterProvidersByTier)(providers, []);
         (0, chai_1.expect)(result).to.deep.equal([]);
     });
-    // MINOR fix (Phase 2a review): the capability accessor must fail OPEN on a
-    // malformed healingTiers cap. Pre-fix, an all-non-numeric array (e.g.
-    // ["1","2"]) filtered to [] and silently DISABLED healing; the contract is
-    // malformed → run all tiers. The cap is meant to RESTRICT healing, never to
-    // disable it — so an explicitly-empty [] also coerces to run-all (opting out
-    // of healing entirely is not a supported use case).
-    describe('coerceHealingTiersCap (malformed cap → fail open)', () => {
-        it('passes a numeric array through unchanged', () => {
+    // The value is a privacy control: a session that leaves out Visual AI (4)
+    // and the LLM (5) keeps its screen away from the AI provider. So a value
+    // that can't be read fails closed for those two, and open for the rest:
+    // the tiers that stay on the server (1, 2, 3) still run. Through 2.14 any
+    // such value, and an empty list, ran every tier, the AI ones included.
+    describe('coerceHealingTiersCap', () => {
+        it('passes a list of tier numbers through unchanged', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([1, 3])).to.deep.equal([1, 3]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([5, 4, 1])).to.deep.equal([5, 4, 1]);
         });
-        it('keeps only the numeric entries of a mixed array', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([1, '2'])).to.deep.equal([1]);
-        });
-        it('non-array (string/undefined/null) → undefined (run all)', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)('1,2')).to.equal(undefined);
+        it('runs every tier when the session sets nothing', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(undefined)).to.equal(undefined);
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(null)).to.equal(undefined);
         });
-        it('all-non-numeric array ["1","2"] → undefined → ALL providers run (fail open)', () => {
-            const coerced = (0, HealingOrchestrator_1.coerceHealingTiersCap)(['1', '2']);
-            (0, chai_1.expect)(coerced).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.filterProvidersByTier)(providers, coerced)).to.deep.equal(providers);
-        });
-        it('explicitly-empty [] also → undefined (run all; the cap restricts, it cannot disable)', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([])).to.equal(undefined);
+        it('runs no tier for an empty list', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([])).to.deep.equal([]);
         });
+        for (const [label, value] of [
+            ['a string', '1,2'],
+            ['numbers as strings', ['1', '2']],
+            ['a list with a string in it', [1, '2']],
+            ['a number that is no tier', [1, 6]],
+            ['tier 0', [0]],
+            ['a fraction', [1.5]],
+            ['a lone number', 4],
+            ['an object', { llm: false }],
+            ['true', true],
+        ]) {
+            it(`runs only the tiers that stay on the server for ${label}`, () => {
+                (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(value)).to.deep.equal([1, 2, 3]);
+                (0, chai_1.expect)((0, HealingOrchestrator_1.filterProvidersByTier)(providers, (0, HealingOrchestrator_1.coerceHealingTiersCap)(value))).to.deep.equal(providers.slice(0, 3));
+            });
+        }
     });
     // What CommandInterceptor hands attemptHealing, read from the session's
     // capabilities.
     describe('healingTiersFromCaps', () => {
         it('reads xe:options.healingTiers', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: [1, 2] } })).to.deep.equal([
-                1, 2,
-            ]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: [1, 2] } })).to.deep.equal({
+                tiers: [1, 2],
+            });
         });
         it('still reads the xenon:options alias', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xenon:options': { healingTiers: [3] } })).to.deep.equal([3]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xenon:options': { healingTiers: [3] } })).to.deep.equal({
+                tiers: [3],
+            });
         });
         it('prefers xe:options when both set it', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({
                 'xenon:options': { healingTiers: [5] },
                 'xe:options': { healingTiers: [1] },
-            })).to.deep.equal([1]);
+            })).to.deep.equal({ tiers: [1] });
+        });
+        it('runs every tier with no capabilities, or none set', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)(undefined)).to.deep.equal({ tiers: undefined });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({})).to.deep.equal({ tiers: undefined });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': {} })).to.deep.equal({ tiers: undefined });
         });
-        it('fails open with no capabilities or a malformed value', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)(undefined)).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({})).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: ['1'] } })).to.equal(undefined);
+        it('names a value it could not read, for the log', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: ['1'] } })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'healingTiers is ["1"], not a list of tier numbers from 1 to 5',
+            });
+        });
+        // xenonOptionsIn skips a namespace that isn't an object, so this one used
+        // to read as "nothing set", and ran every tier.
+        it('runs only the tiers that stay on the server when xe:options is not an object', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': '{"healingTiers":[1]}' })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'xe:options is "{\\"healingTiers\\":[1]}", not an object',
+            });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({
+                'xenon:options': ['healingTiers'],
+                'xe:options': { healingTiers: [1, 2, 3, 4, 5] },
+            })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'xenon:options is ["healingTiers"], not an object',
+            });
         });
     });
 });
@@ -136,6 +166,20 @@ describe('HealingOrchestrator.attemptHealing allowedTiers dispatch gate', () =>
         yield orchestrator.attemptHealing('sess-1', mockDriver, 'xpath', '//broken', [1]);
         (0, chai_1.expect)(dispatched).to.deep.equal(['ResilioTree Provider']);
     }));
+    it('collects nothing and dispatches nothing when no tier is allowed', () => __awaiter(void 0, void 0, void 0, function* () {
+        let collected = 0;
+        const driver = Object.assign(Object.assign({}, mockDriver), { getPageSource: () => __awaiter(void 0, void 0, void 0, function* () {
+                collected++;
+                return '<xml/>';
+            }), getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () {
+                collected++;
+                return 'fake-screenshot';
+            }) });
+        const healed = yield orchestrator.attemptHealing('sess-3', driver, 'xpath', '//broken', []);
+        (0, chai_1.expect)(healed).to.equal(null);
+        (0, chai_1.expect)(dispatched).to.deep.equal([]);
+        (0, chai_1.expect)(collected).to.equal(0);
+    }));
     it('dispatches to the full provider set when allowedTiers is omitted (regression)', () => __awaiter(void 0, void 0, void 0, function* () {
         yield orchestrator.attemptHealing('sess-2', mockDriver, 'xpath', '//broken');
         (0, chai_1.expect)(dispatched).to.deep.equal([

package/lib/test/unit/healing-tiers-every-session.spec.js

@@ -0,0 +1,219 @@
+"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 base_driver_1 = require("@appium/base-driver");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const AIService_1 = require("../../src/services/AIService");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * A session's `xe:options.healingTiers` keeps its screen away from the AI
+ * provider: with `[1, 2, 3]`, Visual AI (4) and the LLM (5) never run, so the
+ * screenshot and page source never leave the server.
+ *
+ * Through 2.14 the interceptor read the tiers from SESSION_MANAGER, which holds
+ * a local session only with the dashboard on or a video recorded. A session
+ * with `record_video: false` on a server with the dashboard off (the default),
+ * a node's for its hub included, wasn't there: the interceptor found no
+ * capabilities and ran every tier. The tiers are now read from the session's
+ * own driver, which Appium hands the plugin with every command. These sessions
+ * are registered nowhere, as such a session isn't.
+ */
+describe("a session's healing tiers, on a session the dashboard doesn't track", () => {
+    (0, scratch_database_1.useScratchDatabase)();
+    let restoreContainer;
+    let dispatched;
+    let visualFind;
+    let healLocator;
+    const drivers = [];
+    const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { enableDashboard: false });
+    beforeEach(() => {
+        restoreContainer = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+        // The switch as at boot with nothing saved: healing on.
+        typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+        const etalons = {
+            getSignature: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        const orchestrator = new HealingOrchestrator_1.HealingOrchestrator(etalons);
+        dispatched = [];
+        const providers = orchestrator.providers;
+        // The three local tiers are only recorded. Visual AI and the LLM run as
+        // they are, up to the AI service, which is stubbed: what reaches it is
+        // what would have gone to the provider.
+        for (const provider of providers.slice(0, 3)) {
+            provider.heal = () => __awaiter(void 0, void 0, void 0, function* () {
+                dispatched.push(provider.name);
+                return null;
+            });
+        }
+        for (const provider of providers.slice(3)) {
+            const heal = provider.heal.bind(provider);
+            provider.heal = (context) => __awaiter(void 0, void 0, void 0, function* () {
+                dispatched.push(provider.name);
+                return heal(context);
+            });
+        }
+        typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, orchestrator);
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'isEnabled').returns(true);
+        visualFind = sinon_1.default.stub(AIService_1.AI_SERVICE, 'visualFind').resolves(null);
+        healLocator = sinon_1.default.stub(AIService_1.AI_SERVICE, 'healLocator').resolves(null);
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        restoreContainer();
+        for (const driver of drivers.splice(0))
+            yield driver.deleteSession();
+    }));
+    /**
+     * The driver Appium hands the plugin for a session's commands: a session
+     * created from the capabilities the client sent, as Appium creates it.
+     */
+    function sessionWith(xenonOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const driver = new base_driver_1.BaseDriver({});
+            // Every driver warns that it doesn't know `xe:options`; not this spec's business.
+            sinon_1.default.stub(driver.log, 'warn');
+            const alwaysMatch = {
+                platformName: 'Android',
+                'appium:automationName': 'UiAutomator2',
+            };
+            if (xenonOptions)
+                Object.assign(alwaysMatch, xenonOptions);
+            yield driver.createSession({ alwaysMatch, firstMatch: [{}] });
+            drivers.push(driver);
+            Object.assign(driver, {
+                getPageSource: () => __awaiter(this, void 0, void 0, function* () { return '<hierarchy><node text="Pay now"/></hierarchy>'; }),
+                getScreenshot: () => __awaiter(this, void 0, void 0, function* () { return 'iVBORw0KGgo='; }),
+                findElements: () => __awaiter(this, void 0, void 0, function* () { return []; }),
+            });
+            return driver;
+        });
+    }
+    /** A findElement the driver answers with NoSuchElement, as a broken selector does. */
+    function findMissing(driver_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (driver, { isHub }) {
+            const sessionId = driver.sessionId;
+            return typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor)
+                .handle(() => __awaiter(this, void 0, void 0, function* () {
+                throw Object.assign(new Error('NoSuchElement: An element could not be located'), {
+                    name: 'NoSuchElementError',
+                });
+            }), driver, 'findElement', ['xpath', '//android.widget.Button[@text="Pay"]', sessionId], pluginArgs, isHub)
+                .then(() => undefined, (err) => err);
+        });
+    }
+    for (const [where, isHub] of [
+        ['on a standalone server', true],
+        ["on a node running its hub's session", false],
+    ]) {
+        describe(where, () => {
+            it('never calls the AI provider for a session that allows tiers 1, 2 and 3', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xe:options': { healingTiers: [1, 2, 3] } });
+                // The case: with the dashboard off and no video, nothing registers it.
+                (0, chai_1.expect)(SessionManager_1.SESSION_MANAGER.getSession(driver.sessionId)).to.equal(undefined);
+                const thrown = yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(visualFind.called, 'Visual AI sent the screenshot').to.equal(false);
+                (0, chai_1.expect)(healLocator.called, 'the LLM was sent the page source').to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                ]);
+                // Nothing healed it, so the test sees its own failure.
+                (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+            }));
+            it('reads the xenon:options alias the same way', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xenon:options': { healingTiers: [2] } });
+                yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(visualFind.called).to.equal(false);
+                (0, chai_1.expect)(healLocator.called).to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal(['Fuzzy XML Provider']);
+            }));
+            it('still runs every tier for a session that asks for none in particular', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith(null);
+                yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                    'Visual AI Provider',
+                    'LLM Reasoning Provider',
+                ]);
+                (0, chai_1.expect)(visualFind.calledOnce).to.equal(true);
+                (0, chai_1.expect)(healLocator.calledOnce).to.equal(true);
+            }));
+        });
+    }
+    describe('a value that is not a list of tier numbers', () => {
+        for (const [label, value] of [
+            ['a string', '1,2,3'],
+            ['numbers as strings', ['1', '2']],
+            ['a list with a string in it', [4, 'llm']],
+            ['a number that is no tier', [1, 6]],
+            ['a lone number', 4],
+            ['an object', { visualAi: false }],
+        ]) {
+            it(`runs only the tiers that stay on the server: ${label}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xe:options': { healingTiers: value } });
+                yield findMissing(driver, { isHub: true });
+                (0, chai_1.expect)(visualFind.called).to.equal(false);
+                (0, chai_1.expect)(healLocator.called).to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                ]);
+            }));
+        }
+        it('runs only the tiers that stay on the server when xe:options is not an object', () => __awaiter(void 0, void 0, void 0, function* () {
+            const driver = yield sessionWith({ 'xe:options': '{"healingTiers":[1,2,3]}' });
+            yield findMissing(driver, { isHub: true });
+            (0, chai_1.expect)(visualFind.called).to.equal(false);
+            (0, chai_1.expect)(healLocator.called).to.equal(false);
+            (0, chai_1.expect)(dispatched).to.deep.equal([
+                'ResilioTree Provider',
+                'Fuzzy XML Provider',
+                'OCR Text Provider',
+            ]);
+        }));
+        it('says so in the log, once per session', () => __awaiter(void 0, void 0, void 0, function* () {
+            const warn = sinon_1.default.stub(typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).log, 'warn');
+            const driver = yield sessionWith({ 'xe:options': { healingTiers: ['1', '2'] } });
+            yield findMissing(driver, { isHub: true });
+            yield findMissing(driver, { isHub: true });
+            const said = warn.getCalls().filter((c) => /healingTiers/.test(String(c.args[0])));
+            (0, chai_1.expect)(said).to.have.length(1);
+            (0, chai_1.expect)(String(said[0].args[0])).to.contain('["1","2"]');
+        }));
+    });
+    it('heals with no tier, and takes no screenshot, for a session that lists none', () => __awaiter(void 0, void 0, void 0, function* () {
+        const driver = yield sessionWith({ 'xe:options': { healingTiers: [] } });
+        const screenshot = sinon_1.default.spy(driver, 'getScreenshot');
+        const source = sinon_1.default.spy(driver, 'getPageSource');
+        const thrown = yield findMissing(driver, { isHub: true });
+        (0, chai_1.expect)(dispatched).to.deep.equal([]);
+        (0, chai_1.expect)(screenshot.called).to.equal(false);
+        (0, chai_1.expect)(source.called).to.equal(false);
+        (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+    }));
+});