UNPKG

9.42 kBtext/coffeescriptView Raw
1###################################################################
2# Setup the tests
3###################################################################
4should = require 'should'
5
6# Import our hero. Noop logging so that we don't clutter the test output
7{Slack} = require '../src/slack'
8Slack::log = ->
9Slack::logError = ->
10
11# Stub a few interfaces to grease the skids for tests. These are intentionally
12# as minimal as possible and only provide enough to make the tests possible.
13# Stubs are recreated before each test.
14stubs = null
15beforeEach ->
16 stubs =
17 # Hubot.Robot instance
18 robot:
19 name: 'Kitt'
20
21 # Express request object
22 request: ->
23 data: {}
24 param: (key) ->
25 @data[key]
26
27
28# Generate a new slack instance for each test.
29slack = null
30beforeEach ->
31 slack = new Slack stubs.robot
32
33
34###################################################################
35# Start the tests
36###################################################################
37describe 'Adapter', ->
38 it 'Should initialize with a robot', ->
39 slack.robot.name.should.eql stubs.robot.name
40
41
42describe '(Un)escaping strings', ->
43 # Generate strings with multiple replacement characters
44 makeTestString = (character) ->
45 "Hello #{character} world and #{character} again"
46
47 escapeChars = [
48 {before: '&', after: '&', name: 'ampersands'}
49 {before: '>', after: '>', name: 'greater than signs'}
50 {before: '<', after: '&lt;', name: 'less than signs'}
51 ]
52
53 for character in escapeChars
54 it "Should escape #{character.name}", ->
55 escaped = slack.escapeHtml(makeTestString(character.before))
56 escaped.should.eql makeTestString(character.after)
57
58 it "Should unescape #{character.name}", ->
59 unescaped = slack.unescapeHtml(makeTestString(character.after))
60 unescaped.should.eql makeTestString(character.before)
61
62 it 'Should return an empty string if input is a non-string', ->
63 for input in [undefined, null, false, {}, [], 123]
64 slack.escapeHtml(input).should.eql('')
65 slack.unescapeHtml(input).should.eql('')
66
67
68describe 'Getting the user from params', ->
69 it 'Should support old Hubot syntax', ->
70 # Old syntax does not have a `user` property
71 oldParams =
72 reply_to: 'Your friend'
73
74 slack.userFromParams(oldParams).should.have.property 'reply_to', 'Your friend'
75
76 it 'Should support new Hubot syntax', ->
77 params =
78 user:
79 reply_to: 'Your new friend'
80
81 slack.userFromParams(params).should.have.property 'reply_to', 'Your new friend'
82
83 it 'Should fall back to room value for reply_to', ->
84 roomParams =
85 room: 'The real reply to'
86
87 slack.userFromParams(roomParams).should.have.property 'reply_to', 'The real reply to'
88
89
90describe 'Sending a message', ->
91 it 'Should JSON-ify args', ->
92 # Shim the post() methd to grab its args value
93 slack.post = (path, args) ->
94 (-> JSON.parse args).should.not.throw()
95
96 params =
97 reply_to: 'A fake room'
98
99 args = slack.send params, 'Hello, fake world'
100
101describe 'Parsing options', ->
102 it 'Should default to the name "slackbot"', ->
103 slack.parseOptions()
104
105 slack.options.name.should.equal 'slackbot'
106
107 it 'Should default to the "blacklist" channel mode', ->
108 slack.parseOptions()
109
110 slack.options.mode.should.equal 'blacklist'
111
112 it 'Should default to [] for channel list', ->
113 slack.parseOptions()
114
115 slack.options.channels.should.be.instanceof(Array).and.have.lengthOf(0);
116
117 it 'Should default to null for missing environment variables', ->
118 slack.parseOptions()
119
120 should.not.exist slack.options.token
121 should.not.exist slack.options.team
122
123 it 'Should use BROBBOT_SLACK_TOKEN environment variable', ->
124 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
125 slack.parseOptions()
126
127 slack.options.token.should.eql 'insecure token'
128 delete process.env.BROBBOT_SLACK_TOKEN
129
130 it 'Should use BROBBOT_SLACK_TEAM environment variable', ->
131 process.env.BROBBOT_SLACK_TEAM = 'fake team'
132 slack.parseOptions()
133
134 slack.options.team.should.eql 'fake team'
135 delete process.env.BROBBOT_SLACK_TEAM
136
137 it 'Should use BROBBOT_SLACK_BOTNAME environment variable', ->
138 process.env.BROBBOT_SLACK_BOTNAME = 'Lonely Bot'
139 slack.parseOptions()
140
141 slack.options.name.should.eql 'Lonely Bot'
142 delete process.env.BROBBOT_SLACK_BOTNAME
143
144 it 'Should use BROBBOT_SLACK_CHANNELMODE environment variable', ->
145 process.env.BROBBOT_SLACK_CHANNELMODE = 'a channel mode'
146 slack.parseOptions()
147
148 slack.options.mode.should.eql 'a channel mode'
149 delete process.env.BROBBOT_SLACK_CHANNELMODE
150
151 it 'Should use BROBBOT_SLACK_CHANNELS environment variable', ->
152 process.env.BROBBOT_SLACK_CHANNELS = 'a,list,of,channels'
153 slack.parseOptions()
154
155 slack.options.channels.should.eql ['a', 'list', 'of', 'channels']
156 delete process.env.BROBBOT_SLACK_CHANNELS
157
158describe 'Parsing the request', ->
159 it 'Should get the message', ->
160 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
161 slack.parseOptions()
162
163 requestText = 'The message from the request'
164 req = stubs.request()
165 req.data.text = requestText
166 req.data.token = process.env.BROBBOT_SLACK_TOKEN
167
168 slack.getMessageFromRequest(req).should.eql requestText
169 delete process.env.BROBBOT_SLACK_TOKEN
170
171 it 'Should return null if the message is missing', ->
172 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
173 slack.parseOptions()
174
175 req = stubs.request()
176 req.data.token = process.env.BROBBOT_SLACK_TOKEN
177 message = slack.getMessageFromRequest req
178 should.not.exist message
179 delete process.env.BROBBOT_SLACK_TOKEN
180
181 it 'Should get the author', ->
182 req = stubs.request()
183 req.data =
184 user_id: 37
185 user_name: 'Luke'
186 channel_id: 760
187 channel_name: 'Home'
188
189 author = slack.getAuthorFromRequest req
190 author.should.include
191 id: 37
192 name: 'Luke'
193
194 it 'Should ignore blacklisted rooms', ->
195 process.env.BROBBOT_SLACK_CHANNELMODE = 'blacklist'
196 process.env.BROBBOT_SLACK_CHANNELS = 'test'
197 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
198 slack.parseOptions()
199
200 requestText = 'The message from the request'
201 req = stubs.request()
202 req.data =
203 channel_name: 'test'
204 token: process.env.BROBBOT_SLACK_TOKEN
205 text: requestText
206
207 message = slack.getMessageFromRequest req
208 should.not.exist message
209 delete process.env.BROBBOT_SLACK_CHANNELMODE
210 delete process.env.BROBBOT_SLACK_CHANNELS
211 delete process.env.BROBBOT_SLACK_TOKEN
212
213 it 'Should strip leading hashes from blacklisted room names', ->
214 process.env.BROBBOT_SLACK_CHANNELMODE = 'blacklist'
215 process.env.BROBBOT_SLACK_CHANNELS = '#foo,#test'
216 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
217 slack.parseOptions()
218
219 requestText = 'The message from the request'
220 req = stubs.request()
221 req.data =
222 channel_name: 'test'
223 token: process.env.BROBBOT_SLACK_TOKEN
224 text: requestText
225
226 message = slack.getMessageFromRequest req
227 should.not.exist message
228 delete process.env.BROBBOT_SLACK_CHANNELMODE
229 delete process.env.BROBBOT_SLACK_CHANNELS
230 delete process.env.BROBBOT_SLACK_TOKEN
231
232 it 'Should not ignore not blacklisted rooms', ->
233 process.env.BROBBOT_SLACK_CHANNELMODE = 'blacklist'
234 process.env.BROBBOT_SLACK_CHANNELS = 'test'
235 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
236 slack.parseOptions()
237
238 requestText = 'The message from the request'
239 req = stubs.request()
240 req.data =
241 channel_name: 'not-test'
242 token: process.env.BROBBOT_SLACK_TOKEN
243 text: requestText
244
245 slack.getMessageFromRequest(req).should.eql requestText
246 delete process.env.BROBBOT_SLACK_CHANNELMODE
247 delete process.env.BROBBOT_SLACK_CHANNELS
248 delete process.env.BROBBOT_SLACK_TOKEN
249
250 it 'Should not ignore whitelisted rooms', ->
251 process.env.BROBBOT_SLACK_CHANNELMODE = 'whitelist'
252 process.env.BROBBOT_SLACK_CHANNELS = 'test'
253 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
254 slack.parseOptions()
255
256 requestText = 'The message from the request'
257 req = stubs.request()
258 req.data =
259 channel_name: 'test'
260 token: process.env.BROBBOT_SLACK_TOKEN
261 text: requestText
262
263 slack.getMessageFromRequest(req).should.eql requestText
264 delete process.env.BROBBOT_SLACK_CHANNELMODE
265 delete process.env.BROBBOT_SLACK_CHANNELS
266 delete process.env.BROBBOT_SLACK_TOKEN
267
268 it 'Should ignore not whitelisted rooms', ->
269 process.env.BROBBOT_SLACK_CHANNELMODE = 'whitelist'
270 process.env.BROBBOT_SLACK_CHANNELS = 'test'
271 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
272 slack.parseOptions()
273
274 requestText = 'The message from the request'
275 req = stubs.request()
276 req.data =
277 channel_name: 'not-test'
278 token: 'token'
279 text: requestText
280
281 message = slack.getMessageFromRequest req
282 should.not.exist message
283 delete process.env.BROBBOT_SLACK_CHANNELMODE
284 delete process.env.BROBBOT_SLACK_CHANNELS
285 delete process.env.BROBBOT_SLACK_TOKEN
286
287 it 'Should fail if the token is incorrect', ->
288 process.env.BROBBOT_SLACK_TOKEN = 'insecure token'
289 slack.parseOptions()
290
291 requestText = 'The message from the request'
292 req = stubs.request()
293 req.data.text = requestText
294 req.data.token = 'secure token'
295
296 message = slack.getMessageFromRequest req
297 should.not.exist message
298 delete process.env.BROBBOT_SLACK_TOKEN