1 |
|
2 |
|
3 |
|
4 | should = require 'should'
|
5 |
|
6 |
|
7 | {Slack} = require '../src/slack'
|
8 | Slack::log = ->
|
9 | Slack::logError = ->
|
10 |
|
11 |
|
12 |
|
13 |
|
14 | stubs = null
|
15 | beforeEach ->
|
16 | stubs =
|
17 |
|
18 | robot:
|
19 | name: 'Kitt'
|
20 |
|
21 |
|
22 | request: ->
|
23 | data: {}
|
24 | param: (key) ->
|
25 | @data[key]
|
26 |
|
27 |
|
28 |
|
29 | slack = null
|
30 | beforeEach ->
|
31 | slack = new Slack stubs.robot
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 | describe 'Adapter', ->
|
38 | it 'Should initialize with a robot', ->
|
39 | slack.robot.name.should.eql stubs.robot.name
|
40 |
|
41 |
|
42 | describe '(Un)escaping strings', ->
|
43 |
|
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: '<', 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 |
|
68 | describe 'Getting the user from params', ->
|
69 | it 'Should support old Hubot syntax', ->
|
70 |
|
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 |
|
90 | describe 'Sending a message', ->
|
91 | it 'Should JSON-ify args', ->
|
92 |
|
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 |
|
101 | describe '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 |
|
158 | describe '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
|