@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/src/services/settings/labSettings.js

@@ -0,0 +1,149 @@
+"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 });
+exports.settingsDefaults = settingsDefaults;
+exports.isValidCron = isValidCron;
+exports.selfHealingEnabled = selfHealingEnabled;
+exports.effectiveSettings = effectiveSettings;
+exports.loadEffectiveSettings = loadEffectiveSettings;
+exports.validateSettingsUpdate = validateSettingsUpdate;
+const typedi_1 = require("typedi");
+const node_schedule_1 = __importDefault(require("node-schedule"));
+const schema_json_1 = __importDefault(require("../../../schema.json"));
+const logger_1 = __importDefault(require("../../logger"));
+const PluginContext_1 = require("../../PluginContext");
+const web_config_service_1 = require("../../data-service/web-config-service");
+const schemaProperties = schema_json_1.default.properties;
+function schemaDefault(key) {
+    return schemaProperties[key].default;
+}
+/** The defaults schema.json declares, which Appium fills in: the server's own. */
+function settingsDefaults() {
+    return {
+        enableSelfHealing: schemaDefault('enableSelfHealing'),
+        healthCheckIntervalMs: schemaDefault('healthCheckIntervalMs'),
+        buildCleanupDays: schemaDefault('buildCleanupDays'),
+        buildCleanupMaxCount: schemaDefault('buildCleanupMaxCount'),
+        buildCleanupSchedule: schemaDefault('buildCleanupSchedule'),
+        deleteBuildAssets: schemaDefault('deleteBuildAssets'),
+    };
+}
+/**
+ * Whether a string is a cron expression the scheduler will run: five or six
+ * fields. node-schedule alone also takes a date ("2030-01-01") as a one-off
+ * job, which is not a schedule that repeats.
+ */
+function isValidCron(value) {
+    if (typeof value !== 'string')
+        return false;
+    const fields = value.trim().split(/\s+/);
+    if (fields.length < 5 || fields.length > 6)
+        return false;
+    if (!fields.every((field) => /^[0-9A-Za-z*/,\-?#]+$/.test(field)))
+        return false;
+    const job = new node_schedule_1.default.Job(() => undefined);
+    const ok = job.schedule(value.trim());
+    job.cancel();
+    return ok;
+}
+const wholeNumberAtLeastOne = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 1;
+const positiveNumber = (v) => typeof v === 'number' && Number.isFinite(v) && v > 0;
+const isBoolean = (v) => typeof v === 'boolean';
+/** The first value that is usable, in the order given. */
+function firstValid(valid, ...candidates) {
+    return candidates.find(valid);
+}
+/**
+ * Whether self-healing runs: the value saved in the dashboard, else the plugin
+ * option, else the default (on). The same rule `effectiveSettings` applies,
+ * on its own because the command interceptor asks at every command and
+ * `effectiveSettings` also checks cron expressions. A value that is not a
+ * boolean is no choice, so `"false"` as an option does not turn healing off.
+ */
+function selfHealingEnabled(startupOption, saved) {
+    var _a;
+    const fallback = schemaDefault('enableSelfHealing');
+    return (_a = firstValid(isBoolean, saved, startupOption, fallback)) !== null && _a !== void 0 ? _a : fallback;
+}
+/**
+ * The settings in effect: saved in the dashboard, else the plugin option the
+ * server started with, else the default. A saved or started-with value that
+ * could not work (a retention window of 0 would purge everything) is skipped,
+ * so a bad row never reaches the cleanup job.
+ */
+function effectiveSettings(startup, saved) {
+    var _a, _b, _c, _d, _e;
+    const defaults = settingsDefaults();
+    const out = {
+        enableSelfHealing: selfHealingEnabled(startup.enableSelfHealing, saved.enableSelfHealing),
+        healthCheckIntervalMs: (_a = firstValid(positiveNumber, saved.healthCheckIntervalMs, startup.healthCheckIntervalMs, defaults.healthCheckIntervalMs)) !== null && _a !== void 0 ? _a : defaults.healthCheckIntervalMs,
+        buildCleanupDays: (_b = firstValid(wholeNumberAtLeastOne, saved.buildCleanupDays, startup.buildCleanupDays, defaults.buildCleanupDays)) !== null && _b !== void 0 ? _b : defaults.buildCleanupDays,
+        buildCleanupMaxCount: (_c = firstValid(wholeNumberAtLeastOne, saved.buildCleanupMaxCount, startup.buildCleanupMaxCount, defaults.buildCleanupMaxCount)) !== null && _c !== void 0 ? _c : defaults.buildCleanupMaxCount,
+        buildCleanupSchedule: (_d = firstValid(isValidCron, saved.buildCleanupSchedule, startup.buildCleanupSchedule, defaults.buildCleanupSchedule)) !== null && _d !== void 0 ? _d : defaults.buildCleanupSchedule,
+        deleteBuildAssets: (_e = firstValid(isBoolean, saved.deleteBuildAssets, startup.deleteBuildAssets, defaults.deleteBuildAssets)) !== null && _e !== void 0 ? _e : defaults.deleteBuildAssets,
+    };
+    // A saved schedule of '' is the person clearing it, to go back to the
+    // interval; only an unsaved one falls through to the startup option.
+    const schedule = typeof saved.healthCheckSchedule === 'string'
+        ? saved.healthCheckSchedule
+        : startup.healthCheckSchedule;
+    if (typeof schedule === 'string' && schedule.trim() !== '') {
+        out.healthCheckSchedule = schedule;
+    }
+    return out;
+}
+/** The settings in effect now: what is saved, over what the server started with. */
+function loadEffectiveSettings() {
+    return __awaiter(this, arguments, void 0, function* (startup = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) {
+        let saved = {};
+        try {
+            saved = yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig();
+        }
+        catch (err) {
+            // A cleanup that can't read the dashboard's values still runs, on the
+            // startup options: skipping a night's cleanup helps nobody.
+            logger_1.default.warn(`Could not read the saved settings, using the startup options: ${err === null || err === void 0 ? void 0 : err.message}`);
+        }
+        return effectiveSettings(startup, saved);
+    });
+}
+/**
+ * What is wrong with a settings update, or null. The cleanup fields are held to
+ * a rule because a retention window of 0, or a cap of 0, would purge every
+ * build, and these values used to be inert; the self-healing switch because
+ * anything but true or false is no answer to "on or off". The other fields are
+ * not checked. Fields not sent are not checked either.
+ */
+function validateSettingsUpdate(body) {
+    const has = (key) => body[key] !== undefined;
+    for (const field of ['buildCleanupDays', 'buildCleanupMaxCount']) {
+        if (has(field) && !wholeNumberAtLeastOne(body[field])) {
+            return { field, message: `${field} must be a whole number of at least 1.` };
+        }
+    }
+    if (has('buildCleanupSchedule') && !isValidCron(body.buildCleanupSchedule)) {
+        return {
+            field: 'buildCleanupSchedule',
+            message: 'buildCleanupSchedule must be a cron expression with five or six fields, ' +
+                "such as '0 0 * * *' for midnight.",
+        };
+    }
+    if (has('deleteBuildAssets') && typeof body.deleteBuildAssets !== 'boolean') {
+        return { field: 'deleteBuildAssets', message: 'deleteBuildAssets must be true or false.' };
+    }
+    if (has('enableSelfHealing') && typeof body.enableSelfHealing !== 'boolean') {
+        return { field: 'enableSelfHealing', message: 'enableSelfHealing must be true or false.' };
+    }
+    return null;
+}

package/lib/src/services/webhookEvents.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * What each webhook event carries.
+ *
+ * One shape per event, documented here and nowhere else. A webhook turns it
+ * into a message in three ways, and all three read these names:
+ *
+ * - the built-in Slack message (`type: slack`, `NotificationService`);
+ * - the generic JSON body, `{ "event": "<event>", "payload": { ... } }`;
+ * - a custom template, where `{{name}}` stands for a name below, `{{eventType}}`
+ *   for the event itself, and `{{a.b}}` or `{{list.0.b}}` reaches inside.
+ *
+ * The dashboard offers the names below as template chips
+ * (`web/src/components/webhook-settings/webhookEvents.ts`; a spec keeps the two
+ * lists equal). A device event also carries the device's other fields, which
+ * may change: only the names listed are promised.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_TYPES = exports.WEBHOOK_EVENTS = void 0;
+exports.isEventType = isEventType;
+exports.sessionFailedPayload = sessionFailedPayload;
+exports.renderTemplate = renderTemplate;
+const DEVICE_VARIABLES = [
+    { name: 'udid', description: "The device's id" },
+    { name: 'name', description: "The device's name" },
+    { name: 'host', description: 'The machine it is plugged into' },
+    { name: 'platform', description: 'android or ios' },
+];
+const sampleDevice = () => ({
+    udid: 'test-device-udid',
+    name: 'Test Device',
+    host: '127.0.0.1',
+    platform: 'android',
+});
+exports.WEBHOOK_EVENTS = {
+    device_offline: {
+        when: 'A device is no longer reported by its machine (unplugged, or its machine stopped).',
+        variables: DEVICE_VARIABLES,
+        sample: sampleDevice,
+    },
+    device_new: {
+        when: 'A device is detected for the first time.',
+        variables: DEVICE_VARIABLES,
+        sample: sampleDevice,
+    },
+    session_failed: {
+        when: 'A session ends as failed, once per session: the test marked it failed, a command failed, ' +
+            'it timed out for inactivity, its driver crashed, or its heartbeat stopped. Not when the ' +
+            'server itself shuts down, and not for a session that was already failed when the server ' +
+            'started.',
+        variables: [
+            { name: 'sessionId', description: "The session's id" },
+            { name: 'sessionName', description: "The session's name, if the test gave it one" },
+            { name: 'failureReason', description: 'Why it failed' },
+            { name: 'udid', description: "The device's id" },
+            { name: 'deviceName', description: "The device's name" },
+            { name: 'platform', description: 'android or ios' },
+            { name: 'osVersion', description: "The device's OS version" },
+            { name: 'startTime', description: 'When it started (ISO 8601)' },
+            { name: 'endTime', description: 'When it ended (ISO 8601)' },
+        ],
+        sample: () => ({
+            sessionId: 'test-session-id',
+            sessionName: 'Checkout flow',
+            failureReason: 'Test message: element not found',
+            udid: 'test-device-udid',
+            deviceName: 'Test Device',
+            platform: 'android',
+            osVersion: '14',
+            startTime: new Date(Date.now() - 150000).toISOString(),
+            endTime: new Date().toISOString(),
+        }),
+    },
+    selector_health_digest: {
+        when: 'The Selector Health digest is sent. `hotspots` lists the most healed selectors, each ' +
+            'with `healCount`, `originalSelector` and, when there is one, `suggestedRewrite`; reach ' +
+            'into it with `{{hotspots.0.originalSelector}}`.',
+        variables: [
+            { name: 'windowDays', description: 'How many days the digest covers' },
+            { name: 'totalHeals', description: 'Heals in that time' },
+            { name: 'distinctSelectors', description: 'Selectors that were healed' },
+        ],
+        sample: () => ({
+            windowDays: 30,
+            totalHeals: 12,
+            distinctSelectors: 3,
+            hotspots: [
+                {
+                    healCount: 7,
+                    originalSelector: "//*[@text='Log in']",
+                    suggestedRewrite: '~login-button',
+                },
+            ],
+        }),
+    },
+};
+exports.EVENT_TYPES = Object.keys(exports.WEBHOOK_EVENTS);
+function isEventType(value) {
+    return typeof value === 'string' && exports.EVENT_TYPES.includes(value);
+}
+/**
+ * `session_failed`'s payload. Not the row: a row has the session's
+ * capabilities, the keys that created it and its AI analysis, and its names
+ * are the database's (`failure_reason`). Unknown values are empty text, never
+ * missing, so a template never shows "undefined" or "null".
+ */
+function sessionFailedPayload(session) {
+    var _a, _b, _c;
+    const iso = (value) => value ? new Date(value).toISOString() : '';
+    return {
+        sessionId: session.id,
+        sessionName: (_a = session.name) !== null && _a !== void 0 ? _a : '',
+        failureReason: (_b = session.failure_reason) !== null && _b !== void 0 ? _b : '',
+        udid: session.device_udid,
+        deviceName: (_c = session.device_name) !== null && _c !== void 0 ? _c : '',
+        platform: session.device_platform,
+        osVersion: session.device_version,
+        startTime: iso(session.startTime),
+        endTime: iso(session.endTime),
+    };
+}
+function lookup(data, path) {
+    let value = data;
+    for (const key of path.trim().split('.')) {
+        value = value === null || value === undefined ? undefined : value[key];
+    }
+    return value;
+}
+const asText = (value) => typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
+/** `{{name}}` filled in from `data` as text; a name `data` doesn't have stays as written. */
+function fill(text, data) {
+    return text.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+        const value = lookup(data, path);
+        return value === undefined ? match : asText(value);
+    });
+}
+function fillStrings(node, data) {
+    if (typeof node === 'string')
+        return fill(node, data);
+    if (Array.isArray(node))
+        return node.map((item) => fillStrings(item, data));
+    if (node && typeof node === 'object') {
+        return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, fillStrings(value, data)]));
+    }
+    return node;
+}
+/**
+ * The body a custom template sends for an event.
+ *
+ * A template that is JSON as written is filled in string by string, so a
+ * value with a quote, a backslash or a line break (an error message, say)
+ * cannot break it. Any other template, such as `{"n": {{totalHeals}}}` or
+ * plain text, is filled in as text, then sent as JSON if the result parses,
+ * and as `{ "text": "<result>" }` if not.
+ */
+function renderTemplate(template, data) {
+    let written;
+    try {
+        written = JSON.parse(template);
+    }
+    catch (_a) {
+        written = undefined;
+    }
+    if (written !== null && typeof written === 'object')
+        return fillStrings(written, data);
+    const text = fill(template, data);
+    try {
+        return JSON.parse(text);
+    }
+    catch (_b) {
+        return { text };
+    }
+}

package/lib/test/helpers/fake-adb.js

@@ -0,0 +1,58 @@
+"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 });
+exports.fakeAdb = fakeAdb;
+exports.useFakeAdb = useFakeAdb;
+const typedi_1 = require("typedi");
+const AndroidDeviceManager_1 = __importDefault(require("../../src/device-managers/AndroidDeviceManager"));
+const container_registration_1 = require("./container-registration");
+function fakeAdb(answers = {}) {
+    const fake = {
+        calls: [],
+        answers,
+        commands(udid) {
+            return fake.calls
+                .filter((args) => udid === undefined || args[1] === udid)
+                .map((args) => args.slice(2).join(' '));
+        },
+    };
+    return fake;
+}
+/**
+ * Registers `fake` as every phone's adb for the enclosing `describe`. Returns
+ * nothing: the registration is put back after each test.
+ */
+function useFakeAdb(get) {
+    let restore;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(AndroidDeviceManager_1.default);
+        typedi_1.Container.set(AndroidDeviceManager_1.default, {
+            getAdbForDevice: (udid) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    adbExec: (args) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const fake = get();
+                        fake.calls.push(args);
+                        const key = args.slice(args[0] === '-s' ? 2 : 0).join(' ');
+                        const answer = (_a = fake.answers[`${udid} ${key}`]) !== null && _a !== void 0 ? _a : fake.answers[key];
+                        if (answer instanceof Error)
+                            throw answer;
+                        return answer !== null && answer !== void 0 ? answer : '';
+                    }),
+                });
+            }),
+        });
+    });
+    afterEach(() => restore());
+}

package/lib/test/helpers/fake-device-table.js

@@ -1,7 +1,8 @@
 "use strict";
 /**
- * An in-memory device table to stub `prisma.device` with, so a spec runs the
- * real PrismaDeviceStore. It follows Prisma's rules: `undefined` leaves a
+ * In-memory tables to stub `prisma.device` (fakeDeviceTable) and
+ * `prisma.deviceSetting` (fakeDeviceSettingTable) with, so a spec runs the
+ * real PrismaDeviceStore. They follow Prisma's rules: `undefined` leaves a
  * column alone, `null` clears it, an upsert takes `create` for a new row and
  * `update` for a known one, and `{ contains }` matches a substring (the store
  * uses it for a host that isn't a URL).
@@ -16,31 +17,69 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeDeviceSettingTable = fakeDeviceSettingTable;
 exports.fakeDeviceTable = fakeDeviceTable;
-function fakeDeviceTable(seed) {
+const key = (udid, host) => `${udid}|${host}`;
+const matches = (row, where) => {
+    if (!where)
+        return true;
+    return Object.entries(where).every(([field, cond]) => {
+        var _a;
+        if (field === 'OR')
+            return cond.some((w) => matches(row, w));
+        if (field === 'AND')
+            return cond.every((w) => matches(row, w));
+        if (cond && typeof cond === 'object' && 'in' in cond)
+            return cond.in.includes(row[field]);
+        if (cond && typeof cond === 'object' && 'contains' in cond)
+            return String((_a = row[field]) !== null && _a !== void 0 ? _a : '').includes(cond.contains);
+        return row[field] === cond;
+    });
+};
+const write = (row, data) => {
+    for (const [field, value] of Object.entries(data))
+        if (value !== undefined)
+            row[field] = value;
+};
+/**
+ * The saved settings of phones (DeviceSetting), to stub `prisma.deviceSetting`
+ * with beside fakeDeviceTable, so the store's settings don't reach a database.
+ */
+function fakeDeviceSettingTable(seed = []) {
     const rows = new Map();
-    const key = (udid, host) => `${udid}|${host}`;
-    const matches = (row, where) => {
-        if (!where)
-            return true;
-        return Object.entries(where).every(([field, cond]) => {
-            var _a;
-            if (field === 'OR')
-                return cond.some((w) => matches(row, w));
-            if (field === 'AND')
-                return cond.every((w) => matches(row, w));
-            if (cond && typeof cond === 'object' && 'in' in cond)
-                return cond.in.includes(row[field]);
-            if (cond && typeof cond === 'object' && 'contains' in cond)
-                return String((_a = row[field]) !== null && _a !== void 0 ? _a : '').includes(cond.contains);
-            return row[field] === cond;
-        });
-    };
-    const write = (row, data) => {
-        for (const [field, value] of Object.entries(data))
-            if (value !== undefined)
-                row[field] = value;
+    for (const r of seed)
+        rows.set(key(r.udid, r.host), Object.assign({ userBlocked: false }, r));
+    return {
+        row: (udid, host) => [...rows.values()].find((r) => r.udid === udid && (host === undefined || r.host === host)),
+        delegate: {
+            findMany: (...args_1) => __awaiter(this, [...args_1], void 0, function* (args = {}) { return [...rows.values()].filter((r) => matches(r, args.where)).map((r) => (Object.assign({}, r))); }),
+            upsert: (_a) => __awaiter(this, [_a], void 0, function* ({ where, create, update, }) {
+                const k = key(where.udid_host.udid, where.udid_host.host);
+                const found = rows.get(k);
+                if (found) {
+                    write(found, update);
+                    return Object.assign({}, found);
+                }
+                const created = { userBlocked: false };
+                write(created, create);
+                rows.set(k, created);
+                return Object.assign({}, created);
+            }),
+            deleteMany: (...args_1) => __awaiter(this, [...args_1], void 0, function* (args = {}) {
+                let count = 0;
+                for (const [k, r] of rows) {
+                    if (matches(r, args.where)) {
+                        rows.delete(k);
+                        count++;
+                    }
+                }
+                return { count };
+            }),
+        },
     };
+}
+function fakeDeviceTable(seed) {
+    const rows = new Map();
     const defaults = () => ({
         busy: false,
         userBlocked: false,

package/lib/test/helpers/scratch-database.js

@@ -29,6 +29,7 @@ const MODELS = [
     'profiling',
     'app',
     'device',
+    'deviceSetting',
     'pendingSession',
     'cLIArgs',
     'webhookConfig',

package/lib/test/unit/TeamService.test.js

@@ -56,6 +56,7 @@ describe('TeamService (User-keyed)', () => {
     }));
     it('delete() blocks when team has devices OR active members', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(prisma_1.prisma.device, 'count').resolves(1);
+        sinon_1.default.stub(prisma_1.prisma.deviceSetting, 'findMany').resolves([]);
         sinon_1.default.stub(prisma_1.prisma.teamMember, 'count').resolves(0);
         sinon_1.default.stub(prisma_1.prisma.app, 'count').resolves(0);
         let err;
@@ -72,6 +73,7 @@ describe('TeamService (User-keyed)', () => {
     // as for its phones: the admin moves them first.
     it('delete() blocks while the team still owns apps', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(prisma_1.prisma.device, 'count').resolves(0);
+        sinon_1.default.stub(prisma_1.prisma.deviceSetting, 'findMany').resolves([]);
         sinon_1.default.stub(prisma_1.prisma.teamMember, 'count').resolves(0);
         const apps = sinon_1.default.stub(prisma_1.prisma.app, 'count').resolves(2);
         const teamDel = sinon_1.default.stub(prisma_1.prisma.team, 'delete').resolves({});
@@ -89,6 +91,7 @@ describe('TeamService (User-keyed)', () => {
     }));
     it('delete() drops FK on revoked apiKeys then deletes the team', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(prisma_1.prisma.device, 'count').resolves(0);
+        sinon_1.default.stub(prisma_1.prisma.deviceSetting, 'findMany').resolves([]);
         sinon_1.default.stub(prisma_1.prisma.teamMember, 'count').resolves(0);
         sinon_1.default.stub(prisma_1.prisma.app, 'count').resolves(0);
         const apiKeyUpdate = sinon_1.default.stub(prisma_1.prisma.apiKey, 'updateMany').resolves({ count: 0 });

package/lib/test/unit/XenonCapabilityManager.spec.js

@@ -47,9 +47,11 @@ describe('XenonCapabilityManager.getXenonCapabilities — interceptor activation
         expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.SESSION_NAME]).to.equal('new-name');
         expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.BUILD_NAME]).to.equal('nightly');
     });
-    it('treats no interceptor cap as disabled', () => {
+    it("leaves no interceptor cap unset, for the server's `interceptor` option to decide", () => {
+        // Off unless the server's option turns it on: resolveInterceptorOptions,
+        // test/unit/phone-network/interceptor-options.spec.ts.
         const out = (0, XenonCapabilityManager_1.getXenonCapabilities)(caps({}));
-        expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(false);
+        expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(undefined);
     });
     it('does not throw when firstMatch is missing entirely', () => {
         const malformed = { alwaysMatch: { interceptor: { enabled: true } } };

package/lib/test/unit/apple-family.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const appleFamily_1 = require("../../src/data-service/appleFamily");
+/**
+ * Whether a phone is an iPhone or an iPad, for `appium:iPhoneOnly` and
+ * `appium:iPadOnly`. Its model and form factor are read before its name: a
+ * real phone is named by its owner.
+ */
+describe('appleFamilyOf', () => {
+    const ios = (over) => (Object.assign({ platform: 'ios', name: 'unknown' }, over));
+    it('reads the family from the model first', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ model: 'iPhone17,3', name: 'My iPad' }))).to.equal('iphone');
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ model: 'iPad13,4', name: 'iPhone spare' }))).to.equal('ipad');
+    });
+    it('reads it from the form factor when there is no model (a simulator)', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ formFactor: 'phone', name: 'Test device 1' }))).to.equal('iphone');
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ formFactor: 'tablet', name: 'Test device 2' }))).to.equal('ipad');
+    });
+    it('puts an Apple TV in neither family', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ formFactor: 'tv', name: 'iPad-like TV' }))).to.equal(undefined);
+    });
+    it('falls back to the marketing name, then the name, for an old row', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ marketingName: 'iPad Air (5th generation)', name: 'x' }))).to.equal('ipad');
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ name: 'iPhone 13' }))).to.equal('iphone');
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ name: 'iPad (9th generation)' }))).to.equal('ipad');
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ name: 'unknown' }))).to.equal(undefined);
+    });
+    it('is case-insensitive about a name', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)(ios({ name: 'IPHONE 12' }))).to.equal('iphone');
+    });
+    it('is nothing for a device that is not iOS', () => {
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)({ platform: 'android', name: 'Pixel Tablet', formFactor: 'tablet' })).to.equal(undefined);
+        (0, chai_1.expect)((0, appleFamily_1.appleFamilyOf)({ platform: 'android', name: 'iPhone clone', model: 'iPhone1,1' })).to.equal(undefined);
+    });
+});