hubot 5.0.4 → 5.0.6

package/test/es2015_test.js

@@ -1,199 +0,0 @@
-'use strict'
-
-/* global describe, it */
-/* eslint-disable no-unused-expressions */
-
-// Assertions and Stubbing
-const chai = require('chai')
-const sinon = require('sinon')
-chai.use(require('sinon-chai'))
-const mockery = require('mockery')
-
-const expect = chai.expect
-
-// Hubot classes
-const Hubot = require('../es2015')
-const User = Hubot.User
-const Brain = Hubot.Brain
-const Robot = Hubot.Robot
-const Adapter = Hubot.Adapter
-const Response = Hubot.Response
-const Listener = Hubot.Listener
-const TextListener = Hubot.TextListener
-const Message = Hubot.Message
-const TextMessage = Hubot.TextMessage
-const EnterMessage = Hubot.EnterMessage
-const LeaveMessage = Hubot.LeaveMessage
-const TopicMessage = Hubot.TopicMessage
-const CatchAllMessage = Hubot.CatchAllMessage
-const loadBot = Hubot.loadBot
-
-describe('hubot/es2015', function () {
-  it('exports User class', function () {
-    class MyUser extends User {}
-    const user = new MyUser('id123', { foo: 'bar' })
-
-    expect(user).to.be.an.instanceof(User)
-    expect(user.id).to.equal('id123')
-    expect(user.foo).to.equal('bar')
-  })
-
-  it('exports Brain class', function () {
-    class MyBrain extends Brain {}
-    const robotMock = {
-      on: sinon.spy()
-    }
-    const brain = new MyBrain(robotMock)
-
-    expect(brain).to.be.an.instanceof(Brain)
-    expect(robotMock.on).to.have.been.called
-
-    brain.set('foo', 'bar')
-    expect(brain.get('foo')).to.equal('bar')
-  })
-
-  it('exports Robot class', async function () {
-    mockery.enable({
-      warnOnReplace: false,
-      warnOnUnregistered: false
-    })
-    mockery.registerMock('hubot-mock-adapter', require('./fixtures/mock-adapter.js'))
-
-    class MyRobot extends Robot {}
-    const robot = new MyRobot('mock-adapter', false, 'TestHubot')
-    await robot.loadAdapter()
-    expect(robot).to.be.an.instanceof(Robot)
-    expect(robot.name).to.equal('TestHubot')
-
-    mockery.disable()
-  })
-
-  it('exports Adapter class', function () {
-    class MyAdapter extends Adapter {}
-    const adapter = new MyAdapter('myrobot')
-
-    expect(adapter).to.be.an.instanceof(Adapter)
-    expect(adapter.robot).to.equal('myrobot')
-  })
-
-  it('exports Response class', function () {
-    class MyResponse extends Response {}
-    const robotMock = 'robotMock'
-    const messageMock = {
-      room: 'room',
-      user: 'user'
-    }
-    const matchMock = 'matchMock'
-    const response = new MyResponse(robotMock, messageMock, matchMock)
-
-    expect(response).to.be.an.instanceof(Response)
-    expect(response.message).to.equal(messageMock)
-    expect(response.match).to.equal(matchMock)
-  })
-
-  it('exports Listener class', function () {
-    class MyListener extends Listener {}
-    const robotMock = 'robotMock'
-    const matcherMock = 'matchMock'
-    const callback = sinon.spy()
-    const listener = new MyListener(robotMock, matcherMock, callback)
-
-    expect(listener).to.be.an.instanceof(Listener)
-    expect(listener.robot).to.equal(robotMock)
-    expect(listener.matcher).to.equal(matcherMock)
-    expect(listener.options).to.deep.include({
-      id: null
-    })
-    expect(listener.callback).to.equal(callback)
-  })
-
-  it('exports TextListener class', function () {
-    class MyTextListener extends TextListener {}
-    const robotMock = 'robotMock'
-    const regex = /regex/
-    const callback = sinon.spy()
-    const textListener = new MyTextListener(robotMock, regex, callback)
-
-    expect(textListener).to.be.an.instanceof(TextListener)
-    expect(textListener.regex).to.equal(regex)
-  })
-
-  it('exports Message class', function () {
-    class MyMessage extends Message {}
-    const userMock = {
-      room: 'room'
-    }
-    const message = new MyMessage(userMock)
-
-    expect(message).to.be.an.instanceof(Message)
-    expect(message.user).to.equal(userMock)
-  })
-
-  it('exports TextMessage class', function () {
-    class MyTextMessage extends TextMessage {}
-    const userMock = {
-      room: 'room'
-    }
-    const textMessage = new MyTextMessage(userMock, 'bla blah')
-
-    expect(textMessage).to.be.an.instanceof(TextMessage)
-    expect(textMessage).to.be.an.instanceof(Message)
-    expect(textMessage.text).to.equal('bla blah')
-  })
-
-  it('exports EnterMessage class', function () {
-    class MyEnterMessage extends EnterMessage {}
-    const userMock = {
-      room: 'room'
-    }
-    const enterMessage = new MyEnterMessage(userMock)
-
-    expect(enterMessage).to.be.an.instanceof(EnterMessage)
-    expect(enterMessage).to.be.an.instanceof(Message)
-  })
-
-  it('exports LeaveMessage class', function () {
-    class MyLeaveMessage extends LeaveMessage {}
-    const userMock = {
-      room: 'room'
-    }
-    const leaveMessage = new MyLeaveMessage(userMock)
-
-    expect(leaveMessage).to.be.an.instanceof(LeaveMessage)
-    expect(leaveMessage).to.be.an.instanceof(Message)
-  })
-
-  it('exports TopicMessage class', function () {
-    class MyTopicMessage extends TopicMessage {}
-    const userMock = {
-      room: 'room'
-    }
-    const topicMessage = new MyTopicMessage(userMock)
-
-    expect(topicMessage).to.be.an.instanceof(TopicMessage)
-    expect(topicMessage).to.be.an.instanceof(Message)
-  })
-
-  it('exports CatchAllMessage class', function () {
-    class MyCatchAllMessage extends CatchAllMessage {}
-    const messageMock = {
-      user: {
-        room: 'room'
-      }
-    }
-    const catchAllMessage = new MyCatchAllMessage(messageMock)
-
-    expect(catchAllMessage).to.be.an.instanceof(CatchAllMessage)
-    expect(catchAllMessage).to.be.an.instanceof(Message)
-    expect(catchAllMessage.message).to.equal(messageMock)
-    expect(catchAllMessage.user).to.equal(messageMock.user)
-  })
-
-  it('exports loadBot function', function () {
-    sinon.stub(Hubot, 'Robot')
-
-    expect(loadBot).to.be.a('function')
-    Hubot.loadBot(null, 'adapter', 'enableHttpd', 'botName', 'botAlias')
-    expect(Hubot.Robot).to.be.called.calledWith(null, 'adapter', 'enableHttpd', 'botName', 'botAlias')
-  })
-})

package/test/fixtures/MockAdapter.coffee

@@ -1,10 +0,0 @@
-{ Adapter } = require "../../index.js"
-class MockAdapter extends Adapter
-    constructor: (robot, @options) ->
-        super robot
-        @name = "MockAdapter"
-    run: ->
-        @emit "connected"
-
-module.exports.use = (robot) ->
-    new MockAdapter robot

package/test/fixtures/MockAdapter.mjs

@@ -1,43 +0,0 @@
-'use strict'
-
-import { Adapter } from '../../es2015.js' // eslint-disable-line import/no-unresolved
-
-class MockAdapter extends Adapter {
-  constructor (robot) {
-    super(robot)
-    this.name = 'MockAdapter'
-  }
-
-  send (envelope, ...strings) {
-    this.emit('send', envelope, strings)
-  }
-
-  reply (envelope, ...strings) {
-    this.emit('reply', envelope, strings)
-  }
-
-  topic (envelope, ...strings) {
-    this.emit('topic', envelope, strings)
-  }
-
-  play (envelope, ...strings) {
-    this.emit('play', envelope, strings)
-  }
-
-  run () {
-    // This is required to get the scripts loaded
-    this.emit('connected')
-  }
-
-  close () {
-    this.emit('closed')
-  }
-}
-export {
-  MockAdapter
-}
-export default {
-  use (robot) {
-    return new MockAdapter(robot)
-  }
-}

package/test/fixtures/TestScript.coffee

@@ -1,9 +0,0 @@
-# Description: A test script for the robot to load
-#
-# Commands:
-#   hubot test - Responds with a test response
-#
-
-module.exports = (robot) ->
-  robot.respond 'test', (res) ->
-    res.send 'test response from coffeescript'

package/test/fixtures/TestScript.js

@@ -1,13 +0,0 @@
-'use strict'
-
-// Description: A test script for the robot to load
-//
-// Commands:
-//   hubot test - Responds with a test response
-//
-
-module.exports = robot => {
-  robot.respond('test', res => {
-    res.send('test response')
-  })
-}

package/test/fixtures/mock-adapter.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const Adapter = require('../..').Adapter
-
-class MockAdapter extends Adapter {
-  send (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    this.emit('send', envelope, strings)
-  }
-
-  reply (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    this.emit('reply', envelope, strings)
-  }
-
-  topic (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    this.emit('topic', envelope, strings)
-  }
-
-  play (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    this.emit('play', envelope, strings)
-  }
-
-  run () {
-    this.emit('connected')
-  }
-
-  close () {
-    this.emit('closed')
-  }
-}
-
-module.exports.use = robot => new MockAdapter(robot)

package/test/listener_test.js

@@ -1,379 +0,0 @@
-'use strict'
-
-/* global describe, beforeEach, it */
-/* eslint-disable no-unused-expressions */
-
-// Assertions and Stubbing
-const chai = require('chai')
-const sinon = require('sinon')
-chai.use(require('sinon-chai'))
-
-const expect = chai.expect
-
-// Hubot classes
-const EnterMessage = require('../src/message').EnterMessage
-const TextMessage = require('../src/message').TextMessage
-const Listener = require('../src/listener').Listener
-const TextListener = require('../src/listener').TextListener
-const Response = require('../src/response')
-const User = require('../src/user')
-
-describe('Listener', function () {
-  beforeEach(function () {
-    // Dummy robot
-    this.robot = {
-      // Re-throw AssertionErrors for clearer test failures
-      emit (name, err, response) {
-        if (err.constructor.name === 'AssertionError') {
-          return process.nextTick(function () {
-            throw err
-          })
-        }
-      },
-      // Ignore log messages
-      logger: {
-        debug () {}
-      },
-      // Why is this part of the Robot object??
-      Response
-    }
-
-    // Test user
-    this.user = new User({
-      id: 1,
-      name: 'hubottester',
-      room: '#mocha'
-    })
-  })
-
-  describe('Unit Tests', function () {
-    describe('#call', function () {
-      it('calls the matcher', function (done) {
-        const callback = sinon.spy()
-        const testMatcher = sinon.spy()
-        const testMessage = {}
-
-        const testListener = new Listener(this.robot, testMatcher, callback)
-        testListener.call(testMessage, function (_) {
-          expect(testMatcher).to.have.been.calledWith(testMessage)
-          done()
-        })
-      })
-
-      it('passes the matcher result on to the listener callback', function (done) {
-        const matcherResult = {}
-        const testMatcher = sinon.stub().returns(matcherResult)
-        const testMessage = {}
-        const listenerCallback = response => expect(response.match).to.be.equal(matcherResult)
-
-        // sanity check; matcherResult must be truthy
-        expect(matcherResult).to.be.ok
-
-        const testListener = new Listener(this.robot, testMatcher, listenerCallback)
-        testListener.call(testMessage, function (result) {
-          // sanity check; message should have been processed
-          expect(testMatcher).to.have.been.called
-          expect(result).to.be.ok
-
-          done()
-        })
-      })
-
-      describe('if the matcher returns true', function () {
-        beforeEach(function () {
-          this.createListener = function (cb) {
-            return new Listener(this.robot, sinon.stub().returns(true), cb)
-          }
-        })
-
-        it('executes the listener callback', function (done) {
-          const listenerCallback = sinon.spy()
-          const testMessage = {}
-
-          const testListener = this.createListener(listenerCallback)
-          testListener.call(testMessage, function (_) {
-            expect(listenerCallback).to.have.been.called
-            done()
-          })
-        })
-
-        it('returns true', function () {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          const result = testListener.call(testMessage)
-          expect(result).to.be.ok
-        })
-
-        it('calls the provided callback with true', function (done) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          testListener.call(testMessage, function (result) {
-            expect(result).to.be.ok
-            done()
-          })
-        })
-
-        it('calls the provided callback after the function returns', function (done) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          let finished = false
-          testListener.call(testMessage, function (result) {
-            expect(finished).to.be.ok
-            done()
-          })
-          finished = true
-        })
-
-        it('handles uncaught errors from the listener callback', function (done) {
-          const testMessage = {}
-          const theError = new Error()
-
-          const listenerCallback = function (response) {
-            throw theError
-          }
-
-          this.robot.emit = function (name, err, response) {
-            expect(name).to.equal('error')
-            expect(err).to.equal(theError)
-            expect(response.message).to.equal(testMessage)
-            done()
-          }
-
-          const testListener = this.createListener(listenerCallback)
-          testListener.call(testMessage, sinon.spy())
-        })
-
-        it('calls the provided callback with true if there is an error thrown by the listener callback', function (done) {
-          const testMessage = {}
-          const theError = new Error()
-
-          const listenerCallback = function (response) {
-            throw theError
-          }
-
-          const testListener = this.createListener(listenerCallback)
-          testListener.call(testMessage, function (result) {
-            expect(result).to.be.ok
-            done()
-          })
-        })
-
-        it('calls the listener callback with a Response that wraps the Message', function (done) {
-          const testMessage = {}
-
-          const listenerCallback = function (response) {
-            expect(response.message).to.equal(testMessage)
-            done()
-          }
-
-          const testListener = this.createListener(listenerCallback)
-
-          testListener.call(testMessage, sinon.spy())
-        })
-
-        it('passes through the provided middleware stack', function (testDone) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          const testMiddleware = {
-            execute (context, next, done) {
-              expect(context.listener).to.be.equal(testListener)
-              expect(context.response).to.be.instanceof(Response)
-              expect(context.response.message).to.be.equal(testMessage)
-              expect(next).to.be.a('function')
-              expect(done).to.be.a('function')
-              testDone()
-            }
-          }
-
-          testListener.call(testMessage, testMiddleware, sinon.spy())
-        })
-
-        it('executes the listener callback if middleware succeeds', function (testDone) {
-          const listenerCallback = sinon.spy()
-          const testMessage = {}
-
-          const testListener = this.createListener(listenerCallback)
-
-          testListener.call(testMessage, function (result) {
-            expect(listenerCallback).to.have.been.called
-            // Matcher matched, so we true
-            expect(result).to.be.ok
-            testDone()
-          })
-        })
-
-        it('does not execute the listener callback if middleware fails', function (testDone) {
-          const listenerCallback = sinon.spy()
-          const testMessage = {}
-
-          const testListener = this.createListener(listenerCallback)
-          const testMiddleware = {
-            execute (context, next, done) {
-              // Middleware fails
-              done()
-            }
-          }
-
-          testListener.call(testMessage, testMiddleware, function (result) {
-            expect(listenerCallback).to.not.have.been.called
-            // Matcher still matched, so we true
-            expect(result).to.be.ok
-            testDone()
-          })
-        })
-
-        it('unwinds the middleware stack if there is an error in the listener callback', function (testDone) {
-          const listenerCallback = sinon.stub().throws(new Error())
-          const testMessage = {}
-          let extraDoneFunc = null
-
-          const testListener = this.createListener(listenerCallback)
-          const testMiddleware = {
-            execute (context, next, done) {
-              extraDoneFunc = sinon.spy(done)
-              next(context, extraDoneFunc)
-            }
-          }
-
-          testListener.call(testMessage, testMiddleware, function (result) {
-            // Listener callback was called (and failed)
-            expect(listenerCallback).to.have.been.called
-            // Middleware stack was unwound correctly
-            expect(extraDoneFunc).to.have.been.called
-            // Matcher still matched, so we true
-            expect(result).to.be.ok
-            testDone()
-          })
-        })
-      })
-
-      describe('if the matcher returns false', function () {
-        beforeEach(function () {
-          this.createListener = function (cb) {
-            return new Listener(this.robot, sinon.stub().returns(false), cb)
-          }
-        })
-
-        it('does not execute the listener callback', function (done) {
-          const listenerCallback = sinon.spy()
-          const testMessage = {}
-
-          const testListener = this.createListener(listenerCallback)
-          testListener.call(testMessage, function (_) {
-            expect(listenerCallback).to.not.have.been.called
-            done()
-          })
-        })
-
-        it('returns false', function () {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          const result = testListener.call(testMessage)
-          expect(result).to.not.be.ok
-        })
-
-        it('calls the provided callback with false', function (done) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          testListener.call(testMessage, function (result) {
-            expect(result).to.not.be.ok
-            done()
-          })
-        })
-
-        it('calls the provided callback after the function returns', function (done) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          let finished = false
-          testListener.call(testMessage, function (result) {
-            expect(finished).to.be.ok
-            done()
-          })
-          finished = true
-        })
-
-        it('does not execute any middleware', function (done) {
-          const testMessage = {}
-
-          const testListener = this.createListener(function () {})
-          const testMiddleware = { execute: sinon.spy() }
-
-          testListener.call(testMessage, result => {
-            expect(testMiddleware.execute).to.not.have.been.called
-            done()
-          })
-        })
-      })
-    })
-
-    describe('#constructor', function () {
-      it('requires a matcher', () => expect(function () {
-        return new Listener(this.robot, undefined, {}, sinon.spy())
-      }).to.throw(Error))
-
-      it('requires a callback', function () {
-        // No options
-        expect(function () {
-          return new Listener(this.robot, sinon.spy())
-        }).to.throw(Error)
-        // With options
-        expect(function () {
-          return new Listener(this.robot, sinon.spy(), {})
-        }).to.throw(Error)
-      })
-
-      it('gracefully handles missing options', function () {
-        const testMatcher = sinon.spy()
-        const listenerCallback = sinon.spy()
-        const testListener = new Listener(this.robot, testMatcher, listenerCallback)
-        // slightly brittle because we are testing for the default options Object
-        expect(testListener.options).to.deep.equal({ id: null })
-        expect(testListener.callback).to.be.equal(listenerCallback)
-      })
-
-      it('gracefully handles a missing ID (set to null)', function () {
-        const testMatcher = sinon.spy()
-        const listenerCallback = sinon.spy()
-        const testListener = new Listener(this.robot, testMatcher, {}, listenerCallback)
-        expect(testListener.options.id).to.be.null
-      })
-    })
-
-    describe('TextListener', () =>
-      describe('#matcher', function () {
-        it('matches TextMessages', function () {
-          const callback = sinon.spy()
-          const testMessage = new TextMessage(this.user, 'test')
-          testMessage.match = sinon.stub().returns(true)
-          const testRegex = /test/
-
-          const testListener = new TextListener(this.robot, testRegex, callback)
-          const result = testListener.matcher(testMessage)
-
-          expect(result).to.be.ok
-          expect(testMessage.match).to.have.been.calledWith(testRegex)
-        })
-
-        it('does not match EnterMessages', function () {
-          const callback = sinon.spy()
-          const testMessage = new EnterMessage(this.user)
-          testMessage.match = sinon.stub().returns(true)
-          const testRegex = /test/
-
-          const testListener = new TextListener(this.robot, testRegex, callback)
-          const result = testListener.matcher(testMessage)
-
-          expect(result).to.not.be.ok
-          expect(testMessage.match).to.not.have.been.called
-        })
-      })
-    )
-  })
-})