@wdio/browserstack-service 7.34.0 → 7.36.0

package/build/service.js

@@ -12,6 +12,10 @@ const util_1 = require("./util");
 const reporter_1 = __importDefault(require("./reporter"));
 const performance_tester_1 = __importDefault(require("./performance-tester"));
 const accessibility_handler_1 = __importDefault(require("./accessibility-handler"));
+const Percy_Handler_1 = __importDefault(require("./Percy/Percy-Handler"));
+const listener_1 = __importDefault(require("./testOps/listener"));
+const data_store_1 = require("./data-store");
+const usageStats_1 = __importDefault(require("./testOps/usageStats"));
 const log = (0, logger_1.default)('@wdio/browserstack-service');
 class BrowserstackService {
     constructor(options, _caps, _config) {
@@ -28,10 +32,11 @@ class BrowserstackService {
         this._config || (this._config = this._options);
         this._observability = this._options.testObservability;
         this._accessibility = this._options.accessibility;
+        this._percy = this._options.percy;
         this._turboScale = this._options.turboScale;
         if (this._observability) {
             (_a = this._config.reporters) === null || _a === void 0 ? void 0 : _a.push(reporter_1.default);
-            if (process.env.BROWSERSTACK_O11Y_PERF_MEASUREMENT) {
+            if (process.env[constants_1.PERF_MEASUREMENT_ENV]) {
                 performance_tester_1.default.startMonitoring('performance-report-service.csv');
             }
         }
@@ -44,6 +49,9 @@ class BrowserstackService {
         if (strict) {
             this._failureStatuses.push('pending');
         }
+        if (process.env.WDIO_WORKER_ID === process.env.BEST_PLATFORM_CID) {
+            process.env.PERCY_SNAPSHOT = 'true';
+        }
     }
     _updateCaps(fn) {
         const multiRemoteCap = this._caps;
@@ -77,29 +85,43 @@ class BrowserstackService {
             this._sessionBaseUrl = 'https://api.browserstack.com/automate-turboscale/v1/sessions';
         }
         this._scenariosThatRan = [];
-        if (this._observability && this._browser) {
+        if (this._browser) {
+            if (this._percy) {
+                this._percyHandler = new Percy_Handler_1.default(this._options.percyCaptureMode, this._browser, this._caps, this._isAppAutomate(), this._config.framework);
+                this._percyHandler.before();
+            }
             try {
-                (0, util_1.patchConsoleLogs)();
-                this._insightsHandler = new insights_handler_1.default(this._browser, this._browser.capabilities, this._isAppAutomate(), this._browser.sessionId, this._config.framework);
-                await this._insightsHandler.before();
+                if (this._observability) {
+                    (0, util_1.patchConsoleLogs)();
+                    this._insightsHandler = new insights_handler_1.default(this._browser, this._browser.capabilities, this._isAppAutomate(), this._browser.sessionId, this._config.framework);
+                    await this._insightsHandler.before();
+                }
                 /**
                  * register command event
                  */
                 this._browser.on('command', async (command) => {
-                    var _a, _b;
-                    return await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.browserCommand('client:beforeCommand', Object.assign(command, { sessionId: (_b = this._browser) === null || _b === void 0 ? void 0 : _b.sessionId }), this._currentTest));
+                    var _a, _b, _c, _d;
+                    if (this._observability) {
+                        await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.browserCommand('client:beforeCommand', Object.assign(command, { sessionId: (_b = this._browser) === null || _b === void 0 ? void 0 : _b.sessionId }), this._currentTest));
+                    }
+                    await ((_c = this._percyHandler) === null || _c === void 0 ? void 0 : _c.browserBeforeCommand(Object.assign(command, { sessionId: (_d = this._browser) === null || _d === void 0 ? void 0 : _d.sessionId })));
                 });
                 /**
                  * register result event
                  */
                 this._browser.on('result', async (result) => {
-                    var _a, _b;
-                    return await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.browserCommand('client:afterCommand', Object.assign(result, { sessionId: (_b = this._browser) === null || _b === void 0 ? void 0 : _b.sessionId }), this._currentTest));
+                    var _a, _b, _c, _d;
+                    if (this._observability) {
+                        await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.browserCommand('client:afterCommand', Object.assign(result, { sessionId: (_b = this._browser) === null || _b === void 0 ? void 0 : _b.sessionId }), this._currentTest));
+                    }
+                    (_c = this._percyHandler) === null || _c === void 0 ? void 0 : _c.browserAfterCommand(Object.assign(result, { sessionId: (_d = this._browser) === null || _d === void 0 ? void 0 : _d.sessionId }));
                 });
             }
             catch (err) {
                 log.error(`Error in service class before function: ${err}`);
-                crash_reporter_1.default.uploadCrashReport(`Error in service class before function: ${err}`, err && err.stack);
+                if (this._observability) {
+                    crash_reporter_1.default.uploadCrashReport(`Error in service class before function: ${err}`, err && err.stack);
+                }
             }
         }
         if (this._browser && (0, util_1.isBrowserstackSession)(this._browser)) {
@@ -159,17 +181,18 @@ class BrowserstackService {
         await ((_c = this._accessibilityHandler) === null || _c === void 0 ? void 0 : _c.beforeTest(suiteTitle, test));
     }
     async afterTest(test, context, results) {
-        var _a, _b;
+        var _a, _b, _c;
         this._specsRan = true;
         const { error, passed } = results;
         if (!passed) {
             this._failReasons.push((error && error.message) || 'Unknown Error');
         }
         await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.afterTest(test, results));
-        await ((_b = this._accessibilityHandler) === null || _b === void 0 ? void 0 : _b.afterTest(this._suiteTitle, test));
+        await ((_b = this._percyHandler) === null || _b === void 0 ? void 0 : _b.afterTest());
+        await ((_c = this._accessibilityHandler) === null || _c === void 0 ? void 0 : _c.afterTest(this._suiteTitle, test));
     }
     async after(result) {
-        var _a, _b;
+        var _a;
         const { preferScenarioName, setSessionName, setSessionStatus } = this._options;
         // For Cucumber: Checks scenarios that ran (i.e. not skipped) on the session
         // Only 1 Scenario ran and option enabled => Redefine session name to Scenario's name
@@ -184,9 +207,10 @@ class BrowserstackService {
                 ...(hasReasons ? { reason: this._failReasons.join('\n') } : {})
             });
         }
-        await ((_a = this._insightsHandler) === null || _a === void 0 ? void 0 : _a.uploadPending());
-        await ((_b = this._insightsHandler) === null || _b === void 0 ? void 0 : _b.teardown());
-        if (process.env.BROWSERSTACK_O11Y_PERF_MEASUREMENT) {
+        await listener_1.default.getInstance().onWorkerEnd();
+        await ((_a = this._percyHandler) === null || _a === void 0 ? void 0 : _a.teardown());
+        this.saveWorkerData();
+        if (process.env[constants_1.PERF_MEASUREMENT_ENV]) {
             await performance_tester_1.default.stopAndGenerate('performance-service.html');
             performance_tester_1.default.calculateTimes([
                 'onRunnerStart', 'onSuiteStart', 'onSuiteEnd',
@@ -219,7 +243,7 @@ class BrowserstackService {
         await this._setAnnotation(`Scenario: ${scenarioName}`);
     }
     async afterScenario(world) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this._specsRan = true;
         const status = (_a = world.result) === null || _a === void 0 ? void 0 : _a.status.toLowerCase();
         if (status !== 'skipped') {
@@ -233,7 +257,8 @@ class BrowserstackService {
             this._failReasons.push(exception);
         }
         await ((_b = this._insightsHandler) === null || _b === void 0 ? void 0 : _b.afterScenario(world));
-        await ((_c = this._accessibilityHandler) === null || _c === void 0 ? void 0 : _c.afterScenario(world));
+        await ((_c = this._percyHandler) === null || _c === void 0 ? void 0 : _c.afterScenario());
+        await ((_d = this._accessibilityHandler) === null || _d === void 0 ? void 0 : _d.afterScenario(world));
     }
     async beforeStep(step, scenario) {
         var _a;
@@ -348,6 +373,7 @@ class BrowserstackService {
         });
     }
     async _setSessionName(suiteTitle, test) {
+        var _a;
         if (!this._options.setSessionName || !suiteTitle) {
             return;
         }
@@ -361,6 +387,7 @@ class BrowserstackService {
             const post = !this._options.sessionNameOmitTestTitle ? ` - ${test.title}` : '';
             name = `${pre}${test.parent}${post}`;
         }
+        (_a = this._percyHandler) === null || _a === void 0 ? void 0 : _a._setSessionName(name);
         if (name !== this._fullTitle) {
             this._fullTitle = name;
             await this._updateJob({ name });
@@ -384,5 +411,10 @@ class BrowserstackService {
         }
         return (await this._browser.execute(script));
     }
+    saveWorkerData() {
+        (0, data_store_1.saveWorkerData)({
+            usageStats: usageStats_1.default.getInstance().getDataToSave()
+        });
+    }
 }
 exports.default = BrowserstackService;

package/build/testOps/featureStats.d.ts

@@ -0,0 +1,45 @@
+import type { FeatureStatsOverview } from '../types';
+interface FeatureStatsMap {
+    [groupId: string]: FeatureStats;
+}
+interface JSONConversionSettings {
+    omitGroups?: boolean;
+    onlyGroups?: boolean;
+    nestedGroups?: boolean;
+}
+declare class FeatureStats {
+    private triggeredCount;
+    private sentCount;
+    private failedCount;
+    private groups;
+    mark(status: string, groupId: string): void;
+    triggered(groupId?: string): void;
+    sent(groupId?: string): void;
+    failed(groupId?: string): void;
+    success(groupId?: string): void;
+    createGroup(groupId: string): FeatureStats;
+    getTriggeredCount(): number;
+    getSentCount(): number;
+    getFailedCount(): number;
+    getUsageForGroup(groupId: string): FeatureStats;
+    getOverview(): FeatureStatsOverview;
+    getGroups(): FeatureStatsMap;
+    add(featureStats: FeatureStats): void;
+    toJSON(config?: JSONConversionSettings): {
+        triggeredCount: number;
+        sentCount: number;
+        failedCount: number;
+    } | {
+        groups: Record<string, FeatureStatsOverview>;
+        triggeredCount: number;
+        sentCount: number;
+        failedCount: number;
+    } | {
+        [x: string]: FeatureStatsOverview;
+    } | {
+        groups: Record<string, FeatureStatsOverview>;
+    };
+    static fromJSON(json: any): FeatureStats;
+}
+export default FeatureStats;
+//# sourceMappingURL=featureStats.d.ts.map

package/build/testOps/featureStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"featureStats.d.ts","sourceRoot":"","sources":["../../src/testOps/featureStats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAGpD,UAAU,eAAe;IACrB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAAC;CACnC;AAED,UAAU,sBAAsB;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,YAAY,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,cAAM,YAAY;IACd,OAAO,CAAC,cAAc,CAAY;IAClC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,MAAM,CAAsB;IAE7B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAkB3C,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAOjC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAO5B,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAO9B,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAI/B,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAO1C,iBAAiB,IAAI,MAAM;IAI3B,YAAY,IAAI,MAAM;IAItB,cAAc,IAAI,MAAM;IAIxB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAI/C,WAAW,IAAI,oBAAoB;IAInC,SAAS,IAAI,eAAe;IAI5B,GAAG,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAarC,MAAM,CAAC,MAAM,GAAE,sBAA2B;;;;;;;;;;;;;;WAqBnC,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,YAAY;CAkBlD;AAED,eAAe,YAAY,CAAA"}

package/build/testOps/featureStats.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bstackLogger_1 = require("../bstackLogger");
+const util_1 = require("../util");
+class FeatureStats {
+    constructor() {
+        this.triggeredCount = 0;
+        this.sentCount = 0;
+        this.failedCount = 0;
+        this.groups = {};
+    }
+    mark(status, groupId) {
+        switch (status) {
+            case 'triggered':
+                this.triggered(groupId);
+                break;
+            case 'success':
+            case 'sent':
+                this.sent(groupId);
+                break;
+            case 'failed':
+                this.failed(groupId);
+                break;
+            default:
+                bstackLogger_1.BStackLogger.debug('Request to mark usage for unknown status - ' + status);
+                break;
+        }
+    }
+    triggered(groupId) {
+        this.triggeredCount += 1;
+        if (groupId) {
+            this.createGroup(groupId).triggered();
+        }
+    }
+    sent(groupId) {
+        this.sentCount += 1;
+        if (groupId) {
+            this.createGroup(groupId).sent();
+        }
+    }
+    failed(groupId) {
+        this.failedCount += 1;
+        if (groupId) {
+            this.createGroup(groupId).failed();
+        }
+    }
+    success(groupId) {
+        this.sent(groupId);
+    }
+    createGroup(groupId) {
+        if (!this.groups[groupId]) {
+            this.groups[groupId] = new FeatureStats();
+        }
+        return this.groups[groupId];
+    }
+    getTriggeredCount() {
+        return this.triggeredCount;
+    }
+    getSentCount() {
+        return this.sentCount;
+    }
+    getFailedCount() {
+        return this.failedCount;
+    }
+    getUsageForGroup(groupId) {
+        return this.groups[groupId] || new FeatureStats();
+    }
+    getOverview() {
+        return { triggeredCount: this.triggeredCount, sentCount: this.sentCount, failedCount: this.failedCount };
+    }
+    getGroups() {
+        return this.groups;
+    }
+    add(featureStats) {
+        this.triggeredCount += featureStats.getTriggeredCount();
+        this.sentCount += featureStats.getSentCount();
+        this.failedCount += featureStats.getFailedCount();
+        Object.entries(featureStats.getGroups()).forEach(([groupId, group]) => {
+            this.createGroup(groupId).add(group);
+        });
+    }
+    // omitGroups: true/false -> Include groups or not
+    // onlyGroups: true/false -> data includes only groups
+    // nestedGroups: true/false -> groups will be nested in groups if true
+    toJSON(config = {}) {
+        const overviewData = !config.onlyGroups ? {
+            triggeredCount: this.triggeredCount,
+            sentCount: this.sentCount,
+            failedCount: this.failedCount
+        } : {};
+        const groupsData = {};
+        if (!config.omitGroups) {
+            Object.entries(this.groups).forEach(([groupId, group]) => {
+                groupsData[groupId] = group.toJSON(); // Currently Nested groups are only overviews
+            });
+        }
+        const group = config.nestedGroups ? { groups: groupsData } : groupsData;
+        return {
+            ...overviewData,
+            ...group
+        };
+    }
+    static fromJSON(json) {
+        const stats = new FeatureStats();
+        if (!json || (0, util_1.isObjectEmpty)(json)) {
+            return stats;
+        }
+        stats.triggeredCount = json.triggeredCount;
+        stats.sentCount = json.sentCount;
+        stats.failedCount = json.failedCount;
+        if (!json.groups) {
+            return stats;
+        }
+        Object.entries(json.groups).forEach(([groupId, group]) => {
+            stats.groups[groupId] = FeatureStats.fromJSON(group);
+        });
+        return stats;
+    }
+}
+exports.default = FeatureStats;

package/build/testOps/featureUsage.d.ts

@@ -0,0 +1,22 @@
+declare class FeatureUsage {
+    private isTriggered?;
+    private status?;
+    private error?;
+    constructor(isTriggered?: boolean);
+    getTriggered(): boolean | undefined;
+    setTriggered(triggered: boolean): void;
+    setStatus(status: string): void;
+    setError(error: string): void;
+    triggered(): void;
+    failed(e: unknown): void;
+    success(): void;
+    getStatus(): string | undefined;
+    getError(): string | undefined;
+    toJSON(): {
+        isTriggered: boolean | undefined;
+        status: string | undefined;
+        error: string | undefined;
+    };
+}
+export default FeatureUsage;
+//# sourceMappingURL=featureUsage.d.ts.map

package/build/testOps/featureUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"featureUsage.d.ts","sourceRoot":"","sources":["../../src/testOps/featureUsage.ts"],"names":[],"mappings":"AAEA,cAAM,YAAY;IACd,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAC,CAAQ;IACvB,OAAO,CAAC,KAAK,CAAC,CAAQ;gBAEV,WAAW,CAAC,EAAE,OAAO;IAM1B,YAAY,IAAI,OAAO,GAAG,SAAS;IAInC,YAAY,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAItC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B,SAAS,IAAI,IAAI;IAIjB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI;IAKxB,OAAO,IAAI,IAAI;IAIf,SAAS,IAAI,MAAM,GAAG,SAAS;IAI/B,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,MAAM;;;;;CAOhB;AAED,eAAe,YAAY,CAAA"}

package/build/testOps/featureUsage.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+class FeatureUsage {
+    constructor(isTriggered) {
+        if (isTriggered !== undefined) {
+            this.isTriggered = isTriggered;
+        }
+    }
+    getTriggered() {
+        return this.isTriggered;
+    }
+    setTriggered(triggered) {
+        this.isTriggered = triggered;
+    }
+    setStatus(status) {
+        this.status = status;
+    }
+    setError(error) {
+        this.error = error;
+    }
+    triggered() {
+        this.isTriggered = true;
+    }
+    failed(e) {
+        this.status = 'failed';
+        this.error = (0, util_1.getErrorString)(e);
+    }
+    success() {
+        this.status = 'success';
+    }
+    getStatus() {
+        return this.status;
+    }
+    getError() {
+        return this.error;
+    }
+    toJSON() {
+        return {
+            isTriggered: this.isTriggered,
+            status: this.status,
+            error: this.error
+        };
+    }
+}
+exports.default = FeatureUsage;

package/build/testOps/listener.d.ts

@@ -0,0 +1,33 @@
+import type { CBTData, LogData, ScreenshotLog, TestData } from '../types';
+declare class Listener {
+    private static instance;
+    private readonly usageStats;
+    private readonly testStartedStats;
+    private readonly testFinishedStats;
+    private readonly hookStartedStats;
+    private readonly hookFinishedStats;
+    private readonly cbtSessionStats;
+    private readonly logEvents;
+    private requestBatcher?;
+    private pendingUploads;
+    private constructor();
+    static getInstance(): Listener;
+    onWorkerEnd(): Promise<void>;
+    uploadPending(waitTimeout?: number, waitInterval?: number): Promise<unknown>;
+    teardown(): Promise<void>;
+    hookStarted(hookData: TestData): void;
+    hookFinished(hookData: TestData): void;
+    testStarted(testData: TestData): void;
+    testFinished(testData: TestData): void;
+    logCreated(logs: LogData[]): void;
+    onScreenshot(jsonArray: ScreenshotLog[]): Promise<void>;
+    cbtSessionCreated(data: CBTData): void;
+    private markLogs;
+    private getResult;
+    private sendBatchEvents;
+    private eventsFailed;
+    private eventsSuccess;
+    private getEventForHook;
+}
+export default Listener;
+//# sourceMappingURL=listener.d.ts.map

package/build/testOps/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../src/testOps/listener.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAc,MAAM,UAAU,CAAA;AAWrF,cAAM,QAAQ;IACV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuC;IAClE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAiD;IAClF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkD;IACpF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAiD;IAClF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkD;IACpF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgD;IAChF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyC;IACnE,OAAO,CAAC,cAAc,CAAC,CAAqB;IAC5C,OAAO,CAAC,cAAc,CAAI;IAG1B,OAAO;WAGO,WAAW,IAAI,QAAQ;IAOxB,WAAW;IASlB,aAAa,CAAC,WAAW,SAA2C,EAAE,YAAY,SAA4C,GAAG,OAAO,CAAC,OAAO,CAAC;IASjJ,QAAQ;IASP,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAUrC,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAUtC,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAUrC,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAUtC,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAY3B,YAAY,CAAC,SAAS,EAAE,aAAa,EAAE;IAgB7C,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAU7C,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,eAAe;CAK1B;AAED,eAAe,QAAQ,CAAA"}

package/build/testOps/listener.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const usageStats_1 = __importDefault(require("./usageStats"));
+const request_handler_1 = __importDefault(require("../request-handler"));
+const util_1 = require("../util");
+const constants_1 = require("../constants");
+const requestUtils_1 = require("./requestUtils");
+const bstackLogger_1 = require("../bstackLogger");
+class Listener {
+    // Making the constructor private to use singleton pattern
+    constructor() {
+        this.usageStats = usageStats_1.default.getInstance();
+        this.testStartedStats = this.usageStats.testStartedStats;
+        this.testFinishedStats = this.usageStats.testFinishedStats;
+        this.hookStartedStats = this.usageStats.hookStartedStats;
+        this.hookFinishedStats = this.usageStats.hookFinishedStats;
+        this.cbtSessionStats = this.usageStats.cbtSessionStats;
+        this.logEvents = this.usageStats.logStats;
+        this.pendingUploads = 0;
+    }
+    static getInstance() {
+        if (!Listener.instance) {
+            Listener.instance = new Listener();
+        }
+        return Listener.instance;
+    }
+    async onWorkerEnd() {
+        try {
+            await this.uploadPending();
+            await this.teardown();
+        }
+        catch (e) {
+            bstackLogger_1.BStackLogger.debug('Exception in onWorkerEnd: ' + e);
+        }
+    }
+    async uploadPending(waitTimeout = constants_1.DEFAULT_WAIT_TIMEOUT_FOR_PENDING_UPLOADS, waitInterval = constants_1.DEFAULT_WAIT_INTERVAL_FOR_PENDING_UPLOADS) {
+        if ((this.pendingUploads <= 0) || waitTimeout <= 0) {
+            return;
+        }
+        await (0, util_1.sleep)(waitInterval);
+        return this.uploadPending(waitTimeout - waitInterval);
+    }
+    async teardown() {
+        var _a;
+        bstackLogger_1.BStackLogger.debug('teardown started');
+        if (this.requestBatcher) {
+            this.requestBatcher.tearDownInvoked = true;
+        }
+        await ((_a = this.requestBatcher) === null || _a === void 0 ? void 0 : _a.shutdown());
+        bstackLogger_1.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 (0, requestUtils_1.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_1.BStackLogger.debug('No log data');
+            return;
+        }
+        try {
+            for (const _log of data) {
+                const kind = _log.kind;
+                this.logEvents.mark(status, constants_1.LOG_KIND_USAGE_MAP[kind] || kind);
+            }
+        }
+        catch (e) {
+            bstackLogger_1.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 === null || runData === void 0 ? void 0 : runData.result;
+    }
+    sendBatchEvents(jsonObject) {
+        if (!this.requestBatcher) {
+            this.requestBatcher = request_handler_1.default.getInstance(async (data) => {
+                bstackLogger_1.BStackLogger.debug('callback: called with events ' + data.length);
+                try {
+                    this.pendingUploads += 1;
+                    await (0, util_1.batchAndPostEvents)(constants_1.DATA_BATCH_ENDPOINT, 'BATCH_DATA', data);
+                    bstackLogger_1.BStackLogger.debug('callback: marking events success ' + data.length);
+                    this.eventsSuccess(data);
+                }
+                catch (e) {
+                    bstackLogger_1.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
+        };
+    }
+}
+exports.default = Listener;