@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/test/unit/self-healing-boot.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * The self-healing value saved on the Settings page is read once at boot, so a
+ * restart doesn't put the server back on the option it was started with. It
+ * has to be loaded once the database is ready (migrations ran) and before the
+ * first route can answer or the first command arrive.
+ */
+describe('loading the saved self-healing setting, at boot', () => {
+    let statics;
+    beforeEach(() => {
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    it('runs once the database is ready, before routes are registered', () => __awaiter(void 0, void 0, void 0, function* () {
+        const steps = [];
+        const step = (name) => () => {
+            steps.push(name);
+            return Promise.resolve();
+        };
+        const boot = ServerManager_1.ServerManager.prototype;
+        sinon_1.default.stub(boot, 'resolvePluginArgs').resolves({});
+        sinon_1.default.stub(logger_1.default, 'banner');
+        sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+        sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').callsFake(step('database config'));
+        sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(step('database and migrations'));
+        // The real one kills every go-ios process on the machine.
+        sinon_1.default.stub(boot, 'reapLeftoverGoIos').callsFake(step('reap'));
+        sinon_1.default.stub(SelfHealingSwitch_1.SelfHealingSwitch.prototype, 'load').callsFake(step('self-healing setting'));
+        sinon_1.default.stub(boot, 'registerRoutes').callsFake(() => {
+            steps.push('routes');
+            throw new Error('boot stopped by the test');
+        });
+        yield typedi_1.Container.get(ServerManager_1.ServerManager)
+            .updateServer({}, null, { port: 4723 })
+            .then(() => chai_1.expect.fail('the stubbed routes step should have stopped the boot'), (err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+        (0, chai_1.expect)(steps).to.deep.equal([
+            'database config',
+            'database and migrations',
+            'reap',
+            'self-healing setting',
+            'routes',
+        ]);
+    }));
+});

package/lib/test/unit/self-healing-setting.spec.js

@@ -0,0 +1,272 @@
+"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 express_1 = __importDefault(require("express"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+const PluginContext_1 = require("../../src/PluginContext");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const web_config_service_1 = require("../../src/data-service/web-config-service");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const logger_1 = __importDefault(require("../../src/logger"));
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * The Settings page's "AI self-healing" toggle used to do nothing: POST /config
+ * stored only the fields its table knew, GET /config never sent the switch back
+ * (so the page always showed Enabled), and CommandInterceptor read the copy of
+ * the plugin options the server started with, which nothing updates.
+ *
+ * It follows the other lab settings now: a value saved in the dashboard wins
+ * over the startup option, which wins over the default, and applies to the very
+ * next command without a restart. The interceptor runs on every command, so it
+ * reads an in-memory value (SelfHealingSwitch), never the database.
+ */
+describe('the AI self-healing switch', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    let context;
+    let startedWith;
+    let restoreContainer;
+    let healingSwitch;
+    const startup = (over = {}) => {
+        context.pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), over);
+        return context.pluginArgs;
+    };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        startedWith = context.pluginArgs;
+        restoreContainer = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+        // A switch of its own, as at boot, so no saved value leaks in from another spec.
+        typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+        healingSwitch = typedi_1.Container.get(SelfHealingSwitch_1.SelfHealingSwitch);
+        yield scratch.db.webConfig.deleteMany({});
+    }));
+    afterEach(() => {
+        context.pluginArgs = startedWith;
+        restoreContainer();
+        sinon_1.default.restore();
+    });
+    function app() {
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use((req, _res, next) => {
+            req.auth = {
+                kind: 'user-session',
+                userId: 'usr_x',
+                role: 'SUPER_ADMIN',
+                scopes: 'admin,devices,sessions,read',
+                rateLimit: 1000,
+            };
+            next();
+        });
+        dashboard_1.default.register(a);
+        return a;
+    }
+    const save = (body) => (0, loopbackRequest_1.default)(app()).post('/config').send(body).timeout(5000);
+    const read = () => (0, loopbackRequest_1.default)(app()).get('/config').timeout(5000);
+    describe('as the Settings page saves and reads it', () => {
+        it('is kept: what POST /config saves, GET /config sends back', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            const saved = yield save({ enableSelfHealing: false });
+            (0, chai_1.expect)(saved.status).to.equal(200);
+            const shown = yield read();
+            (0, chai_1.expect)(shown.status).to.equal(200);
+            (0, chai_1.expect)(shown.body.enableSelfHealing).to.equal(false);
+            (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({
+                enableSelfHealing: false,
+            });
+        }));
+        it('can be turned back on', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            yield save({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(true);
+        }));
+        it('is on, and says so, when nothing was saved and the server was started with nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            const shown = yield read();
+            (0, chai_1.expect)(shown.body.enableSelfHealing).to.equal(true);
+            (0, chai_1.expect)(shown.body.defaults.enableSelfHealing).to.equal(true);
+        }));
+        it('shows the option the server started with when nothing was saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup({ enableSelfHealing: false });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(false);
+        }));
+        it('shows a saved value over the option the server started with', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            (0, chai_1.expect)((yield read()).body.enableSelfHealing).to.equal(true);
+        }));
+        it('is saved on its own, without touching the other settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            startup();
+            yield save({ buildCleanupDays: 7 });
+            yield save({ enableSelfHealing: false });
+            (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({
+                buildCleanupDays: 7,
+                enableSelfHealing: false,
+            });
+        }));
+        for (const bad of ['false', 'no', 0, 1, null, {}, []]) {
+            it(`refuses ${JSON.stringify(bad)} with a 400 naming the setting, and saves nothing`, () => __awaiter(void 0, void 0, void 0, function* () {
+                startup();
+                const refused = yield save({ enableSelfHealing: bad, buildCleanupDays: 9 });
+                (0, chai_1.expect)(refused.status).to.equal(400);
+                (0, chai_1.expect)(refused.body).to.include({ error: 'invalid_setting', field: 'enableSelfHealing' });
+                (0, chai_1.expect)(yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()).to.deep.equal({});
+            }));
+        }
+    });
+    describe('on a running interceptor', () => {
+        const noSuchElement = () => Object.assign(new Error('NoSuchElement: An element could not be located'), {
+            name: 'NoSuchElementError',
+        });
+        let attemptHealing;
+        let pluginArgs;
+        beforeEach(() => {
+            pluginArgs = startup();
+            attemptHealing = sinon_1.default.stub().resolves(null);
+            typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, { attemptHealing });
+        });
+        /** A findElement the driver answers with NoSuchElement, as a broken selector does. */
+        function findMissing(sessionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let thrown;
+                try {
+                    yield typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(() => __awaiter(this, void 0, void 0, function* () {
+                        throw noSuchElement();
+                    }), { sessionId }, 'findElement', ['xpath', '//android.widget.Button[@text="Gone"]', sessionId], pluginArgs, false);
+                }
+                catch (err) {
+                    thrown = err;
+                }
+                return thrown;
+            });
+        }
+        it('heals a missing element while the switch is on, as it always did', () => __awaiter(void 0, void 0, void 0, function* () {
+            const thrown = yield findMissing('sess-on');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+            // Nothing healed it, so the test still sees its own NoSuchElement.
+            (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+        }));
+        it('stops healing for the next command once off is saved, with no restart', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield findMissing('sess-1');
+            (0, chai_1.expect)(attemptHealing.callCount).to.equal(1);
+            (0, chai_1.expect)((yield save({ enableSelfHealing: false })).status).to.equal(200);
+            const thrown = yield findMissing('sess-1');
+            (0, chai_1.expect)(attemptHealing.callCount).to.equal(1);
+            // The failure reaches the test untouched, which is the point of turning it off.
+            (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+        }));
+        it('heals again once on is saved after off', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield save({ enableSelfHealing: false });
+            yield findMissing('sess-2');
+            (0, chai_1.expect)(attemptHealing.called).to.equal(false);
+            yield save({ enableSelfHealing: true });
+            yield findMissing('sess-2');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+        }));
+        it('does not read the database for a command', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield save({ enableSelfHealing: false });
+            const reads = sinon_1.default.spy(typedi_1.Container.get(web_config_service_1.WebConfigService), 'getConfig');
+            yield findMissing('sess-3');
+            yield findMissing('sess-3');
+            (0, chai_1.expect)(reads.called).to.equal(false);
+        }));
+        it('follows the startup option when nothing is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginArgs = startup({ enableSelfHealing: false });
+            yield findMissing('sess-4');
+            (0, chai_1.expect)(attemptHealing.called).to.equal(false);
+        }));
+        it('lets a saved on beat a startup off', () => __awaiter(void 0, void 0, void 0, function* () {
+            pluginArgs = startup({ enableSelfHealing: false });
+            yield save({ enableSelfHealing: true });
+            yield findMissing('sess-5');
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+        }));
+        it("still hands a session's own healing tiers to the healing it runs", () => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns({
+                getCapabilities: () => ({ 'xe:options': { healingTiers: [1, 2] } }),
+            });
+            const driver = { sessionId: 'sess-6' };
+            yield typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor)
+                .handle(() => __awaiter(void 0, void 0, void 0, function* () {
+                throw noSuchElement();
+            }), driver, 'findElement', ['id', 'gone', 'sess-6'], pluginArgs, false)
+                .catch(() => undefined);
+            (0, chai_1.expect)(attemptHealing.calledOnce).to.equal(true);
+            (0, chai_1.expect)(attemptHealing.firstCall.args).to.deep.equal(['sess-6', driver, 'id', 'gone', [1, 2]]);
+        }));
+        describe('and what it learns from a found element', () => {
+            let learn;
+            beforeEach(() => {
+                sinon_1.default.stub(event_manager_1.DASHBORD_EVENT_MANAGER, 'afterSessionCommand').resolves();
+                learn = sinon_1.default.stub(CommandInterceptor_1.CommandInterceptor.prototype, 'triggerLearning');
+            });
+            const afterFind = () => typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).runPostCommandHooks('sess-7', 'findElement', {}, ['id', 'there'], { ELEMENT: 'el-1' }, pluginArgs);
+            it('learns the selector while the switch is on', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield afterFind();
+                (0, chai_1.expect)(learn.calledOnce).to.equal(true);
+            }));
+            it('learns nothing once off is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield save({ enableSelfHealing: false });
+                yield afterFind();
+                (0, chai_1.expect)(learn.called).to.equal(false);
+            }));
+        });
+    });
+    describe('at boot', () => {
+        it('is the saved value, over the startup option', () => __awaiter(void 0, void 0, void 0, function* () {
+            const pluginArgs = startup({ enableSelfHealing: true });
+            yield scratch.db.webConfig.create({
+                data: { id: 'enableSelfHealing', name: 'enableSelfHealing', value: 'false' },
+            });
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled(pluginArgs)).to.equal(false);
+        }));
+        it('is the startup option when nothing is saved', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled(startup({ enableSelfHealing: false }))).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled(startup({ enableSelfHealing: true }))).to.equal(true);
+        }));
+        it('is on when neither was set', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield healingSwitch.load();
+            (0, chai_1.expect)(healingSwitch.isEnabled({})).to.equal(true);
+        }));
+        it('is the startup option, and says so once, when the saved value cannot be read', () => __awaiter(void 0, void 0, void 0, function* () {
+            const warn = sinon_1.default.stub(logger_1.default, 'warn');
+            sinon_1.default.stub(typedi_1.Container.get(web_config_service_1.WebConfigService), 'getConfig').rejects(new Error('db is down'));
+            yield healingSwitch.load();
+            const off = startup({ enableSelfHealing: false });
+            const on = startup({ enableSelfHealing: true });
+            (0, chai_1.expect)(healingSwitch.isEnabled(off)).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled(on)).to.equal(true);
+            // However many commands follow, it is said once, at the load.
+            (0, chai_1.expect)(warn.calledOnce).to.equal(true);
+            (0, chai_1.expect)(String(warn.firstCall.args[0])).to.match(/self-healing/i);
+            (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include('db is down');
+        }));
+        it('uses the startup option until it has loaded', () => {
+            (0, chai_1.expect)(healingSwitch.isEnabled({ enableSelfHealing: false })).to.equal(false);
+            (0, chai_1.expect)(healingSwitch.isEnabled({ enableSelfHealing: true })).to.equal(true);
+        });
+    });
+});

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