1 | 'use strict'
|
2 |
|
3 |
|
4 |
|
5 | const { expect } = require('chai')
|
6 |
|
7 | const { cleanup, clientConnect, parallel,
|
8 | startService } = require('./testutils')
|
9 |
|
10 | const { cleanupTimeout, user1, user2, user3,
|
11 | roomName1 } = require('./config')
|
12 |
|
13 | module.exports = function () {
|
14 | let chatService, socket1, socket2, socket3
|
15 |
|
16 | afterEach(function (cb) {
|
17 | this.timeout(cleanupTimeout)
|
18 | cleanup(chatService, [socket1, socket2, socket3], cb)
|
19 | chatService = socket1 = socket2 = socket3 = null
|
20 | })
|
21 |
|
22 | it('should reject room messages from not joined users', function (done) {
|
23 | let txt = 'Test message.'
|
24 | let message = { textMessage: txt }
|
25 | chatService = startService()
|
26 | chatService.addRoom(roomName1, null, () => {
|
27 | socket1 = clientConnect(user1)
|
28 | socket1.on('loginConfirmed', () => {
|
29 | socket1.emit('roomMessage', roomName1, message, (error, data) => {
|
30 | expect(error).ok
|
31 | expect(data).null
|
32 | socket1.emit('roomRecentHistory', roomName1, (error, data) => {
|
33 | expect(error).ok
|
34 | expect(data).null
|
35 | done()
|
36 | })
|
37 | })
|
38 | })
|
39 | })
|
40 | })
|
41 |
|
42 | it('should send a whitelistonly mode', function (done) {
|
43 | chatService = startService()
|
44 | chatService.addRoom(
|
45 | roomName1,
|
46 | { whitelistOnly: true, whitelist: [user1] },
|
47 | () => {
|
48 | socket1 = clientConnect(user1)
|
49 | socket1.on('loginConfirmed', () => {
|
50 | socket1.emit('roomJoin', roomName1, () => {
|
51 | socket1.emit('roomGetWhitelistMode', roomName1, (error, data) => {
|
52 | expect(error).not.ok
|
53 | expect(data).true
|
54 | done()
|
55 | })
|
56 | })
|
57 | })
|
58 | })
|
59 | })
|
60 |
|
61 | it('should send lists to room users', function (done) {
|
62 | chatService = startService()
|
63 | chatService.addRoom(roomName1, null, () => {
|
64 | socket1 = clientConnect(user1)
|
65 | socket1.on('loginConfirmed', () => {
|
66 | socket1.emit('roomJoin', roomName1, () => {
|
67 | socket1.emit(
|
68 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
69 | expect(error).not.ok
|
70 | expect(data).an('array')
|
71 | expect(data).include(user1)
|
72 | done()
|
73 | })
|
74 | })
|
75 | })
|
76 | })
|
77 | })
|
78 |
|
79 | it('should reject send lists to not joined users', function (done) {
|
80 | chatService = startService()
|
81 | chatService.addRoom(roomName1, null, () => {
|
82 | socket1 = clientConnect(user1)
|
83 | socket1.on('loginConfirmed', () => {
|
84 | socket1.emit(
|
85 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
86 | expect(error).ok
|
87 | expect(data).null
|
88 | done()
|
89 | })
|
90 | })
|
91 | })
|
92 | })
|
93 |
|
94 | it('should check room list names', function (done) {
|
95 | chatService = startService()
|
96 | chatService.addRoom(roomName1, null, () => {
|
97 | socket1 = clientConnect(user1)
|
98 | socket1.on('loginConfirmed', () => {
|
99 | socket1.emit('roomJoin', roomName1, () => {
|
100 | socket1.emit(
|
101 | 'roomGetAccessList', roomName1, 'nolist', (error, data) => {
|
102 | expect(error).ok
|
103 | expect(data).null
|
104 | done()
|
105 | })
|
106 | })
|
107 | })
|
108 | })
|
109 | })
|
110 |
|
111 | it('should allow duplicate adding to lists', function (done) {
|
112 | chatService = startService({ enableRoomsManagement: true })
|
113 | socket1 = clientConnect(user1)
|
114 | socket1.on('loginConfirmed', u => {
|
115 | socket1.emit('roomCreate', roomName1, false, () => {
|
116 | socket1.emit('roomJoin', roomName1, () => {
|
117 | socket1.emit(
|
118 | 'roomAddToList', roomName1, 'adminlist', [user2],
|
119 | (error, data) => {
|
120 | expect(error).not.ok
|
121 | expect(data).null
|
122 | socket1.emit(
|
123 | 'roomAddToList', roomName1, 'adminlist', [user2]
|
124 | , (error, data) => {
|
125 | expect(error).not.ok
|
126 | expect(data).null
|
127 | done()
|
128 | })
|
129 | })
|
130 | })
|
131 | })
|
132 | })
|
133 | })
|
134 |
|
135 | it('should allow deleting non-existing items from lists', function (done) {
|
136 | chatService = startService({ enableRoomsManagement: true })
|
137 | socket1 = clientConnect(user1)
|
138 | socket1.on('loginConfirmed', u => {
|
139 | socket1.emit('roomCreate', roomName1, false, () => {
|
140 | socket1.emit('roomJoin', roomName1, () => {
|
141 | socket1.emit(
|
142 | 'roomRemoveFromList', roomName1, 'adminlist', [user2],
|
143 | (error, data) => {
|
144 | expect(error).not.ok
|
145 | expect(data).null
|
146 | done()
|
147 | })
|
148 | })
|
149 | })
|
150 | })
|
151 | })
|
152 |
|
153 | it('should send access list changed messages', function (done) {
|
154 | chatService = startService({ enableAccessListsUpdates: true })
|
155 | chatService.addRoom(roomName1, { owner: user1 }, () => {
|
156 | socket1 = clientConnect(user1)
|
157 | socket1.on('loginConfirmed', () => {
|
158 | socket1.emit('roomJoin', roomName1, () => {
|
159 | socket1.emit('roomAddToList', roomName1, 'adminlist', [user3])
|
160 | socket1.on('roomAccessListAdded', (r, l, us) => {
|
161 | expect(r).equal(roomName1)
|
162 | expect(l).equal('adminlist')
|
163 | expect(us[0]).equal(user3)
|
164 | socket1.emit('roomRemoveFromList', roomName1, 'adminlist', [user3])
|
165 | socket1.on('roomAccessListRemoved', (r, l, us) => {
|
166 | expect(r).equal(roomName1)
|
167 | expect(l).equal('adminlist')
|
168 | expect(us[0]).equal(user3)
|
169 | done()
|
170 | })
|
171 | })
|
172 | })
|
173 | })
|
174 | })
|
175 | })
|
176 |
|
177 | it('should send mode changed messages', function (done) {
|
178 | chatService = startService({ enableAccessListsUpdates: true })
|
179 | chatService.addRoom(
|
180 | roomName1,
|
181 | { owner: user1, whitelistOnly: true },
|
182 | () => {
|
183 | socket1 = clientConnect(user1)
|
184 | socket1.on('loginConfirmed', () => {
|
185 | socket1.emit('roomJoin', roomName1, () => {
|
186 | socket1.emit('roomSetWhitelistMode', roomName1, false)
|
187 | socket1.on('roomModeChanged', (roomName, mode) => {
|
188 | expect(roomName).equal(roomName1)
|
189 | expect(mode).false
|
190 | done()
|
191 | })
|
192 | })
|
193 | })
|
194 | })
|
195 | })
|
196 |
|
197 | it('should allow wl and bl modifications for admins', function (done) {
|
198 | chatService = startService()
|
199 | chatService.addRoom(roomName1, { adminlist: [user1] }, () => {
|
200 | socket1 = clientConnect(user1)
|
201 | socket1.on('loginConfirmed', () => {
|
202 | socket1.emit('roomJoin', roomName1, () => {
|
203 | socket1.emit(
|
204 | 'roomAddToList', roomName1, 'whitelist', [user2], (error, data) => {
|
205 | expect(error).not.ok
|
206 | expect(data).null
|
207 | socket1.emit(
|
208 | 'roomGetAccessList', roomName1, 'whitelist', (error, data) => {
|
209 | expect(error).not.ok
|
210 | expect(data).include(user2)
|
211 | socket1.emit(
|
212 | 'roomRemoveFromList', roomName1, 'whitelist', [user2],
|
213 | (error, data) => {
|
214 | expect(error).not.ok
|
215 | expect(data).null
|
216 | socket1.emit(
|
217 | 'roomGetAccessList', roomName1, 'whitelist',
|
218 | (error, data) => {
|
219 | expect(error).not.ok
|
220 | expect(data).not.include(user2)
|
221 | done()
|
222 | })
|
223 | })
|
224 | })
|
225 | })
|
226 | })
|
227 | })
|
228 | })
|
229 | })
|
230 |
|
231 | it('should reject adminlist modifications for admins', function (done) {
|
232 | chatService = startService()
|
233 | chatService.addRoom(roomName1, { adminlist: [user1, user2] }, () => {
|
234 | socket1 = clientConnect(user1)
|
235 | socket1.on('loginConfirmed', () => {
|
236 | socket1.emit('roomJoin', roomName1, () => {
|
237 | socket2 = clientConnect(user2)
|
238 | socket2.on('loginConfirmed', () => {
|
239 | socket2.emit('roomJoin', roomName1, () => {
|
240 | socket1.emit(
|
241 | 'roomRemoveFromList', roomName1, 'adminlist', [user2],
|
242 | (error, data) => {
|
243 | expect(error).ok
|
244 | expect(data).null
|
245 | done()
|
246 | })
|
247 | })
|
248 | })
|
249 | })
|
250 | })
|
251 | })
|
252 | })
|
253 |
|
254 | it('should reject list modifications with owner for admins', function (done) {
|
255 | chatService = startService({ enableRoomsManagement: true })
|
256 | socket1 = clientConnect(user1)
|
257 | socket1.on('loginConfirmed', () => {
|
258 | socket1.emit('roomCreate', roomName1, false, () => {
|
259 | socket1.emit('roomJoin', roomName1, () => {
|
260 | socket1.emit(
|
261 | 'roomAddToList', roomName1, 'adminlist', [user2], (error, data) => {
|
262 | expect(error).not.ok
|
263 | expect(data).null
|
264 | socket2 = clientConnect(user2)
|
265 | socket2.on('loginConfirmed', () => {
|
266 | socket2.emit('roomJoin', roomName1, () => {
|
267 | socket2.emit(
|
268 | 'roomAddToList', roomName1, 'whitelist', [user1],
|
269 | (error, data) => {
|
270 | expect(error).ok
|
271 | expect(data).null
|
272 | done()
|
273 | })
|
274 | })
|
275 | })
|
276 | })
|
277 | })
|
278 | })
|
279 | })
|
280 | })
|
281 |
|
282 | it('should reject to modify userlists directly', function (done) {
|
283 | chatService = startService()
|
284 | chatService.addRoom(roomName1, { adminlist: [user1] }, () => {
|
285 | socket1 = clientConnect(user1)
|
286 | socket1.on('loginConfirmed', () => {
|
287 | socket1.emit('roomJoin', roomName1, () => {
|
288 | socket1.emit(
|
289 | 'roomAddToList', roomName1, 'userlist', [user2], (error, data) => {
|
290 | expect(error).ok
|
291 | expect(data).null
|
292 | done()
|
293 | })
|
294 | })
|
295 | })
|
296 | })
|
297 | })
|
298 |
|
299 | it('should reject any lists modifications for non-admins', function (done) {
|
300 | chatService = startService()
|
301 | chatService.addRoom(roomName1, null, () => {
|
302 | socket1 = clientConnect(user1)
|
303 | socket1.on('loginConfirmed', () => {
|
304 | socket1.emit('roomJoin', roomName1, () => {
|
305 | socket1.emit(
|
306 | 'roomAddToList', roomName1, 'whitelist', [user2], (error, data) => {
|
307 | expect(error).ok
|
308 | expect(data).null
|
309 | done()
|
310 | })
|
311 | })
|
312 | })
|
313 | })
|
314 | })
|
315 |
|
316 | it('should reject mode changes for non-admins', function (done) {
|
317 | chatService = startService()
|
318 | chatService.addRoom(roomName1, null, () => {
|
319 | socket1 = clientConnect(user1)
|
320 | socket1.on('loginConfirmed', () => {
|
321 | socket1.emit('roomJoin', roomName1, () => {
|
322 | socket1.emit(
|
323 | 'roomSetWhitelistMode', roomName1, true, (error, data) => {
|
324 | expect(error).ok
|
325 | expect(data).null
|
326 | done()
|
327 | })
|
328 | })
|
329 | })
|
330 | })
|
331 | })
|
332 |
|
333 | it('should check room permissions', function (done) {
|
334 | chatService = startService()
|
335 | chatService.addRoom(roomName1, { blacklist: [user1] }, () => {
|
336 | socket1 = clientConnect(user1)
|
337 | socket1.on('loginConfirmed', () => {
|
338 | socket1.emit('roomJoin', roomName1, (error, data) => {
|
339 | expect(error).ok
|
340 | expect(data).null
|
341 | done()
|
342 | })
|
343 | })
|
344 | })
|
345 | })
|
346 |
|
347 | it('should check room permissions in whitelist mode', function (done) {
|
348 | chatService = startService()
|
349 | chatService.addRoom(roomName1
|
350 | , { whitelist: [user2], whitelistOnly: true }
|
351 | , () => {
|
352 | socket1 = clientConnect(user1)
|
353 | socket1.on('loginConfirmed', () => {
|
354 | socket1.emit('roomJoin', roomName1, (error, data) => {
|
355 | expect(error).ok
|
356 | expect(data).null
|
357 | socket2 = clientConnect(user2)
|
358 | socket2.on('loginConfirmed', () => {
|
359 | socket2.emit('roomJoin', roomName1, (error, data) => {
|
360 | expect(error).not.ok
|
361 | expect(data).equal(1)
|
362 | done()
|
363 | })
|
364 | })
|
365 | })
|
366 | })
|
367 | })
|
368 | })
|
369 |
|
370 | it('should remove users on permissions changes', function (done) {
|
371 | this.timeout(4000)
|
372 | this.slow(2000)
|
373 | chatService = startService({enableUserlistUpdates: true})
|
374 | chatService.addRoom(
|
375 | roomName1, { adminlist: [user1, user3] }, () => parallel([
|
376 | cb => {
|
377 | socket1 = clientConnect(user1)
|
378 | socket1.on('loginConfirmed',
|
379 | () => socket1.emit('roomJoin', roomName1, cb))
|
380 | },
|
381 | cb => {
|
382 | socket2 = clientConnect(user2)
|
383 | socket2.on('loginConfirmed',
|
384 | () => socket2.emit('roomJoin', roomName1, cb))
|
385 | },
|
386 | cb => {
|
387 | socket3 = clientConnect(user3)
|
388 | socket3.on('loginConfirmed',
|
389 | () => socket3.emit('roomJoin', roomName1, cb))
|
390 | }
|
391 | ], error => {
|
392 | expect(error).not.ok
|
393 | socket3.on('roomAccessRemoved',
|
394 | () => done(new Error('Wrong user removed.')))
|
395 | parallel([
|
396 | cb => socket1.emit('roomAddToList', roomName1,
|
397 | 'blacklist', [user2, user3, 'nouser'], cb),
|
398 | cb => socket2.on('roomAccessRemoved', r => {
|
399 | expect(r).equal(roomName1)
|
400 | cb()
|
401 | }),
|
402 | cb => socket1.on('roomUserLeft', (r, u) => {
|
403 | expect(r).equal(roomName1)
|
404 | expect(u).equal(user2)
|
405 | cb()
|
406 | })
|
407 | ], error => setTimeout(done, 1000, error))
|
408 | })
|
409 | )
|
410 | })
|
411 |
|
412 | it('should remove affected users on mode changes', function (done) {
|
413 | this.timeout(4000)
|
414 | this.slow(2000)
|
415 | chatService = startService()
|
416 | chatService.addRoom(roomName1, { adminlist: [user1] }, () => {
|
417 | socket1 = clientConnect(user1)
|
418 | socket1.on('loginConfirmed', () => {
|
419 | socket1.emit('roomJoin', roomName1, () => {
|
420 | socket2 = clientConnect(user2)
|
421 | socket2.on('loginConfirmed', () => {
|
422 | socket2.emit('roomJoin', roomName1, () => {
|
423 | socket1.emit('roomSetWhitelistMode', roomName1, true)
|
424 | socket1.on('roomAccessRemoved', () => {
|
425 | done(new Error('Wrong user removed.'))
|
426 | })
|
427 | socket2.on('roomAccessRemoved', r => {
|
428 | expect(r).equal(roomName1)
|
429 | setTimeout(done, 1000)
|
430 | })
|
431 | })
|
432 | })
|
433 | })
|
434 | })
|
435 | })
|
436 | })
|
437 |
|
438 | it('should remove users on permissions changes in wl mode', function (done) {
|
439 | this.timeout(4000)
|
440 | this.slow(2000)
|
441 | chatService = startService()
|
442 | chatService.addRoom(
|
443 | roomName1,
|
444 | { adminlist: [user1, user3], whitelist: [user2], whitelistOnly: true },
|
445 | () => {
|
446 | socket1 = clientConnect(user1)
|
447 | socket1.on('loginConfirmed', () => {
|
448 | socket1.emit('roomJoin', roomName1, () => {
|
449 | socket2 = clientConnect(user2)
|
450 | socket2.on('loginConfirmed', () => {
|
451 | socket2.emit('roomJoin', roomName1, () => {
|
452 | socket3 = clientConnect(user3)
|
453 | socket3.on('loginConfirmed', () => {
|
454 | socket3.emit('roomJoin', roomName1, () => {
|
455 | socket1.emit('roomRemoveFromList', roomName1
|
456 | , 'whitelist', [user2, user3, 'nouser'])
|
457 | socket3.on('roomAccessRemoved', () =>
|
458 | done(new Error('Wrong user removed.')))
|
459 | socket2.on('roomAccessRemoved', r => {
|
460 | expect(r).equal(roomName1)
|
461 | setTimeout(done, 1000)
|
462 | })
|
463 | })
|
464 | })
|
465 | })
|
466 | })
|
467 | })
|
468 | })
|
469 | })
|
470 | })
|
471 |
|
472 | it('should honour room list size limit', function (done) {
|
473 | chatService = startService({ roomListSizeLimit: 1 })
|
474 | chatService.addRoom(
|
475 | roomName1, { owner: user1 },
|
476 | () => {
|
477 | socket1 = clientConnect(user1)
|
478 | socket1.on('loginConfirmed', () => {
|
479 | socket1.emit(
|
480 | 'roomAddToList', roomName1, 'blacklist', [user2, user3],
|
481 | (error, data) => {
|
482 | expect(error).ok
|
483 | done()
|
484 | })
|
485 | })
|
486 | })
|
487 | })
|
488 | }
|