@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/test/helpers/otlp-probe.js

@@ -0,0 +1,107 @@
+"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 });
+exports.startOtlpProbe = startOtlpProbe;
+exports.attributeOf = attributeOf;
+exports.resetOtelGlobals = resetOtelGlobals;
+exports.flushOtelGlobals = flushOtelGlobals;
+const http_1 = __importDefault(require("http"));
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+/**
+ * A stand-in OTLP/HTTP collector on 127.0.0.1. It answers every request 200
+ * and keeps what it was sent, so a spec can see where Xenon's telemetry went
+ * and in which encoding (Xenon's own exporters send OTLP/JSON; the ones the
+ * OTel SDK builds from OTEL_* variables send protobuf).
+ */
+function startOtlpProbe() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requests = [];
+        const server = http_1.default.createServer((req, res) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                var _a, _b;
+                const body = Buffer.concat(chunks);
+                const contentType = String((_a = req.headers['content-type']) !== null && _a !== void 0 ? _a : '');
+                let json;
+                if (contentType.includes('json')) {
+                    try {
+                        json = JSON.parse(body.toString('utf8'));
+                    }
+                    catch (_c) {
+                        json = undefined;
+                    }
+                }
+                requests.push({ path: (_b = req.url) !== null && _b !== void 0 ? _b : '', contentType, body, json });
+                if (contentType.includes('json')) {
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                    res.end('{}');
+                }
+                else {
+                    res.writeHead(200, { 'content-type': 'application/x-protobuf' });
+                    res.end();
+                }
+            });
+        });
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        return {
+            url: (path) => `http://127.0.0.1:${port}${path}`,
+            requests,
+            spans: () => requests.flatMap((r) => {
+                var _a, _b;
+                return ((_b = (_a = r.json) === null || _a === void 0 ? void 0 : _a.resourceSpans) !== null && _b !== void 0 ? _b : []).flatMap((rs) => { var _a; return ((_a = rs.scopeSpans) !== null && _a !== void 0 ? _a : []).flatMap((ss) => { var _a; return ((_a = ss.spans) !== null && _a !== void 0 ? _a : []); }); });
+            }),
+            close: () => new Promise((resolve) => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+/** A span attribute's value, whatever its OTLP/JSON type. */
+function attributeOf(attributes, key) {
+    const found = attributes === null || attributes === void 0 ? void 0 : attributes.find((a) => a.key === key);
+    if (!found)
+        return undefined;
+    return Object.values(found.value)[0];
+}
+/**
+ * Takes every OTel global (tracer, meter and logger providers, context
+ * manager, propagator) off the API, so the next registration wins. The API
+ * keeps the first registration for the life of the process and refuses the
+ * rest: a spec that leaves one behind decides what every later spec exports.
+ */
+function resetOtelGlobals() {
+    api_1.trace.disable();
+    api_1.metrics.disable();
+    api_logs_1.logs.disable();
+    api_1.context.disable();
+    api_1.propagation.disable();
+}
+/** Exports whatever the registered meter and logger providers hold now. */
+function flushOtelGlobals() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const meterProvider = api_1.metrics.getMeterProvider();
+        yield ((_a = meterProvider.forceFlush) === null || _a === void 0 ? void 0 : _a.call(meterProvider));
+        const loggerProvider = api_logs_1.logs.getLoggerProvider();
+        yield ((_b = loggerProvider.forceFlush) === null || _b === void 0 ? void 0 : _b.call(loggerProvider));
+    });
+}

package/lib/test/integration/androidDevices.spec.js

@@ -133,6 +133,6 @@ describe('Android Test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 1000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'Device is busy or blocked.. Device request: {"platform":"android"}'));
+            .with.property('message', 'Device is busy or blocked. Device request: {"platform":"android"}'));
     }));
 });

package/lib/test/integration/ios/01iOSSimulator.spec.js

@@ -145,7 +145,7 @@ describe('Max sessions CLI argument test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 6000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'Device is busy or blocked.. Device request: {"platform":"ios","name":"iPhone","deviceType":"simulator"}'));
+            .with.property('message', 'Device is busy or blocked. Device request: {"platform":"ios","name":"iPhone","deviceType":"simulator"}'));
     }));
 });
 describe('IOS Simulator Test', () => {

package/lib/test/integration/ios/02iOSDevices.spec.js

@@ -53,7 +53,7 @@ describe('IOS Test', () => {
         };
         yield (0, device_utils_1.allocateDeviceForSession)(capabilities, 6000, 1000, pluginArgs).catch((error) => (0, chai_1.expect)(error)
             .to.be.an('error')
-            .with.property('message', 'No device matching request.. Device request: {"platform":"ios","name":"iPhone","deviceType":"real"}'));
+            .with.property('message', 'No device matching request. Device request: {"platform":"ios","name":"iPhone","deviceType":"real"}'));
     }));
     it('Should throw error if the IPA does not match with device type real', () => __awaiter(void 0, void 0, void 0, function* () {
         yield (0, device_utils_1.initializeStorage)();

package/lib/test/integration/selector-state-flow.spec.js

@@ -105,7 +105,7 @@ describe('Selector state full flow (integration)', function () {
             stdio: 'pipe',
         });
         prisma = new client_1.PrismaClient({ datasources: { db: { url } } });
-        socketStub = { emitToDashboard: sinon_1.default.stub() };
+        socketStub = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         stateService = new SelectorStateService_1.SelectorStateService(prisma, socketStub);
         verifier = new SelectorVerificationJob_1.SelectorVerificationJob(prisma, socketStub);
     }));
@@ -116,7 +116,7 @@ describe('Selector state full flow (integration)', function () {
             fs.unlinkSync(dbPath);
     }));
     beforeEach(() => __awaiter(this, void 0, void 0, function* () {
-        socketStub.emitToDashboard.resetHistory();
+        socketStub.emitToDashboardForSelector.resetHistory();
         // SessionLog → Session → Build — delete children before parents.
         yield prisma.sessionLog.deleteMany({});
         yield prisma.session.deleteMany({});
@@ -156,7 +156,7 @@ describe('Selector state full flow (integration)', function () {
         });
         (0, chai_1.expect)(fixed.status).to.equal('pending');
         (0, chai_1.expect)(fixed.fixed_at).to.be.instanceOf(Date);
-        (0, chai_1.expect)(socketStub.emitToDashboard.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
         // Three distinct CI builds, each with one un-healed findElement on the tuple.
         for (const buildId of ['b-1', 'b-2', 'b-3']) {
             const sid = `s-${buildId}`;
@@ -190,7 +190,7 @@ describe('Selector state full flow (integration)', function () {
         (0, chai_1.expect)(final.status).to.equal('resolved');
         (0, chai_1.expect)(final.clean_builds_count).to.equal(3);
         (0, chai_1.expect)(final.resolved_at).to.be.instanceOf(Date);
-        const resolvedEmits = socketStub.emitToDashboard
+        const resolvedEmits = socketStub.emitToDashboardForSelector
             .getCalls()
             .filter((c) => c.args[0] === SocketEvents_1.SocketEvents.SELECTOR_RESOLVED);
         (0, chai_1.expect)(resolvedEmits.length).to.equal(1);
@@ -226,6 +226,6 @@ describe('Selector state full flow (integration)', function () {
         (0, chai_1.expect)(after.regression_count).to.equal(1);
         (0, chai_1.expect)(after.resolved_at).to.be.null;
         (0, chai_1.expect)(after.fixed_at).to.be.null;
-        (0, chai_1.expect)(socketStub.emitToDashboard.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.lastCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
     }));
 });

package/lib/test/unit/XenonCapabilityManager.spec.js

@@ -60,3 +60,26 @@ describe('XenonCapabilityManager.getXenonCapabilities — interceptor activation
         expect(out[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]).to.equal(true);
     });
 });
+/**
+ * `xe:save_device_logs` is a switch like `xe:record_video`: on by default,
+ * on only for `true` or "true" once set. Through 2.15 it was read nowhere.
+ */
+describe('XenonCapabilityManager.getXenonCapabilities — xe:save_device_logs', () => {
+    const saved = (always) => (0, XenonCapabilityManager_1.getXenonCapabilities)(caps(always))[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS];
+    it('is on when the session says nothing', () => {
+        expect(saved({})).to.equal(true);
+    });
+    it('is on for true or "true"', () => {
+        expect(saved({ 'xe:save_device_logs': true })).to.equal(true);
+        expect(saved({ 'xe:saveDeviceLogs': 'true' })).to.equal(true);
+    });
+    it('is off for false, and for any other value, as every switch is', () => {
+        for (const value of [false, 'false', 'yes', 1]) {
+            expect(saved({ 'xe:save_device_logs': value }), String(value)).to.equal(false);
+        }
+    });
+    it('is read from xe:options and its xenon:options alias too', () => {
+        expect(saved({ 'xe:options': { save_device_logs: false } })).to.equal(false);
+        expect(saved({ 'xenon:options': { saveDeviceLogs: false } })).to.equal(false);
+    });
+});

package/lib/test/unit/android-adb-retry.spec.js

@@ -0,0 +1,112 @@
+"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 adbkit_1 = __importDefault(require("@devicefarmer/adbkit"));
+const appium_adb_1 = require("appium-adb");
+const test_container_1 = require("../helpers/test-container");
+const RETRY_MS = 60000;
+/**
+ * When adb couldn't be started, or its device tracking couldn't, the server
+ * logged "Could not find ADB" without the reason and never looked again: every
+ * later discovery answered no phones until a restart, even once adb worked
+ * (an SDK installed, a stuck adb server killed). It now says why, and tries
+ * again a minute later.
+ */
+describe('Android discovery when adb is unavailable', () => {
+    const sandbox = sinon_1.default.createSandbox();
+    let manager;
+    let createADB;
+    let trackDevices;
+    let errors;
+    let clock;
+    let savedNodeEnv;
+    const workingAdb = () => ({
+        adbRemoteHost: null,
+        getConnectedDevices: sandbox.stub().resolves([]),
+    });
+    beforeEach(() => {
+        savedNodeEnv = process.env.NODE_ENV;
+        clock = sandbox.useFakeTimers({ now: Date.now(), toFake: ['Date'] });
+        createADB = sandbox.stub(appium_adb_1.ADB, 'createADB');
+        trackDevices = sandbox.stub().resolves({ on: sandbox.stub() });
+        sandbox.stub(adbkit_1.default, 'createClient').returns({ trackDevices });
+        manager = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        sandbox.stub(manager, 'requireSdkRoot').resolves();
+        errors = sandbox.stub(manager.log, 'error');
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox.restore();
+        if (savedNodeEnv === undefined)
+            delete process.env.NODE_ENV;
+        else
+            process.env.NODE_ENV = savedNodeEnv;
+        yield (0, test_container_1.resetTestContainer)();
+    }));
+    const discover = () => manager.getDevices({ androidDeviceType: 'both' }, []);
+    it('says why adb could not be started', () => __awaiter(void 0, void 0, void 0, function* () {
+        createADB.rejects(new Error('Could not find adb. spawn adb ENOENT'));
+        (0, chai_1.expect)(yield discover()).to.deep.equal([]);
+        const logged = errors.getCalls().map((c) => String(c.args[0]));
+        (0, chai_1.expect)(logged.some((m) => m.includes('spawn adb ENOENT')), logged.join('\n')).to.equal(true);
+    }));
+    it('tries adb again a minute later, and not before', () => __awaiter(void 0, void 0, void 0, function* () {
+        const adb = workingAdb();
+        createADB.onFirstCall().rejects(new Error('spawn adb ENOENT'));
+        createADB.onSecondCall().resolves(adb);
+        yield discover();
+        clock.tick(RETRY_MS - 1000);
+        yield discover();
+        (0, chai_1.expect)(createADB.callCount, 'within the minute').to.equal(1);
+        clock.tick(2000);
+        yield discover();
+        (0, chai_1.expect)(createADB.callCount, 'after the minute').to.equal(2);
+        (0, chai_1.expect)(adb.getConnectedDevices.called, 'discovery ran').to.equal(true);
+    }));
+    it('says why device tracking failed, keeps listing phones, and tries it again', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.NODE_ENV = 'development';
+        const adb = workingAdb();
+        createADB.resolves(adb);
+        trackDevices.onFirstCall().rejects(new Error('connect ECONNREFUSED 127.0.0.1:5037'));
+        yield discover();
+        const logged = errors.getCalls().map((c) => String(c.args[0]));
+        (0, chai_1.expect)(logged.some((m) => m.includes('ECONNREFUSED')), logged.join('\n')).to.equal(true);
+        yield discover();
+        (0, chai_1.expect)(adb.getConnectedDevices.callCount, 'phones still listed').to.equal(2);
+        (0, chai_1.expect)(trackDevices.callCount, 'within the minute').to.equal(1);
+        clock.tick(RETRY_MS + 1000);
+        yield discover();
+        (0, chai_1.expect)(trackDevices.callCount, 'after the minute').to.equal(2);
+    }));
+    it('starts one device tracker when two discoveries start adb at once', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Each tracker runs the whole plug-in handling again for every phone
+        // plugged in, and nothing could end the extra one.
+        process.env.NODE_ENV = 'development';
+        createADB.resolves(workingAdb());
+        const pending = [];
+        trackDevices.callsFake(() => new Promise((resolve) => pending.push(() => resolve({ on: sandbox.stub() }))));
+        const both = Promise.all([discover(), discover()]);
+        while (pending.length === 0)
+            yield new Promise((r) => setImmediate(r));
+        // Time for a second discovery to reach the tracker too, if it would.
+        for (let i = 0; i < 20; i++)
+            yield new Promise((r) => setImmediate(r));
+        pending.forEach((start) => start());
+        yield both;
+        (0, chai_1.expect)(createADB.callCount, 'adb started').to.equal(1);
+        (0, chai_1.expect)(trackDevices.callCount, 'trackers started').to.equal(1);
+    }));
+});

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

@@ -50,6 +50,7 @@ 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");
@@ -84,6 +85,7 @@ describe('EventManager: an Android session’s device log', () => {
         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, {
@@ -101,32 +103,93 @@ describe('EventManager: an Android session’s device log', () => {
         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* () {
+    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(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(prisma_1.prisma.session, 'create').callsFake(() => __awaiter(this, 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' };
+        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("collects a node session's from the node, through the session", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { device } = stubSessionStart();
+        const session = {
+            getId: () => 's-logs-node',
+            getType: () => 'remote',
+            getCapabilities: () => ({ platformName: 'Android' }),
+            getLiveVideoUrl: () => null,
+            nodeOrigin: () => 'http://node:4723',
+            nodeDeviceLogs: () => __awaiter(void 0, void 0, void 0, function* () { return ({ kind: 'refused' }); }),
+            apiKeyId: null,
+            userId: null,
+        };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(parsed({}), session, Object.assign(Object.assign({}, device), { host: 'http://node:4723' }));
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0].source).to.equal(session);
+    }));
     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 []; }) });