Merge pull request #2 from hubot-friends/server-commands

feat: Servers can have scripts and handle messages itself

Author: joeyguerra

DiscoveryService.mjs

@@ -499,21 +499,13 @@ export class DiscoveryService {
       })
 
       this.robot.receiveMiddleware(async context => {
-        if (!Array.from([/help/
-          , /test\s+routing/
-          , /discover\s+services/i
-          , /discovery\s+status/i
-          , /(?:load.?balancer|lb)\s+reset/
-          , /(?:load.?balancer|lb)\s+strategy\s+(\w+)/
-          , /(?:load.?balancer|lb)\s+status/i
-        ]).some(matcher => {
-          return matcher.test(context.response.message.text)
+        if (!this.robot.listeners.some(listener => {
+          return listener instanceof TextListener && listener.test(context.response.message)
         })) {
           this.robot.logger.debug('Routing message')
           const result = await this.routeMessage(context.response.message)
           return false
         }
-
         return true
       })
 

test/DiscoveryServiceMiddleware.mjs

@@ -0,0 +1,104 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert'
+import { EventEmitter } from 'events'
+import { existsSync, rmSync, mkdirSync } from 'fs'
+import { join } from 'path'
+import DiscoveryServiceScript from '../DiscoveryService.mjs'
+import { TextMessage, TextListener, Robot, Adapter, Middleware} from 'hubot'
+
+
+class MockAdapter extends Adapter {
+  constructor (robot) {
+    super(robot)
+    this.name = 'MockAdapter'
+  }
+
+  async send (envelope, ...strings) {
+    this.emit('send', envelope, ...strings)
+  }
+
+  async reply (envelope, ...strings) {
+    this.emit('reply', envelope, ...strings)
+  }
+
+  async topic (envelope, ...strings) {
+    this.emit('topic', envelope, ...strings)
+  }
+
+  async play (envelope, ...strings) {
+    this.emit('play', envelope, ...strings)
+  }
+
+  run () {
+    // This is required to get the scripts loaded
+    this.emit('connected')
+  }
+
+  close () {
+    this.emit('closed')
+  }
+}
+
+describe('Incoming Message Handling as Server', () => {
+  let robot
+  let testDir
+  let originalEnv
+
+  beforeEach(async () => {
+    // Save original environment
+    originalEnv = { ...process.env }
+    
+    // Setup test environment with more unique directory naming
+    const timestamp = Date.now()
+    const random = Math.floor(Math.random() * 10000)
+    testDir = join(process.cwd(), 'test-data', `message-test-${timestamp}-${random}`)
+    mkdirSync(testDir, { recursive: true })
+    
+    process.env.HUBOT_DISCOVERY_STORAGE = testDir
+    process.env.HUBOT_DISCOVERY_PORT = '0' // Use random port
+    process.env.HUBOT_INSTANCE_ID = 'test-instance'
+    process.env.HUBOT_HOST = 'localhost'
+    process.env.HUBOT_PORT = '8080'
+    process.env.NODE_ENV = 'test'
+    
+    robot = new Robot({
+        async use(robot) {
+            return new MockAdapter(robot)
+        }
+    }, false, 'MockityMcMockFace')
+    await robot.loadAdapter()
+    await robot.run()
+  })
+
+  afterEach(async () => {
+    // Restore environment
+    process.env = originalEnv
+    
+    // Cleanup service discovery
+    if (robot.discoveryService) {
+      await robot.discoveryService.stop()
+    }
+    
+    // Cleanup test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+
+    robot.shutdown()
+  })
+
+  test('Server can handle messages and not route them to the workers', async () => {
+    await DiscoveryServiceScript(robot)
+    let wasRouted = false
+    robot.discoveryService.routeMessage = async (message) => {
+      wasRouted = true
+    }
+    robot.respond(/handled by server/, async res => {
+      await res.reply('This message was handled by the server')
+      assert.ok(!wasRouted)
+    })
+    const testMessage = new TextMessage({ user: { id: 'U123', name: 'tester', room: 'general' } }, '@MockityMcMockFace handled by server', Date.now())
+    await robot.receive(testMessage)
+    assert.ok(!wasRouted)
+  })
+})

test/DiscoveryServiceScript.test.mjs

@@ -4,6 +4,7 @@ import { EventEmitter } from 'events'
 import { existsSync, rmSync, mkdirSync } from 'fs'
 import { join } from 'path'
 import DiscoveryServiceScript from '../DiscoveryService.mjs'
+import { TextListener } from 'hubot'
 
 // Mock robot for testing
 class MockRobot extends EventEmitter {
@@ -23,21 +24,19 @@ class MockRobot extends EventEmitter {
       connectToPeer: mock.fn(),
       getPeerCount: mock.fn(() => 0)
     }
-    this.commands = []
+    this.listeners = []
   }
 
   parseHelp(fileName) {
     // Mock help parsing
   }
 
-  respond(pattern, callback) {
+  respond(regex, options, callback) {
     // Mock respond method for command registration
-    this.commands.push({ pattern, callback })
+    this.hear(regex, options, callback)
   }
-
-  hear(pattern, callback) {
-    // Mock hear method for command registration  
-    this.commands.push({ pattern, callback })
+  hear(regex, options, callback) {
+    this.listeners.push(new TextListener(this, regex, options, callback))
   }
 }
 
@@ -109,18 +108,18 @@ describe('DiscoveryService Script', () => {
     await DiscoveryServiceScript(robot)
 
     // Check that commands were registered
-    assert(robot.commands.length > 0, 'Should have registered some commands')
-    
-    // Check for specific command patterns based on current design
-    const patterns = robot.commands.map(cmd => cmd.pattern.toString())
-    assert(patterns.some(p => p.includes('discover')), 'Should register discover command')
-    assert(patterns.some(p => p.includes('status')), 'Should register status command')
-    
+    assert(robot.listeners.length > 0, 'Should have registered some commands')
+
+    // Check for specific command regexes based on current design
+    const regexes = robot.listeners.map(cmd => cmd.regex.toString())
+    assert(regexes.some(r => r.includes('discover')), 'Should register discover command')
+    assert(regexes.some(r => r.includes('status')), 'Should register status command')
+
     // Load balancer commands are always available (DiscoveryService is always a server)
     const DiscoveryService = robot.discoveryService
     if (DiscoveryService.loadBalancer) {
-      assert(patterns.some(p => p.includes('load') || p.includes('lb')), 'Should register load balancer commands')
-      assert(patterns.some(p => p.includes('routing')), 'Should register routing test command')
+      assert(regexes.some(r => r.includes('load') || r.includes('lb')), 'Should register load balancer commands')
+      assert(regexes.some(r => r.includes('routing')), 'Should register routing test command')
     }
   })
 
@@ -293,8 +292,8 @@ describe('DiscoveryService Script', () => {
     // Start as server
 
     // Find the discover command
-    const discoverCommand = robot.commands.find(cmd => 
-      cmd.pattern.toString().includes('discover')
+    const discoverCommand = robot.listeners.find(cmd => 
+      cmd.regex.toString().includes('discover')
     )
     assert(discoverCommand, 'Should have discover command')
 
@@ -315,8 +314,8 @@ describe('DiscoveryService Script', () => {
     // Start as server
 
     // Find the status command
-    const statusCommand = robot.commands.find(cmd => 
-      cmd.pattern.toString().includes('status')
+    const statusCommand = robot.listeners.find(cmd => 
+      cmd.regex.toString().includes('status')
     )
     assert(statusCommand, 'Should have status command')
 
@@ -388,4 +387,4 @@ describe('DiscoveryService Script', () => {
     assert.strictEqual(selfInstance.host, 'localhost')
     assert.strictEqual(selfInstance.port, 8080)
   })
-})
+})