@wdio/browserstack-service 9.0.0-alpha.78 → 9.0.0

package/build/log4jsAppender.js

@@ -1,19 +0,0 @@
-import logReportingAPI from './logReportingAPI.js';
-const BSTestOpsLogger = new logReportingAPI({});
-//Disabling eslint here as there params can be used later
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function BSTestOpsLog4JSAppender(layout, timezoneOffset) {
-    return (loggingEvent) => {
-        BSTestOpsLogger.log({
-            level: loggingEvent.level ? loggingEvent.level.levelStr : null,
-            message: loggingEvent.data ? loggingEvent.data.join(' ') : null
-        });
-    };
-}
-export const configure = (config, layouts) => {
-    let layout = layouts.colouredLayout;
-    if (config.layout) {
-        layout = layouts.layout(config.layout.type, config.layout);
-    }
-    return BSTestOpsLog4JSAppender(layout, config.timezoneOffset);
-};

package/build/logPatcher.js

@@ -1,38 +0,0 @@
-import Transport from 'winston-transport';
-const LOG_LEVELS = {
-    INFO: 'INFO', ERROR: 'ERROR', DEBUG: 'DEBUG', TRACE: 'TRACE', WARN: 'WARN',
-};
-class logPatcher extends Transport {
-    constructor(opts) {
-        super(opts);
-    }
-    logToTestOps = (level = LOG_LEVELS.INFO, message = ['']) => {
-        process.emit(`bs:addLog:${process.pid}`, {
-            timestamp: new Date().toISOString(),
-            level: level.toUpperCase(),
-            message: `"${message.join(', ')}"`,
-            kind: 'TEST_LOG',
-            http_response: {}
-        });
-    };
-    /* Patching this would show user an extended trace on their cli */
-    trace = (...message) => {
-        this.logToTestOps(LOG_LEVELS.TRACE, message);
-    };
-    debug = (...message) => {
-        this.logToTestOps(LOG_LEVELS.DEBUG, message);
-    };
-    info = (...message) => {
-        this.logToTestOps(LOG_LEVELS.INFO, message);
-    };
-    warn = (...message) => {
-        this.logToTestOps(LOG_LEVELS.WARN, message);
-    };
-    error = (...message) => {
-        this.logToTestOps(LOG_LEVELS.ERROR, message);
-    };
-    log = (...message) => {
-        this.logToTestOps(LOG_LEVELS.INFO, message);
-    };
-}
-export default logPatcher;

package/build/logReportingAPI.js

@@ -1,56 +0,0 @@
-import Transport from 'winston-transport';
-import { consoleHolder } from './constants.js';
-const LOG_LEVELS = {
-    INFO: 'INFO',
-    ERROR: 'ERROR',
-    DEBUG: 'DEBUG',
-    TRACE: 'TRACE',
-    WARN: 'WARN',
-};
-class logReportingAPI extends Transport {
-    log(info, callback = undefined) {
-        setImmediate(() => {
-            this.emit('logged', info);
-        });
-        if (typeof (info) === 'object') {
-            /* From log appender */
-            this.logToTestOps(info.level || LOG_LEVELS.INFO, info.message, false);
-        }
-        else {
-            /* From default console */
-            this.logToTestOps(LOG_LEVELS.INFO, info);
-        }
-        if (callback && typeof callback === 'function') {
-            callback();
-        }
-    }
-    logToTestOps = (level = LOG_LEVELS.INFO, message = '', consoleLog = true) => {
-        if (consoleLog) {
-            consoleHolder[level.toLowerCase()](message);
-        }
-        process.emit(`bs:addLog:${process.pid}`, {
-            timestamp: new Date().toISOString(),
-            level: level.toUpperCase(),
-            message: message,
-            kind: 'TEST_LOG',
-            http_response: {}
-        });
-    };
-    /* Patching this would show user an extended trace on their cli */
-    trace = (message) => {
-        this.logToTestOps(LOG_LEVELS.TRACE, message);
-    };
-    debug = (message) => {
-        this.logToTestOps(LOG_LEVELS.DEBUG, message);
-    };
-    info = (message) => {
-        this.logToTestOps(LOG_LEVELS.INFO, message);
-    };
-    warn = (message) => {
-        this.logToTestOps(LOG_LEVELS.WARN, message);
-    };
-    error = (message) => {
-        this.logToTestOps(LOG_LEVELS.ERROR, message);
-    };
-}
-export default logReportingAPI;

package/build/performance-tester.js

@@ -1,94 +0,0 @@
-import { createObjectCsvWriter } from 'csv-writer';
-import fs from 'node:fs';
-import { performance, PerformanceObserver } from 'node:perf_hooks';
-import { sleep } from './util.js';
-import { BStackLogger } from './bstackLogger.js';
-export default class PerformanceTester {
-    static _observer;
-    static _csvWriter;
-    static _events = [];
-    static started = false;
-    static startMonitoring(csvName = 'performance-report.csv') {
-        this._observer = new PerformanceObserver(list => {
-            list.getEntries().forEach(entry => {
-                this._events.push(entry);
-            });
-        });
-        this._observer.observe({ buffered: true, entryTypes: ['function'] });
-        this.started = true;
-        this._csvWriter = createObjectCsvWriter({
-            path: csvName,
-            header: [
-                { id: 'name', title: 'Function Name' },
-                { id: 'time', title: 'Execution Time (ms)' }
-            ]
-        });
-    }
-    static getPerformance() {
-        return performance;
-    }
-    static calculateTimes(methods) {
-        const times = {};
-        this._events.map((entry) => {
-            if (!times[entry.name]) {
-                times[entry.name] = 0;
-            }
-            times[entry.name] += entry.duration;
-        });
-        const timeTaken = methods.reduce((a, c) => {
-            return times[c] + (a || 0);
-        }, 0);
-        BStackLogger.info(`Time for ${methods} is ${timeTaken}`);
-        return timeTaken;
-    }
-    static async stopAndGenerate(filename = 'performance-own.html') {
-        if (!this.started) {
-            return;
-        }
-        await sleep(2000); // Wait to 2s just to finish any running callbacks for timerify
-        this._observer.disconnect();
-        this.started = false;
-        this.generateCSV(this._events);
-        const content = this.generateReport(this._events);
-        const path = process.cwd() + '/' + filename;
-        fs.writeFile(path, content, err => {
-            if (err) {
-                BStackLogger.error(`Error in writing html ${err}`);
-                return;
-            }
-            BStackLogger.info(`Performance report is at ${path}`);
-        });
-    }
-    static generateReport(entries) {
-        let html = '<!DOCTYPE html><html><head><title>Performance Report</title></head><body>';
-        html += '<h1>Performance Report</h1>';
-        html += '<table><thead><tr><th>Function Name</th><th>Duration (ms)</th></tr></thead><tbody>';
-        entries.forEach((entry) => {
-            html += `<tr><td>${entry.name}</td><td>${entry.duration}</td></tr>`;
-        });
-        html += '</tbody></table></body></html>';
-        return html;
-    }
-    static generateCSV(entries) {
-        const times = {};
-        entries.map((entry) => {
-            if (!times[entry.name]) {
-                times[entry.name] = 0;
-            }
-            times[entry.name] += entry.duration;
-            return {
-                name: entry.name,
-                time: entry.duration
-            };
-        });
-        const dat = Object.entries(times).map(([key, value]) => {
-            return {
-                name: key,
-                time: value
-            };
-        });
-        this._csvWriter.writeRecords(dat)
-            .then(() => BStackLogger.info('Performance CSV report generated successfully'))
-            .catch((error) => console.error(error));
-    }
-}

package/build/reporter.js

@@ -1,251 +0,0 @@
-import path from 'node:path';
-import WDIOReporter from '@wdio/reporter';
-import * as url from 'node:url';
-import { v4 as uuidv4 } from 'uuid';
-import { getCloudProvider, o11yClassErrorHandler, getGitMetaData, removeAnsiColors, getHookType, getPlatformVersion } from './util.js';
-import { BStackLogger } from './bstackLogger.js';
-import Listener from './testOps/listener.js';
-class _TestReporter extends WDIOReporter {
-    _capabilities = {};
-    _config;
-    _observability = true;
-    _sessionId;
-    _suiteName;
-    _suites = [];
-    static _tests = {};
-    _gitConfigPath;
-    _gitConfigured = false;
-    _currentHook = {};
-    _currentTest = {};
-    _userCaps = {};
-    listener = Listener.getInstance();
-    async onRunnerStart(runnerStats) {
-        this._capabilities = runnerStats.capabilities;
-        this._userCaps = this.getUserCaps(runnerStats);
-        this._config = runnerStats.config;
-        this._sessionId = runnerStats.sessionId;
-        if (typeof this._config.testObservability !== 'undefined') {
-            this._observability = this._config.testObservability;
-        }
-        await this.configureGit();
-        this.registerListeners();
-    }
-    getUserCaps(runnerStats) {
-        return runnerStats.instanceOptions[runnerStats.sessionId]?.capabilities;
-    }
-    registerListeners() {
-        if (this._config?.framework !== 'jasmine') {
-            return;
-        }
-        process.removeAllListeners(`bs:addLog:${process.pid}`);
-        process.on(`bs:addLog:${process.pid}`, this.appendTestItemLog.bind(this));
-    }
-    async appendTestItemLog(stdLog) {
-        if (this._currentHook.uuid && !this._currentHook.finished) {
-            stdLog.hook_run_uuid = this._currentHook.uuid;
-        }
-        else if (this._currentTest.uuid) {
-            stdLog.test_run_uuid = this._currentTest.uuid;
-        }
-        if (stdLog.hook_run_uuid || stdLog.test_run_uuid) {
-            this.listener.logCreated([stdLog]);
-        }
-    }
-    setCurrentHook(hookDetails) {
-        if (hookDetails.finished) {
-            if (this._currentHook.uuid === hookDetails.uuid) {
-                this._currentHook.finished = true;
-            }
-            return;
-        }
-        this._currentHook = {
-            uuid: hookDetails.uuid,
-            finished: false
-        };
-    }
-    async configureGit() {
-        if (this._gitConfigured) {
-            return;
-        }
-        const gitMeta = await getGitMetaData();
-        if (gitMeta) {
-            this._gitConfigPath = gitMeta.root;
-        }
-        this._gitConfigured = true;
-    }
-    static getTests() {
-        return _TestReporter._tests;
-    }
-    onSuiteStart(suiteStats) {
-        let filename = suiteStats.file;
-        if (this._config?.framework === 'jasmine') {
-            try {
-                if (suiteStats.file.startsWith('file://')) {
-                    filename = url.fileURLToPath(suiteStats.file);
-                }
-                if (filename === 'unknown spec file') {
-                    // Sometimes in cases where a file has two suites. Then the file name be unknown for second suite, so getting the filename from first suite
-                    filename = this._suiteName || suiteStats.file;
-                }
-            }
-            catch (e) {
-                BStackLogger.debug('Error in decoding file name of suite');
-            }
-        }
-        this._suiteName = filename;
-        this._suites.push(suiteStats);
-    }
-    onSuiteEnd() {
-        this._suites.pop();
-    }
-    needToSendData(testType, event) {
-        if (!this._observability) {
-            return false;
-        }
-        switch (this._config?.framework) {
-            case 'mocha':
-                return event === 'skip';
-            case 'cucumber':
-                return false;
-            case 'jasmine':
-                return event !== 'skip';
-            default:
-                return false;
-        }
-    }
-    async onTestEnd(testStats) {
-        if (!this.needToSendData('test', 'end')) {
-            return;
-        }
-        if (testStats.fullTitle === '<unknown test>') {
-            return;
-        }
-        testStats.end ||= new Date();
-        this.listener.testFinished(await this.getRunData(testStats, 'TestRunFinished'));
-    }
-    async onTestStart(testStats) {
-        if (!this.needToSendData('test', 'start')) {
-            return;
-        }
-        if (testStats.fullTitle === '<unknown test>') {
-            return;
-        }
-        const uuid = uuidv4();
-        this._currentTest.uuid = uuid;
-        _TestReporter._tests[testStats.fullTitle] = {
-            uuid: uuid,
-        };
-        this.listener.testStarted(await this.getRunData(testStats, 'TestRunStarted'));
-    }
-    async onHookStart(hookStats) {
-        if (!this.needToSendData('hook', 'start')) {
-            return;
-        }
-        const identifier = this.getHookIdentifier(hookStats);
-        const hookId = uuidv4();
-        this.setCurrentHook({ uuid: hookId });
-        _TestReporter._tests[identifier] = {
-            uuid: hookId,
-            startedAt: (new Date()).toISOString()
-        };
-        this.listener.hookStarted(await this.getRunData(hookStats, 'HookRunStarted'));
-    }
-    async onHookEnd(hookStats) {
-        if (!this.needToSendData('hook', 'end')) {
-            return;
-        }
-        const identifier = this.getHookIdentifier(hookStats);
-        if (_TestReporter._tests[identifier]) {
-            _TestReporter._tests[identifier].finishedAt = (new Date()).toISOString();
-        }
-        else {
-            _TestReporter._tests[identifier] = {
-                finishedAt: (new Date()).toISOString()
-            };
-        }
-        this.setCurrentHook({ uuid: _TestReporter._tests[identifier].uuid, finished: true });
-        if (!hookStats.state && !hookStats.error) {
-            hookStats.state = 'passed';
-        }
-        this.listener.hookFinished(await this.getRunData(hookStats, 'HookRunFinished'));
-    }
-    getHookIdentifier(hookStats) {
-        return `${hookStats.title} for ${this._suites.at(-1)?.title}`;
-    }
-    async onTestSkip(testStats) {
-        // cucumber steps call this method. We don't want step skipped state so skip for cucumber
-        if (!this.needToSendData('test', 'skip')) {
-            return;
-        }
-        testStats.start ||= new Date();
-        testStats.end ||= new Date();
-        this.listener.testFinished(await this.getRunData(testStats, 'TestRunSkipped'));
-    }
-    async getRunData(testStats, eventType) {
-        const framework = this._config?.framework;
-        const scopes = this._suites.map(s => s.title);
-        const identifier = testStats.type === 'test' ? testStats.fullTitle : this.getHookIdentifier(testStats);
-        const testMetaData = _TestReporter._tests[identifier];
-        const scope = testStats.type === 'test' ? testStats.fullTitle : `${this._suites[0].title} - ${testStats.title}`;
-        await this.configureGit();
-        const testData = {
-            uuid: testMetaData ? testMetaData.uuid : uuidv4(),
-            type: testStats.type,
-            name: testStats.title,
-            body: {
-                lang: 'webdriverio',
-                code: null
-            },
-            scope: scope,
-            scopes: scopes,
-            identifier: identifier,
-            file_name: this._suiteName ? path.relative(process.cwd(), this._suiteName) : undefined,
-            location: this._suiteName ? path.relative(process.cwd(), this._suiteName) : undefined,
-            vc_filepath: (this._gitConfigPath && this._suiteName) ? path.relative(this._gitConfigPath, this._suiteName) : undefined,
-            started_at: testStats.start && testStats.start.toISOString(),
-            finished_at: testStats.end && testStats.end.toISOString(),
-            framework: framework,
-            duration_in_ms: testStats._duration,
-            result: testStats.state,
-        };
-        if (testStats.type === 'test') {
-            testData.retries = { limit: testStats.retries || 0, attempts: testStats.retries || 0 };
-        }
-        if (eventType.startsWith('TestRun') || eventType === 'HookRunStarted') {
-            /* istanbul ignore next */
-            const cloudProvider = getCloudProvider({ options: { hostname: this._config?.hostname } });
-            testData.integrations = {};
-            /* istanbul ignore next */
-            testData.integrations[cloudProvider] = {
-                capabilities: this._capabilities,
-                session_id: this._sessionId,
-                browser: this._capabilities?.browserName,
-                browser_version: this._capabilities?.browserVersion,
-                platform: this._capabilities?.platformName,
-                platform_version: getPlatformVersion(this._userCaps)
-            };
-        }
-        if (eventType === 'TestRunFinished' || eventType === 'HookRunFinished') {
-            const { error } = testStats;
-            const failed = testStats.state === 'failed';
-            if (failed) {
-                testData.result = (error && error.message && error.message.includes('sync skip; aborting execution')) ? 'ignore' : 'failed';
-                if (error && testData.result !== 'skipped') {
-                    testData.failure = [{ backtrace: [removeAnsiColors(error.message)] }]; // add all errors here
-                    testData.failure_reason = removeAnsiColors(error.message);
-                    testData.failure_type = error.message === null ? null : error.message.toString().match(/AssertionError/) ? 'AssertionError' : 'UnhandledError'; //verify if this is working
-                }
-            }
-        }
-        if (eventType === 'TestRunSkipped') {
-            eventType = 'TestRunFinished';
-        }
-        if (eventType.match(/HookRun/)) {
-            testData.hook_type = testData.name?.toLowerCase() ? getHookType(testData.name.toLowerCase()) : 'undefined';
-        }
-        return testData;
-    }
-}
-// https://github.com/microsoft/TypeScript/issues/6543
-const TestReporter = o11yClassErrorHandler(_TestReporter);
-export default TestReporter;

package/build/request-handler.js

@@ -1,74 +0,0 @@
-import { DATA_BATCH_SIZE, DATA_BATCH_INTERVAL, TESTOPS_BUILD_COMPLETED_ENV } from './constants.js';
-import { BStackLogger } from './bstackLogger.js';
-export default class RequestQueueHandler {
-    queue = [];
-    callback;
-    pollEventBatchInterval;
-    static tearDownInvoked = false;
-    static instance;
-    // making it private to use singleton pattern
-    constructor(callback) {
-        this.callback = callback;
-        this.startEventBatchPolling();
-    }
-    static getInstance(callback) {
-        if (!RequestQueueHandler.instance && callback) {
-            RequestQueueHandler.instance = new RequestQueueHandler(callback);
-        }
-        return RequestQueueHandler.instance;
-    }
-    add(event) {
-        if (!process.env[TESTOPS_BUILD_COMPLETED_ENV]) {
-            throw new Error('Observability build start not completed yet.');
-        }
-        this.queue.push(event);
-        BStackLogger.debug(`Added data to request queue. Queue length = ${this.queue.length}`);
-        const shouldProceed = this.shouldProceed();
-        if (shouldProceed) {
-            this.sendBatch().catch((e) => {
-                BStackLogger.debug('Exception in sending batch: ' + e);
-            });
-        }
-    }
-    async shutdown() {
-        BStackLogger.debug('shutdown started');
-        this.removeEventBatchPolling('Shutting down');
-        while (this.queue.length > 0) {
-            const data = this.queue.splice(0, DATA_BATCH_SIZE);
-            await this.callCallback(data, 'SHUTDOWN_QUEUE');
-        }
-        BStackLogger.debug('shutdown ended');
-    }
-    startEventBatchPolling() {
-        this.pollEventBatchInterval = setInterval(this.sendBatch.bind(this), DATA_BATCH_INTERVAL);
-    }
-    async sendBatch() {
-        const data = this.queue.splice(0, DATA_BATCH_SIZE);
-        if (data.length === 0) {
-            return;
-        }
-        BStackLogger.debug(`Sending data from request queue. Data length = ${data.length}, Queue length after removal = ${this.queue.length}`);
-        await this.callCallback(data, 'INTERVAL_QUEUE');
-    }
-    callCallback = async (data, kind) => {
-        BStackLogger.debug('calling callback with kind ' + kind);
-        this.callback && await this.callback(data);
-    };
-    resetEventBatchPolling() {
-        this.removeEventBatchPolling('Resetting');
-        this.startEventBatchPolling();
-    }
-    removeEventBatchPolling(tag) {
-        if (this.pollEventBatchInterval) {
-            BStackLogger.debug(`${tag} request queue`);
-            clearInterval(this.pollEventBatchInterval);
-        }
-    }
-    shouldProceed() {
-        if (RequestQueueHandler.tearDownInvoked) {
-            BStackLogger.debug('Force request-queue shutdown, as test run event is received after teardown');
-            return true;
-        }
-        return this.queue.length >= DATA_BATCH_SIZE;
-    }
-}

package/build/scripts/accessibility-scripts.js

@@ -1,61 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-class AccessibilityScripts {
-    static instance = null;
-    performScan = null;
-    getResults = null;
-    getResultsSummary = null;
-    saveTestResults = null;
-    commandsToWrap = null;
-    browserstackFolderPath = path.join(os.homedir(), '.browserstack');
-    commandsPath = path.join(this.browserstackFolderPath, 'commands.json');
-    // don't allow to create instances from it other than through `checkAndGetInstance`
-    constructor() { }
-    static checkAndGetInstance() {
-        if (!AccessibilityScripts.instance) {
-            AccessibilityScripts.instance = new AccessibilityScripts();
-            AccessibilityScripts.instance.readFromExistingFile();
-        }
-        return AccessibilityScripts.instance;
-    }
-    readFromExistingFile() {
-        try {
-            if (fs.existsSync(this.commandsPath)) {
-                const data = fs.readFileSync(this.commandsPath, 'utf8');
-                if (data) {
-                    this.update(JSON.parse(data));
-                }
-            }
-        }
-        catch (error) {
-            /* Do nothing */
-        }
-    }
-    update(data) {
-        if (data.scripts) {
-            this.performScan = data.scripts.scan;
-            this.getResults = data.scripts.getResults;
-            this.getResultsSummary = data.scripts.getResultsSummary;
-            this.saveTestResults = data.scripts.saveResults;
-        }
-        if (data.commands && data.commands.length) {
-            this.commandsToWrap = data.commands;
-        }
-    }
-    store() {
-        if (!fs.existsSync(this.browserstackFolderPath)) {
-            fs.mkdirSync(this.browserstackFolderPath);
-        }
-        fs.writeFileSync(this.commandsPath, JSON.stringify({
-            commands: this.commandsToWrap,
-            scripts: {
-                scan: this.performScan,
-                getResults: this.getResults,
-                getResultsSummary: this.getResultsSummary,
-                saveResults: this.saveTestResults,
-            }
-        }));
-    }
-}
-export default AccessibilityScripts.checkAndGetInstance();