@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/src/dashboard/commands.js

@@ -45,56 +45,123 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardCommands = exports.DashboardCommands = void 0;
+exports.dashboardCommands = exports.DashboardCommands = exports.SESSION_DETAILS_COMMANDS = void 0;
+exports.sessionDetailsCommandOf = sessionDetailsCommandOf;
 const session_service_1 = require("./services/session-service");
 const prisma_1 = require("../prisma");
 const logger_1 = __importDefault(require("../logger"));
-const lodash_1 = __importDefault(require("lodash"));
 const SessionManager_1 = require("../sessions/SessionManager");
 const asset_manager_1 = require("./asset-manager");
+const xenonScripts_1 = require("../interceptors/xenonScripts");
+/**
+ * The execute commands that write to a session's record (its Session row):
+ * `driver.execute('xenon: setSessionName', 'Checkout')` and the like.
+ *
+ * Each answers `{ recorded: true }` when it wrote, or `{ recorded: false,
+ * message }` saying why nothing was written: no record of the session on this
+ * server (it runs without `enableDashboard`, or it is a node, which keeps
+ * none for the hub's sessions), an argument it can't use, or a failed write.
+ * None of them fails the test's command. They are bookkeeping, and a test
+ * shouldn't die because the server it ran on records no sessions. Through 2.13.2
+ * setSessionName, setSessionStatus and debug failed the command there
+ * (Prisma's P2025, a foreign-key error), and addTag and captureEvidence
+ * answered `null` as if they had worked.
+ */
+exports.SESSION_DETAILS_COMMANDS = [
+    'setSessionName',
+    'setSessionStatus',
+    'debug',
+    'addTag',
+    'captureEvidence',
+];
+const RECORDED = { recorded: true };
+const notRecorded = (message) => ({ recorded: false, message });
+/** The session-details command a script names (`xenon: addTag`), or null for any other script. */
+function sessionDetailsCommandOf(script) {
+    const name = (0, xenonScripts_1.xenonScriptName)(script);
+    return name !== null && exports.SESSION_DETAILS_COMMANDS.includes(name)
+        ? name
+        : null;
+}
+/** The script's arguments as a list, as both the W3C body and Appium's executeScript give them. */
+function argumentList(args) {
+    if (Array.isArray(args))
+        return args;
+    return args === undefined || args === null ? [] : [args];
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** A string argument, or the named field of an object argument. */
+function stringArg(value, field) {
+    if (typeof value === 'string')
+        return value;
+    if (isObject(value) && typeof value[field] === 'string')
+        return value[field];
+    return undefined;
+}
 class DashboardCommands {
-    isDashboardCommand(commandName) {
-        return commandName.startsWith('xenon') || commandName.startsWith('xe');
-    }
+    /**
+     * Answers a session-details command on an Express-style response, as
+     * `{ value: <answer> }`, and returns the answer. The hub's gateway passes
+     * the client's response; CommandInterceptor passes one that keeps it.
+     */
     process(sessionId, request, response) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { script } = request.body;
-            logger_1.default.info(`[DashboardCommands] Processing command: ${script}`);
-            if (!script) {
-                return this.sendSuccessResponse(response);
-            }
-            const commandName = script.split(':')[1];
-            logger_1.default.info(`[DashboardCommands] Parsed command name: ${commandName}`);
-            if (commandName && commandName.trim()) {
-                const trimmedCommand = commandName.trim();
-                logger_1.default.info(`[DashboardCommands] Trimmed command: ${trimmedCommand}`);
-                switch (trimmedCommand) {
-                    case 'setSessionName':
-                        logger_1.default.info('[DashboardCommands] Executing setSessionName');
-                        return yield this.setSessionName(sessionId, request, response);
-                    case 'setSessionStatus':
-                        logger_1.default.info('[DashboardCommands] Executing setSessionStatus');
-                        return yield this.setSessionStatus(sessionId, request, response);
-                    case 'debug':
-                        logger_1.default.info('[DashboardCommands] Executing debug command');
-                        return yield this.debug(sessionId, request, response);
-                    case 'captureEvidence':
-                        logger_1.default.info('[DashboardCommands] Executing captureEvidence');
-                        return yield this.captureEvidence(sessionId, request, response);
-                    case 'addTag':
-                        logger_1.default.info('[DashboardCommands] Executing addTag');
-                        return yield this.addTag(sessionId, request, response);
-                    default:
-                        logger_1.default.warn(`[DashboardCommands] Unknown command: ${trimmedCommand}`);
-                        return this.sendSuccessResponse(response);
+            var _a;
+            const { script, args } = (_a = request.body) !== null && _a !== void 0 ? _a : {};
+            const command = sessionDetailsCommandOf(script);
+            const answer = command
+                ? yield this.run(sessionId, command, args)
+                : notRecorded(`"${script}" is not a command that records session details.`);
+            response.status(200).json({ value: answer });
+            return answer;
+        });
+    }
+    /** Runs one command. Never throws: a failure is `{ recorded: false, message }`. */
+    run(sessionId, command, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.default.info(`[DashboardCommands] ${command} for session ${sessionId}`);
+            const list = argumentList(args);
+            let answer;
+            try {
+                const row = yield prisma_1.prisma.session.findUnique({
+                    where: { id: sessionId },
+                    select: { id: true, tags: true },
+                });
+                if (!row) {
+                    answer = notRecorded(`This server keeps no record of session ${sessionId}, so nothing was saved. ` +
+                        'Sessions are recorded by a server started with enableDashboard, never by a node.');
+                }
+                else {
+                    switch (command) {
+                        case 'setSessionName':
+                            answer = yield this.setSessionName(sessionId, list);
+                            break;
+                        case 'setSessionStatus':
+                            answer = yield this.setSessionStatus(sessionId, list);
+                            break;
+                        case 'debug':
+                            answer = yield this.debug(sessionId, list);
+                            break;
+                        case 'captureEvidence':
+                            answer = yield this.captureEvidence(sessionId, list);
+                            break;
+                        case 'addTag':
+                            answer = yield this.addTag(sessionId, list, row.tags);
+                            break;
+                    }
                 }
             }
-            return this.sendSuccessResponse(response);
+            catch (err) {
+                answer = notRecorded(`Xenon could not save it: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            if (!answer.recorded)
+                logger_1.default.warn(`[DashboardCommands] ${command}: ${answer.message}`);
+            return answer;
         });
     }
-    sendSuccessResponse(response) {
-        return response.status(200).json({ value: null });
-    }
     /* Commands */
     /**
      * Set the name of current test(session)
@@ -103,63 +170,50 @@ class DashboardCommands {
      * or
      * driver.executeScript("xenon: setSessionName", {"name": "MyTestName"})
      */
-    setSessionName(sessionId, request, response) {
+    setSessionName(sessionId, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { args } = request.body;
-            yield (0, session_service_1.updateSessionDetails)(sessionId, {
-                name: typeof args[0] === 'object' && args[0].name ? args[0].name : args[0],
-            });
-            return this.sendSuccessResponse(response);
+            const name = stringArg(args[0], 'name');
+            if (!name || !name.trim()) {
+                return notRecorded('setSessionName needs a name, as a string or { name }.');
+            }
+            yield (0, session_service_1.updateSessionDetails)(sessionId, { name });
+            return RECORDED;
         });
     }
     /**
      * Update the status of the session
      *
      * driver.executeScript("xenon: setSessionStatus", {"status": "passed/failed", "reason": "optional reason"})
+     * or, positionally, ("xe:setSessionStatus", "failed", "reason")
      */
-    setSessionStatus(sessionId, request, response) {
+    setSessionStatus(sessionId, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { args } = request.body;
-            let statusArg = {};
-            if (lodash_1.default.isArray(args)) {
-                if (typeof args[0] === 'object') {
-                    statusArg = args[0];
-                }
-                else {
-                    // Handle positional: executeScript("xe:setSessionStatus", "failed", "reason")
-                    statusArg = {
-                        status: args[0],
-                        reason: args[1],
-                    };
-                }
-            }
-            else if (typeof args === 'object') {
-                statusArg = args;
-            }
-            // Normalize input
-            const inputStatus = (statusArg.status || '').toLowerCase();
+            const statusArg = isObject(args[0]) ? args[0] : { status: args[0], reason: args[1] };
+            const given = statusArg.status;
+            const inputStatus = typeof given === 'string' ? given.toLowerCase() : '';
             const validStatuses = ['success', 'failed', 'passed'];
             if (!validStatuses.includes(inputStatus)) {
-                logger_1.default.warn(`[DashboardCommands] Invalid status: ${statusArg.status}. Valid: ${validStatuses.join(', ')}`);
-                return this.sendSuccessResponse(response);
+                return notRecorded('setSessionStatus takes "passed" or "failed" ("success" also means passed); ' +
+                    `it was given ${JSON.stringify(given !== null && given !== void 0 ? given : null)}.`);
             }
             // Normalize 'passed' to 'success' for consistency with SessionStatus enum
             const normalizedStatus = inputStatus === 'passed' ? 'success' : inputStatus;
+            const reason = typeof statusArg.reason === 'string' ? statusArg.reason : undefined;
             const updated = yield (0, session_service_1.updateSessionDetails)(sessionId, {
                 status: normalizedStatus,
-                failure_reason: statusArg.reason || undefined,
+                failure_reason: reason || undefined,
             });
             // --- REAL-TIME UI UPDATE ---
-            // Principal Speed: Emit a socket event so the dashboard row updates immediately.
+            // Emit a socket event so the dashboard row updates immediately.
             const { SocketServer } = yield Promise.resolve().then(() => __importStar(require('../services/SocketServer')));
             const { Container } = yield Promise.resolve().then(() => __importStar(require('typedi')));
             const { SocketEvents } = yield Promise.resolve().then(() => __importStar(require('../enums/SocketEvents')));
             void Container.get(SocketServer).emitToDashboardForDevices(SocketEvents.SESSION_STOPPED, {
                 id: sessionId,
                 status: normalizedStatus,
-                failure_reason: args.reason || undefined,
+                failure_reason: reason || undefined,
             }, { udid: updated === null || updated === void 0 ? void 0 : updated.device_udid });
-            return this.sendSuccessResponse(response);
+            return RECORDED;
         });
     }
     /**
@@ -169,12 +223,18 @@ class DashboardCommands {
      * or
      * driver.executeScript("xenon: debug", "Debug message")
      */
-    debug(sessionId, request, response) {
+    debug(sessionId, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { args } = request.body;
-            const logData = lodash_1.default.isArray(args) ? args[0] : args;
-            // Support both string and object format
-            const message = typeof logData === 'string' ? logData : logData.message || JSON.stringify(logData);
+            const logData = args[0];
+            let message;
+            if (typeof logData === 'string')
+                message = logData;
+            else if (isObject(logData)) {
+                message = typeof logData.message === 'string' ? logData.message : JSON.stringify(logData);
+            }
+            if (!message) {
+                return notRecorded('debug needs a message, as a string or { message }.');
+            }
             yield prisma_1.prisma.log.create({
                 data: {
                     session_id: sessionId,
@@ -182,7 +242,7 @@ class DashboardCommands {
                     message: message,
                 },
             });
-            return this.sendSuccessResponse(response);
+            return RECORDED;
         });
     }
     /**
@@ -192,44 +252,43 @@ class DashboardCommands {
      * or
      * driver.executeScript("xenon: captureEvidence", "Checkpoint reached")
      */
-    captureEvidence(sessionId, request, response) {
+    captureEvidence(sessionId, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { args } = request.body;
-            const evidenceData = lodash_1.default.isArray(args) ? args[0] : args;
-            const reason = typeof evidenceData === 'string' ? evidenceData : evidenceData.reason || 'Manual capture';
-            const label = typeof evidenceData === 'object' ? evidenceData.label : undefined;
+            var _a;
+            const evidenceData = args[0];
+            const reason = stringArg(evidenceData, 'reason') || 'Manual capture';
+            const label = isObject(evidenceData) ? evidenceData.label : undefined;
+            const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+            if (!session) {
+                return notRecorded(`Session ${sessionId} isn't running here, so no screenshot was taken.`);
+            }
+            let screenshotBase64;
             try {
-                const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
-                if (!session) {
-                    logger_1.default.warn(`[DashboardCommands] captureEvidence: Session ${sessionId} not found`);
-                    return this.sendSuccessResponse(response);
-                }
-                const screenshotBase64 = yield session.getScreenShot();
-                if (screenshotBase64) {
-                    const screenshotPath = (0, asset_manager_1.saveScreenShot)(sessionId, screenshotBase64);
-                    // Log the evidence capture
-                    yield prisma_1.prisma.sessionLog.create({
-                        data: {
-                            session_id: sessionId,
-                            command_name: 'captureEvidence',
-                            body: JSON.stringify({ reason, label }),
-                            response: JSON.stringify({ captured: true }),
-                            is_success: true,
-                            is_error: false,
-                            method: 'POST',
-                            title: 'Evidence Captured',
-                            subtitle: reason,
-                            screenshot: screenshotPath,
-                            url: '/execute/sync',
-                        },
-                    });
-                    logger_1.default.info(`[DashboardCommands] Evidence captured for ${sessionId}: ${reason}`);
-                }
+                screenshotBase64 = yield session.getScreenShot();
             }
             catch (err) {
-                logger_1.default.error(`[DashboardCommands] captureEvidence failed: ${err.message}`);
+                return notRecorded(`No screenshot could be taken: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
             }
-            return this.sendSuccessResponse(response);
+            if (!screenshotBase64)
+                return notRecorded('No screenshot could be taken.');
+            const screenshotPath = (0, asset_manager_1.saveScreenShot)(sessionId, screenshotBase64);
+            yield prisma_1.prisma.sessionLog.create({
+                data: {
+                    session_id: sessionId,
+                    command_name: 'captureEvidence',
+                    body: JSON.stringify({ reason, label }),
+                    response: JSON.stringify({ captured: true }),
+                    is_success: true,
+                    is_error: false,
+                    method: 'POST',
+                    title: 'Evidence Captured',
+                    subtitle: reason,
+                    screenshot: screenshotPath,
+                    url: '/execute/sync',
+                },
+            });
+            logger_1.default.info(`[DashboardCommands] Evidence captured for ${sessionId}: ${reason}`);
+            return RECORDED;
         });
     }
     /**
@@ -239,44 +298,29 @@ class DashboardCommands {
      * or
      * driver.executeScript("xenon: addTag", "smoke-test")
      */
-    addTag(sessionId, request, response) {
+    addTag(sessionId, args, tags) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { args } = request.body;
-            const tagData = lodash_1.default.isArray(args) ? args[0] : args;
-            const newTag = typeof tagData === 'string' ? tagData : tagData.tag;
-            if (!newTag) {
-                logger_1.default.warn('[DashboardCommands] addTag: No tag provided');
-                return this.sendSuccessResponse(response);
+            const newTag = stringArg(args[0], 'tag');
+            if (!newTag || !newTag.trim()) {
+                return notRecorded('addTag needs a tag, as a string or { tag }.');
             }
-            try {
-                // Get current session to append tag
-                const session = yield prisma_1.prisma.session.findUnique({
-                    where: { id: sessionId },
-                    select: { tags: true },
-                });
-                // Parse existing tags or initialize empty array
-                let existingTags = [];
-                if (session === null || session === void 0 ? void 0 : session.tags) {
-                    try {
-                        existingTags = JSON.parse(session.tags);
-                    }
-                    catch (_a) {
-                        existingTags = [];
-                    }
+            let existingTags = [];
+            if (tags) {
+                try {
+                    const parsed = JSON.parse(tags);
+                    if (Array.isArray(parsed))
+                        existingTags = parsed;
                 }
-                // Add new tag if not already present
-                if (!existingTags.includes(newTag)) {
-                    existingTags.push(newTag);
-                    yield (0, session_service_1.updateSessionDetails)(sessionId, {
-                        tags: JSON.stringify(existingTags),
-                    });
-                    logger_1.default.info(`[DashboardCommands] Tag added to ${sessionId}: ${newTag}`);
+                catch (_a) {
+                    existingTags = [];
                 }
             }
-            catch (err) {
-                logger_1.default.error(`[DashboardCommands] addTag failed: ${err.message}`);
+            if (!existingTags.includes(newTag)) {
+                existingTags.push(newTag);
+                yield (0, session_service_1.updateSessionDetails)(sessionId, { tags: JSON.stringify(existingTags) });
+                logger_1.default.info(`[DashboardCommands] Tag added to ${sessionId}: ${newTag}`);
             }
-            return this.sendSuccessResponse(response);
+            return RECORDED;
         });
     }
 }