playwright-slack-report-burak 1.2.0

package/dist/src/ResultsParser.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { failure, flaky, pass, skipper, SummaryResults } from '.';
+export declare type testResult = {
+    suiteName: string;
+    name: string;
+    browser?: string;
+    projectName: string;
+    endedAt: string;
+    reason: string;
+    retry: number;
+    retries: number;
+    startedAt: string;
+    status: 'passed' | 'failed' | 'timedOut' | 'skipped';
+    attachments?: {
+        body: string | undefined | Buffer;
+        contentType: string;
+        name: string;
+        path: string;
+    }[];
+};
+export declare type testSuite = {
+    testSuite: {
+        title: string;
+        tests: testResult[];
+        testRunId?: number;
+    };
+};
+export default class ResultsParser {
+    private result;
+    private separateFlakyTests;
+    constructor(options?: {
+        separateFlakyTests: boolean;
+    });
+    getParsedResults(): Promise<SummaryResults>;
+    getFailures(): Promise<Array<failure>>;
+    getFlakes(): Promise<Array<flaky>>;
+    getPasses(): Promise<Array<pass>>;
+    getSkippers(): Promise<Array<skipper>>;
+    static getTestName(failedTest: any): any;
+    updateResults(data: {
+        testSuite: any;
+    }): void;
+    addTestResult(suiteName: any, testCase: any, projectBrowserMapping: any): void;
+    safelyDetermineFailure(result: {
+        errors: any[];
+        error: {
+            message: string;
+            stack: string;
+        };
+    }): string;
+    cleanseReason(rawReaseon: string): string;
+    determineBrowser(projectName: string, browserMappings: {
+        projectName: string;
+        browser: string;
+    }[]): {
+        projectName: string;
+        browser: string;
+    };
+    /** removes tests from the passed array that only passed on a retry (flaky).
+     * Does not modify param passed, returns a new passed array. */
+    doSeparateFlakyTests(passes: Array<pass>, flakes: Array<flaky>): pass[];
+}

package/dist/src/ResultsParser.js

@@ -0,0 +1,187 @@
+"use strict";
+/* eslint-disable no-shadow */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable import/extensions */
+/* eslint-disable no-control-regex */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-param-reassign */
+Object.defineProperty(exports, "__esModule", { value: true });
+class ResultsParser {
+    result;
+    separateFlakyTests;
+    constructor(options = { separateFlakyTests: false }) {
+        this.result = [];
+        this.separateFlakyTests = options.separateFlakyTests;
+    }
+    async getParsedResults() {
+        const failures = await this.getFailures();
+        const flakes = await this.getFlakes();
+        let passes = await this.getPasses();
+        const skippers = await this.getSkippers();
+        if (this.separateFlakyTests) {
+            passes = this.doSeparateFlakyTests(passes, flakes);
+        }
+        const summary = {
+            passed: passes.length,
+            failed: failures.length,
+            flaky: this.separateFlakyTests ? flakes.length : undefined,
+            skipped: skippers.length,
+            failures,
+            tests: [],
+        };
+        for (const suite of this.result) {
+            summary.tests = summary.tests.concat(suite.testSuite.tests);
+            for (const test of suite.testSuite.tests) {
+                if (test.status === 'skipped') {
+                    summary.skipped += 1;
+                }
+            }
+        }
+        return summary;
+    }
+    async getFailures() {
+        const failures = [];
+        for (const suite of this.result) {
+            for (const test of suite.testSuite.tests) {
+                if (test.status === 'failed' || test.status === 'timedOut') {
+                    // only flag as failed if the last attempt has failed
+                    if (test.retries === test.retry) {
+                        failures.push({
+                            test: ResultsParser.getTestName(test),
+                            failureReason: test.reason,
+                        });
+                    }
+                }
+            }
+        }
+        return failures;
+    }
+    async getFlakes() {
+        const flaky = [];
+        for (const suite of this.result) {
+            for (const test of suite.testSuite.tests) {
+                if (test.status === 'passed' && test.retry > 0) {
+                    flaky.push({
+                        test: ResultsParser.getTestName(test),
+                        retry: test.retry,
+                    });
+                }
+            }
+        }
+        return flaky;
+    }
+    async getPasses() {
+        const passes = [];
+        for (const suite of this.result) {
+            for (const test of suite.testSuite.tests) {
+                if (test.status === 'passed') {
+                    passes.push({
+                        test: ResultsParser.getTestName(test),
+                    });
+                }
+            }
+        }
+        return passes;
+    }
+
+    async getSkippers() {
+        const skippers = [];
+        for (const suite of this.result) {
+            for (const test of suite.testSuite.tests) {
+                if (test.status === 'skipped') {
+                    skippers.push({
+                        test: ResultsParser.getTestName(test),
+                    });
+                }
+            }
+        }
+        return skippers;
+    }
+
+
+    static getTestName(failedTest) {
+        const testName = failedTest.name;
+        if (failedTest.browser && failedTest.projectName) {
+            if (failedTest.browser === failedTest.projectName) {
+                return `${testName} [${failedTest.browser}]`;
+            }
+            return `${testName} [Project Name: ${failedTest.projectName}] using ${failedTest.browser}`;
+        }
+        return testName;
+    }
+    updateResults(data) {
+        if (data.testSuite.tests.length > 0) {
+            this.result.push(data);
+        }
+    }
+    addTestResult(suiteName, testCase, projectBrowserMapping) {
+        const testResults = [];
+        const projectSettings = this.determineBrowser(testCase._projectId, projectBrowserMapping);
+        for (const result of testCase.results) {
+            testResults.push({
+                suiteName,
+                name: testCase.title,
+                status: result.status,
+                browser: projectSettings.browser,
+                projectName: projectSettings.projectName,
+                retry: result.retry,
+                retries: testCase.retries,
+                startedAt: new Date(result.startTime).toISOString(),
+                endedAt: new Date(new Date(result.startTime).getTime() + result.duration).toISOString(),
+                reason: this.safelyDetermineFailure(result),
+                attachments: result.attachments,
+            });
+        }
+        this.updateResults({
+            testSuite: {
+                title: suiteName,
+                tests: testResults,
+            },
+        });
+    }
+    safelyDetermineFailure(result) {
+        if (result.errors.length > 0) {
+            const fullError = result.errors
+                .map((e) => `${e.message}\r\n${e.stack ? e.stack : ''}\r\n`)
+                .join();
+            return this.cleanseReason(fullError);
+        }
+        return `${this.cleanseReason(result.error?.message)} \n ${this.cleanseReason(result.error?.stack)}`;
+    }
+    cleanseReason(rawReaseon) {
+        // eslint-disable-next-line prefer-regex-literals
+        const ansiRegex = new RegExp('([\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))', 'g');
+        const ansiCleansed = rawReaseon ? rawReaseon.replace(ansiRegex, '') : '';
+        const logsStripped = ansiCleansed
+            .replace(/============================================================\n/g, '')
+            .replace(/============================================================\r\n/g, '')
+            .replace(/=========================== logs ===========================\n/g, '');
+        return logsStripped;
+    }
+    determineBrowser(projectName, browserMappings) {
+        const browserMapping = browserMappings.find((mapping) => mapping.projectName === projectName);
+        if (browserMapping) {
+            return {
+                projectName: browserMapping.projectName,
+                browser: browserMapping.browser,
+            };
+        }
+        return {
+            projectName: '',
+            browser: '',
+        };
+    }
+    /** removes tests from the passed array that only passed on a retry (flaky).
+     * Does not modify param passed, returns a new passed array. */
+    doSeparateFlakyTests(passes, flakes) {
+        const _passes = new Map();
+        for (const pass of passes) {
+            _passes.set(pass.test, pass);
+        }
+        for (const flake of flakes) {
+            _passes.delete(flake.test);
+        }
+        return [..._passes.values()];
+    }
+}
+exports.default = ResultsParser;

package/dist/src/SlackClient.d.ts

@@ -0,0 +1,37 @@
+import { WebClient, KnownBlock, Block, ChatPostMessageResponse, LogLevel } from '@slack/web-api';
+import { SummaryResults } from '.';
+export declare type additionalInfo = Array<{
+    key: string;
+    value: string;
+}>;
+export default class SlackClient {
+    private slackWebClient;
+    constructor(slackClient: WebClient);
+    sendMessage({ options, }: {
+        options: {
+            channelIds: Array<string>;
+            customLayout: Function | undefined;
+            customLayoutAsync: Function | undefined;
+            fakeRequest?: Function;
+            maxNumberOfFailures: number;
+            slackOAuthToken?: string;
+            slackLogLevel?: LogLevel;
+            disableUnfurl?: boolean;
+            summaryResults: SummaryResults;
+            showInThread: boolean;
+        };
+    }): Promise<Array<{
+        channel: string;
+        outcome: string;
+        ts: string;
+    }>>;
+    attachDetailsToThread({ channelIds, ts, summaryResults, maxNumberOfFailures, disableUnfurl, fakeRequest, }: {
+        channelIds: Array<string>;
+        ts: string;
+        summaryResults: SummaryResults;
+        maxNumberOfFailures: number;
+        disableUnfurl?: boolean;
+        fakeRequest?: Function;
+    }): Promise<any[]>;
+    static doPostRequest(slackWebClient: WebClient, channel: string, blocks: Array<KnownBlock | Block>, unfurl: boolean, threadTimestamp?: string): Promise<ChatPostMessageResponse>;
+}

package/dist/src/SlackClient.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LayoutGenerator_1 = require("./LayoutGenerator");
+class SlackClient {
+    slackWebClient;
+    constructor(slackClient) {
+        this.slackWebClient = slackClient;
+    }
+    async sendMessage({ options, }) {
+        let blocks;
+        if (options.customLayout) {
+            blocks = options.customLayout(options.summaryResults);
+        }
+        else if (options.customLayoutAsync) {
+            blocks = await options.customLayoutAsync(options.summaryResults);
+        }
+        else if (options.showInThread) {
+            const modifiedOptions = JSON.parse(JSON.stringify(options));
+            modifiedOptions.summaryResults.failures = [];
+            blocks = await (0, LayoutGenerator_1.generateBlocks)(modifiedOptions.summaryResults, options.maxNumberOfFailures);
+        }
+        else {
+            blocks = await (0, LayoutGenerator_1.generateBlocks)(options.summaryResults, options.maxNumberOfFailures);
+        }
+        if (!options.channelIds) {
+            throw new Error(`Channel ids [${options.channelIds}] is not valid`);
+        }
+        const result = [];
+        const unfurl = !options.disableUnfurl;
+        for (const channel of options.channelIds) {
+            let chatResponse;
+            try {
+                // under test
+                if (options.fakeRequest) {
+                    chatResponse = await options.fakeRequest();
+                }
+                else {
+                    // send request for reals
+                    chatResponse = await SlackClient.doPostRequest(this.slackWebClient, channel, blocks, unfurl);
+                }
+                if (chatResponse.ok) {
+                    result.push({
+                        channel,
+                        outcome: `✅ Message sent to ${channel}`,
+                        ts: chatResponse.ts,
+                    });
+                    // eslint-disable-next-line no-console
+                    console.log(`✅ Message sent to ${channel}`);
+                }
+                else {
+                    result.push({
+                        channel,
+                        outcome: `❌ Message not sent to ${channel} \r\n ${JSON.stringify(chatResponse, null, 2)}`,
+                    });
+                }
+            }
+            catch (error) {
+                result.push({
+                    channel,
+                    outcome: `❌ Message not sent to ${channel} \r\n ${error.message}`,
+                });
+            }
+        }
+        return result;
+    }
+    async attachDetailsToThread({ channelIds, ts, summaryResults, maxNumberOfFailures, disableUnfurl, fakeRequest, }) {
+        const result = [];
+        const blocks = await (0, LayoutGenerator_1.generateFailures)(summaryResults, maxNumberOfFailures);
+        for (const channel of channelIds) {
+            // under test
+            let chatResponse;
+            if (fakeRequest) {
+                chatResponse = await fakeRequest();
+            }
+            else {
+                chatResponse = await SlackClient.doPostRequest(this.slackWebClient, channel, blocks, disableUnfurl, ts);
+            }
+            if (chatResponse.ok) {
+                // eslint-disable-next-line no-console
+                console.log(`✅ Message sent to ${channel} within thread ${ts}`);
+                result.push({
+                    channel,
+                    outcome: `✅ Message sent to ${channel} within thread ${ts}`,
+                    ts: chatResponse.ts,
+                });
+            }
+        }
+        return result;
+    }
+    static async doPostRequest(slackWebClient, channel, blocks, unfurl, threadTimestamp) {
+        const chatResponse = await slackWebClient.chat.postMessage({
+            channel,
+            text: ' ',
+            unfurl_link: unfurl,
+            blocks,
+            thread_ts: threadTimestamp,
+        });
+        return chatResponse;
+    }
+}
+exports.default = SlackClient;

package/dist/src/SlackReporter.d.ts

@@ -0,0 +1,30 @@
+import { FullConfig, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+declare class SlackReporter implements Reporter {
+    private customLayout;
+    private customLayoutAsync;
+    private maxNumberOfFailuresToShow;
+    private showInThread;
+    private meta;
+    private resultsParser;
+    private sendResults;
+    private slackChannels;
+    private slackLogLevel;
+    private slackOAuthToken;
+    private slackWebHookUrl;
+    private disableUnfurl;
+    private proxy;
+    private browsers;
+    private suite;
+    private separateFlaky;
+    logs: string[];
+    onBegin(fullConfig: FullConfig, suite: Suite): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(): Promise<void>;
+    preChecks(): {
+        okToProceed: boolean;
+        message?: string;
+    };
+    log(message: string | undefined): void;
+    printsToStdio(): boolean;
+}
+export default SlackReporter;

package/dist/src/SlackReporter.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web_api_1 = require("@slack/web-api");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const webhook_1 = require("@slack/webhook");
+const ResultsParser_1 = require("./ResultsParser");
+const SlackClient_1 = require("./SlackClient");
+const SlackWebhookClient_1 = require("./SlackWebhookClient");
+class SlackReporter {
+    customLayout;
+    customLayoutAsync;
+    maxNumberOfFailuresToShow;
+    showInThread;
+    meta = [];
+    resultsParser;
+    sendResults = 'on-failure';
+    slackChannels = [];
+    slackLogLevel;
+    slackOAuthToken;
+    slackWebHookUrl;
+    disableUnfurl;
+    proxy;
+    browsers = [];
+    suite;
+    separateFlaky = false;
+    logs = [];
+    onBegin(fullConfig, suite) {
+        this.suite = suite;
+        this.logs = [];
+        const slackReporterConfig = fullConfig.reporter.filter((f) => f[0].toLowerCase().includes('slackreporter'))[0][1];
+        if (fullConfig.projects.length === 0) {
+            this.browsers = [];
+        }
+        else {
+            // eslint-disable-next-line max-len
+            this.browsers = fullConfig.projects.map((obj) => ({
+                projectName: obj.name,
+                browser: obj.use.browserName
+                    ? obj.use.browserName
+                    : obj.use.defaultBrowserType,
+            }));
+        }
+        if (slackReporterConfig) {
+            this.meta = slackReporterConfig.meta || [];
+            this.sendResults = slackReporterConfig.sendResults || 'always';
+            this.customLayout = slackReporterConfig.layout;
+            this.customLayoutAsync = slackReporterConfig.layoutAsync;
+            this.slackChannels = slackReporterConfig.channels;
+            this.maxNumberOfFailuresToShow
+                = slackReporterConfig.maxNumberOfFailuresToShow || 10;
+            this.slackOAuthToken = slackReporterConfig.slackOAuthToken || undefined;
+            this.slackWebHookUrl = slackReporterConfig.slackWebHookUrl || undefined;
+            this.disableUnfurl = slackReporterConfig.disableUnfurl || false;
+            this.showInThread = slackReporterConfig.showInThread || false;
+            this.slackLogLevel = slackReporterConfig.slackLogLevel || web_api_1.LogLevel.DEBUG;
+            this.proxy = slackReporterConfig.proxy || undefined;
+            this.separateFlaky = slackReporterConfig.separateFlaky || false;
+        }
+        this.resultsParser = new ResultsParser_1.default({
+            separateFlakyTests: this.separateFlaky,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this, no-unused-vars
+    onTestEnd(test, result) {
+        this.resultsParser.addTestResult(test.parent.title, test, this.browsers);
+    }
+    async onEnd() {
+        const { okToProceed, message } = this.preChecks();
+        if (!okToProceed) {
+            this.log(message);
+            return;
+        }
+        const resultSummary = await this.resultsParser.getParsedResults();
+        resultSummary.meta = this.meta;
+        const maxRetry = Math.max(...resultSummary.tests.map((o) => o.retry));
+        if (this.sendResults === 'on-failure'
+            && resultSummary.tests.filter((z) => (z.status === 'failed' || z.status === 'timedOut')
+                && z.retry === maxRetry).length === 0) {
+            this.log('⏩ Slack reporter - no failures found');
+            return;
+        }
+        const agent = this.proxy ? new https_proxy_agent_1.HttpsProxyAgent(this.proxy) : undefined;
+        if (this.slackWebHookUrl) {
+            const webhook = new webhook_1.IncomingWebhook(this.slackWebHookUrl, { agent });
+            const slackWebhookClient = new SlackWebhookClient_1.default(webhook);
+            const webhookResult = await slackWebhookClient.sendMessage({
+                customLayout: this.customLayout,
+                customLayoutAsync: this.customLayoutAsync,
+                maxNumberOfFailures: this.maxNumberOfFailuresToShow,
+                disableUnfurl: this.disableUnfurl,
+                summaryResults: resultSummary,
+            });
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify(webhookResult, null, 2));
+        }
+        else {
+            const slackClient = new SlackClient_1.default(new web_api_1.WebClient(this.slackOAuthToken || process.env.SLACK_BOT_USER_OAUTH_TOKEN, {
+                logLevel: this.slackLogLevel || web_api_1.LogLevel.DEBUG,
+                agent,
+            }));
+            const result = await slackClient.sendMessage({
+                options: {
+                    channelIds: this.slackChannels,
+                    customLayout: this.customLayout,
+                    customLayoutAsync: this.customLayoutAsync,
+                    maxNumberOfFailures: this.maxNumberOfFailuresToShow,
+                    disableUnfurl: this.disableUnfurl,
+                    summaryResults: resultSummary,
+                    showInThread: this.showInThread,
+                },
+            });
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify(result, null, 2));
+            if (this.showInThread && resultSummary.failures.length > 0) {
+                for (let i = 0; i < result.length; i += 1) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await slackClient.attachDetailsToThread({
+                        channelIds: [result[i].channel],
+                        ts: result[i].ts,
+                        summaryResults: resultSummary,
+                        maxNumberOfFailures: this.maxNumberOfFailuresToShow,
+                    });
+                }
+            }
+        }
+    }
+    preChecks() {
+        if (this.sendResults === 'off') {
+            return { okToProceed: false, message: '❌ Slack reporter is disabled' };
+        }
+        if (!this.slackWebHookUrl
+            && !this.slackOAuthToken
+            && !process.env.SLACK_BOT_USER_OAUTH_TOKEN) {
+            return {
+                okToProceed: false,
+                message: '❌ Neither slack webhook url, slackOAuthToken nor process.env.SLACK_BOT_USER_OAUTH_TOKEN were found',
+            };
+        }
+        if (this.slackWebHookUrl
+            && (process.env.SLACK_BOT_USER_OAUTH_TOKEN || this.slackOAuthToken)) {
+            return {
+                okToProceed: false,
+                message: '❌ You can only enable a single option, either provide a slack webhook url, slackOAuthToken or process.env.SLACK_BOT_USER_OAUTH_TOKEN were found',
+            };
+        }
+        if (!this.sendResults
+            || !['always', 'on-failure', 'off'].includes(this.sendResults)) {
+            return {
+                okToProceed: false,
+                message: "❌ \"sendResults\" is not valid. Expecting one of ['always', 'on-failure', 'off'].",
+            };
+        }
+        if (!this.sendResults || this.slackChannels?.length === 0) {
+            return {
+                okToProceed: false,
+                message: '❌ Slack channel(s) was not provided in the config',
+            };
+        }
+        if (this.customLayout && typeof this.customLayout !== 'function') {
+            return {
+                okToProceed: false,
+                message: '❌ Custom layout is not a function',
+            };
+        }
+        if (this.customLayoutAsync
+            && typeof this.customLayoutAsync !== 'function') {
+            return {
+                okToProceed: false,
+                message: '❌ customLayoutAsync is not a function',
+            };
+        }
+        if (this.meta && !Array.isArray(this.meta)) {
+            return { okToProceed: false, message: '❌ Meta is not an array' };
+        }
+        return { okToProceed: true };
+    }
+    log(message) {
+        // eslint-disable-next-line no-console
+        console.log(message);
+        if (message) {
+            this.logs.push(message);
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    printsToStdio() {
+        return false;
+    }
+}
+exports.default = SlackReporter;

package/dist/src/SlackWebhookClient.d.ts

@@ -0,0 +1,15 @@
+import { IncomingWebhook } from '@slack/webhook';
+import { SummaryResults } from '.';
+export default class SlackWebhookClient {
+    private webhook;
+    constructor(webhook: IncomingWebhook);
+    sendMessage({ customLayout, customLayoutAsync, maxNumberOfFailures, summaryResults, disableUnfurl, }: {
+        customLayout: Function | undefined;
+        customLayoutAsync: Function | undefined;
+        maxNumberOfFailures: number;
+        summaryResults: SummaryResults;
+        disableUnfurl: boolean;
+    }): Promise<{
+        outcome: string;
+    }>;
+}

package/dist/src/SlackWebhookClient.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LayoutGenerator_1 = require("./LayoutGenerator");
+class SlackWebhookClient {
+    webhook;
+    constructor(webhook) {
+        this.webhook = webhook;
+    }
+    async sendMessage({ customLayout, customLayoutAsync, maxNumberOfFailures, summaryResults, disableUnfurl, }) {
+        let blocks;
+        if (customLayout) {
+            blocks = customLayout(summaryResults);
+        }
+        else if (customLayoutAsync) {
+            blocks = await customLayoutAsync(summaryResults);
+        }
+        else {
+            blocks = await (0, LayoutGenerator_1.generateBlocks)(summaryResults, maxNumberOfFailures);
+        }
+        let result;
+        try {
+            result = await this.webhook.send({
+                blocks,
+                unfurl_links: !disableUnfurl,
+            });
+        }
+        catch (error) {
+            return {
+                outcome: `error: ${JSON.stringify(error, null, 2)}`,
+            };
+        }
+        if (result && result.text === 'ok') {
+            return {
+                outcome: result.text,
+            };
+        }
+        return {
+            outcome: '😵 Failed to send webhook message, ensure your webhook url is valid',
+        };
+    }
+}
+exports.default = SlackWebhookClient;

package/dist/src/custom_block/my_block.d.ts

@@ -0,0 +1,4 @@
+import { Block, KnownBlock } from '@slack/types';
+import { SummaryResults } from '..';
+declare const generateCustomLayout: (summaryResults: SummaryResults) => Array<KnownBlock | Block>;
+export default generateCustomLayout;