@xenon-device-management/xenon 2.13.2 → 2.14.0

package/lib/test/unit/session-failed-webhook.spec.js

@@ -0,0 +1,170 @@
+"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 axios_1 = __importDefault(require("axios"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const MetricsService_1 = require("../../src/services/MetricsService");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const device_store_1 = require("../../src/data-service/device-store");
+const SessionStatus_1 = require("../../src/types/SessionStatus");
+const prisma_1 = require("../../src/prisma");
+const container_registration_1 = require("../helpers/container-registration");
+/**
+ * `session_failed` goes out when a session ends as failed, whichever way it
+ * ends, and once per session.
+ *
+ * It was sent only from the client's own delete, so a session that timed out
+ * for inactivity, whose driver crashed, or whose heartbeat stopped was marked
+ * failed on the dashboard and counted in the failure metric, and no webhook
+ * heard of it. Every one of those ends through `onSessionStopped`, which is
+ * where the final status is decided, so that is where it is sent. A session
+ * that ends twice (a crash, then the client's delete) is still sent once.
+ */
+describe('session_failed: when it is sent', () => {
+    const URL = 'https://hooks.example.com/T000/B000/xyz';
+    let restore;
+    let post;
+    let row;
+    let svc;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(SessionMetricsService_1.SessionMetricsService, SocketServer_1.SocketServer, MetricsService_1.MetricsService);
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, { stop: sinon_1.default.stub().resolves() });
+        typedi_1.Container.set(SocketServer_1.SocketServer, {
+            emitToDashboard: sinon_1.default.stub(),
+            emitToDashboardForDevices: sinon_1.default.stub().resolves(),
+            hasScopedDashboard: sinon_1.default.stub().returns(false),
+        });
+        typedi_1.Container.set(MetricsService_1.MetricsService, {
+            incrementSessionSuccess: sinon_1.default.stub(),
+            incrementSessionFailure: sinon_1.default.stub(),
+        });
+        sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns(undefined);
+        sinon_1.default
+            .stub(device_store_1.DeviceStoreFactory, 'getStore')
+            .returns({ getDevices: () => __awaiter(void 0, void 0, void 0, function* () { return []; }), findDevices: () => __awaiter(void 0, void 0, void 0, function* () { return []; }) });
+        sinon_1.default.stub(prisma_1.prisma.sessionLog, 'findFirst').resolves(null);
+        row = {
+            id: 'sess-1',
+            name: 'Checkout flow',
+            status: 'running',
+            failure_reason: null,
+            device_udid: 'R58M123',
+            device_name: 'Galaxy S9+',
+            device_platform: 'android',
+            device_version: '10',
+            startTime: new Date('2026-10-04T09:00:00.000Z'),
+            endTime: null,
+            desired_capabilities: '{"appium:app":"/secret.apk"}',
+        };
+        sinon_1.default.stub(prisma_1.prisma.session, 'findFirst').callsFake((() => __awaiter(void 0, void 0, void 0, function* () { return (Object.assign({}, row)); })));
+        sinon_1.default.stub(prisma_1.prisma.session, 'update').callsFake(((_a) => __awaiter(void 0, [_a], void 0, function* ({ data }) {
+            row = Object.assign(Object.assign({}, row), data);
+            return row;
+        })));
+        // A real service with a slack webhook for the event, so what is checked is
+        // what would reach the channel.
+        svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+        post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+        sinon_1.default
+            .stub(svc, 'getConfigs')
+            .resolves([
+            { id: 'w', url: URL, events: '["session_failed"]', type: 'slack', active: true },
+        ]);
+        // A session id nobody has notified for yet, however many specs ran before.
+        row.id = `sess-${Math.random().toString(36).slice(2)}`;
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    /** onSessionStopped fires the webhook without being awaited: let it finish. */
+    const settle = () => new Promise((resolve) => setTimeout(resolve, 30));
+    it('is sent when a session times out for inactivity (device-utils)', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, 'failed', 'Session timed out due to inactivity');
+        yield settle();
+        (0, chai_1.expect)(post.calledOnce).to.equal(true);
+        const text = post.firstCall.args[1].attachments[0].text;
+        (0, chai_1.expect)(text).to.contain(row.id);
+        (0, chai_1.expect)(text).to.contain('Session timed out due to inactivity');
+        (0, chai_1.expect)(text).to.contain('Galaxy S9+');
+        (0, chai_1.expect)(text).not.to.contain('undefined');
+    }));
+    it('is sent when the driver crashes (plugin onUnexpectedShutdown)', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'Driver shut down unexpectedly');
+        yield settle();
+        (0, chai_1.expect)(post.calledOnce).to.equal(true);
+        (0, chai_1.expect)(post.firstCall.args[1].attachments[0].text).to.contain('Driver shut down unexpectedly');
+    }));
+    it('is sent when the heartbeat stops (OrphanSweeper)', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'Session heartbeat timeout');
+        yield settle();
+        (0, chai_1.expect)(post.calledOnce).to.equal(true);
+    }));
+    it('is sent when the client deletes a session a command failed in', () => __awaiter(void 0, void 0, void 0, function* () {
+        prisma_1.prisma.sessionLog.findFirst.resolves({
+            command_name: 'findElement',
+            response: '{"value":{"error":"no such element"}}',
+        });
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id);
+        yield settle();
+        (0, chai_1.expect)(post.calledOnce).to.equal(true);
+        (0, chai_1.expect)(post.firstCall.args[1].attachments[0].text).to.contain('no such element');
+    }));
+    it('is sent when the test marked the session failed and the client then deletes it', () => __awaiter(void 0, void 0, void 0, function* () {
+        row.status = 'failed';
+        row.failure_reason = 'Assertion failed: total is 12';
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id);
+        yield settle();
+        (0, chai_1.expect)(post.calledOnce).to.equal(true);
+        (0, chai_1.expect)(post.firstCall.args[1].attachments[0].text).to.contain('Assertion failed: total is 12');
+    }));
+    it('is not sent for a session that passes', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id);
+        yield settle();
+        (0, chai_1.expect)(row.status).to.equal('success');
+        (0, chai_1.expect)(post.called).to.equal(false);
+    }));
+    it('is sent once when a session ends twice: a crash, then the client’s delete', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'Driver shut down unexpectedly');
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id);
+        yield settle();
+        (0, chai_1.expect)(post.callCount).to.equal(1);
+    }));
+    it('is not sent when the server itself is shutting down', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'Hub shutdown', {
+            notify: false,
+        });
+        yield settle();
+        (0, chai_1.expect)(row.status).to.equal('failed'); // still recorded as failed
+        (0, chai_1.expect)(post.called).to.equal(false);
+    }));
+    it('does not hold the session’s end up for a webhook, and survives one that fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        post.rejects(new Error('slack is down'));
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'boom');
+        yield settle();
+        (0, chai_1.expect)(row.status).to.equal('failed');
+    }));
+    it('does not send the session’s capabilities to the webhook', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(row.id, SessionStatus_1.SessionStatus.FAILED, 'boom');
+        yield settle();
+        (0, chai_1.expect)(JSON.stringify(post.firstCall.args[1])).not.to.contain('secret.apk');
+    }));
+});

package/lib/test/unit/shell-commands.spec.js

@@ -0,0 +1,133 @@
+"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 shellCommands_1 = require("../../src/device-managers/shellCommands");
+const AndroidDeviceManager_1 = __importDefault(require("../../src/device-managers/AndroidDeviceManager"));
+// The device control Shell tab's allow-list was a `startsWith` test, and the
+// command then reached the phone's `sh`: `ls; reboot`, `ls && pm uninstall …`
+// and `lsof` all ran. A command now has to be an allowed command word for word,
+// and its arguments may only use characters a shell gives no meaning to.
+describe('parseShellCommand', () => {
+    const allowed = (cmd) => (0, shellCommands_1.parseShellCommand)(cmd, shellCommands_1.ANDROID_SHELL_COMMANDS);
+    it('accepts an allowed command and its plain arguments', () => {
+        (0, chai_1.expect)(allowed('ls -la /sdcard/Download')).to.deep.equal({
+            argv: ['ls', '-la', '/sdcard/Download'],
+        });
+        (0, chai_1.expect)(allowed('  getprop   ro.product.model ')).to.deep.equal({
+            argv: ['getprop', 'ro.product.model'],
+        });
+        (0, chai_1.expect)(allowed('pm list packages -3')).to.deep.equal({
+            argv: ['pm', 'list', 'packages', '-3'],
+        });
+        (0, chai_1.expect)(allowed('dumpsys battery')).to.deep.equal({ argv: ['dumpsys', 'battery'] });
+        (0, chai_1.expect)(allowed('date +%s')).to.deep.equal({ argv: ['date', '+%s'] });
+    });
+    for (const cmd of [
+        'ls; reboot',
+        'ls;reboot',
+        'ls && pm uninstall com.example.app',
+        'ls || reboot',
+        'ls | sh',
+        'ls `reboot`',
+        'getprop $(reboot)',
+        'ls > /sdcard/x',
+        'ls < /sdcard/x',
+        'ls &',
+        'ls\nreboot',
+        "ls 'a b'",
+        'ls "a b"',
+        'ls \\; reboot',
+        'getprop ${PATH}',
+        'ls *',
+        'ls ~',
+    ]) {
+        it(`refuses a shell metacharacter: ${JSON.stringify(cmd)}`, () => {
+            (0, chai_1.expect)(allowed(cmd)).to.have.property('refused');
+        });
+    }
+    it('refuses a command that only starts like an allowed one', () => {
+        (0, chai_1.expect)(allowed('lsof')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('pstree')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('dumpsys batteryproperties')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('pm list packagesx')).to.have.property('refused');
+    });
+    it('refuses arguments to a command that takes none', () => {
+        (0, chai_1.expect)(allowed('dumpsys battery set level 5')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('cat /proc/meminfo /data/system/users/0.xml')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('whoami --help')).to.have.property('refused');
+    });
+    it('refuses an empty command and anything not listed', () => {
+        (0, chai_1.expect)(allowed('   ')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('reboot')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('pm uninstall com.example.app')).to.have.property('refused');
+        (0, chai_1.expect)(allowed('cat /data/system/users/0.xml')).to.have.property('refused');
+    });
+    it('keeps every command the Android allow-list offered usable', () => {
+        for (const cmd of [
+            'ls',
+            'ps -A',
+            'top -n 1',
+            'dumpsys battery',
+            'dumpsys wifi',
+            'dumpsys power',
+            'whoami',
+            'getprop',
+            'pm list packages',
+            'ip addr',
+            'cat /proc/meminfo',
+            'cat /proc/cpuinfo',
+            'date',
+            'uptime',
+            'netstat -tn',
+        ]) {
+            (0, chai_1.expect)(allowed(cmd), cmd).to.have.property('argv');
+        }
+    });
+    it("lets a simulator's generic commands take no arguments", () => {
+        (0, chai_1.expect)((0, shellCommands_1.parseShellCommand)('ls', shellCommands_1.IOS_SIMULATOR_COMMANDS)).to.have.property('argv');
+        (0, chai_1.expect)((0, shellCommands_1.parseShellCommand)('ls /Users', shellCommands_1.IOS_SIMULATOR_COMMANDS)).to.have.property('refused');
+    });
+});
+describe('AndroidDeviceManager.executeShell', () => {
+    afterEach(() => sinon_1.default.restore());
+    function managerWithAdb() {
+        const manager = new AndroidDeviceManager_1.default({});
+        const adbExec = sinon_1.default.stub().resolves('ok');
+        sinon_1.default.stub(manager, 'getAdb').resolves({ adbInstance: { adbExec } });
+        return { manager, adbExec };
+    }
+    it('passes an allowed command to adb shell word by word', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { manager, adbExec } = managerWithAdb();
+        (0, chai_1.expect)(yield manager.executeShell('R5CT32ABCDE', 'getprop ro.product.model')).to.equal('ok');
+        (0, chai_1.expect)(adbExec.firstCall.args[0]).to.deep.equal([
+            '-s',
+            'R5CT32ABCDE',
+            'shell',
+            'getprop',
+            'ro.product.model',
+        ]);
+    }));
+    it('never reaches adb for a refused command', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { manager, adbExec } = managerWithAdb();
+        for (const cmd of ['ls; reboot', 'lsof', 'dumpsys battery set level 5']) {
+            const err = yield manager.executeShell('R5CT32ABCDE', cmd).then(() => null, (e) => e);
+            (0, chai_1.expect)(err, cmd).to.be.an('Error');
+            (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message, cmd).to.match(/not allowed/);
+        }
+        (0, chai_1.expect)(adbExec.called).to.equal(false);
+    }));
+});

package/lib/test/unit/socketServer.scopedEmit.spec.js

@@ -353,6 +353,8 @@ describe('Auth disabled: the lab path looks nothing up', () => {
         const row = { udid: 'phone-a', host: 'h', teamId: 'team-a' };
         sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
             removeDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+            // removeDevice reads the row for the device_offline webhook's name and platform.
+            findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
             addDevices: () => __awaiter(void 0, void 0, void 0, function* () { return [row]; }),
             updateDevice: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
             getDevices: () => __awaiter(void 0, void 0, void 0, function* () { return [Object.assign(Object.assign({}, row), { sessionStartTime: 0, totalUtilizationTimeMilliSec: 0 })]; }),

package/lib/test/unit/stream-start-pipelines.spec.js

@@ -0,0 +1,210 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const typedi_1 = require("typedi");
+const control_1 = __importDefault(require("../../src/app/routers/control"));
+const device_store_1 = require("../../src/data-service/device-store");
+const deviceService = __importStar(require("../../src/data-service/device-service"));
+const recording_store_1 = require("../../src/services/recording/recording-store");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
+const AndroidH264StreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidH264StreamService"));
+const PluginContext_1 = require("../../src/PluginContext");
+const container_registration_1 = require("../helpers/container-registration");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const own_node_id_1 = require("../helpers/own-node-id");
+/**
+ * Which capture pipelines POST /control/:udid/stream/start runs.
+ *
+ * With `streaming.androidH264` on, the start ran the H.264 service (scrcpy),
+ * and device control's `<img>` then asked GET /stream, which ran the screencap
+ * MJPEG loop beside it: two captures of one phone, the very thing the comment
+ * in the handler says must not happen. Device control, and any browser that
+ * cannot decode H.264 (WebCodecs exists only in a secure context, so plain
+ * http://hub:4723 has none), shows MJPEG, so it says so when it starts the
+ * stream (`player: 'mjpeg'`), and the server then runs MJPEG only.
+ */
+const UDID = 'DEV-1';
+function buildApp() {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    const apiRouter = express_1.default.Router();
+    apiRouter.use((req, _res, next) => {
+        req.auth = {
+            kind: 'user-session',
+            userId: 'usr_alice',
+            role: 'ADMIN',
+            scopes: 'admin,devices,sessions,read',
+            rateLimit: 100,
+        };
+        next();
+    });
+    control_1.default.register(apiRouter);
+    app.use('/xenon/api', apiRouter);
+    return app;
+}
+describe('POST /control/:udid/stream/start: which capture runs', () => {
+    (0, own_node_id_1.useOwnNodeId)();
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let restoreContainer;
+    let savedArgs;
+    let mjpegStart;
+    let h264Start;
+    let h264Stop;
+    let h264Running;
+    let row;
+    const flag = (androidH264) => {
+        typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs = Object.assign(Object.assign({}, savedArgs), { streaming: { androidH264 } });
+    };
+    beforeEach(() => {
+        restoreContainer = (0, container_registration_1.saveRegistrations)(AndroidStreamService_1.default, AndroidH264StreamService_1.default, IOSStreamService_1.default, recording_store_1.RecordingStore);
+        savedArgs = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs;
+        row = {
+            udid: UDID,
+            host: '127.0.0.1',
+            nodeId: own_node_id_1.OWN_NODE_ID,
+            platform: 'android',
+            busy: false,
+            session_id: null,
+            screenWidth: '1080',
+            screenHeight: '2220',
+        };
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({ findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return row; }) });
+        sinon_1.default.stub(deviceService, 'blockDevice').resolves();
+        h264Running = false;
+        mjpegStart = sinon_1.default.stub().resolves({ mjpegPort: 9100 });
+        h264Start = sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            h264Running = true;
+            return {};
+        }));
+        h264Stop = sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            h264Running = false;
+        }));
+        typedi_1.Container.set(AndroidStreamService_1.default, {
+            startStream: mjpegStart,
+            getStreamStatus: () => undefined,
+        });
+        typedi_1.Container.set(IOSStreamService_1.default, { getStreamStatus: () => undefined });
+        typedi_1.Container.set(AndroidH264StreamService_1.default, {
+            start: h264Start,
+            stop: h264Stop,
+            getMultiplexer: () => (h264Running ? { clientCount: 0 } : undefined),
+        });
+        typedi_1.Container.set(recording_store_1.RecordingStore, { isRecording: () => __awaiter(void 0, void 0, void 0, function* () { return false; }) });
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs = savedArgs;
+        restoreContainer();
+        yield loopback.closeAll();
+    }));
+    const start = (body) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, loopbackRequest_1.default)(yield loopback.serve(buildApp()))
+            .post(`/xenon/api/control/${UDID}/stream/start`)
+            .send(body !== null && body !== void 0 ? body : {});
+    });
+    it('runs the H.264 service alone when the flag is on and the page can play it', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        const res = yield start();
+        (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+        (0, chai_1.expect)(res.body.type).to.equal('h264');
+        (0, chai_1.expect)(res.body.h264Path).to.equal(`/xenon/api/control/${UDID}/stream/h264`);
+        (0, chai_1.expect)(h264Start.calledOnce).to.equal(true);
+        (0, chai_1.expect)(mjpegStart.called).to.equal(false);
+    }));
+    it('runs the MJPEG capture alone when the page says it shows MJPEG', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        const res = yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(res.status, JSON.stringify(res.body)).to.equal(200);
+        (0, chai_1.expect)(res.body.type).to.equal('mjpeg');
+        (0, chai_1.expect)(res.body.streamUrl).to.equal(`/xenon/api/control/${UDID}/stream`);
+        (0, chai_1.expect)(mjpegStart.calledOnce).to.equal(true);
+        (0, chai_1.expect)(h264Start.called).to.equal(false);
+    }));
+    it('ends an H.264 capture already running for the phone, so the two never overlap', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        h264Running = true;
+        yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(h264Stop.calledOnceWith(UDID)).to.equal(true);
+        (0, chai_1.expect)(mjpegStart.calledOnce).to.equal(true);
+        (0, chai_1.expect)(h264Running).to.equal(false);
+    }));
+    it('stops the H.264 capture before it starts the MJPEG one', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        h264Running = true;
+        yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(h264Stop.calledBefore(mjpegStart)).to.equal(true);
+    }));
+    it('runs MJPEG alone, and stops nothing, when the flag is off', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(false);
+        const res = yield start();
+        (0, chai_1.expect)(res.body.type).to.equal('mjpeg');
+        (0, chai_1.expect)(mjpegStart.calledOnce).to.equal(true);
+        (0, chai_1.expect)(h264Start.called).to.equal(false);
+        (0, chai_1.expect)(h264Stop.called).to.equal(false);
+    }));
+    it('ignores a player it does not know, and uses the server’s choice', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        const res = yield start({ player: 'hologram' });
+        (0, chai_1.expect)(res.body.type).to.equal('h264');
+        (0, chai_1.expect)(h264Start.calledOnce).to.equal(true);
+        (0, chai_1.expect)(mjpegStart.called).to.equal(false);
+    }));
+    it('keeps MJPEG for a phone that is being recorded, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        typedi_1.Container.set(recording_store_1.RecordingStore, { isRecording: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) });
+        const res = yield start();
+        (0, chai_1.expect)(res.body.type).to.equal('mjpeg');
+        (0, chai_1.expect)(mjpegStart.calledOnce).to.equal(true);
+        (0, chai_1.expect)(h264Start.called).to.equal(false);
+    }));
+});

package/lib/test/unit/stream-status-type.spec.js

@@ -20,4 +20,8 @@ describe('resolveStreamType', () => {
         (0, chai_1.expect)((0, streamType_1.resolveStreamType)('android', true, false)).to.equal('h264');
         (0, chai_1.expect)((0, streamType_1.resolveStreamType)('androidtv', true, false)).to.equal('h264');
     });
+    it('a page that shows MJPEG => mjpeg, whatever the flag', () => {
+        (0, chai_1.expect)((0, streamType_1.resolveStreamType)('android', true, false, false)).to.equal('mjpeg');
+        (0, chai_1.expect)((0, streamType_1.resolveStreamType)('android', true, false, true)).to.equal('h264');
+    });
 });

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

@@ -0,0 +1,118 @@
+"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 VisionAssertionService_1 = require("../../src/services/omni-vision/VisionAssertionService");
+const AIService_1 = require("../../src/services/AIService");
+/**
+ * `xenon: assertVisualState` answered `{ result: true, message: 'Assertion
+ * placeholder' }` whenever the AI step gave it nothing usable: with no AI
+ * provider, when the provider failed, and usually even with one, because the
+ * condition was wrapped in a "find the centre coordinates, answer {x, y}"
+ * prompt. A test asserting a screen state passed without anything being
+ * checked.
+ *
+ * Now it asks the provider a yes/no question of the screenshot and answers
+ * with the provider's verdict. Whenever there is no verdict (no provider, a
+ * failed call, an answer that isn't true or false, no screenshot, no
+ * condition) it fails with an error the test sees, never `true` and never
+ * `false`: a `false` would pass a test that asserts a state is absent.
+ */
+describe('xenon: assertVisualState', () => {
+    const SCREEN = 'c2NyZWVuc2hvdA==';
+    let service;
+    let driver;
+    beforeEach(() => {
+        service = new VisionAssertionService_1.VisionAssertionService();
+        driver = { getScreenshot: sinon_1.default.stub().resolves(SCREEN) };
+        // The real provider set-up reads the server's AI settings; these tests set the provider themselves.
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'initializeProvider');
+    });
+    afterEach(() => sinon_1.default.restore());
+    const failureOf = (p) => p.then((value) => {
+        throw new Error(`expected a failure, got ${JSON.stringify(value)}`);
+    }, (e) => e);
+    function withProvider(answer) {
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'provider').value({ analyze: () => __awaiter(this, void 0, void 0, function* () { return ''; }) });
+        const call = sinon_1.default.stub(AIService_1.AI_SERVICE, 'callProvider');
+        if (answer instanceof Error)
+            call.rejects(answer);
+        else
+            call.resolves(answer);
+        return call;
+    }
+    it('fails, rather than passing, 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 failureOf(service.assertState(driver, 'The Login button is visible'));
+        (0, chai_1.expect)(err.message).to.match(/No AI provider is configured/);
+        (0, chai_1.expect)(err.message).to.match(/not checked/);
+    }));
+    it('asks a yes/no question about the condition, with the screenshot', () => __awaiter(void 0, void 0, void 0, function* () {
+        const call = withProvider('{"result": true, "reason": "A Login button is shown."}');
+        const answer = yield service.assertState(driver, 'The Login button is visible');
+        (0, chai_1.expect)(answer).to.deep.equal({ result: true, message: 'A Login button is shown.' });
+        (0, chai_1.expect)(call.calledOnce).to.equal(true);
+        const [prompt, image] = call.firstCall.args;
+        (0, chai_1.expect)(image).to.equal(SCREEN);
+        (0, chai_1.expect)(prompt).to.include('The Login button is visible');
+        (0, chai_1.expect)(prompt).to.match(/true or false/i);
+        (0, chai_1.expect)(prompt).to.not.match(/coordinates/i);
+    }));
+    it("answers false when the provider says the condition doesn't hold", () => __awaiter(void 0, void 0, void 0, function* () {
+        withProvider('```json\n{"result": false, "reason": "The cart shows 2 items."}\n```');
+        (0, chai_1.expect)(yield service.assertState(driver, 'The cart is empty')).to.deep.equal({
+            result: false,
+            message: 'The cart shows 2 items.',
+        });
+    }));
+    it("fails when the provider's answer is not a true/false verdict", () => __awaiter(void 0, void 0, void 0, function* () {
+        for (const answer of ['{"x": 120, "y": 340}', 'Yes, I can see it.', '{"result": "maybe"}']) {
+            sinon_1.default.restore();
+            sinon_1.default.stub(AIService_1.AI_SERVICE, 'initializeProvider');
+            driver = { getScreenshot: sinon_1.default.stub().resolves(SCREEN) };
+            withProvider(answer);
+            const err = yield failureOf(service.assertState(driver, 'The cart is empty'));
+            (0, chai_1.expect)(err.message, answer).to.match(/could not read/i);
+        }
+    }));
+    it('fails when the provider call fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        withProvider(new Error('429 quota exceeded'));
+        const err = yield failureOf(service.assertState(driver, 'The cart is empty'));
+        (0, chai_1.expect)(err.message).to.match(/429 quota exceeded/);
+    }));
+    it('fails when the provider is rate-limited', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Gemini's provider answers this instead of throwing on a 429.
+        withProvider('CONNECTION_OK_RATE_LIMITED');
+        const err = yield failureOf(service.assertState(driver, 'The cart is empty'));
+        (0, chai_1.expect)(err.message).to.match(/rate-limited/i);
+    }));
+    it('fails without asking when there is no condition', () => __awaiter(void 0, void 0, void 0, function* () {
+        const call = withProvider('{"result": true, "reason": "ok"}');
+        for (const empty of ['', '   ', undefined]) {
+            const err = yield failureOf(service.assertState(driver, empty));
+            (0, chai_1.expect)(err.message).to.match(/needs a condition/);
+        }
+        (0, chai_1.expect)(call.called).to.equal(false);
+        (0, chai_1.expect)(driver.getScreenshot.called).to.equal(false);
+    }));
+    it('fails when no screenshot can be taken', () => __awaiter(void 0, void 0, void 0, function* () {
+        const call = withProvider('{"result": true, "reason": "ok"}');
+        driver.getScreenshot.rejects(new Error('WDA is not running'));
+        const err = yield failureOf(service.assertState(driver, 'The cart is empty'));
+        (0, chai_1.expect)(err.message).to.match(/WDA is not running/);
+        (0, chai_1.expect)(call.called).to.equal(false);
+    }));
+});