@xenon-device-management/xenon 2.13.2 → 2.15.0

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

@@ -0,0 +1,249 @@
+"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 typedi_1 = require("typedi");
+const assetManager = __importStar(require("../../src/dashboard/asset-manager"));
+const commands_1 = require("../../src/dashboard/commands");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * The five execute commands that write to a session's record:
+ * setSessionName, setSessionStatus, debug, addTag and captureEvidence.
+ *
+ * A session has a record (a Session row) only on a hub with its dashboard
+ * on. Elsewhere (the dashboard off, or on a node, which never keeps one for
+ * the hub's sessions) setSessionName and setSessionStatus threw Prisma's
+ * P2025 and debug a foreign-key error, failing the test's command, while
+ * addTag and captureEvidence answered as if they had worked.
+ *
+ * Each now answers `{ recorded: true }` when it wrote, or `{ recorded: false,
+ * message }` saying why nothing was written. None of them fails the test's
+ * command: they are bookkeeping, and a test shouldn't die because its server
+ * keeps no dashboard.
+ */
+describe('xenon: session-details commands', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'session-details-1';
+    let restoreContainer;
+    let emitted;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.log.deleteMany({});
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        restoreContainer = (0, container_registration_1.saveRegistrations)(SocketServer_1.SocketServer);
+        const socket = new SocketServer_1.SocketServer();
+        typedi_1.Container.set(SocketServer_1.SocketServer, socket);
+        emitted = sinon_1.default.stub(socket, 'emitToDashboardForDevices').resolves();
+    }));
+    afterEach(() => {
+        SessionManager_1.SESSION_MANAGER.removeSession(SESSION);
+        sinon_1.default.restore();
+        restoreContainer();
+    });
+    function withRecord() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.session.create({
+                data: {
+                    id: SESSION,
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: 'node-1',
+                    has_live_video: false,
+                    device_udid: 'phone-1',
+                    device_platform: 'android',
+                    device_version: '14',
+                },
+            });
+        });
+    }
+    /** What the command answers, as the local interceptor and the hub's gateway both see it. */
+    function run(script, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let body;
+            const response = {
+                status: (code) => ({
+                    json: (d) => {
+                        body = Object.assign({ code }, d);
+                        return d;
+                    },
+                }),
+            };
+            yield commands_1.dashboardCommands.process(SESSION, { body: { script, args } }, response);
+            return body;
+        });
+    }
+    describe('which scripts are session-details commands', () => {
+        it('knows the five, under either prefix, and nothing else', () => {
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)('xenon: setSessionName')).to.equal('setSessionName');
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)('xe:addTag')).to.equal('addTag');
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)(' xenon :  captureEvidence ')).to.equal('captureEvidence');
+            for (const other of [
+                'xenon: smartTap',
+                'xe: setAutowaitProperties',
+                'xenon: addMock',
+                'xenon: unknownThing',
+                'mobile: shell',
+                'xenonsetSessionName',
+                'return 1',
+                undefined,
+                42,
+            ]) {
+                (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)(other), String(other)).to.equal(null);
+            }
+        });
+    });
+    describe('with no session record', () => {
+        const cases = [
+            ['xenon: setSessionName', ['Checkout']],
+            ['xenon: setSessionStatus', [{ status: 'passed' }]],
+            ['xenon: debug', ['reached checkout']],
+            ['xenon: addTag', ['smoke']],
+            ['xenon: captureEvidence', ['Payment confirmed']],
+        ];
+        for (const [script, args] of cases) {
+            it(`${script} answers that nothing was recorded, and writes nothing`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const body = yield run(script, args);
+                (0, chai_1.expect)(body.code).to.equal(200);
+                (0, chai_1.expect)(body.value).to.include({ recorded: false });
+                (0, chai_1.expect)(body.value.message).to.match(/no record/i);
+                (0, chai_1.expect)(yield scratch.db.log.count()).to.equal(0);
+                (0, chai_1.expect)(yield scratch.db.sessionLog.count()).to.equal(0);
+            }));
+        }
+    });
+    describe('with a session record', () => {
+        beforeEach(withRecord);
+        it('setSessionName names the session', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            (0, chai_1.expect)((yield run('xenon: setSessionName', ['Checkout'])).value).to.deep.equal({
+                recorded: true,
+            });
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.name).to.equal('Checkout');
+            yield run('xe: setSessionName', [{ name: 'Checkout by card' }]);
+            (0, chai_1.expect)((_b = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _b === void 0 ? void 0 : _b.name).to.equal('Checkout by card');
+        }));
+        it('setSessionName without a name records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            const body = yield run('xenon: setSessionName', []);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/name/);
+        }));
+        it('setSessionStatus sets the status and reason, and tells the dashboard', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const body = yield run('xenon: setSessionStatus', [{ status: 'failed', reason: 'No total' }]);
+            (0, chai_1.expect)(body.value).to.deep.equal({ recorded: true });
+            const row = yield scratch.db.session.findUnique({ where: { id: SESSION } });
+            (0, chai_1.expect)(row).to.include({ status: 'failed', failure_reason: 'No total' });
+            (0, chai_1.expect)(emitted.firstCall.args[1]).to.include({
+                id: SESSION,
+                status: 'failed',
+                failure_reason: 'No total',
+            });
+            yield run('xenon: setSessionStatus', ['passed']);
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.status).to.equal('success');
+        }));
+        it('setSessionStatus with a status it does not know records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const body = yield run('xenon: setSessionStatus', [{ status: 'skipped' }]);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/skipped/);
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.status).to.equal('running');
+        }));
+        it('debug adds a debug line', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)((yield run('xenon: debug', ['reached checkout'])).value).to.deep.equal({
+                recorded: true,
+            });
+            yield run('xenon: debug', [{ message: 'paid' }]);
+            const lines = yield scratch.db.log.findMany({ orderBy: { createdAt: 'asc' } });
+            (0, chai_1.expect)(lines.map((l) => [l.log_type, l.message])).to.deep.equal([
+                ['DEBUG', 'reached checkout'],
+                ['DEBUG', 'paid'],
+            ]);
+        }));
+        it('debug without a message records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            const body = yield run('xenon: debug', []);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(yield scratch.db.log.count()).to.equal(0);
+        }));
+        it('addTag adds a tag once', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)((yield run('xenon: addTag', ['smoke'])).value).to.deep.equal({ recorded: true });
+            (0, chai_1.expect)((yield run('xenon: addTag', [{ tag: 'smoke' }])).value).to.deep.equal({
+                recorded: true,
+            });
+            yield run('xenon: addTag', ['regression']);
+            const row = yield scratch.db.session.findUnique({ where: { id: SESSION } });
+            (0, chai_1.expect)(JSON.parse(String(row === null || row === void 0 ? void 0 : row.tags))).to.deep.equal(['smoke', 'regression']);
+        }));
+        it('captureEvidence records a screenshot of a session this server drives', () => __awaiter(void 0, void 0, void 0, function* () {
+            SessionManager_1.SESSION_MANAGER.addSession(SESSION, { getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () { return 'aGVsbG8='; }) });
+            sinon_1.default.stub(assetManager, 'saveScreenShot').returns(`${SESSION}/screenshots/x.png`);
+            const body = yield run('xenon: captureEvidence', [{ reason: 'Paid', label: 'receipt' }]);
+            (0, chai_1.expect)(body.value).to.deep.equal({ recorded: true });
+            const rows = yield scratch.db.sessionLog.findMany({});
+            (0, chai_1.expect)(rows.map((r) => [r.command_name, r.subtitle, r.screenshot])).to.deep.equal([
+                ['captureEvidence', 'Paid', `${SESSION}/screenshots/x.png`],
+            ]);
+        }));
+        it("captureEvidence records nothing, and says so, when it can't take a screenshot", () => __awaiter(void 0, void 0, void 0, function* () {
+            let body = yield run('xenon: captureEvidence', ['Paid']);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            SessionManager_1.SESSION_MANAGER.addSession(SESSION, {
+                getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('WDA is not running');
+                }),
+            });
+            body = yield run('xenon: captureEvidence', ['Paid']);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/WDA is not running/);
+            (0, chai_1.expect)(yield scratch.db.sessionLog.count()).to.equal(0);
+        }));
+    });
+});

package/lib/test/unit/dashboard-events-device-logs.spec.js

@@ -0,0 +1,207 @@
+"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 typedi_1 = require("typedi");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const assets = __importStar(require("../../src/dashboard/asset-manager"));
+const sessionService = __importStar(require("../../src/dashboard/services/session-service"));
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const TracingService_1 = require("../../src/services/TracingService");
+const MetricsService_1 = require("../../src/services/MetricsService");
+const device_store_1 = require("../../src/data-service/device-store");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const pendingSessions = __importStar(require("../../src/data-service/pending-sessions-service"));
+const deviceService = __importStar(require("../../src/data-service/device-service"));
+const deviceUtils = __importStar(require("../../src/device-utils"));
+const config_1 = require("../../src/config");
+const prisma_1 = require("../../src/prisma");
+const container_registration_1 = require("../helpers/container-registration");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * A session's device log is recorded from about when its phone was given to
+ * it, once the session's row exists (the lines point at it), and written to
+ * the end however the session ends: every ending reaches onSessionStopped.
+ */
+describe('EventManager: an Android session’s device log', () => {
+    let restore;
+    let deviceLogs;
+    let order;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(SessionDeviceLogs_1.SessionDeviceLogs, SessionMetricsService_1.SessionMetricsService, SocketServer_1.SocketServer);
+        order = [];
+        deviceLogs = {
+            start: sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return order.push('device logs'); })),
+            stop: sinon_1.default.stub().resolves(),
+        };
+        typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, deviceLogs);
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, {
+            appliesTo: () => false,
+            start: sinon_1.default.stub(),
+            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),
+        });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    it("starts once the session's row is written, from when the phone was given to it", () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(assets, 'prepareDirectory');
+        sinon_1.default.stub(sessionService, 'getOrCreateNewBuild').resolves({ id: 'b-logs' });
+        sinon_1.default.stub(TracingService_1.TracingService.prototype, 'getTraceId').returns('t-1');
+        sinon_1.default.stub(MetricsService_1.MetricsService.prototype, 'incrementSessionStart');
+        sinon_1.default.stub(prisma_1.prisma.session, 'create').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            order.push('row');
+            return {};
+        }));
+        const session = {
+            getId: () => 's-logs-1',
+            getCapabilities: () => ({ platformName: 'Android' }),
+            getLiveVideoUrl: () => null,
+            apiKeyId: null,
+            userId: null,
+            allocatedAt: 1700000000000,
+        };
+        const device = { udid: 'phone-l', platform: 'android', host: 'h', name: 'S9', sdk: '10' };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, session, device);
+        (0, chai_1.expect)(order).to.deep.equal(['row', 'device logs']);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0]).to.deep.equal({
+            sessionId: 's-logs-1',
+            device,
+            since: 1700000000000,
+        });
+    }));
+    it('writes it to the end when the session stops, even one no longer in memory', () => __awaiter(void 0, void 0, void 0, function* () {
+        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 []; }) });
+        sinon_1.default
+            .stub(prisma_1.prisma.session, 'findFirst')
+            .resolves({ id: 's-logs-2', status: 'running', device_udid: 'phone-l' });
+        sinon_1.default.stub(prisma_1.prisma.session, 'update').resolves({});
+        sinon_1.default.stub(prisma_1.prisma.sessionLog, 'findFirst').resolves(null);
+        let statusWritten = false;
+        prisma_1.prisma.session.update.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            statusWritten = true;
+            return {};
+        }));
+        deviceLogs.stop.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            // The session page reads the device log again once the session has
+            // ended: by then every line is written.
+            (0, chai_1.expect)(statusWritten, 'the session was marked ended first').to.equal(false);
+        }));
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped('s-logs-2');
+        (0, chai_1.expect)(deviceLogs.stop.calledOnceWithExactly('s-logs-2')).to.equal(true);
+        (0, chai_1.expect)(statusWritten).to.equal(true);
+    }));
+});
+describe('createSession: when the phone was given to the session', () => {
+    (0, loki_stores_1.useLokiStores)();
+    let context;
+    let saved;
+    let authDisabledBefore;
+    beforeEach(() => {
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = true;
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = { pluginArgs: context.pluginArgs, nodeId: context.nodeId };
+        context.pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, { bindHostOrIp: '127.0.0.1' });
+        context.nodeId = 'node-here';
+    });
+    afterEach(() => {
+        config_1.config.authDisabled = authDisabledBefore;
+        Object.assign(context, saved);
+        sinon_1.default.restore();
+    });
+    it('is noted on the session, between the allocation and the driver starting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = {
+            udid: 'u1',
+            host: 'h1',
+            platform: 'android',
+            nodeId: 'node-here',
+            teamId: null,
+        };
+        let allocatedBy = 0;
+        let driverAt = 0;
+        sinon_1.default.stub(pendingSessions, 'addNewPendingSession').resolves();
+        sinon_1.default.stub(pendingSessions, 'removePendingSession').resolves();
+        sinon_1.default.stub(deviceService, 'updateDeviceProgress').resolves();
+        sinon_1.default.stub(deviceService, 'updatedAllocatedDevice').resolves();
+        sinon_1.default.stub(deviceUtils, 'allocateDeviceForSession').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            allocatedBy = Date.now();
+            return device;
+        }));
+        const svc = new SessionLifecycleService_1.SessionLifecycleService();
+        const instance = {};
+        sinon_1.default.stub(svc, 'createSessionInstance').returns(instance);
+        sinon_1.default.stub(svc, 'applyPostSessionLogic').resolves();
+        const next = sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            driverAt = Date.now();
+            // A slow driver start: the session's log still counts from before it.
+            yield new Promise((r) => setTimeout(r, 20));
+            return { value: ['s-alloc', { platformName: 'Android' }] };
+        }));
+        yield svc.createSession(next, {}, {
+            alwaysMatch: { platformName: 'Android', 'appium:automationName': 'UiAutomator2' },
+            firstMatch: [{}],
+        });
+        (0, chai_1.expect)(instance.allocatedAt).to.be.a('number');
+        (0, chai_1.expect)(instance.allocatedAt).to.be.at.least(allocatedBy);
+        (0, chai_1.expect)(instance.allocatedAt).to.be.at.most(driverAt);
+    }));
+});

package/lib/test/unit/dashboard-events-team-scope.spec.js

@@ -253,6 +253,8 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
                     delete teams[filter.udid];
                 })),
                 updateDevice: sinon_1.default.stub().resolves(),
+                // removeDevice reads the row for the device_offline webhook's name and platform.
+                findDevice: sinon_1.default.stub().resolves(null),
                 getDevices: sinon_1.default.stub().resolves([
                     {
                         udid: 'phone-b',
@@ -308,13 +310,14 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
         }));
     });
     it("xenon: setSessionStatus: the updated session's device", () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(prisma_1.prisma.session, 'findUnique').resolves({ id: 's3', tags: null });
         sinon_1.default.stub(prisma_1.prisma.session, 'update').resolves({ id: 's3', device_udid: 'phone-b' });
         const res = { status: () => res, json: () => res };
         yield new commands_1.DashboardCommands().process('s3', {
             body: { script: 'xenon: setSessionStatus', args: [{ status: 'failed', reason: 'boom' }] },
         }, res);
         const [call] = scoped(SocketEvents_1.SocketEvents.SESSION_STOPPED);
-        (0, chai_1.expect)(call.args[1]).to.deep.equal({ id: 's3', status: 'failed', failure_reason: undefined });
+        (0, chai_1.expect)(call.args[1]).to.deep.equal({ id: 's3', status: 'failed', failure_reason: 'boom' });
         (0, chai_1.expect)(call.args[2]).to.deep.equal({ udid: 'phone-b' });
     }));
     describe('interceptor', () => {
@@ -400,11 +403,10 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
     }));
     it('a team change (PUT /device/:udid/team) refreshes the resolver at once', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(prisma_1.prisma.team, 'findUnique').resolves({ id: 'team-c' });
-        sinon_1.default.stub(prisma_1.prisma.device, 'updateMany').resolves({ count: 1 });
-        sinon_1.default
-            .stub(prisma_1.prisma.device, 'findMany')
-            .resolves([{ udid: 'phone-a', host: 'h', teamId: 'team-c' }]);
-        sinon_1.default.stub(device_store_1.DeviceStoreFactory.getStore(), 'updateDevice').resolves();
+        const store = device_store_1.DeviceStoreFactory.getStore();
+        sinon_1.default.stub(store, 'findDevices').resolves([{ udid: 'phone-a', host: 'h' }]);
+        sinon_1.default.stub(store, 'findSavedPhones').resolves([]);
+        const write = sinon_1.default.stub(store, 'updateDevice').resolves();
         const resolver = typedi_1.Container.get(DeviceTeamResolver_1.DeviceTeamResolver);
         yield resolver.resolve('phone-a'); // cached as team-a
         const app = (0, express_1.default)();
@@ -424,6 +426,7 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
         app.use(router);
         const res = yield (0, loopbackRequest_1.default)(app).put('/device/phone-a/team').send({ teamId: 'team-c' });
         (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(write.firstCall.args).to.deep.equal(['phone-a', 'h', { teamId: 'team-c' }]);
         (0, chai_1.expect)(yield resolver.resolve('phone-a')).to.deep.equal({ known: true, teamId: 'team-c' });
         (0, chai_1.expect)(lookups).to.deep.equal(['phone-a']);
     }));