@wdio/browserstack-service 9.0.0-alpha.9 → 9.0.1

package/build/testOps/listener.js

@@ -1,222 +0,0 @@
-import UsageStats from './usageStats.js';
-import RequestQueueHandler from '../request-handler.js';
-import { batchAndPostEvents, sleep } from '../util.js';
-import { DATA_BATCH_ENDPOINT, DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS, DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, LOG_KIND_USAGE_MAP } from '../constants.js';
-import { sendScreenshots } from './requestUtils.js';
-import { BStackLogger } from '../bstackLogger.js';
-class Listener {
-    static instance;
-    usageStats = UsageStats.getInstance();
-    testStartedStats = this.usageStats.testStartedStats;
-    testFinishedStats = this.usageStats.testFinishedStats;
-    hookStartedStats = this.usageStats.hookStartedStats;
-    hookFinishedStats = this.usageStats.hookFinishedStats;
-    cbtSessionStats = this.usageStats.cbtSessionStats;
-    logEvents = this.usageStats.logStats;
-    requestBatcher;
-    pendingUploads = 0;
-    // Making the constructor private to use singleton pattern
-    constructor() {
-    }
-    static getInstance() {
-        if (!Listener.instance) {
-            Listener.instance = new Listener();
-        }
-        return Listener.instance;
-    }
-    async onWorkerEnd() {
-        try {
-            await this.uploadPending();
-            await this.teardown();
-        }
-        catch (e) {
-            BStackLogger.debug('Exception in onWorkerEnd: ' + e);
-        }
-    }
-    async uploadPending(waitTimeout = DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, waitInterval = DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS) {
-        if ((this.pendingUploads <= 0) || waitTimeout <= 0) {
-            return;
-        }
-        await sleep(waitInterval);
-        return this.uploadPending(waitTimeout - waitInterval);
-    }
-    async teardown() {
-        BStackLogger.debug('teardown started');
-        RequestQueueHandler.tearDownInvoked = true;
-        await this.requestBatcher?.shutdown();
-        BStackLogger.debug('teardown ended');
-    }
-    hookStarted(hookData) {
-        try {
-            this.hookStartedStats.triggered();
-            this.sendBatchEvents(this.getEventForHook('HookRunStarted', hookData));
-        }
-        catch (e) {
-            this.hookStartedStats.failed();
-            throw e;
-        }
-    }
-    hookFinished(hookData) {
-        try {
-            this.hookFinishedStats.triggered(hookData.result);
-            this.sendBatchEvents(this.getEventForHook('HookRunFinished', hookData));
-        }
-        catch (e) {
-            this.hookFinishedStats.failed(hookData.result);
-            throw e;
-        }
-    }
-    testStarted(testData) {
-        try {
-            this.testStartedStats.triggered();
-            this.sendBatchEvents(this.getEventForHook('TestRunStarted', testData));
-        }
-        catch (e) {
-            this.testStartedStats.failed();
-            throw e;
-        }
-    }
-    testFinished(testData) {
-        try {
-            this.testFinishedStats.triggered(testData.result);
-            this.sendBatchEvents(this.getEventForHook('TestRunFinished', testData));
-        }
-        catch (e) {
-            this.testFinishedStats.failed(testData.result);
-            throw e;
-        }
-    }
-    logCreated(logs) {
-        try {
-            this.markLogs('triggered', logs);
-            this.sendBatchEvents({
-                event_type: 'LogCreated', logs: logs
-            });
-        }
-        catch (e) {
-            this.markLogs('failed', logs);
-            throw e;
-        }
-    }
-    async onScreenshot(jsonArray) {
-        try {
-            this.markLogs('triggered', jsonArray);
-            this.pendingUploads += 1;
-            await sendScreenshots([{
-                    event_type: 'LogCreated', logs: jsonArray
-                }]);
-            this.markLogs('success', jsonArray);
-        }
-        catch (e) {
-            this.markLogs('failed', jsonArray);
-            throw e;
-        }
-        finally {
-            this.pendingUploads -= 1;
-        }
-    }
-    cbtSessionCreated(data) {
-        try {
-            this.cbtSessionStats.triggered();
-            this.sendBatchEvents({ event_type: 'CBTSessionCreated', test_run: data });
-        }
-        catch (e) {
-            this.cbtSessionStats.failed();
-            throw e;
-        }
-    }
-    markLogs(status, data) {
-        if (!data) {
-            BStackLogger.debug('No log data');
-            return;
-        }
-        try {
-            for (const _log of data) {
-                const kind = _log.kind;
-                this.logEvents.mark(status, LOG_KIND_USAGE_MAP[kind] || kind);
-            }
-        }
-        catch (e) {
-            BStackLogger.debug('Exception in marking logs status ' + e);
-            throw e;
-        }
-    }
-    getResult(jsonObject, kind) {
-        const runStr = kind === 'test' ? 'test_run' : 'hook_run';
-        const runData = jsonObject[runStr];
-        return runData?.result;
-    }
-    sendBatchEvents(jsonObject) {
-        if (!this.requestBatcher) {
-            this.requestBatcher = RequestQueueHandler.getInstance(async (data) => {
-                BStackLogger.debug('callback: called with events ' + data.length);
-                try {
-                    this.pendingUploads += 1;
-                    await batchAndPostEvents(DATA_BATCH_ENDPOINT, 'BATCH_DATA', data);
-                    BStackLogger.debug('callback: marking events success ' + data.length);
-                    this.eventsSuccess(data);
-                }
-                catch (e) {
-                    BStackLogger.debug('callback: marking events failed ' + data.length);
-                    this.eventsFailed(data);
-                }
-                finally {
-                    this.pendingUploads -= 1;
-                }
-            });
-        }
-        this.requestBatcher.add(jsonObject);
-    }
-    eventsFailed(events) {
-        for (const event of events) {
-            const eventType = event.event_type;
-            if (eventType === 'TestRunStarted') {
-                this.testStartedStats.failed();
-            }
-            else if (eventType === 'TestRunFinished') {
-                this.testFinishedStats.failed(this.getResult(event, 'test'));
-            }
-            else if (eventType === 'HookRunStarted') {
-                this.hookStartedStats.failed();
-            }
-            else if (eventType === 'HookRunFinished') {
-                this.hookFinishedStats.failed(this.getResult(event, 'hook'));
-            }
-            else if (eventType === 'CBTSessionCreated') {
-                this.cbtSessionStats.failed();
-            }
-            else if (eventType === 'LogCreated') {
-                this.markLogs('failed', event.logs);
-            }
-        }
-    }
-    eventsSuccess(events) {
-        for (const event of events) {
-            const eventType = event.event_type;
-            if (eventType === 'TestRunStarted') {
-                this.testStartedStats.success();
-            }
-            else if (eventType === 'TestRunFinished') {
-                this.testFinishedStats.success(this.getResult(event, 'test'));
-            }
-            else if (eventType === 'HookRunStarted') {
-                this.hookStartedStats.success();
-            }
-            else if (eventType === 'HookRunFinished') {
-                this.hookFinishedStats.success(this.getResult(event, 'hook'));
-            }
-            else if (eventType === 'CBTSessionCreated') {
-                this.cbtSessionStats.success();
-            }
-            else if (eventType === 'LogCreated') {
-                this.markLogs('success', event.logs);
-            }
-        }
-    }
-    getEventForHook(eventType, data) {
-        return {
-            event_type: eventType, [data.type === 'hook' ? 'hook_run' : 'test_run']: data
-        };
-    }
-}
-export default Listener;

package/build/testOps/requestUtils.js

@@ -1,39 +0,0 @@
-import { DATA_ENDPOINT, DATA_EVENT_ENDPOINT, DATA_SCREENSHOT_ENDPOINT, TESTOPS_BUILD_COMPLETED_ENV, TESTOPS_JWT_ENV } from '../constants.js';
-import { BStackLogger } from '../bstackLogger.js';
-import { DEFAULT_REQUEST_CONFIG, getLogTag } from '../util.js';
-import fetchWrap from '../fetchWrapper.js';
-export async function uploadEventData(eventData, eventUrl = DATA_EVENT_ENDPOINT) {
-    let logTag = 'BATCH_UPLOAD';
-    if (!Array.isArray(eventData)) {
-        logTag = getLogTag(eventData.event_type);
-    }
-    if (eventUrl === DATA_SCREENSHOT_ENDPOINT) {
-        logTag = 'screenshot_upload';
-    }
-    if (!process.env[TESTOPS_BUILD_COMPLETED_ENV]) {
-        throw new Error('Build start not completed yet');
-    }
-    if (!process.env[TESTOPS_JWT_ENV]) {
-        BStackLogger.debug(`[${logTag}] Missing Authentication Token/ Build ID`);
-        throw new Error('Token/buildID is undefined, build creation might have failed');
-    }
-    try {
-        const url = `${DATA_ENDPOINT}/${eventUrl}`;
-        const data = await fetchWrap(url, {
-            method: 'POST',
-            headers: {
-                ...DEFAULT_REQUEST_CONFIG.headers,
-                'Authorization': `Bearer ${process.env[TESTOPS_JWT_ENV]}`
-            },
-            body: JSON.stringify(eventData)
-        });
-        BStackLogger.debug(`[${logTag}] Success response: ${JSON.stringify(await data.json())}`);
-    }
-    catch (error) {
-        BStackLogger.debug(`[${logTag}] Failed. Error: ${error}`);
-        throw error;
-    }
-}
-export function sendScreenshots(eventData) {
-    return uploadEventData(eventData, DATA_SCREENSHOT_ENDPOINT);
-}

package/build/testOps/testOpsConfig.js

@@ -1,19 +0,0 @@
-class TestOpsConfig {
-    enabled;
-    manuallySet;
-    static _instance;
-    buildStopped = false;
-    buildHashedId;
-    static getInstance(...args) {
-        if (!this._instance) {
-            this._instance = new TestOpsConfig(...args);
-        }
-        return this._instance;
-    }
-    constructor(enabled = true, manuallySet = false) {
-        this.enabled = enabled;
-        this.manuallySet = manuallySet;
-        TestOpsConfig._instance = this;
-    }
-}
-export default TestOpsConfig;

package/build/testOps/usageStats.js

@@ -1,114 +0,0 @@
-import FeatureStats from './featureStats.js';
-import FeatureUsage from './featureUsage.js';
-import { BStackLogger } from '../bstackLogger.js';
-import TestOpsConfig from './testOpsConfig.js';
-class UsageStats {
-    static instance;
-    testStartedStats;
-    testFinishedStats;
-    hookStartedStats;
-    hookFinishedStats;
-    cbtSessionStats;
-    logStats;
-    launchBuildUsage;
-    stopBuildUsage;
-    static getInstance() {
-        if (!UsageStats.instance) {
-            UsageStats.instance = new UsageStats();
-        }
-        return UsageStats.instance;
-    }
-    constructor() {
-        this.testStartedStats = new FeatureStats();
-        this.testFinishedStats = new FeatureStats();
-        this.hookStartedStats = new FeatureStats();
-        this.hookFinishedStats = new FeatureStats();
-        this.cbtSessionStats = new FeatureStats();
-        this.logStats = new FeatureStats();
-        this.launchBuildUsage = new FeatureUsage();
-        this.stopBuildUsage = new FeatureUsage();
-    }
-    add(usageStats) {
-        this.testStartedStats.add(usageStats.testStartedStats);
-        this.testFinishedStats.add(usageStats.testFinishedStats);
-        this.hookStartedStats.add(usageStats.hookStartedStats);
-        this.hookFinishedStats.add(usageStats.hookFinishedStats);
-        this.cbtSessionStats.add(usageStats.cbtSessionStats);
-        this.logStats.add(usageStats.logStats);
-    }
-    getFormattedData(workersData) {
-        this.addDataFromWorkers(workersData);
-        const testOpsConfig = TestOpsConfig.getInstance();
-        const usage = {
-            enabled: testOpsConfig.enabled,
-            manuallySet: testOpsConfig.manuallySet,
-            buildHashedId: testOpsConfig.buildHashedId
-        };
-        if (!usage.enabled) {
-            return usage;
-        }
-        try {
-            usage.events = this.getEventsData();
-        }
-        catch (e) {
-            BStackLogger.debug('exception in getFormattedData: ' + e);
-        }
-        return usage;
-    }
-    addDataFromWorkers(workersData) {
-        workersData.map(workerData => {
-            try {
-                const usageStatsForWorker = UsageStats.fromJSON(workerData.usageStats);
-                this.add(usageStatsForWorker);
-            }
-            catch (e) {
-                BStackLogger.debug('Exception in adding workerData: ' + e);
-            }
-        });
-    }
-    getEventsData() {
-        return {
-            buildEvents: {
-                started: this.launchBuildUsage.toJSON(),
-                finished: this.stopBuildUsage.toJSON()
-            },
-            testEvents: {
-                started: this.testStartedStats.toJSON(),
-                finished: this.testFinishedStats.toJSON({ omitGroups: true }),
-                ...this.testFinishedStats.toJSON({ onlyGroups: true })
-            },
-            hookEvents: {
-                started: this.hookStartedStats.toJSON(),
-                finished: this.hookFinishedStats.toJSON({ omitGroups: true }),
-                ...this.hookFinishedStats.toJSON({ onlyGroups: true })
-            },
-            logEvents: this.logStats.toJSON(),
-            cbtSessionEvents: this.cbtSessionStats.toJSON()
-        };
-    }
-    getDataToSave() {
-        return {
-            testEvents: {
-                started: this.testStartedStats.toJSON(),
-                finished: this.testFinishedStats.toJSON({ nestedGroups: true }),
-            },
-            hookEvents: {
-                started: this.hookStartedStats.toJSON(),
-                finished: this.hookFinishedStats.toJSON({ nestedGroups: true }),
-            },
-            logEvents: this.logStats.toJSON({ nestedGroups: true }),
-            cbtSessionEvents: this.cbtSessionStats.toJSON()
-        };
-    }
-    static fromJSON(data) {
-        const usageStats = new UsageStats();
-        usageStats.testStartedStats = FeatureStats.fromJSON(data.testEvents.started);
-        usageStats.testFinishedStats = FeatureStats.fromJSON(data.testEvents.finished);
-        usageStats.hookStartedStats = FeatureStats.fromJSON(data.hookEvents.started);
-        usageStats.hookFinishedStats = FeatureStats.fromJSON(data.hookEvents.finished);
-        usageStats.logStats = FeatureStats.fromJSON(data.logEvents);
-        usageStats.cbtSessionStats = FeatureStats.fromJSON(data.cbtSessionStats);
-        return usageStats;
-    }
-}
-export default UsageStats;

package/build/types.js

@@ -1 +0,0 @@
-export {};