@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/test/unit/session-log-indexes.spec.js

@@ -17,6 +17,7 @@ const chai_1 = require("chai");
 const supertest_1 = __importDefault(require("supertest"));
 const typedi_1 = require("typedi");
 const CleanupService_1 = require("../../src/services/CleanupService");
+const SelectorVerificationJob_1 = require("../../src/services/SelectorVerificationJob");
 const scratch_database_1 = require("../helpers/scratch-database");
 const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
 /** The SQL statements `run` makes. */
@@ -30,16 +31,24 @@ function sqlOf(db, run) {
 /** How SQLite reads `table` in these statements: one line per step. */
 function stepsOn(db, table, queries) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b;
         const steps = [];
         for (const q of queries) {
-            if (!q.query.includes(`\`${table}\``))
+            // Prisma's own SQL quotes names with backticks; a raw query's, with ".
+            if (!q.query.includes(`\`${table}\``) && !q.query.includes(`"${table}"`))
                 continue;
             // SQLite plans without looking at the values, and Prisma's logged
             // parameters aren't JSON, so every placeholder gets null.
             const placeholders = ((_a = q.query.match(/\?/g)) !== null && _a !== void 0 ? _a : []).length;
             const plan = yield db.db.$queryRawUnsafe(`EXPLAIN QUERY PLAN ${q.query}`, ...new Array(placeholders).fill(null));
-            steps.push(...plan.map((p) => p.detail).filter((d) => new RegExp(`\\b${table}\\b`).test(d)));
+            // A raw query may name the table by an alias (`"SessionLog" sl`), which
+            // is what SQLite's plan then says.
+            const alias = (_b = q.query.match(new RegExp(`"${table}"\\s+(?:AS\\s+)?(\\w+)`, 'i'))) === null || _b === void 0 ? void 0 : _b[1];
+            for (const { detail } of plan) {
+                const named = alias ? detail.replace(new RegExp(`\\b${alias}\\b`), table) : detail;
+                if (new RegExp(`\\b${table}\\b`).test(named))
+                    steps.push(named);
+            }
         }
         return steps;
     });
@@ -145,3 +154,55 @@ describe("A session's logs and profiling are read through an index", function ()
         }
     }));
 });
+/**
+ * The selector verification reads every find of a selector being verified
+ * since it was marked fixed (SelectorVerificationJob), every 15 minutes, by
+ * the selector's own index.
+ */
+describe('The selector verification reads SessionLog through an index', function () {
+    this.timeout(30000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)({ captureQueries: true });
+    before(() => __awaiter(this, void 0, void 0, function* () {
+        yield scratch.db.build.create({ data: { id: 'sv-build', name: 'sv' } });
+        yield scratch.db.session.create({
+            data: {
+                id: 'sv-session',
+                build_id: 'sv-build',
+                device_udid: 'sv-phone',
+                device_platform: 'android',
+                device_version: '14',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'localhost',
+                has_live_video: false,
+            },
+        });
+        yield scratch.db.sessionLog.create({
+            data: {
+                session_id: 'sv-session',
+                command_name: 'findElement',
+                url: '/findElement',
+                method: 'POST',
+                title: 'Find element',
+                response: '{"value":{"ELEMENT":"e-1"}}',
+                original_strategy: 'xpath',
+                original_selector: '//sv',
+            },
+        });
+        yield scratch.db.selectorState.create({
+            data: {
+                original_strategy: 'xpath',
+                original_selector: '//sv',
+                status: 'pending',
+                fixed_at: new Date(Date.now() - 60 * 60 * 1000),
+            },
+        });
+    }));
+    it("reads a selector's finds without a scan", () => __awaiter(this, void 0, void 0, function* () {
+        const socket = { emitToDashboard: () => undefined };
+        const ran = yield sqlOf(scratch, () => new SelectorVerificationJob_1.SelectorVerificationJob(scratch.db, socket).run());
+        const steps = yield stepsOn(scratch, 'SessionLog', ran);
+        (0, chai_1.expect)(steps, 'no SessionLog statement was captured').to.not.be.empty;
+        (0, chai_1.expect)(scansOf('SessionLog', steps), steps.join('\n')).to.deep.equal([]);
+    }));
+});

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/socketServer.sessionCookie.spec.js

@@ -59,7 +59,8 @@ describe('SocketServer — a signed-in dashboard session cookie', () => {
         restore = (0, container_registration_1.saveRegistrations)(UserSessionService_1.UserSessionService, UserService_1.UserService, ApiKeyService_1.ApiKeyService, EventLogService_1.EventLogService);
         resolve = sinon_1.default.stub().callsFake((id) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = SESSIONS[id]) !== null && _a !== void 0 ? _a : null; }));
         verify = sinon_1.default.stub().resolves(null);
-        typedi_1.Container.set(UserSessionService_1.UserSessionService, { resolve });
+        // ttlMs: authMiddleware renews the cookie for the session's lifetime.
+        typedi_1.Container.set(UserSessionService_1.UserSessionService, { resolve, ttlMs: () => 24 * 3600000 });
         typedi_1.Container.set(UserService_1.UserService, { findById: (id) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = USERS[id]) !== null && _a !== void 0 ? _a : null; }) });
         typedi_1.Container.set(ApiKeyService_1.ApiKeyService, { verify, verifyPair: sinon_1.default.stub().resolves(null) });
         typedi_1.Container.set(EventLogService_1.EventLogService, { appendSafe: () => undefined });

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

@@ -0,0 +1,264 @@
+"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.
+ *
+ * Only once nobody plays the H.264 capture, though. A Live devices tile, or a
+ * second tab, may still be playing it when one page falls back to MJPEG; the
+ * capture then ends when its last viewer leaves, not under them.
+ */
+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 h264;
+    let h264Start;
+    let h264Stop;
+    let captureKills;
+    let pushPacket;
+    let row;
+    /** The real H.264 service with its capture (scrcpy) stubbed out. */
+    const h264Service = () => {
+        const svc = Object.create(AndroidH264StreamService_1.default.prototype);
+        svc.sessions = new Map();
+        svc.startPromises = new Map();
+        svc.scrcpyIncompatible = new Set();
+        svc.openCapture = (_udid, onPacket) => __awaiter(void 0, void 0, void 0, function* () {
+            pushPacket = onPacket;
+            onPacket({ type: 'config', data: Buffer.from([0]), ptsMs: 0 });
+            return { kill: () => (captureKills += 1) };
+        });
+        return svc;
+    };
+    /** Another page playing the phone's H.264 preview: what it got, and its leave. */
+    const h264Viewer = () => __awaiter(void 0, void 0, void 0, function* () {
+        const got = [];
+        const leave = (yield h264.start(UDID)).addClient((p) => got.push(p.type));
+        return { got, leave };
+    });
+    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();
+        captureKills = 0;
+        mjpegStart = sinon_1.default.stub().resolves({ mjpegPort: 9100 });
+        h264 = h264Service();
+        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, h264);
+        typedi_1.Container.set(recording_store_1.RecordingStore, { isRecording: () => __awaiter(void 0, void 0, void 0, function* () { return false; }) });
+        // Spied after any setup start, so they count only what the route does.
+        h264Start = sinon_1.default.spy(h264, 'start');
+        h264Stop = sinon_1.default.spy(h264, 'stop');
+    });
+    /** An H.264 capture already running for the phone, as a tile's start leaves it. */
+    const h264AlreadyRunning = () => __awaiter(void 0, void 0, void 0, function* () {
+        h264Start.restore();
+        yield h264.start(UDID);
+        h264Start = sinon_1.default.spy(h264, 'start');
+    });
+    const h264Running = () => h264.getMultiplexer(UDID) !== undefined;
+    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 nobody is watching, so the two never overlap', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        yield h264AlreadyRunning();
+        yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(h264Stop.calledOnceWith(UDID)).to.equal(true);
+        (0, chai_1.expect)(captureKills).to.equal(1);
+        (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);
+        yield h264AlreadyRunning();
+        yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(h264Stop.calledBefore(mjpegStart)).to.equal(true);
+    }));
+    it('keeps the H.264 capture for another page still playing it', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        const other = yield h264Viewer();
+        const res = yield start({ player: 'mjpeg' });
+        (0, chai_1.expect)(res.body.type).to.equal('mjpeg');
+        (0, chai_1.expect)(mjpegStart.calledOnce).to.equal(true);
+        (0, chai_1.expect)(captureKills).to.equal(0);
+        pushPacket({ type: 'key', data: Buffer.from([1]), ptsMs: 1 });
+        (0, chai_1.expect)(other.got).to.deep.equal(['config', 'key']);
+    }));
+    it('ends the H.264 capture when that last page leaves, without waiting for the idle stop', () => __awaiter(void 0, void 0, void 0, function* () {
+        flag(true);
+        const other = yield h264Viewer();
+        yield start({ player: 'mjpeg' });
+        other.leave();
+        (0, chai_1.expect)(captureKills).to.equal(1);
+        (0, chai_1.expect)(h264Running()).to.equal(false);
+    }));
+    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);
+    }));
+    it('ends H.264 at once for a phone being recorded, viewers or not, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+        // A recording reads the MJPEG capture, and H.264 never runs beside it
+        // (ensureMjpegForRecording stopped it when the recording began).
+        flag(true);
+        yield h264Viewer();
+        typedi_1.Container.set(recording_store_1.RecordingStore, { isRecording: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) });
+        yield start();
+        (0, chai_1.expect)(captureKills).to.equal(1);
+        (0, chai_1.expect)(h264Running()).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');
+    });
 });