playwright-slack-report 1.1.4 → 1.1.16

package/README.md

@@ -129,7 +129,8 @@ An example advanced configuration is shown below:
         ],
         slackOAuthToken: 'YOUR_SLACK_OAUTH_TOKEN',
         slackLogLevel: LogLevel.DEBUG,
-        enableUnfurl: false,
+        disableUnfurl: true,
+        showInThread: true,
       },
 
     ],
@@ -154,10 +155,15 @@ Limits the number of failures shown in the Slack message, defaults to 10.
 Instead of providing an environment variable `SLACK_BOT_USER_OAUTH_TOKEN` you can specify the token in the config in the `slackOAuthToken` field.
 ### **slackLogLevel** (default LogLevel.DEBUG)
 This option allows you to control slack client severity levels for log entries. It accepts a value from @slack/web-api `LogLevel` enum
-### **enableUnfurl** (default: true)
+### **disableUnfurl** (default: true)
 Enable or disable unfurling of links in Slack messages.
+### **showInThread** (default: false)
+Instructs the reporter to show the failure details in a thread instead of the main channel.
 
+![Show failures in threads](./assets/threads.png)
 
+### **meta** (default: empty array)
+The meta data to be sent to Slack.  This is useful for providing additional context to your test run.
 
 **Examples:**
 ```typescript

package/dist/src/LayoutGenerator.d.ts

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

package/dist/src/LayoutGenerator.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFailures = exports.generateBlocks = void 0;
 const generateBlocks = async (summaryResults, maxNumberOfFailures) => {
     const maxNumberOfFailureLength = 650;
     const fails = [];
@@ -66,4 +67,41 @@ const generateBlocks = async (summaryResults, maxNumberOfFailures) => {
         ...fails,
     ];
 };
-exports.default = generateBlocks;
+exports.generateBlocks = generateBlocks;
+const generateFailures = async (summaryResults, maxNumberOfFailures) => {
+    const maxNumberOfFailureLength = 650;
+    const fails = [];
+    for (let i = 0; i < summaryResults.failures.length; i += 1) {
+        const { failureReason, test } = summaryResults.failures[i];
+        const formattedFailure = failureReason
+            .substring(0, maxNumberOfFailureLength)
+            .split('\n')
+            .map((l) => `>${l}`)
+            .join('\n');
+        fails.push({
+            type: 'section',
+            text: {
+                type: 'mrkdwn',
+                text: `*${test}*
+        \n${formattedFailure}`,
+            },
+        });
+        if (i > maxNumberOfFailures) {
+            fails.push({
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `*There are too many failures to display - ${fails.length} out of ${summaryResults.failures.length} failures shown*`,
+                },
+            });
+            break;
+        }
+    }
+    return [
+        {
+            type: 'divider',
+        },
+        ...fails,
+    ];
+};
+exports.generateFailures = generateFailures;

package/dist/src/SlackClient.d.ts

@@ -16,12 +16,22 @@ export default class SlackClient {
             maxNumberOfFailures: number;
             slackOAuthToken?: string;
             slackLogLevel?: LogLevel;
-            unfurlEnable?: boolean;
+            disableUnfurl?: boolean;
             summaryResults: SummaryResults;
+            showInThread: boolean;
         };
     }): Promise<Array<{
         channel: string;
         outcome: string;
+        ts: string;
     }>>;
-    doPostRequest(channel: string, blocks: Array<KnownBlock | Block>, unfurl: boolean): Promise<ChatPostMessageResponse>;
+    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

@@ -14,14 +14,19 @@ class SlackClient {
         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.default)(options.summaryResults, options.maxNumberOfFailures);
+            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.unfurlEnable;
+        const unfurl = !options.disableUnfurl;
         for (const channel of options.channelIds) {
             let chatResponse;
             try {
@@ -31,15 +36,22 @@ class SlackClient {
                 }
                 else {
                     // send request for reals
-                    chatResponse = await this.doPostRequest(channel, blocks, unfurl);
+                    chatResponse = await SlackClient.doPostRequest(this.slackWebClient, channel, blocks, unfurl);
                 }
                 if (chatResponse.ok) {
-                    result.push({ channel, outcome: `✅ Message sent to ${channel}` });
+                    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)}` });
+                    result.push({
+                        channel,
+                        outcome: `❌ Message not sent to ${channel} \r\n ${JSON.stringify(chatResponse, null, 2)}`,
+                    });
                 }
             }
             catch (error) {
@@ -51,12 +63,37 @@ class SlackClient {
         }
         return result;
     }
-    async doPostRequest(channel, blocks, unfurl) {
-        const chatResponse = await this.slackWebClient.chat.postMessage({
+    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;
     }

package/dist/src/SlackReporter.d.ts

@@ -3,13 +3,14 @@ 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 enableUnfurl;
+    private disableUnfurl;
     private suite;
     logs: string[];
     onBegin(fullConfig: FullConfig, suite: Suite): void;

package/dist/src/SlackReporter.js

@@ -7,13 +7,14 @@ class SlackReporter {
     customLayout;
     customLayoutAsync;
     maxNumberOfFailuresToShow;
+    showInThread;
     meta = [];
     resultsParser;
     sendResults = 'on-failure';
     slackChannels = [];
     slackLogLevel;
     slackOAuthToken;
-    enableUnfurl;
+    disableUnfurl;
     suite;
     logs = [];
     onBegin(fullConfig, suite) {
@@ -28,7 +29,8 @@ class SlackReporter {
             this.slackChannels = slackReporterConfig.channels;
             this.maxNumberOfFailuresToShow = slackReporterConfig.maxNumberOfFailuresToShow || 10;
             this.slackOAuthToken = slackReporterConfig.slackOAuthToken || undefined;
-            this.enableUnfurl = slackReporterConfig.enableUnfurl || true;
+            this.disableUnfurl = slackReporterConfig.disableUnfurl || false;
+            this.showInThread = slackReporterConfig.showInThread || false;
         }
         this.resultsParser = new ResultsParser_1.default();
     }
@@ -46,7 +48,8 @@ class SlackReporter {
         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) {
+            && resultSummary.tests.filter((z) => (z.status === 'failed' || z.status === 'timedOut')
+                && z.retry === maxRetry).length === 0) {
             this.log('⏩ Slack reporter - no failures found');
             return;
         }
@@ -59,12 +62,21 @@ class SlackReporter {
                 customLayout: this.customLayout,
                 customLayoutAsync: this.customLayoutAsync,
                 maxNumberOfFailures: this.maxNumberOfFailuresToShow,
-                unfurlEnable: this.enableUnfurl,
+                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) {
+            await slackClient.attachDetailsToThread({
+                channelIds: this.slackChannels,
+                ts: result[0].ts,
+                summaryResults: resultSummary,
+                maxNumberOfFailures: this.maxNumberOfFailuresToShow,
+            });
+        }
     }
     preChecks() {
         if (this.sendResults === 'off') {

package/package.json

@@ -28,7 +28,7 @@
     "lint":"npx eslint . --ext .ts"
   },
   "name": "playwright-slack-report",
-  "version": "1.1.4",
+  "version": "1.1.16",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "repository": "git@github.com:ryanrosello-og/playwright-slack-report.git",