@xenon-device-management/xenon 2.13.1 → 2.14.0

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

package/lib/test/unit/wda-client-shell.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 fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const IOSTunnels_1 = require("../../src/device-managers/ios/IOSTunnels");
+const WDAClient_1 = require("../../src/device-managers/ios/WDAClient");
+const device_store_1 = require("../../src/data-service/device-store");
+/**
+ * The Shell tab on iOS: simctl commands and a few generic ones on simulators,
+ * go-ios commands on real iPhones. Through 2.13.2 a real iPhone's command could
+ * carry its own `--udid` (another phone on the Mac), `list` named every device
+ * attached to the Mac, simulator commands took any path on this Mac, and the
+ * go-ios call ran without the phone's tunnel, so iOS 17+ phones never answered.
+ *
+ * `xcrun` and `ios` here are scripts that print the arguments they were given.
+ */
+const SIMULATOR = 'TEST-SIM-0000-AAAA';
+const IPHONE = '00008110-00084CE80E51401E';
+const ECHO = `#!/bin/sh
+printf '%s|' "$@"
+printf 'port=%s' "$GO_IOS_AGENT_PORT"
+`;
+describe('WDAClient.executeShell', () => {
+    let dir;
+    let savedPath;
+    let realDevice;
+    const borrowed = [];
+    before(() => {
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-fake-shell-'));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'xcrun'), ECHO, { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'ios'), ECHO, { mode: 0o755 });
+    });
+    after(() => fs_1.default.rmSync(dir, { recursive: true, force: true }));
+    beforeEach(() => {
+        savedPath = process.env.PATH;
+        process.env.PATH = `${dir}:${process.env.PATH}`;
+        borrowed.length = 0;
+        const stream = { isGoIOSAvailable: () => __awaiter(void 0, void 0, void 0, function* () { return true; }), goIOSPath: path_1.default.join(dir, 'ios') };
+        const tunnels = {
+            borrow(udid) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    borrowed.push(udid);
+                    return 12100;
+                });
+            },
+            envFor: () => (Object.assign(Object.assign({}, process.env), { GO_IOS_AGENT_PORT: '12100' })),
+        };
+        const real = typedi_1.Container.get.bind(typedi_1.Container);
+        sinon_1.default.stub(typedi_1.Container, 'get').callsFake((token) => {
+            if (token === IOSStreamService_1.default)
+                return stream;
+            if (token === IOSTunnels_1.IOSTunnels)
+                return tunnels;
+            return real(token);
+        });
+        sinon_1.default
+            .stub(device_store_1.DeviceStoreFactory, 'getStore')
+            .returns({ findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ realDevice }); }) });
+    });
+    afterEach(() => {
+        process.env.PATH = savedPath;
+        sinon_1.default.restore();
+    });
+    const run = (udid, command) => new WDAClient_1.WDAClient().executeShell(udid, command).then((out) => ({ out }), (err) => ({ err: err.message }));
+    describe('on a simulator', () => {
+        beforeEach(() => {
+            realDevice = false;
+        });
+        it('runs a simctl command for this simulator', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { out } = (yield run(SIMULATOR, 'getenv HOME'));
+            (0, chai_1.expect)(out).to.match(new RegExp(`^simctl\\|getenv\\|${SIMULATOR}\\|HOME\\|`));
+        }));
+        it('spawns a generic command in this simulator, without arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { out } = (yield run(SIMULATOR, 'ls'));
+            (0, chai_1.expect)(out).to.match(new RegExp(`^simctl\\|spawn\\|${SIMULATOR}\\|ls\\|`));
+            (0, chai_1.expect)(yield run(SIMULATOR, 'ls /Users'))
+                .to.have.property('err')
+                .that.match(/not allowed/);
+        }));
+        it('refuses list, chaining and look-alikes', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const cmd of ['list', 'ls; id', 'lsof', 'getenv $HOME']) {
+                (0, chai_1.expect)(yield run(SIMULATOR, cmd), cmd)
+                    .to.have.property('err')
+                    .that.match(/not allowed/);
+            }
+        }));
+    });
+    describe('on a real iPhone', () => {
+        beforeEach(() => {
+            realDevice = true;
+        });
+        it('runs a go-ios command for this phone, through its tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { out } = (yield run(IPHONE, 'apps --list'));
+            (0, chai_1.expect)(out).to.equal(`apps|--list|--udid|${IPHONE}|port=12100`);
+            (0, chai_1.expect)(borrowed).to.deep.equal([IPHONE]);
+        }));
+        it('refuses a command that names another device, and list', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const cmd of [
+                'apps --udid 00008101-OTHER',
+                'apps --udid=00008101-OTHER',
+                'list',
+                'info --json',
+            ]) {
+                (0, chai_1.expect)(yield run(IPHONE, cmd), cmd)
+                    .to.have.property('err')
+                    .that.match(/not allowed/);
+            }
+        }));
+        it('says a generic command needs a simulator', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield run(IPHONE, 'ls'))
+                .to.have.property('err')
+                .that.match(/real/i);
+        }));
+    });
+});

package/lib/test/unit/web-config-service.spec.js

@@ -0,0 +1,79 @@
+"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 typedi_1 = require("typedi");
+const web_config_service_1 = require("../../src/data-service/web-config-service");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * WebConfig holds the dashboard's saved settings, one row each. Its `id`
+ * column is the table's primary key and defaulted to 'global', and every
+ * setting was written with that id, so the table could hold one setting:
+ * saving a second failed with "Unique constraint failed on the fields (`id`)".
+ * These run the service against a real (scratch) database.
+ */
+describe('WebConfigService', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const service = () => typedi_1.Container.get(web_config_service_1.WebConfigService);
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.webConfig.deleteMany({});
+    }));
+    it('saves every setting of one update', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({
+            buildCleanupDays: 7,
+            buildCleanupMaxCount: 5,
+            buildCleanupSchedule: '0 3 * * *',
+            deleteBuildAssets: false,
+        });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 7,
+            buildCleanupMaxCount: 5,
+            buildCleanupSchedule: '0 3 * * *',
+            deleteBuildAssets: false,
+        });
+    }));
+    it('saves settings from separate updates, as two pages save them', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ healthCheckIntervalMs: 600000 });
+        yield service().setConfig({ buildCleanupDays: 7 });
+        yield service().setConfig({ healthCheckSchedule: '0 * * * *', deleteBuildAssets: true });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            healthCheckIntervalMs: 600000,
+            buildCleanupDays: 7,
+            healthCheckSchedule: '0 * * * *',
+            deleteBuildAssets: true,
+        });
+    }));
+    it('keeps the self-healing switch, off as well as on', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ enableSelfHealing: false });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({ enableSelfHealing: false });
+        yield service().setConfig({ enableSelfHealing: true });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({ enableSelfHealing: true });
+    }));
+    it('changes a setting saved before', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ buildCleanupDays: 7, buildCleanupMaxCount: 5 });
+        yield service().setConfig({ buildCleanupDays: 14 });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 14,
+            buildCleanupMaxCount: 5,
+        });
+    }));
+    it('still reads the row an earlier version saved under the id "global"', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.webConfig.create({
+            data: { id: 'global', name: 'buildCleanupDays', value: '9' },
+        });
+        yield service().setConfig({ buildCleanupMaxCount: 5 });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 9,
+            buildCleanupMaxCount: 5,
+        });
+    }));
+});

package/lib/test/unit/webhook-delivery.spec.js

@@ -129,6 +129,30 @@ describe('webhook delivery', () => {
             (0, chai_1.expect)(r.status).to.equal(200);
             (0, chai_1.expect)(r.body).to.deep.equal({ success: true });
         }));
+        it('POST /api/webhook/test sends a sample of the event it is asked for, through the template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            const r = yield (0, loopbackRequest_1.default)(app)
+                .post('/xenon/api/webhook/test')
+                .send({
+                url: URL,
+                type: 'slack',
+                payloadTemplate: '{"text": "{{eventType}}: {{sessionId}}"}',
+                event: 'session_failed',
+            })
+                .timeout(5000);
+            (0, chai_1.expect)(r.status).to.equal(200);
+            (0, chai_1.expect)(post.firstCall.args[1]).to.deep.equal({ text: 'session_failed: test-session-id' });
+        }));
+        it('POST /api/webhook/test with an event it does not know answers 400, sending nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            const r = yield (0, loopbackRequest_1.default)(app)
+                .post('/xenon/api/webhook/test')
+                .send({ url: URL, event: 'device_exploded' })
+                .timeout(5000);
+            (0, chai_1.expect)(r.status).to.equal(400);
+            (0, chai_1.expect)(r.body.error).to.contain('session_failed');
+            (0, chai_1.expect)(post.called).to.equal(false);
+        }));
         it('POST /api/webhook/test without a url answers 400', () => __awaiter(void 0, void 0, void 0, function* () {
             const r = yield (0, loopbackRequest_1.default)(app).post('/xenon/api/webhook/test').send({}).timeout(5000);
             (0, chai_1.expect)(r.status).to.equal(400);