@xenon-device-management/xenon 2.13.2 → 2.15.0

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

@@ -71,6 +71,11 @@ const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
 const internalCall_1 = require("../../src/gateway/internalCall");
 const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
 const defaultGateway_1 = require("../../src/gateway/defaultGateway");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const types_1 = require("../../src/services/healing/types");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
 const container_registration_1 = require("../helpers/container-registration");
 const scratch_database_1 = require("../helpers/scratch-database");
 /**
@@ -104,6 +109,13 @@ const DRIVER_ROUTES = {
         POST: { command: 'stopRecordingScreen', payloadParams: { optional: ['options'] } },
     },
 };
+/**
+ * The node's findElement as its plugin runs it, when a test sets it: the
+ * driver's own find goes through Xenon's CommandInterceptor.
+ */
+let nodeFind;
+/** The hub's findElement as its plugin runs it, for a session the hub runs itself. */
+let hubFind;
 function fakeDriver(name) {
     const { errors } = appiumBaseDriver();
     const commands = [];
@@ -120,12 +132,18 @@ function fakeDriver(name) {
             if (command === 'getUrl')
                 return `https://${name}.example/`;
             if (command === 'findElement') {
+                if (name === 'node' && nodeFind)
+                    return nodeFind(args);
+                if (name === 'hub' && hubFind)
+                    return hubFind(args);
                 if (args[1] === 'missing')
                     throw new errors.NoSuchElementError();
                 return { 'element-6066-11e4-a52e-4f735466cecf': `${name}-el` };
             }
             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 +196,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 +439,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 });
@@ -591,4 +655,159 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
             yield (0, loopbackRequest_1.default)(nodeOrigin).get(`${nodeBase}/session/${id}/url`).expect(200);
         }));
     });
+    /**
+     * A find on a node's phone runs on the node, so the node's interceptor
+     * heals it. Through 2.14 the heal was recorded nowhere: the node keeps no
+     * record of a session the hub created, and the hub saw only the element the
+     * node answered with, so the find was logged as found (and counted toward
+     * the selector's verification as a clean find). The node now hands the heal
+     * back on its answer, and the hub, which owns the session record, records
+     * it as it records a local session's.
+     */
+    describe("a heal on a node's phone", () => {
+        const W3C = 'element-6066-11e4-a52e-4f735466cecf';
+        let attemptHealing;
+        let nodeLogged;
+        let restoreHealing;
+        beforeEach(() => {
+            restoreHealing = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+            typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+            attemptHealing = sinon_1.default.stub().resolves({
+                id: 'node-healed-el',
+                tier: types_1.HealingTier.TIER_2_FUZZY_XML,
+                confidence: 0.82,
+                originalSelector: 'broken',
+                originalStrategy: 'xpath',
+                recommendedSelector: "//*[@resource-id='com.example:id/login']",
+                recommendedStrategy: 'xpath',
+            });
+            typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, { attemptHealing });
+            // Hub and node share this process; the node's own record of a heal is
+            // the node's (on a real node it has no Session row to write it to).
+            nodeLogged = sinon_1.default.stub(CommandInterceptor_1.CommandInterceptor.prototype, 'logHealingEvent').resolves();
+            const { errors } = appiumBaseDriver();
+            nodeFind = hubFind = (args) => typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(() => __awaiter(this, void 0, void 0, function* () {
+                if (args[1] === 'broken')
+                    throw new errors.NoSuchElementError();
+                return { [W3C]: 'node-el' };
+            }), { sessionId: args[2] }, 'findElement', args, Object.assign({}, IPluginArgs_1.DefaultPluginArgs), false);
+        });
+        afterEach(() => {
+            nodeFind = hubFind = undefined;
+            restoreHealing();
+        });
+        /** The session's logged finds; the hub logs a command after it has answered it. */
+        function logsOf(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < 100; i++) {
+                    const rows = yield scratch.db.sessionLog.findMany({
+                        where: { session_id: id, command_name: 'findElement' },
+                    });
+                    if (rows.length)
+                        return rows;
+                    yield new Promise((r) => setTimeout(r, 20));
+                }
+                return [];
+            });
+        }
+        it('is recorded on the hub, against the session, with what it healed to', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.value[W3C]).to.equal('node-healed-el');
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row, 'the find was logged').to.not.equal(undefined);
+            (0, chai_1.expect)(row).to.deep.include({
+                is_healed: true,
+                original_strategy: 'xpath',
+                original_selector: 'broken',
+                healed_strategy: 'xpath',
+                healed_selector: "//*[@resource-id='com.example:id/login']",
+                healing_confidence: 0.82,
+                healing_tier: 'Fuzzy XML',
+            });
+            (0, chai_1.expect)(nodeLogged.called, 'recorded on the node as well').to.equal(false);
+        }));
+        it("is Xenon's own: the client's answer carries nothing about it", () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(Object.keys(res.headers).filter((h) => h.startsWith('x-xenon'))).to.deep.equal([]);
+        }));
+        it("records the selector of a find on a node's phone that needed no heal", () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'id', value: 'login' })
+                .expect(200);
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row).to.deep.include({
+                is_healed: false,
+                original_strategy: 'id',
+                original_selector: 'login',
+            });
+        }));
+        it('takes a heal only from the node, never from the client', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const forged = Buffer.from(JSON.stringify({ originalSelector: 'login', healedSelector: '//x', confidence: 1 })).toString('base64url');
+            yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .set('x-xenon-heal', forged)
+                .send({ using: 'id', value: 'login' })
+                .expect(200);
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row.is_healed).to.equal(false);
+            (0, chai_1.expect)(nodeRequests[0].headers['x-xenon-heal']).to.equal(undefined);
+        }));
+        it('is recorded by the node itself when the find did not come from a hub', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            const { id } = yield remoteSession({ registered: false });
+            const res = yield (0, loopbackRequest_1.default)(nodeOrigin)
+                .post(`/node/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.headers['x-xenon-heal']).to.equal(undefined);
+            (0, chai_1.expect)(nodeLogged.calledOnce).to.equal(true);
+        }));
+        it('is recorded on the hub for its own session, whatever hub token a client sends', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const id = `hub-session-${stamp}`;
+            hub.sessions.add(id);
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'not-a-hub')
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.headers['x-xenon-heal']).to.equal(undefined);
+            (0, chai_1.expect)(nodeLogged.calledOnce, 'recorded by the server that healed it').to.equal(true);
+        }));
+        it('is neither sent nor recorded on the node when too long for the header', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            attemptHealing.resolves({
+                id: 'node-healed-el',
+                tier: types_1.HealingTier.TIER_2_FUZZY_XML,
+                confidence: 0.82,
+                originalSelector: 'broken',
+                originalStrategy: 'xpath',
+                recommendedSelector: `//*[@text='${'x'.repeat(10000)}']`,
+                recommendedStrategy: 'xpath',
+            });
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.value[W3C]).to.equal('node-healed-el');
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row.is_healed).to.equal(false);
+            (0, chai_1.expect)(nodeLogged.called, 'recorded on the node, which has no row for it').to.equal(false);
+        }));
+    });
 });

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/interceptor-visual-elements.spec.js

@@ -0,0 +1,192 @@
+"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 CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const types_1 = require("../../src/services/healing/types");
+const OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * Elements Xenon found in a screenshot (Omni-Vision's `-custom:ai-*` locators,
+ * and self-healing's OCR and Visual AI tiers) are boxes on the screen with an
+ * id of Xenon's own (`omni_*`, `healed_ocr*`, `healed_visual*`). The
+ * interceptor answers their commands itself. Through 2.14:
+ *
+ * - a `-custom:ai-*` findElement that matched nothing answered `unknown error`
+ *   ("NoSuchElement: AI Vision failed…"), and self-healing then ran on it;
+ * - a healed OCR or Visual AI element was tapped during the find, and the
+ *   test's own click tapped it again;
+ * - `getText` on a healed element answered Xenon's note about the match;
+ * - `setValue` never reached the element: Appium passes it (text, elementId),
+ *   and the interceptor read the text as the element id.
+ *
+ * No AI provider, OCR or phone: healing, OCR and the driver are stubbed.
+ */
+describe('Elements Xenon found in a screenshot', () => {
+    (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'visual-session';
+    let pluginArgs;
+    let restoreContainer;
+    let attemptHealing;
+    let driver;
+    let omni;
+    beforeEach(() => {
+        pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs);
+        restoreContainer = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+        typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+        attemptHealing = sinon_1.default.stub().resolves(null);
+        typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, { attemptHealing });
+        sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'afterSessionCommand').resolves();
+        omni = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+        driver = {
+            sessionId: SESSION,
+            caps: { platformName: 'Android' },
+            performActions: sinon_1.default.stub().resolves(),
+            releaseActions: sinon_1.default.stub().resolves(),
+            findElement: sinon_1.default.stub().rejects(new Error('unexpected find')),
+            active: sinon_1.default.stub().resolves({ 'element-6066-11e4-a52e-4f735466cecf': 'field-1' }),
+            setValue: sinon_1.default.stub().resolves(null),
+            elementEnabled: sinon_1.default.stub().resolves(true),
+        };
+    });
+    afterEach(() => {
+        restoreContainer();
+        sinon_1.default.restore();
+    });
+    const run = (command, args, next = () => undefined) => typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(() => __awaiter(void 0, void 0, void 0, function* () { return next(); }), driver, command, [...args, SESSION], pluginArgs, false);
+    const failure = (promise) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield promise;
+        }
+        catch (err) {
+            return err;
+        }
+        throw new Error('expected the command to fail');
+    });
+    const tapsAt = () => driver.performActions.getCalls().map((c) => {
+        const move = c.args[0][0].actions[0];
+        return { x: move.x, y: move.y };
+    });
+    describe('a -custom:ai-* find that matches nothing', () => {
+        it('fails with the standard "no such element" error for ai-text', () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(omni, 'findByText').resolves([]);
+            const err = yield failure(run('findElement', ['-custom:ai-text', 'Checkout']));
+            (0, chai_1.expect)(err.error).to.equal('no such element');
+            (0, chai_1.expect)(err.w3cStatus).to.equal(404);
+        }));
+        it('fails with the standard "no such element" error for ai-icon', () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(omni, 'findByIcon').resolves(null);
+            const err = yield failure(run('findElement', ['-custom:ai-icon', 'a cart icon']));
+            (0, chai_1.expect)(err.error).to.equal('no such element');
+        }));
+        it('is not handed to self-healing', () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(omni, 'findByText').resolves([]);
+            yield failure(run('findElement', ['-custom:ai-text', 'Checkout']));
+            (0, chai_1.expect)(attemptHealing.called).to.equal(false);
+        }));
+        it('still answers an empty list to findElements', () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(omni, 'findByText').resolves([]);
+            (0, chai_1.expect)(yield run('findElements', ['-custom:ai-text', 'Checkout'])).to.deep.equal([]);
+        }));
+    });
+    describe('a healed OCR or Visual AI element', () => {
+        const healedBy = (id, tier, text) => (Object.assign({ id,
+            tier, confidence: 0.9, originalSelector: "//*[@text='Login']", originalStrategy: 'xpath', recommendedSelector: 'ocr:text="Login"', recommendedStrategy: 'xenon:visual', message: 'Found text "Login" via local OCR (90% confidence)', rect: { x: 100, y: 400, width: 80, height: 24 } }, (text !== undefined ? { text } : {})));
+        const findHealed = (healed) => __awaiter(void 0, void 0, void 0, function* () {
+            attemptHealing.resolves(healed);
+            return run('findElement', ['xpath', "//*[@text='Login']"], () => {
+                throw Object.assign(new Error('NoSuchElement: gone'), { name: 'NoSuchElementError' });
+            });
+        });
+        it('is not tapped during the find', () => __awaiter(void 0, void 0, void 0, function* () {
+            const found = yield findHealed(healedBy('healed_ocr_1', types_1.HealingTier.TIER_3_LOCAL_OCR, 'Login'));
+            (0, chai_1.expect)(found).to.deep.include({ 'element-6066-11e4-a52e-4f735466cecf': 'healed_ocr_1' });
+            (0, chai_1.expect)(driver.performActions.called, 'tapped during the find').to.equal(false);
+        }));
+        it("is tapped once, by the test's own click", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield findHealed(healedBy('healed_visual_1', types_1.HealingTier.TIER_4_VISUAL_AI));
+            yield run('click', ['healed_visual_1']);
+            (0, chai_1.expect)(tapsAt()).to.deep.equal([{ x: 140, y: 412 }]);
+        }));
+        it('answers getText with the text OCR read, not a note about the match', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield findHealed(healedBy('healed_ocr_2', types_1.HealingTier.TIER_3_LOCAL_OCR, 'Login'));
+            (0, chai_1.expect)(yield run('getText', ['healed_ocr_2'])).to.equal('Login');
+        }));
+        it('refuses getText when Visual AI found it, since no text was read', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield findHealed(healedBy('healed_visual_2', types_1.HealingTier.TIER_4_VISUAL_AI));
+            const err = yield failure(run('getText', ['healed_visual_2']));
+            (0, chai_1.expect)(err.error).to.equal('unsupported operation');
+            (0, chai_1.expect)(err.message).to.match(/text/i);
+        }));
+    });
+    describe('setValue on an element found in a screenshot', () => {
+        beforeEach(() => {
+            omni.remember(SESSION, {
+                id: 'omni_ocr_field',
+                text: 'Email',
+                rect: { x: 10, y: 20, width: 100, height: 40 },
+                confidence: 0.9,
+            });
+        });
+        it('taps it, then types into the field that has the keyboard focus', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield run('setValue', ['me@example.com', 'omni_ocr_field']);
+            (0, chai_1.expect)(tapsAt()).to.deep.equal([{ x: 60, y: 40 }]);
+            (0, chai_1.expect)(driver.active.calledAfter(driver.performActions)).to.equal(true);
+            (0, chai_1.expect)(driver.setValue.firstCall.args.slice(0, 2)).to.deep.equal([
+                'me@example.com',
+                'field-1',
+            ]);
+        }));
+        it('refuses before tapping when the driver cannot tell which field has the focus', () => __awaiter(void 0, void 0, void 0, function* () {
+            delete driver.active;
+            const err = yield failure(run('setValue', ['me@example.com', 'omni_ocr_field']));
+            (0, chai_1.expect)(err.error).to.equal('unsupported operation');
+            (0, chai_1.expect)(driver.performActions.called, 'tapped').to.equal(false);
+        }));
+        it('says so when no field took the focus after the tap', () => __awaiter(void 0, void 0, void 0, function* () {
+            driver.active.rejects(new Error('no element has focus'));
+            const err = yield failure(run('setValue', ['me@example.com', 'omni_ocr_field']));
+            (0, chai_1.expect)(err.error).to.equal('element not interactable');
+            (0, chai_1.expect)(driver.setValue.called).to.equal(false);
+        }));
+    });
+    describe('other commands on an element found in a screenshot', () => {
+        it("refuses them clearly instead of sending Xenon's id to the driver", () => __awaiter(void 0, void 0, void 0, function* () {
+            omni.remember(SESSION, {
+                id: 'omni_ai_cart',
+                rect: { x: 0, y: 0, width: 40, height: 40 },
+                confidence: 0.85,
+            });
+            const next = sinon_1.default.stub();
+            const err = yield failure(run('getAttribute', ['content-desc', 'omni_ai_cart'], next));
+            (0, chai_1.expect)(err.error).to.equal('unsupported operation');
+            (0, chai_1.expect)(next.called, 'sent to the driver').to.equal(false);
+        }));
+    });
+    describe('autowait before setValue on a real element', () => {
+        it('waits for the element, not for an element named after the text', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { autowait: Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs.autowait), { enabled: true }) });
+            yield run('setValue', ['hello', 'el-1']);
+            (0, chai_1.expect)(driver.elementEnabled.firstCall.args[0]).to.equal('el-1');
+        }));
+    });
+});

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']);
+    }));
+});