@hubot-friends/hubot-slack 3.1.3 → 3.2.0

package/.github/workflows/ci-build.yml

@@ -16,8 +16,7 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - '20.x'
-          - '22.x'
+          - '23.x'
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -41,8 +40,7 @@ jobs:
     strategy:
       matrix:
         node-version:
-          - '20.x'
-          - '22.x'
+          - '23.x'
     steps:
       - name: Checkout
         uses: actions/checkout@v4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubot-friends/hubot-slack",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "description": "A new Slack adapter for Hubot",
   "homepage": "https://github.com/hubot-friends/hubot-slack#readme",
   "main": "./index.mjs",

package/src/Bot.mjs

@@ -9,10 +9,10 @@ class SlackClient {
     process.env.HUBOT_SLACK_CONVERSATION_CACHE_TTL_MS
     ? parseInt(process.env.HUBOT_SLACK_CONVERSATION_CACHE_TTL_MS, 10)
     : (5 * 60 * 1000);
-  constructor(options, robot) {
+  constructor(options, robot, socket, web) {
     this.robot = robot;
-    this.socket = new SocketModeClient({ appToken: options.appToken, ...options.socketModeOptions });
-    this.web = new WebClient(options.botToken, { maxRequestConcurrency: 1, logLevel: 'error'});
+    this.socket = socket ?? new SocketModeClient({ appToken: options.appToken, ...options.socketModeOptions });
+    this.web = web ?? new WebClient(options.botToken, { maxRequestConcurrency: 1, logLevel: 'error'});
     this.apiPageSize = 100;
     if (!isNaN(options.apiPageSize)) {
       this.apiPageSize = parseInt(options.apiPageSize, 10);
@@ -72,26 +72,24 @@ class SlackClient {
   }
   async send(envelope, message) {
     const room = envelope.room || envelope.id;
+    const thread_ts = envelope.message?.thread_ts
     if (room == null) {
       this.robot.logger.error("Cannot send message without a valid room. Envelopes should contain a room property set to a Slack conversation ID.");
       return;
     }
     this.robot.logger.debug(`SlackClient#send() room: ${room}, message: ${message}`);
-    if (typeof message !== "string") {
-      message.channel = room
-      try {
-        const result = await this.web.chat.postMessage(message)
-        this.robot.logger.debug(`Successfully sent message to ${room}`)
-      } catch (e) {
-        this.robot.logger.error(e, `SlackClient#send(message) error: ${e.message}`)
-      }
-    } else {
-      try {
-        const result = await this.web.chat.postMessage({ channel: room, text: message })
-        this.robot.logger.debug(`Successfully sent message (string) to ${room}`)
-      } catch (e) {
-        this.robot.logger.error(e, `SlackClient#send(string) error: ${e.message}`)
-      }
+    const messageOptions = {
+      channel: room,
+      text: typeof message === "string" ? message : message.text,
+      thread_ts, // Include thread_ts if it's defined
+      ...message, // Spread other properties from the message if it's an object
+    };
+  
+    try {
+      const result = await this.web.chat.postMessage(messageOptions);
+      this.robot.logger.debug(`Successfully sent message to ${room}`);
+    } catch (e) {
+      this.robot.logger.error(e, `SlackClient#send() error: ${e.message}`);
     }
   }
   loadUsers(callback) {
@@ -254,6 +252,7 @@ class SlackBot extends Adapter {
    * @param {...(string|Object)} messages - fully documented in SlackClient
    */
   async send(envelope, ...messages) {
+    
     this.robot.logger.debug('Sending message to Slack');
     let callback = function() {};
     if (typeof(messages[messages.length - 1]) === "function") {

package/test/Bot.mjs

@@ -191,6 +191,44 @@ describe('Send Messages', () => {
     assert.deepEqual(stubs._sendCount, 1)
     assert.deepEqual(stubs._msg, 'message with a callback')
   })
+
+  it('envelope thread_ts should be undefined', () => {
+    slackbot.client.send = (envelope, message) => {
+      stubs._sendCount++;
+      stubs._msg = message;
+      stubs._envelope = envelope;
+    }
+    const fakeEnvelope = {
+      room: stubs.channel.id,
+      user: stubs.user
+    }
+    slackbot.send(fakeEnvelope, 'message');
+    assert.deepEqual(stubs._sendCount, 1);
+    assert.deepEqual(stubs._msg, 'message');
+    assert.strictEqual(stubs._envelope.message, undefined);
+  });
+
+  it('Should send a message with thread_ts when message is included in envelope', () => {
+    slackbot.client.send = (envelope, message) => {
+      stubs._sendCount++;
+      stubs._msg = message;
+      stubs._envelope = envelope;
+    }
+    const fakeEnvelope = {
+      room: stubs.channel.id,
+      user: stubs.user,
+      message: {
+        room: stubs.channel.id,
+        user: stubs.user,
+        thread_ts: '1234567890.123456'
+      }
+    }
+    slackbot.send(fakeEnvelope, 'message');
+    assert.deepEqual(stubs._sendCount, 1);
+    assert.deepEqual(stubs._msg, 'message');
+    assert.strictEqual(stubs._envelope.message.thread_ts, '1234567890.123456');
+  });
+
 })
 
 describe('Reply to Messages', () => {

package/test/Thread_ts_ShouldPassThruTest.mjs

@@ -0,0 +1,100 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { SlackBot, SlackClient } from '../src/Bot.mjs'
+import hubotSlackMock from '../index.mjs'
+import { loadBot, Robot } from 'hubot'
+import { SlackTextMessage, ReactionMessage, FileSharedMessage } from '../src/Message.mjs'
+import EventEmitter from 'node:events'
+
+class SocketModeClientMock extends EventEmitter{
+    constructor() {
+        super()
+    }
+
+    send() {
+        return Promise.resolve()
+    }
+}
+
+class WebClientMock extends EventEmitter{
+    constructor(api) {
+        super()
+        Object.keys(api).forEach((key) => {
+            this[key] = api[key]
+        })
+    }
+}
+
+describe('thread_ts should pass thru', () => {
+    it('Message should include thread_ts if present', async () => {
+        const user = { id
+            : 'U12345678', name: 'testuser' }
+        const text = 'Hello, world!'
+        const rawText = 'Hello, world!'
+        const rawMessage = {
+            type: 'message',
+            user: user.id,
+            text: rawText,
+            ts: '1234567890.123456',
+            thread_ts: '1234567890.123456'
+        }
+        const channel_id = 'C12345678'
+        const robot_name = 'testbot'
+        const robot_alias = 'testbot_alias'
+        const envelope = {
+            user: user,
+            message: rawMessage,
+            room: channel_id
+        }
+        const message = {
+            text: text,
+            user: user.id,
+            room: channel_id,
+            thread_ts: '1234567890.123456'
+        }
+        const msg = new SlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias)
+        const sut = new SlackClient({}, new Robot('TestBot', 'testbot', 'testbot_alias'), new SocketModeClientMock(), new WebClientMock({
+            chat: {
+                postMessage: async (params) => {
+                    assert.strictEqual(params.thread_ts, '1234567890.123456')
+                    return { ok: true, ts: '1234567890.123456' }
+                }
+            }
+        }))
+        await sut.send(envelope, message)
+    })
+
+    it('Message send a text only message', async () => {
+        const user = { id
+            : 'U12345678', name: 'testuser' }
+        const text = 'Hello, world!'
+        const rawText = 'Hello, world!'
+        const rawMessage = {
+            type: 'message',
+            user: user.id,
+            text: rawText,
+            ts: '1234567890.123456',
+            thread_ts: '1234567890.123456'
+        }
+        const channel_id = 'C12345678'
+        const robot_name = 'testbot'
+        const robot_alias = 'testbot_alias'
+        const envelope = {
+            user: user,
+            message: rawMessage,
+            room: channel_id
+        }
+        const message = text
+        const msg = new SlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias)
+        const sut = new SlackClient({}, new Robot('TestBot', 'testbot', 'testbot_alias'), new SocketModeClientMock(), new WebClientMock({
+            chat: {
+                postMessage: async (param) => {
+                    assert.strictEqual(param.text, 'Hello, world!')
+                    return { ok: true, param }
+                }
+            }
+        }))
+        await sut.send(envelope, message)
+    })
+
+})