@testingbot/cli 1.0.0

package/dist/providers/espresso.js

@@ -0,0 +1,527 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("../logger"));
+const axios_1 = __importDefault(require("axios"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const socket_io_client_1 = require("socket.io-client");
+const testingbot_error_1 = __importDefault(require("../models/testingbot_error"));
+const utils_1 = __importDefault(require("../utils"));
+const upload_1 = __importDefault(require("../upload"));
+const platform_1 = __importDefault(require("../utils/platform"));
+class Espresso {
+    URL = 'https://api.testingbot.com/v1/app-automate/espresso';
+    POLL_INTERVAL_MS = 5000;
+    MAX_POLL_ATTEMPTS = 720; // 1 hour max with 5s interval
+    credentials;
+    options;
+    upload;
+    appId = undefined;
+    activeRunIds = [];
+    isShuttingDown = false;
+    signalHandler = null;
+    socket = null;
+    updateServer = null;
+    updateKey = null;
+    constructor(credentials, options) {
+        this.credentials = credentials;
+        this.options = options;
+        this.upload = new upload_1.default();
+    }
+    async validate() {
+        if (this.options.app === undefined) {
+            throw new testingbot_error_1.default(`app option is required`);
+        }
+        try {
+            await node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK);
+        }
+        catch {
+            throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+        }
+        if (this.options.testApp === undefined) {
+            throw new testingbot_error_1.default(`testApp option is required`);
+        }
+        try {
+            await node_fs_1.default.promises.access(this.options.testApp, node_fs_1.default.constants.R_OK);
+        }
+        catch {
+            throw new testingbot_error_1.default(`testApp path does not exist ${this.options.testApp}`);
+        }
+        // Validate report options
+        if (this.options.report && !this.options.reportOutputDir) {
+            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
+        }
+        if (this.options.reportOutputDir) {
+            await this.ensureOutputDirectory(this.options.reportOutputDir);
+        }
+        return true;
+    }
+    async ensureOutputDirectory(dirPath) {
+        try {
+            const stat = await node_fs_1.default.promises.stat(dirPath);
+            if (!stat.isDirectory()) {
+                throw new testingbot_error_1.default(`Report output path exists but is not a directory: ${dirPath}`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                try {
+                    await node_fs_1.default.promises.mkdir(dirPath, { recursive: true });
+                }
+                catch (mkdirError) {
+                    throw new testingbot_error_1.default(`Failed to create report output directory: ${dirPath}`, { cause: mkdirError });
+                }
+            }
+            else if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            else {
+                throw new testingbot_error_1.default(`Failed to access report output directory: ${dirPath}`, { cause: error });
+            }
+        }
+    }
+    async run() {
+        if (!(await this.validate())) {
+            return { success: false, runs: [] };
+        }
+        try {
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading Espresso App');
+            }
+            await this.uploadApp();
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading Espresso Test App');
+            }
+            await this.uploadTestApp();
+            if (!this.options.quiet) {
+                logger_1.default.info('Running Espresso Tests');
+            }
+            await this.runTests();
+            if (this.options.async) {
+                if (!this.options.quiet) {
+                    logger_1.default.info(`Tests started in async mode. Project ID: ${this.appId}`);
+                }
+                return { success: true, runs: [] };
+            }
+            // Set up signal handlers before waiting for completion
+            this.setupSignalHandlers();
+            // Connect to real-time update server (unless --quiet is specified)
+            this.connectToUpdateServer();
+            if (!this.options.quiet) {
+                logger_1.default.info('Waiting for test results...');
+            }
+            const result = await this.waitForCompletion();
+            // Clean up
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            return result;
+        }
+        catch (error) {
+            // Clean up on error
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            logger_1.default.error(error instanceof Error ? error.message : error);
+            if (error instanceof Error && error.cause) {
+                const causeMessage = this.extractErrorMessage(error.cause);
+                if (causeMessage) {
+                    logger_1.default.error(`  Reason: ${causeMessage}`);
+                }
+            }
+            return { success: false, runs: [] };
+        }
+    }
+    async uploadApp() {
+        const result = await this.upload.upload({
+            filePath: this.options.app,
+            url: `${this.URL}/app`,
+            credentials: this.credentials,
+            contentType: 'application/vnd.android.package-archive',
+            showProgress: !this.options.quiet,
+        });
+        this.appId = result.id;
+        return true;
+    }
+    async uploadTestApp() {
+        await this.upload.upload({
+            filePath: this.options.testApp,
+            url: `${this.URL}/${this.appId}/tests`,
+            credentials: this.credentials,
+            contentType: 'application/vnd.android.package-archive',
+            showProgress: !this.options.quiet,
+        });
+        return true;
+    }
+    async runTests() {
+        try {
+            const capabilities = this.options.getCapabilities();
+            const espressoOptions = this.options.getEspressoOptions();
+            const response = await axios_1.default.post(`${this.URL}/${this.appId}/run`, {
+                capabilities: [capabilities],
+                ...(espressoOptions && { espressoOptions }),
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            // Check for version update notification
+            const latestVersion = response.headers?.['x-testingbotctl-version'];
+            utils_1.default.checkForUpdate(latestVersion);
+            const result = response.data;
+            // Capture real-time update server info
+            if (result.update_server && result.update_key) {
+                this.updateServer = result.update_server;
+                this.updateKey = result.update_key;
+            }
+            if (result.success === false) {
+                const errorMessage = result.errors?.join('\n') || result.error || 'Unknown error';
+                throw new testingbot_error_1.default(`Running Espresso test failed`, {
+                    cause: errorMessage,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            throw new testingbot_error_1.default(`Running Espresso test failed`, {
+                cause: error,
+            });
+        }
+    }
+    async getStatus() {
+        try {
+            const response = await axios_1.default.get(`${this.URL}/${this.appId}`, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to get Espresso test status`, {
+                cause: error,
+            });
+        }
+    }
+    async waitForCompletion() {
+        let attempts = 0;
+        const startTime = Date.now();
+        const previousStatus = new Map();
+        while (attempts < this.MAX_POLL_ATTEMPTS) {
+            if (this.isShuttingDown) {
+                throw new testingbot_error_1.default('Test run cancelled by user');
+            }
+            const status = await this.getStatus();
+            // Track active run IDs for graceful shutdown
+            this.activeRunIds = status.runs
+                .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
+                .map((run) => run.id);
+            // Log current status of runs (unless quiet mode)
+            if (!this.options.quiet) {
+                this.displayRunStatus(status.runs, startTime, previousStatus);
+            }
+            if (status.completed) {
+                // Clear the updating line and print final status
+                if (!this.options.quiet) {
+                    this.clearLine();
+                    for (const run of status.runs) {
+                        const statusEmoji = run.success === 1 ? '✅' : '❌';
+                        const statusText = run.success === 1 ? 'Test completed successfully' : 'Test failed';
+                        console.log(`  ${statusEmoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusText}`);
+                    }
+                }
+                const allSucceeded = status.runs.every((run) => run.success === 1);
+                if (allSucceeded) {
+                    if (!this.options.quiet) {
+                        logger_1.default.info('All tests completed successfully!');
+                    }
+                }
+                else {
+                    const failedRuns = status.runs.filter((run) => run.success !== 1);
+                    logger_1.default.error(`${failedRuns.length} test run(s) failed:`);
+                    for (const run of failedRuns) {
+                        logger_1.default.error(`  - Run ${run.id} (${run.capabilities.deviceName}): ${run.report || 'No report available'}`);
+                    }
+                }
+                // Fetch reports if requested
+                if (this.options.report && this.options.reportOutputDir) {
+                    await this.fetchReports();
+                }
+                return {
+                    success: status.success,
+                    runs: status.runs,
+                };
+            }
+            attempts++;
+            await this.sleep(this.POLL_INTERVAL_MS);
+        }
+        throw new testingbot_error_1.default(`Test timed out after ${(this.MAX_POLL_ATTEMPTS * this.POLL_INTERVAL_MS) / 1000 / 60} minutes`);
+    }
+    displayRunStatus(runs, startTime, previousStatus) {
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        const elapsedStr = this.formatElapsedTime(elapsedSeconds);
+        for (const run of runs) {
+            const prevStatus = previousStatus.get(run.id);
+            const statusChanged = prevStatus !== run.status;
+            if (statusChanged &&
+                prevStatus &&
+                (prevStatus === 'WAITING' || prevStatus === 'READY')) {
+                this.clearLine();
+            }
+            previousStatus.set(run.id, run.status);
+            const statusInfo = this.getStatusInfo(run.status);
+            if (run.status === 'WAITING' || run.status === 'READY') {
+                const message = `  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text} (${elapsedStr})`;
+                process.stdout.write(`\r${message}`);
+            }
+            else if (statusChanged) {
+                console.log(`  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text}`);
+            }
+        }
+    }
+    clearLine() {
+        platform_1.default.clearLine();
+    }
+    formatElapsedTime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    getStatusInfo(status) {
+        switch (status) {
+            case 'WAITING':
+                return { emoji: '⏳', text: 'Waiting for test to start' };
+            case 'READY':
+                return { emoji: '🔄', text: 'Running test' };
+            case 'DONE':
+                return { emoji: '✅', text: 'Test has finished running' };
+            case 'FAILED':
+                return { emoji: '❌', text: 'Test failed' };
+            default:
+                return { emoji: '❓', text: status };
+        }
+    }
+    async fetchReports() {
+        const reportFormat = this.options.report;
+        const outputDir = this.options.reportOutputDir;
+        if (!reportFormat || !outputDir) {
+            return;
+        }
+        // Espresso only supports junit report format via the project-level /report endpoint
+        if (reportFormat !== 'junit') {
+            logger_1.default.warn('Espresso only supports junit report format');
+            return;
+        }
+        if (!this.options.quiet) {
+            logger_1.default.info('Fetching junit report...');
+        }
+        try {
+            const response = await axios_1.default.get(`${this.URL}/${this.appId}/report`, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            const reportContent = response.data;
+            if (!reportContent) {
+                logger_1.default.error('No report content received');
+                return;
+            }
+            const fileName = `espresso_report_${this.appId}.xml`;
+            const filePath = node_path_1.default.join(outputDir, fileName);
+            await node_fs_1.default.promises.writeFile(filePath, reportContent, 'utf-8');
+            if (!this.options.quiet) {
+                logger_1.default.info(`  Saved report: ${filePath}`);
+            }
+        }
+        catch (error) {
+            logger_1.default.error(`Failed to fetch report: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    extractErrorMessage(cause) {
+        if (typeof cause === 'string') {
+            return cause;
+        }
+        if (Array.isArray(cause)) {
+            return cause.join('\n');
+        }
+        if (cause && typeof cause === 'object') {
+            const axiosError = cause;
+            if (axiosError.response?.data?.errors) {
+                return axiosError.response.data.errors.join('\n');
+            }
+            if (axiosError.response?.data?.error) {
+                return axiosError.response.data.error;
+            }
+            if (axiosError.response?.data?.message) {
+                return axiosError.response.data.message;
+            }
+            if (cause instanceof Error) {
+                return cause.message;
+            }
+            const obj = cause;
+            if (obj.errors) {
+                return obj.errors.join('\n');
+            }
+            if (obj.error) {
+                return obj.error;
+            }
+            if (obj.message) {
+                return obj.message;
+            }
+        }
+        return null;
+    }
+    setupSignalHandlers() {
+        this.signalHandler = () => {
+            this.handleShutdown();
+        };
+        platform_1.default.setupSignalHandlers(this.signalHandler);
+    }
+    removeSignalHandlers() {
+        if (this.signalHandler) {
+            platform_1.default.removeSignalHandlers(this.signalHandler);
+            this.signalHandler = null;
+        }
+    }
+    handleShutdown() {
+        if (this.isShuttingDown) {
+            logger_1.default.warn('Force exiting...');
+            process.exit(1);
+        }
+        this.isShuttingDown = true;
+        this.clearLine();
+        logger_1.default.warn('Received interrupt signal, stopping test runs...');
+        this.stopActiveRuns()
+            .then(() => {
+            logger_1.default.info('All test runs have been stopped.');
+            process.exit(1);
+        })
+            .catch((error) => {
+            logger_1.default.error(`Failed to stop some test runs: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        });
+    }
+    async stopActiveRuns() {
+        if (!this.appId || this.activeRunIds.length === 0) {
+            return;
+        }
+        const stopPromises = this.activeRunIds.map((runId) => this.stopRun(runId).catch((error) => {
+            logger_1.default.error(`Failed to stop run ${runId}: ${error instanceof Error ? error.message : error}`);
+        }));
+        await Promise.all(stopPromises);
+    }
+    async stopRun(runId) {
+        if (!this.appId) {
+            return;
+        }
+        try {
+            await axios_1.default.post(`${this.URL}/${this.appId}/${runId}/stop`, {}, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            if (!this.options.quiet) {
+                logger_1.default.info(`  Stopped run ${runId}`);
+            }
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to stop run ${runId}`, {
+                cause: error,
+            });
+        }
+    }
+    connectToUpdateServer() {
+        if (!this.updateServer || !this.updateKey || this.options.quiet) {
+            return;
+        }
+        try {
+            this.socket = (0, socket_io_client_1.io)(this.updateServer, {
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionAttempts: 3,
+                reconnectionDelay: 1000,
+                timeout: 10000,
+            });
+            this.socket.on('connect', () => {
+                // Join the room for this test run
+                this.socket?.emit('join', this.updateKey);
+            });
+            this.socket.on('espresso_data', (data) => {
+                this.handleEspressoData(data);
+            });
+            this.socket.on('espresso_error', (data) => {
+                this.handleEspressoError(data);
+            });
+            this.socket.on('connect_error', () => {
+                // Silently fail - real-time updates are optional
+                this.disconnectFromUpdateServer();
+            });
+        }
+        catch {
+            // Socket connection failed, continue without real-time updates
+            this.socket = null;
+        }
+    }
+    disconnectFromUpdateServer() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    handleEspressoData(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing output
+                this.clearLine();
+                // Print the Espresso output
+                process.stdout.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+    handleEspressoError(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing error
+                this.clearLine();
+                // Print the error output
+                process.stderr.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+}
+exports.default = Espresso;

package/dist/providers/login.d.ts

@@ -0,0 +1,18 @@
+export interface LoginResult {
+    success: boolean;
+    message: string;
+}
+export default class Login {
+    private server;
+    private port;
+    run(): Promise<LoginResult>;
+    private startServer;
+    private stopServer;
+    private waitForCallback;
+    private parseRequestBody;
+    private sendSuccessResponse;
+    private sendErrorResponse;
+    private saveCredentials;
+    private openBrowser;
+}
+//# sourceMappingURL=login.d.ts.map

package/dist/providers/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/providers/login.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,OAAO,KAAK;IACxB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,IAAI,CAAa;IAEZ,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC;IAiCxC,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,eAAe;IA4DvB,OAAO,CAAC,gBAAgB;IAoCxB,OAAO,CAAC,mBAAmB;IAoD3B,OAAO,CAAC,iBAAiB;YAwDX,eAAe;YAKf,WAAW;CAqB1B"}