hubot 11.0.3 → 11.1.1

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2023 GitHub Inc.
+Copyright (c) 2011-2024 GitHub Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hubot",
-  "version": "11.0.3",
+  "version": "11.1.1",
   "author": "hubot",
   "keywords": [
     "github",

package/src/GenHubot.mjs

@@ -26,7 +26,7 @@ function runCommands (hubotDirectory, options) {
   }
   output = spawnSync('npm', ['i', 'hubot-help@latest', 'hubot-rules@latest', 'hubot-diagnostics@latest'].concat([options.adapter]).filter(Boolean))
   console.log('npm i', output.stderr.toString(), output.stdout.toString())
-  spawnSync('mkdir', ['scripts'])
+  spawnSync('mkdir', ['scripts', 'tests', 'tests/doubles'])
   spawnSync('touch', ['external-scripts.json'])
 
   const externalScriptsPath = path.resolve('./', 'external-scripts.json')
@@ -39,7 +39,7 @@ function runCommands (hubotDirectory, options) {
 
   File.writeFileSync(externalScriptsPath, JSON.stringify(externalScripts, null, 2))
 
-  File.writeFileSync('./scripts/example.mjs', `// Description:
+  File.writeFileSync('./scripts/Xample.mjs', `// Description:
 //   Test script
 //
 // Commands:
@@ -50,16 +50,129 @@ function runCommands (hubotDirectory, options) {
 //
 
 export default (robot) => {
-  robot.respond(/helo/, async res => {
+  robot.respond(/helo$/, async res => {
+    await res.reply("HELO World! I'm Dumbotheelephant.")
+  })
+  robot.respond(/helo room/, async res => {
     await res.send('Hello World!')
   })
+  robot.router.get('/helo', async (req, res) => {
+    res.send("HELO World! I'm Dumbotheelephant.")
+  })
 }`)
 
+  File.writeFileSync('./tests/doubles/DummyAdapter.mjs', `
+  'use strict'
+  import { Adapter, TextMessage } from 'hubot'
+  
+  export class DummyAdapter extends Adapter {
+    constructor (robot) {
+      super(robot)
+      this.name = 'DummyAdapter'
+      this.messages = new Set()
+    }
+  
+    async send (envelope, ...strings) {
+      this.emit('send', envelope, ...strings)
+      this.robot.emit('send', envelope, ...strings)
+    }
+  
+    async reply (envelope, ...strings) {
+      this.emit('reply', envelope, ...strings)
+      this.robot.emit('reply', envelope, ...strings)
+    }
+  
+    async topic (envelope, ...strings) {
+      this.emit('topic', envelope, ...strings)
+      this.robot.emit('topic', envelope, ...strings)
+    }
+  
+    async play (envelope, ...strings) {
+      this.emit('play', envelope, ...strings)
+      this.robot.emit('play', envelope, ...strings)
+    }
+  
+    run () {
+      // This is required to get the scripts loaded
+      this.emit('connected')
+    }
+  
+    close () {
+      this.emit('closed')
+    }
+  
+    async say (user, message, room) {
+      this.messages.add(message)
+      user.room = room
+      await this.robot.receive(new TextMessage(user, message))
+    }
+  }
+  export default {
+    use (robot) {
+      return new DummyAdapter(robot)
+    }
+  }
+`)
+  File.writeFileSync('./tests/XampleTest.mjs', `
+  import { describe, it, beforeEach, afterEach } from 'node:test'
+  import assert from 'node:assert/strict'
+  
+  import { Robot } from 'hubot'
+  
+  // You need a dummy adapter to test scripts
+  import dummyRobot from './doubles/DummyAdapter.mjs'
+  
+  // Mocks Aren't Stubs
+  // https://www.martinfowler.com/articles/mocksArentStubs.html
+  
+  describe('Xample testing Hubot scripts', () => {
+    let robot = null
+    beforeEach(async () => {
+      robot = new Robot(dummyRobot, true, 'Dumbotheelephant')
+      await robot.loadAdapter()
+      await robot.run()
+      await robot.loadFile('./scripts', 'Xample.mjs')
+    })
+    afterEach(() => {
+      robot.shutdown()
+    })
+    it('should handle /helo request', async () => {
+      const expected = "HELO World! I'm Dumbotheelephant."
+      const url = 'http://localhost:' + robot.server.address().port + '/helo'
+      const response = await fetch(url)
+      const actual = await response.text()
+      assert.strictEqual(actual, expected)
+      })
+    it('should reply with expected message', async () => {
+      const expected = "HELO World! I'm Dumbotheelephant."
+      const user = robot.brain.userForId('test-user', { name: 'test user' })
+      let actual = ''
+      robot.on('reply', (envelope, ...strings) => {
+        actual = strings.join('')
+      })
+      await robot.adapter.say(user, '@Dumbotheelephant helo', 'test-room')
+      assert.strictEqual(actual, expected)
+    })
+  
+    it('should send message to the #general room', async () => {
+      const expected = 'general'
+      const user = robot.brain.userForId('test-user', { name: 'test user' })
+      let actual = ''
+      robot.on('send', (envelope, ...strings) => {
+        actual = envelope.room
+      })
+      await robot.adapter.say(user, '@Dumbotheelephant helo room', 'general')
+      assert.strictEqual(actual, expected)
+    })
+  })  
+`)
+
   const packageJsonPath = path.resolve(process.cwd(), 'package.json')
   const packageJson = JSON.parse(File.readFileSync(packageJsonPath, 'utf8'))
 
   packageJson.scripts = {
-    start: 'hubot'
+    start: 'hubot',
+    test: 'node --test'
   }
   packageJson.description = 'A simple helpful robot for your Company'
   if (options.adapter) {

package/src/Robot.mjs

@@ -470,12 +470,12 @@ class Robot {
   // returns nothing
   setupNullRouter () {
     const msg = 'A script has tried registering a HTTP route while the HTTP server is disabled with --disabled-httpd.'
-
+    const self = this
     this.router = {
-      get: () => this.logger.warning(msg),
-      post: () => this.logger.warning(msg),
-      put: () => this.logger.warning(msg),
-      delete: () => this.logger.warning(msg)
+      get: () => self.logger.info(msg),
+      post: () => self.logger.info(msg),
+      put: () => self.logger.info(msg),
+      delete: () => self.logger.info(msg)
     }
   }