@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/test/unit/bug-report/video-slice.spec.js

@@ -8,9 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 const chai_1 = require("chai");
 const events_1 = require("events");
+const path_1 = __importDefault(require("path"));
+const ffmpegPath_1 = require("../../../src/helpers/ffmpegPath");
 const video_slice_1 = require("../../../src/services/bug-report/video-slice");
 class FakeProc extends events_1.EventEmitter {
     constructor() {
@@ -41,6 +46,20 @@ describe('sliceVideo', () => {
         if (!result.ok)
             (0, chai_1.expect)(result.error).to.include('exit 1');
     }));
+    it("runs Xenon's own ffmpeg, never a bare `ffmpeg` from PATH", () => __awaiter(void 0, void 0, void 0, function* () {
+        // A server started from the Mac app has no shell PATH, and src/index.ts puts
+        // Xenon's ffmpeg folder at the end of PATH, behind any system ffmpeg.
+        const proc = new FakeProc();
+        let command = '';
+        const p = (0, video_slice_1.sliceVideo)('/in.mp4', 0, 60, '/tmp/out.mp4', (cmd) => {
+            command = cmd;
+            return proc;
+        });
+        setImmediate(() => proc.emit('exit', 0));
+        yield p;
+        (0, chai_1.expect)(command).to.equal((0, ffmpegPath_1.resolveFfmpegPath)());
+        (0, chai_1.expect)(path_1.default.isAbsolute(command)).to.equal(true);
+    }));
     it('returns ok=false on spawn error', () => __awaiter(void 0, void 0, void 0, function* () {
         const proc = new FakeProc();
         const p = (0, video_slice_1.sliceVideo)('/in.mp4', 0, 60, '/tmp/out.mp4', fakeSpawn(proc));

package/lib/test/unit/command-log-network-capture.spec.js

@@ -0,0 +1,191 @@
+"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 express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const commandLogFields_1 = require("../../src/dashboard/commandLogFields");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SelectorStateService_1 = require("../../src/services/SelectorStateService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const typedi_1 = require("typedi");
+const scratch_database_1 = require("../helpers/scratch-database");
+const container_registration_1 = require("../helpers/container-registration");
+/**
+ * A session's network capture (its requests, its HAR, its mocks) is for admins
+ * only: the /interceptor routes, the Network panel and the live events. The
+ * command log is read by anyone who can see the session (`session_log`, bug
+ * reports). A hub records every command it forwards to a node, so a test's own
+ * `xenon: exportHar` put the whole capture, sign-in headers included, in front
+ * of every member of the phone's team.
+ */
+describe('The command log keeps no network capture', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'cl-session-1';
+    const SECRET = 'eyJ-app-access-token';
+    const HAR = {
+        log: {
+            entries: [{ request: { headers: [{ name: 'authorization', value: `Bearer ${SECRET}` }] } }],
+        },
+    };
+    let restore;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        restore = (0, container_registration_1.saveRegistrations)(SocketServer_1.SocketServer);
+        typedi_1.Container.set(SocketServer_1.SocketServer, {
+            emitToDashboardForDevices: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+            hasScopedDashboard: () => false,
+        });
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        yield scratch.db.device.deleteMany({});
+        yield scratch.db.team.deleteMany({});
+        yield scratch.db.team.create({ data: { id: 'team-a', name: 'Team A' } });
+        yield scratch.db.device.create({
+            data: {
+                udid: 'cl-phone-a',
+                host: 'http://node:4723',
+                platform: 'android',
+                teamId: 'team-a',
+            },
+        });
+        yield scratch.db.session.create({
+            data: {
+                id: SESSION,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+                device_udid: 'cl-phone-a',
+                device_platform: 'android',
+                device_version: '14',
+            },
+        });
+        sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns({
+            getId: () => SESSION,
+            getDevice: () => ({ udid: 'cl-phone-a', name: 'P', platform: 'android' }),
+            getXenonOption: () => undefined,
+            getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
+        });
+        sinon_1.default.stub(SelectorStateService_1.SelectorStateService.prototype, 'onHealRecorded').resolves(null);
+    }));
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    /** A command as the hub's gateway hands it over: the client's W3C body and the node's answer. */
+    function forwarded(script, args, answer) {
+        return event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(SESSION, 'execute', null, {
+            body: { script, args },
+            method: 'POST',
+            originalUrl: `/wd/hub/session/${SESSION}/execute/sync`,
+        }, {}, JSON.stringify(answer));
+    }
+    /** What a member of the phone's team reads. */
+    function sessionLogAsMember() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = (0, express_1.default)();
+            app.use((req, _res, next) => {
+                req.auth = {
+                    kind: 'user-session',
+                    userId: 'cl-u-member',
+                    role: 'MEMBER',
+                    scopes: 'devices,sessions,read',
+                    teamIds: ['team-a'],
+                };
+                next();
+            });
+            dashboard_1.default.register(app);
+            const res = yield (0, loopbackRequest_1.default)(app).get(`/session/${SESSION}/session_log`);
+            (0, chai_1.expect)(res.status).to.equal(200);
+            return res.body;
+        });
+    }
+    it('records which network script ran and whether it worked, never its arguments or its answer', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield forwarded('xenon: exportHar', [], { value: HAR });
+        yield forwarded('xe:getRequests', [], { value: [HAR] });
+        yield forwarded('getMocks', [], { value: [{ respond: { body: { token: SECRET } } }] });
+        yield forwarded('xenon: addMock', [{ respond: { body: { token: SECRET } } }], {
+            value: { id: 'm1' },
+        });
+        yield forwarded('xenon: removeMock', [{ id: 'm1' }], { value: { removed: true } });
+        yield forwarded('xenon: clearMocks', [], { value: { ok: true } });
+        const rows = yield sessionLogAsMember();
+        (0, chai_1.expect)(rows).to.have.length(6);
+        for (const row of rows) {
+            (0, chai_1.expect)(`${row.body}${row.response}`).to.not.include(SECRET);
+            (0, chai_1.expect)(row.is_success).to.equal(true);
+            // Every one, removeMock and clearMocks included, whose answers hold no secret.
+            (0, chai_1.expect)(JSON.parse(row.response), (_a = row.body) !== null && _a !== void 0 ? _a : '').to.deep.equal({
+                value: commandLogFields_1.NETWORK_CAPTURE_NOT_KEPT,
+            });
+            (0, chai_1.expect)(JSON.parse((_b = row.body) !== null && _b !== void 0 ? _b : '{}').args).to.equal(commandLogFields_1.NETWORK_CAPTURE_NOT_KEPT);
+        }
+        (0, chai_1.expect)(rows.map((r) => { var _a; return JSON.parse((_a = r.body) !== null && _a !== void 0 ? _a : '{}').script; })).to.have.members([
+            'xenon: exportHar',
+            'xe:getRequests',
+            'getMocks',
+            'xenon: addMock',
+            'xenon: removeMock',
+            'xenon: clearMocks',
+        ]);
+    }));
+    it('keeps a failed network script’s error, which carries no capture', () => __awaiter(void 0, void 0, void 0, function* () {
+        const error = {
+            value: {
+                error: 'unknown error',
+                message: `Interceptor not active for session ${SESSION}`,
+                stacktrace: '',
+            },
+        };
+        yield forwarded('xenon: exportHar', [], error);
+        const [row] = yield sessionLogAsMember();
+        (0, chai_1.expect)(row.is_success).to.equal(false);
+        (0, chai_1.expect)(JSON.parse(row.response)).to.deep.equal(error);
+    }));
+    it('on the server that drives the phone, a failed network script keeps its error but not its arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // CommandInterceptor answers these scripts before its hooks; only a throw
+        // (no capture running) reaches the log, from its catch, with the
+        // command's arguments as they came: [script, args].
+        const error = {
+            value: { error: `Interceptor not active for session ${SESSION}` },
+            sessionId: SESSION,
+        };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(SESSION, 'execute', null, {
+            body: ['xenon: addMock', [{ respond: { body: { token: SECRET } } }]],
+            method: 'POST',
+            originalUrl: '/execute',
+        }, {}, JSON.stringify(error));
+        const [row] = yield sessionLogAsMember();
+        (0, chai_1.expect)(row.body).to.not.include(SECRET);
+        (0, chai_1.expect)(JSON.parse((_a = row.body) !== null && _a !== void 0 ? _a : '[]')[0]).to.equal('xenon: addMock');
+        (0, chai_1.expect)(JSON.parse(row.response)).to.deep.equal(error);
+        (0, chai_1.expect)(row.is_success).to.equal(false);
+    }));
+    it('logs every other script, and a script the node’s interceptor doesn’t answer, whole', () => __awaiter(void 0, void 0, void 0, function* () {
+        // `plugin:` is only the autowait commands' prefix: `plugin: exportHar` is
+        // never a network script, and its answer is the driver's.
+        yield forwarded('mobile: shell', [{ command: 'echo' }], { value: SECRET });
+        yield forwarded('plugin: exportHar', [], { value: SECRET });
+        const rows = yield sessionLogAsMember();
+        (0, chai_1.expect)(rows).to.have.length(2);
+        for (const row of rows)
+            (0, chai_1.expect)(row.response).to.include(SECRET);
+    }));
+});

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

@@ -0,0 +1,255 @@
+"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 XenonCapabilityManager_1 = require("../../src/XenonCapabilityManager");
+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(),
+            noteOff: 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();
+    });
+    function startSession(platform, deviceLog) {
+        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(this, void 0, void 0, function* () {
+            order.push('row');
+            return {};
+        }));
+        const session = Object.assign({ getId: () => 's-logs-1', getCapabilities: () => ({ platformName: platform }), getLiveVideoUrl: () => null, startPerformanceRecording: sinon_1.default.stub().resolves(), apiKeyId: null, userId: null, allocatedAt: 1700000000000 }, (deviceLog ? { deviceLog } : {}));
+        const device = { udid: 'phone-l', platform, host: 'h', name: 'phone', sdk: '10' };
+        return { session, device };
+    }
+    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* () {
+        const { session, device } = startSession('android');
+        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,
+            driverLog: undefined,
+            appUnderTest: undefined,
+        });
+    }));
+    // The switch, from the session's capabilities as the create parses them.
+    const parsed = (alwaysMatch) => (0, XenonCapabilityManager_1.getXenonCapabilities)({ alwaysMatch, firstMatch: [{}] });
+    function stubSessionStart() {
+        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').resolves({});
+        return {
+            session: {
+                getId: () => 's-logs-off',
+                getCapabilities: () => ({ platformName: 'Android' }),
+                getLiveVideoUrl: () => null,
+                apiKeyId: null,
+                userId: null,
+            },
+            device: { udid: 'phone-l', platform: 'android', host: 'h', name: 'S9', sdk: '10' },
+        };
+    }
+    it('records it when the session says nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = stubSessionStart();
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({}), session, device);
+        (0, chai_1.expect)(deviceLogs.start.calledOnce).to.equal(true);
+        (0, chai_1.expect)(deviceLogs.noteOff.called).to.equal(false);
+    }));
+    it('keeps none, and says so, for a session that turned it off', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { session, device } = stubSessionStart();
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({ 'xe:save_device_logs': false }), session, device);
+        (0, chai_1.expect)(deviceLogs.start.called).to.equal(false);
+        (0, chai_1.expect)(deviceLogs.noteOff.calledOnceWithExactly('s-logs-off')).to.equal(true);
+    }));
+    it("doesn't listen to an iPhone's driver log when the session turned it off", () => __awaiter(void 0, void 0, void 0, function* () {
+        const driverLog = { on: sinon_1.default.stub(), removeListener: sinon_1.default.stub() };
+        const { session, device } = startSession('ios', () => driverLog);
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({ 'xe:saveDeviceLogs': 'false' }), session, device);
+        (0, chai_1.expect)(deviceLogs.start.called).to.equal(false);
+        (0, chai_1.expect)(deviceLogs.noteOff.calledOnceWithExactly('s-logs-1')).to.equal(true);
+        (0, chai_1.expect)(driverLog.on.called).to.equal(false);
+    }));
+    it("hands an iPhone's session the log its driver captures, and its app", () => __awaiter(void 0, void 0, void 0, function* () {
+        const driverLog = { on() { }, removeListener() { } };
+        const { session, device } = startSession('ios', () => driverLog);
+        session.appUnderTest = () => 'com.example.shop';
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, session, device);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].driverLog).to.equal(driverLog);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].appUnderTest).to.equal('com.example.shop');
+    }));
+    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

@@ -332,7 +332,7 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
             config_1.config.sessionAssetsPath = assets;
             fs_1.default.rmSync(dir, { recursive: true, force: true });
         });
-        it("request, started and stopped: the session's device, even after stop() drops the state", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("request, started and stopped: the session's device, admins only, even after stop() drops the state", () => __awaiter(void 0, void 0, void 0, function* () {
             const svc = new InterceptorService_1.InterceptorService();
             typedi_1.Container.set(PortAllocator_1.PortAllocator, { releaseForUdid: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }) });
             svc.androidAdapter = {
@@ -353,16 +353,19 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
             svc.emit({ type: 'request', sessionId: 's4', payload: { id: 'q1' } }, 'phone-a');
             svc.emit({ type: 'session_started', sessionId: 's4', port: 1, host: 'h' }, 'phone-a');
             yield svc.stop('s4');
+            // Captured traffic (headers, bodies) is for admins only, as REST's
+            // /interceptor routes are; so are the capture's start and stop.
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_REQUEST)[0].args.slice(1)).to.deep.equal([
                 { id: 'q1' },
-                { udid: 'phone-a' },
+                { udid: 'phone-a', adminOnly: true },
             ]);
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_SESSION_STARTED)[0].args[2]).to.deep.equal({
                 udid: 'phone-a',
+                adminOnly: true,
             });
             (0, chai_1.expect)(scoped(SocketEvents_1.SocketEvents.INTERCEPTOR_SESSION_STOPPED)[0].args.slice(1)).to.deep.equal([
                 { sessionId: 's4' },
-                { udid: 'phone-a' },
+                { udid: 'phone-a', adminOnly: true },
             ]);
         }));
     });