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