@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/test/unit/omni-vision-ios-points.spec.js

@@ -0,0 +1,161 @@
+"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 sharp_1 = __importDefault(require("sharp"));
+const OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
+const AIService_1 = require("../../src/services/AIService");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const types_1 = require("../../src/services/healing/types");
+const screenScale_1 = require("../../src/services/omni-vision/screenScale");
+/**
+ * OCR and the AI find a target in screenshot pixels. An iPhone's screenshot is
+ * 2x or 3x its screen in points, and XCUITest's W3C actions and element rects
+ * are in points, so a tap at the pixel position landed 2-3 times too far right
+ * and down. Nothing converted: not smartTap/visualTap, not the virtual
+ * elements the -custom:ai-* locators return, not the healing tiers' tap.
+ *
+ * Positions found in a screenshot are now converted to the driver's
+ * coordinates on iOS (screenshot size over window size). Android's W3C
+ * coordinates are the screenshot's pixels, so nothing changes there.
+ */
+describe('Omni-Vision taps in points on iOS', () => {
+    // A 3x screen: 30 x 60 pixels for a 10 x 20 point window.
+    let png3x;
+    before(() => __awaiter(void 0, void 0, void 0, function* () {
+        const image = yield (0, sharp_1.default)({
+            create: { width: 30, height: 60, channels: 3, background: { r: 255, g: 255, b: 255 } },
+        })
+            .png()
+            .toBuffer();
+        png3x = image.toString('base64');
+    }));
+    // "OK" at pixels 12..18 x 30..36: its middle is (15, 33) px, (5, 11) pt.
+    const OK_WORD = { text: 'OK', confidence: 90, bbox: { x0: 12, y0: 30, x1: 18, y1: 36 } };
+    let service;
+    let ios;
+    let android;
+    function driverFor(platformName) {
+        return {
+            sessionId: `session-${platformName}`,
+            caps: { platformName },
+            getScreenshot: sinon_1.default.stub().resolves(png3x),
+            getWindowRect: sinon_1.default.stub().resolves({ x: 0, y: 0, width: 10, height: 20 }),
+            performActions: sinon_1.default.stub().resolves(),
+            releaseActions: sinon_1.default.stub().resolves(),
+        };
+    }
+    beforeEach(() => {
+        service = new OmniVisionService_1.OmniVisionService();
+        sinon_1.default.stub(service, 'performOcr').resolves({ text: 'OK', words: [OK_WORD] });
+        ios = driverFor('iOS');
+        android = driverFor('Android');
+    });
+    afterEach(() => sinon_1.default.restore());
+    const tappedAt = (driver) => {
+        const move = driver.performActions.firstCall.args[0][0].actions[0];
+        return { x: move.x, y: move.y };
+    };
+    it('smartTap by text taps in points on iOS', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield service.omniClickByText(ios, { text: 'OK' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)(tappedAt(ios)).to.deep.equal({ x: 5, y: 11 });
+        (0, chai_1.expect)(result.target).to.deep.include({
+            x: 5,
+            y: 11,
+            rect: { x: 4, y: 10, width: 2, height: 2 },
+        });
+    }));
+    it('smartTap by text taps in pixels on Android, without asking for the window', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield service.omniClickByText(android, { text: 'OK' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)(tappedAt(android)).to.deep.equal({ x: 15, y: 33 });
+        (0, chai_1.expect)(android.getWindowRect.called).to.equal(false);
+    }));
+    it('visualTap taps in points on iOS', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'visualFind').resolves({ x: 15, y: 33 });
+        const result = yield service.omniClickByIcon(ios, { icon: 'the gear icon' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)(tappedAt(ios)).to.deep.equal({ x: 5, y: 11 });
+    }));
+    it('gives the -custom:ai-text locator an element in points on iOS', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const [found] = yield service.findByText(ios, 'OK');
+        (0, chai_1.expect)(found.rect).to.deep.equal({ x: 4, y: 10, width: 2, height: 2 });
+        (0, chai_1.expect)((_a = service.getVirtualElement(found.id)) === null || _a === void 0 ? void 0 : _a.rect).to.deep.equal(found.rect);
+    }));
+    it("doesn't tap on iOS when the window size can't be read", () => __awaiter(void 0, void 0, void 0, function* () {
+        ios.getWindowRect.rejects(new Error('WDA is not running'));
+        const err = yield service.omniClickByText(ios, { text: 'OK' }).then(() => null, (e) => e);
+        (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/WDA is not running/);
+        (0, chai_1.expect)(ios.performActions.called).to.equal(false);
+    }));
+    it('reads the window from getWindowSize when there is no getWindowRect', () => __awaiter(void 0, void 0, void 0, function* () {
+        const driver = {
+            caps: { platformName: 'iOS' },
+            getWindowSize: () => __awaiter(void 0, void 0, void 0, function* () { return ({ width: 15, height: 30 }); }),
+        };
+        (0, chai_1.expect)(yield (0, screenScale_1.screenScaleOf)(driver, png3x)).to.deep.equal({ x: 2, y: 2 });
+    }));
+    it("keeps pixels for a driver that isn't iOS, or can't be placed", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, chai_1.expect)(yield (0, screenScale_1.screenScaleOf)({}, 'not an image')).to.deep.equal({ x: 1, y: 1 });
+        (0, chai_1.expect)(yield (0, screenScale_1.screenScaleOf)({ caps: { platformName: 'Android' } }, 'x')).to.deep.equal({
+            x: 1,
+            y: 1,
+        });
+    }));
+    it('converts the OCR and Visual AI healing tiers’ rect to points on iOS', () => __awaiter(void 0, void 0, void 0, function* () {
+        const orchestrator = new HealingOrchestrator_1.HealingOrchestrator({
+            getSignature: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+        });
+        const ocr = orchestrator.providers.find((p) => p.tier === types_1.HealingTier.TIER_3_LOCAL_OCR);
+        sinon_1.default.stub(ocr, 'heal').resolves({
+            id: 'healed_ocr_1',
+            tier: types_1.HealingTier.TIER_3_LOCAL_OCR,
+            confidence: 0.9,
+            originalSelector: '//*[@label="OK"]',
+            recommendedSelector: 'ocr:text="OK"',
+            rect: { x: 12, y: 30, width: 6, height: 6 },
+        });
+        ios.getPageSource = sinon_1.default.stub().resolves('<AppiumAUT/>');
+        const healed = yield orchestrator.attemptHealing('s1', ios, 'xpath', '//*[@label="OK"]', [3]);
+        (0, chai_1.expect)(healed === null || healed === void 0 ? void 0 : healed.rect).to.deep.equal({ x: 4, y: 10, width: 2, height: 2 });
+    }));
+    it("drops a healed virtual element whose position on an iPhone can't be worked out", () => __awaiter(void 0, void 0, void 0, function* () {
+        const orchestrator = new HealingOrchestrator_1.HealingOrchestrator({
+            getSignature: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+        });
+        const ocr = orchestrator.providers.find((p) => p.tier === types_1.HealingTier.TIER_3_LOCAL_OCR);
+        const found = {
+            tier: types_1.HealingTier.TIER_3_LOCAL_OCR,
+            confidence: 0.9,
+            originalSelector: '//*[@label="OK"]',
+            recommendedSelector: 'ocr:text="OK"',
+            rect: { x: 12, y: 30, width: 6, height: 6 },
+        };
+        const heal = sinon_1.default.stub(ocr, 'heal').resolves(Object.assign(Object.assign({}, found), { id: 'healed_ocr_1' }));
+        ios.getPageSource = sinon_1.default.stub().resolves('<AppiumAUT/>');
+        ios.getWindowRect.rejects(new Error('WDA is not running'));
+        (0, chai_1.expect)(yield orchestrator.attemptHealing('s1', ios, 'xpath', '//x', [3])).to.equal(null);
+        // A real element the tier resolved is kept, without the rect.
+        heal.resolves(Object.assign(Object.assign({}, found), { id: 'real-element-1' }));
+        const healed = yield orchestrator.attemptHealing('s1', ios, 'xpath', '//x', [3]);
+        (0, chai_1.expect)(healed === null || healed === void 0 ? void 0 : healed.id).to.equal('real-element-1');
+        (0, chai_1.expect)(healed === null || healed === void 0 ? void 0 : healed.rect).to.equal(undefined);
+    }));
+});

package/lib/test/unit/omni-vision-tap-text.spec.js

@@ -0,0 +1,129 @@
+"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 OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
+const AIService_1 = require("../../src/services/AIService");
+/**
+ * `xenon: smartTap { text }` (and `omniClick`) compared the text with one OCR
+ * word at a time, so any text with a space in it ("Sign in", "Forgot
+ * password?") never matched: the answer was `clicked: false`. The
+ * `-custom:ai-text` locator had the same rule. Now the text is looked for
+ * across neighbouring words on one line, and the tap goes to the middle of
+ * the words it covers.
+ */
+describe('Omni-Vision text taps match phrases', () => {
+    // Tesseract's words, in screenshot pixels. One line holds "Sign in" and,
+    // far to the right, "Help"; "Sign" and "in" also appear on two lines.
+    const word = (text, x0, y0, x1, y1) => ({
+        text,
+        confidence: 90,
+        bbox: { x0, y0, x1, y1 },
+    });
+    const WORDS = [
+        word('Sign', 100, 200, 150, 224),
+        word('in', 158, 200, 180, 224),
+        word('Help', 600, 200, 650, 224),
+        word('Forgot', 100, 300, 170, 324),
+        word('password?', 178, 300, 290, 324),
+        word('Sign', 100, 400, 150, 424),
+        word('in', 100, 440, 120, 464),
+    ];
+    let service;
+    let driver;
+    beforeEach(() => {
+        service = new OmniVisionService_1.OmniVisionService();
+        sinon_1.default.stub(service, 'performOcr').resolves({ text: '', words: WORDS });
+        driver = {
+            sessionId: 'session-1',
+            // An Android driver: its W3C coordinates are the screenshot's pixels.
+            caps: { platformName: 'Android' },
+            getScreenshot: sinon_1.default.stub().resolves('aGVsbG8='),
+            performActions: sinon_1.default.stub().resolves(),
+            releaseActions: sinon_1.default.stub().resolves(),
+        };
+    });
+    afterEach(() => sinon_1.default.restore());
+    const tappedAt = () => {
+        const move = driver.performActions.firstCall.args[0][0].actions[0];
+        return { x: move.x, y: move.y };
+    };
+    it('taps the middle of a two-word text', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield service.omniClickByText(driver, { text: 'Sign in' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)(result.target).to.deep.include({
+            text: 'Sign in',
+            x: 140,
+            y: 212,
+            rect: { x: 100, y: 200, width: 80, height: 24 },
+        });
+        (0, chai_1.expect)(tappedAt()).to.deep.equal({ x: 140, y: 212 });
+    }));
+    it('matches a phrase whatever its case, and part of a word at either end', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const result = yield service.omniClickByText(driver, { text: 'forgot PASSWORD' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)((_a = result.target) === null || _a === void 0 ? void 0 : _a.text).to.equal('Forgot password?');
+        (0, chai_1.expect)(tappedAt()).to.deep.equal({ x: 195, y: 312 });
+    }));
+    it('does not join words on different lines, or far apart on one line', () => __awaiter(void 0, void 0, void 0, function* () {
+        for (const text of ['in Help', 'Sign in Help', 'password? Sign']) {
+            const result = yield service.omniClickByText(driver, { text });
+            (0, chai_1.expect)(result.clicked, text).to.equal(false);
+        }
+        (0, chai_1.expect)(driver.performActions.called).to.equal(false);
+    }));
+    it('still matches a single word, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield service.omniClickByText(driver, { text: 'help' });
+        (0, chai_1.expect)(result.clicked, result.message).to.equal(true);
+        (0, chai_1.expect)(tappedAt()).to.deep.equal({ x: 625, y: 212 });
+    }));
+    it('finds a phrase with the -custom:ai-text locator too', () => __awaiter(void 0, void 0, void 0, function* () {
+        const found = yield service.findByText(driver, 'Sign in');
+        (0, chai_1.expect)(found).to.have.lengthOf(1);
+        (0, chai_1.expect)(found[0].text).to.equal('Sign in');
+        (0, chai_1.expect)(found[0].rect).to.deep.equal({ x: 100, y: 200, width: 80, height: 24 });
+    }));
+});
+/**
+ * `xenon: smartTap { icon }` / `visualTap` answered `clicked: false`, "No visual
+ * match found", when it never looked: no AI provider, or the AI call failed.
+ * It now fails with the reason; `clicked: false` means the AI looked and found
+ * nothing.
+ */
+describe('Omni-Vision icon taps that cannot look', () => {
+    const driver = {
+        sessionId: 'session-1',
+        caps: { platformName: 'Android' },
+        getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () { return 'aGVsbG8='; }),
+        performActions: sinon_1.default.stub().resolves(),
+    };
+    beforeEach(() => {
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'initializeProvider');
+    });
+    afterEach(() => sinon_1.default.restore());
+    it('fails when no AI provider is configured', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'provider').value(null);
+        const err = yield new OmniVisionService_1.OmniVisionService().omniClickByIcon(driver, { icon: 'the gear' }).then(() => null, (e) => e);
+        (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/No AI provider is configured/);
+    }));
+    it('answers clicked: false when the AI looked and found nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'visualFind').resolves(null);
+        const result = yield new OmniVisionService_1.OmniVisionService().omniClickByIcon(driver, { icon: 'the gear' });
+        (0, chai_1.expect)(result.clicked).to.equal(false);
+        (0, chai_1.expect)(result.message).to.match(/No visual match/);
+    }));
+});

package/lib/test/unit/omni-vision.spec.js

@@ -95,7 +95,7 @@ describe('OmniVisionService Unit Tests', () => {
             terminate: sinon_1.default.stub().resolves(),
         };
         sinon_1.default.stub(tesseract_js_1.default, 'createWorker').resolves(mockWorker);
-        sinon_1.default.stub(AIService_1.AI_SERVICE, 'analyzeFailure').resolves('AI Insights text');
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'describeScreen').resolves('AI Insights text');
         const analysis = yield omniService.analyzeScreen(mockDriver);
         (0, chai_1.expect)(analysis.ocr.text).to.equal('Screen Text');
         (0, chai_1.expect)(analysis.ai_insights).to.equal('AI Insights text');

package/lib/test/unit/partial-config-file.spec.js

@@ -0,0 +1,114 @@
+"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 fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
+// An Appium config file is checked against Xenon's schema.json before Appium
+// fills in defaults (appium/build/lib/main.js: readConfigFile, then
+// defaultsDeep(cli, file, schema defaults)). A `required` option therefore
+// makes Appium refuse any file that leaves it out, even though it has a
+// default. Through 2.13.1 the README's own five-option sample was refused with
+// "REQUIRED must have required property 'enableJsonLogging'". These checks run
+// Appium's own loader so a file that sets a few options keeps starting.
+/* eslint-disable @typescript-eslint/no-var-requires -- Appium's internals have no type exports */
+const appiumSchema = require('appium/build/lib/schema/schema');
+const { readConfigFile } = require('appium/build/lib/config-file');
+/* eslint-enable @typescript-eslint/no-var-requires */
+const xenonSchema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'schema.json'), 'utf8'));
+// The README's sample, verbatim.
+const README_SAMPLE = `server:
+  use-plugins: [xenon]
+  plugin:
+    xenon:
+      platform: both
+      enableDashboard: true
+      maxSessions: 8
+      enableSelfHealing: true
+      buildCleanupDays: 30
+`;
+describe('An Appium config file for Xenon', function () {
+    let dir;
+    function load(yaml) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = path_1.default.join(dir, `config-${Math.random().toString(36).slice(2)}.yaml`);
+            fs_1.default.writeFileSync(file, yaml);
+            return readConfigFile(file);
+        });
+    }
+    before(function () {
+        appiumSchema.resetSchema();
+        appiumSchema.registerSchema('plugin', 'xenon', xenonSchema);
+        appiumSchema.finalizeSchema();
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-config-'));
+    });
+    after(function () {
+        appiumSchema.resetSchema();
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    it('is accepted when it sets only a few options (the README sample)', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = yield load(README_SAMPLE);
+            (0, chai_1.expect)((_a = result.reason) !== null && _a !== void 0 ? _a : result.errors).to.be.empty;
+        });
+    });
+    it('is accepted when it sets no Xenon option at all', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = yield load('server:\n  use-plugins: [xenon]\n');
+            (0, chai_1.expect)((_a = result.reason) !== null && _a !== void 0 ? _a : result.errors).to.be.empty;
+        });
+    });
+    it('is accepted with the network capture option Xenon Control writes', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // The server's `interceptor` option is now each session's default
+            // (resolveInterceptorOptions); configs that set it must keep starting.
+            const result = yield load(`${README_SAMPLE}      interceptor:\n        enabled: true\n        bufferSize: 50\n        captureBodies: false\n`);
+            (0, chai_1.expect)((_a = result.reason) !== null && _a !== void 0 ? _a : result.errors).to.be.empty;
+            (0, chai_1.expect)(result.config.server.plugin.xenon.interceptor).to.deep.equal({
+                enabled: true,
+                bufferSize: 50,
+                captureBodies: false,
+            });
+        });
+    });
+    it('is still refused when a value is invalid', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield load(README_SAMPLE.replace('platform: both', 'platform: windows'));
+            (0, chai_1.expect)(result.errors).to.not.be.empty;
+        });
+    });
+    it('leaves Appium to fill every option the file leaves out with its default', function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // What Appium's main does after a file passes: CLI args, then the file,
+            // then the schema's defaults.
+            const result = yield load(README_SAMPLE);
+            const defaults = appiumSchema.getDefaultsForSchema(false);
+            const server = lodash_1.default.defaultsDeep({}, (_a = result.config) === null || _a === void 0 ? void 0 : _a.server, defaults);
+            const xenon = server.plugin.xenon;
+            const setInFile = new Set(Object.keys(result.config.server.plugin.xenon));
+            (0, chai_1.expect)(xenon.maxSessions).to.equal(8); // from the file
+            for (const [key, prop] of Object.entries(xenonSchema.properties)) {
+                if ('default' in prop && !setInFile.has(key)) {
+                    (0, chai_1.expect)(xenon[key], `${key} should take its default`).to.deep.equal(prop.default);
+                }
+            }
+        });
+    });
+});

package/lib/test/unit/phone-network/boot-clean-up.spec.js

@@ -0,0 +1,64 @@
+"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 ServerManager_1 = require("../../../src/services/ServerManager");
+const PhoneNetworkRestore_1 = require("../../../src/services/network/PhoneNetworkRestore");
+const device_store_1 = require("../../../src/data-service/device-store");
+const container_registration_1 = require("../../helpers/container-registration");
+const ME = 'http://10.0.0.5:4723';
+const NODE_ID = 'node-me';
+/**
+ * At its start a server checks the network of the Android phones it drives:
+ * never a phone another server on the same machine drives (a hub keeps its
+ * nodes' rows), a cloud phone or an iPhone.
+ */
+describe('the phone network check at boot', () => {
+    let restoreRegs;
+    let cleanUpAtBoot;
+    beforeEach(() => {
+        restoreRegs = (0, container_registration_1.saveRegistrations)(PhoneNetworkRestore_1.PhoneNetworkRestore);
+        cleanUpAtBoot = sinon_1.default.stub().resolves();
+        typedi_1.Container.set(PhoneNetworkRestore_1.PhoneNetworkRestore, { cleanUpAtBoot });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restoreRegs();
+    });
+    it("checks this server's own Android phones, once each", () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
+            getAllDevices: () => __awaiter(void 0, void 0, void 0, function* () {
+                return [
+                    { udid: 'MINE', platform: 'android', host: ME, nodeId: NODE_ID },
+                    { udid: 'MINE', platform: 'android', host: ME, nodeId: NODE_ID },
+                    { udid: 'NO-ID', platform: 'android', host: ME },
+                    { udid: 'NODE', platform: 'android', host: 'http://10.0.0.5:4724', nodeId: 'node-b' },
+                    { udid: 'CLOUD', platform: 'android', host: ME, nodeId: NODE_ID, cloud: { name: 'x' } },
+                    { udid: 'IPHONE', platform: 'ios', host: ME, nodeId: NODE_ID },
+                ];
+            }),
+        });
+        yield typedi_1.Container.get(ServerManager_1.ServerManager).cleanUpPhoneNetworks({ origin: ME, hosts: new Set([ME]) }, NODE_ID);
+        (0, chai_1.expect)(cleanUpAtBoot.calledOnce).to.equal(true);
+        (0, chai_1.expect)(cleanUpAtBoot.firstCall.args[0]).to.deep.equal(['MINE', 'NO-ID']);
+    }));
+    it('never fails the boot', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').throws(new Error('no store'));
+        yield typedi_1.Container.get(ServerManager_1.ServerManager).cleanUpPhoneNetworks({ origin: ME, hosts: new Set([ME]) }, NODE_ID);
+        (0, chai_1.expect)(cleanUpAtBoot.called).to.equal(false);
+    }));
+});

package/lib/test/unit/phone-network/interceptor-options.spec.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const XenonCapabilityManager_1 = require("../../../src/XenonCapabilityManager");
+const interceptorOptions_1 = require("../../../src/services/interceptor/interceptorOptions");
+const capsOf = (alwaysMatch) => (0, XenonCapabilityManager_1.getXenonCapabilities)({ alwaysMatch, firstMatch: [{}] });
+/**
+ * The server's `interceptor` option was declared in schema.json and shown in
+ * Xenon Control, but nothing read it: turning it on did nothing. It is now the
+ * default for this server's sessions, and a session's own capability wins
+ * field by field.
+ */
+describe('resolveInterceptorOptions: the server option is the default, the session decides', () => {
+    it('leaves capture off when neither the session nor the server turns it on', () => {
+        (0, chai_1.expect)((0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({}), undefined).enabled).to.equal(false);
+        (0, chai_1.expect)((0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({}), {}).enabled).to.equal(false);
+    });
+    it("turns capture on for a session that doesn't say, when the server's option is on", () => {
+        const opts = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({}), { enabled: true });
+        (0, chai_1.expect)(opts.enabled).to.equal(true);
+        (0, chai_1.expect)(opts.captureBodies).to.equal(true);
+        (0, chai_1.expect)(opts.mocks).to.deep.equal([]);
+    });
+    it("lets a session turn capture off when the server's option is on", () => {
+        const object = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({ 'xe:interceptor': { enabled: false } }), {
+            enabled: true,
+        });
+        (0, chai_1.expect)(object.enabled).to.equal(false);
+        const flat = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({ 'xe:interceptorEnabled': false }), {
+            enabled: true,
+        });
+        (0, chai_1.expect)(flat.enabled).to.equal(false);
+    });
+    it("lets a session turn capture on when the server's option is off", () => {
+        const opts = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({ 'xe:interceptor': { enabled: true } }), {
+            enabled: false,
+        });
+        (0, chai_1.expect)(opts.enabled).to.equal(true);
+    });
+    it("takes bufferSize and captureBodies from the server when the session doesn't set them", () => {
+        const opts = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({ 'xe:interceptor': { enabled: true } }), {
+            bufferSize: 50,
+            captureBodies: false,
+        });
+        (0, chai_1.expect)(opts.bufferSize).to.equal(50);
+        (0, chai_1.expect)(opts.captureBodies).to.equal(false);
+    });
+    it("keeps the session's own bufferSize and captureBodies over the server's", () => {
+        const opts = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({ 'xe:interceptor': { enabled: true, bufferSize: 7, captureBodies: true } }), { bufferSize: 50, captureBodies: false });
+        (0, chai_1.expect)(opts.bufferSize).to.equal(7);
+        (0, chai_1.expect)(opts.captureBodies).to.equal(true);
+    });
+    it('keeps mocks and host filters from the session only', () => {
+        const mocks = [{ match: { url: '**/x' }, respondWith: { status: 204 } }];
+        const opts = (0, interceptorOptions_1.resolveInterceptorOptions)(capsOf({
+            'xe:interceptor': { mocks, includeHosts: ['a.example'], excludeHosts: ['b.example'] },
+        }), { enabled: true });
+        (0, chai_1.expect)(opts.mocks).to.deep.equal(mocks);
+        (0, chai_1.expect)(opts.includeHosts).to.deep.equal(['a.example']);
+        (0, chai_1.expect)(opts.excludeHosts).to.deep.equal(['b.example']);
+    });
+    it('reads a session that sets nothing about capture as unset, not as off', () => {
+        const caps = capsOf({});
+        (0, chai_1.expect)(caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(undefined);
+        (0, chai_1.expect)(caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_CAPTURE_BODIES]).to.equal(undefined);
+    });
+    it('reads an interceptor object without `enabled` as unset', () => {
+        const caps = capsOf({ 'xe:interceptor': { bufferSize: 3 } });
+        (0, chai_1.expect)(caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(undefined);
+        (0, chai_1.expect)((0, interceptorOptions_1.resolveInterceptorOptions)(caps, { enabled: true }).enabled).to.equal(true);
+    });
+    it("reads `enabled: 'false'` as off", () => {
+        const caps = capsOf({ 'xe:interceptor': { enabled: 'false' } });
+        (0, chai_1.expect)(caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(false);
+    });
+});