| 1 | 'use strict'
|
| 2 |
|
| 3 |
|
| 4 | const { expect } = require('chai')
|
| 5 |
|
| 6 | const { cleanup, clientConnect,
|
| 7 | parallel, series, startService } = require('./testutils')
|
| 8 |
|
| 9 | const { cleanupTimeout, user1, user2,
|
| 10 | roomName1, roomName2 } = 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 emit echos to a non-joined user\'s socket', function (done) {
|
| 22 | chatService = startService()
|
| 23 | chatService.addRoom(roomName1, null, () => {
|
| 24 | socket1 = clientConnect(user1)
|
| 25 | socket1.on('loginConfirmed', (u, data) => {
|
| 26 | socket2 = clientConnect(user1)
|
| 27 | socket2.on('loginConfirmed', (u, data) => {
|
| 28 | let sid2 = data.id
|
| 29 | socket2.emit('roomJoin', roomName1)
|
| 30 | socket1.on('roomJoinedEcho', (room, id, njoined) => {
|
| 31 | expect(room).equal(roomName1)
|
| 32 | expect(id).equal(sid2)
|
| 33 | expect(njoined).equal(1)
|
| 34 | socket2.emit('roomLeave', roomName1)
|
| 35 | socket1.on('roomLeftEcho', (room, id, njoined) => {
|
| 36 | expect(room).equal(roomName1)
|
| 37 | expect(id).equal(sid2)
|
| 38 | expect(njoined).equal(0)
|
| 39 | done()
|
| 40 | })
|
| 41 | })
|
| 42 | })
|
| 43 | })
|
| 44 | })
|
| 45 | })
|
| 46 |
|
| 47 | it('should emit echos to a joined user\'s socket', function (done) {
|
| 48 | chatService = startService()
|
| 49 | chatService.addRoom(roomName1, null, () => {
|
| 50 | socket1 = clientConnect(user1)
|
| 51 | socket1.on('loginConfirmed', (u, data) => {
|
| 52 | socket1.emit('roomJoin', roomName1, () => {
|
| 53 | socket2 = clientConnect(user1)
|
| 54 | socket2.on('loginConfirmed', (u, data) => {
|
| 55 | let sid2 = data.id
|
| 56 | socket2.emit('roomJoin', roomName1)
|
| 57 | socket1.on('roomJoinedEcho', (room, id, njoined) => {
|
| 58 | expect(room).equal(roomName1)
|
| 59 | expect(id).equal(sid2)
|
| 60 | expect(njoined).equal(2)
|
| 61 | socket2.emit('roomLeave', roomName1)
|
| 62 | socket1.on('roomLeftEcho', (room, id, njoined) => {
|
| 63 | expect(room).equal(roomName1)
|
| 64 | expect(id).equal(sid2)
|
| 65 | expect(njoined).equal(1)
|
| 66 | done()
|
| 67 | })
|
| 68 | })
|
| 69 | })
|
| 70 | })
|
| 71 | })
|
| 72 | })
|
| 73 | })
|
| 74 |
|
| 75 | it('should emit leave echo on a disconnect', function (done) {
|
| 76 | let sid1, sid2
|
| 77 | chatService = startService()
|
| 78 | chatService.addRoom(roomName1, null, () => parallel([
|
| 79 | cb => {
|
| 80 | socket3 = clientConnect(user1)
|
| 81 | socket3.on('loginConfirmed', () => cb())
|
| 82 | },
|
| 83 | cb => {
|
| 84 | socket1 = clientConnect(user1)
|
| 85 | socket1.on('loginConfirmed', (u, data) => {
|
| 86 | sid1 = data.id
|
| 87 | socket1.emit('roomJoin', roomName1, cb)
|
| 88 | })
|
| 89 | },
|
| 90 | cb => {
|
| 91 | socket2 = clientConnect(user1)
|
| 92 | socket2.on('loginConfirmed', (u, data) => {
|
| 93 | sid2 = data.id
|
| 94 | socket2.emit('roomJoin', roomName1, cb)
|
| 95 | })
|
| 96 | }
|
| 97 | ], error => {
|
| 98 | expect(error).not.ok
|
| 99 | socket2.disconnect()
|
| 100 | parallel([
|
| 101 | cb => socket1.once('roomLeftEcho', (room, id, njoined) => {
|
| 102 | expect(room).equal(roomName1)
|
| 103 | expect(id).equal(sid2)
|
| 104 | expect(njoined).equal(1)
|
| 105 | cb()
|
| 106 | }),
|
| 107 | cb => socket3.once('roomLeftEcho', (room, id, njoined) => {
|
| 108 | expect(room).equal(roomName1)
|
| 109 | expect(id).equal(sid2)
|
| 110 | expect(njoined).equal(1)
|
| 111 | cb()
|
| 112 | })
|
| 113 |
|
| 114 | ], () => {
|
| 115 | socket1.disconnect()
|
| 116 | socket3.on('roomLeftEcho', (room, id, njoined) => {
|
| 117 | expect(room).equal(roomName1)
|
| 118 | expect(id).equal(sid1)
|
| 119 | expect(njoined).equal(0)
|
| 120 | done()
|
| 121 | })
|
| 122 | })
|
| 123 | }))
|
| 124 | })
|
| 125 |
|
| 126 | it('should remove disconnected users', function (done) {
|
| 127 | chatService = startService({ enableUserlistUpdates: true })
|
| 128 | chatService.addRoom(roomName1, null, () => {
|
| 129 | socket1 = clientConnect(user1)
|
| 130 | socket1.on('loginConfirmed', () => {
|
| 131 | socket1.emit('roomJoin', roomName1, () => {
|
| 132 | socket2 = clientConnect(user2)
|
| 133 | socket2.on('loginConfirmed', () => {
|
| 134 | socket2.emit('roomJoin', roomName1, () => {
|
| 135 | socket2.disconnect()
|
| 136 | socket1.on('roomUserLeft', (r, u) => {
|
| 137 | expect(r).equal(roomName1)
|
| 138 | expect(u).equal(user2)
|
| 139 | done()
|
| 140 | })
|
| 141 | })
|
| 142 | })
|
| 143 | })
|
| 144 | })
|
| 145 | })
|
| 146 | })
|
| 147 |
|
| 148 | it('should remove disconnected users', function (done) {
|
| 149 | this.timeout(4000)
|
| 150 | this.slow(2000)
|
| 151 | chatService = startService({ enableUserlistUpdates: true })
|
| 152 | chatService.addRoom(roomName1, null, () => {
|
| 153 | socket1 = clientConnect(user1)
|
| 154 | socket1.on('loginConfirmed', () => {
|
| 155 | socket1.emit('roomJoin', roomName1, () => {
|
| 156 | socket2 = clientConnect(user2)
|
| 157 | socket2.on('loginConfirmed', () => {
|
| 158 | socket2.emit('roomLeave', roomName1)
|
| 159 | socket1.on('roomLeftEcho', () => done(new Error('Wrong echo')))
|
| 160 | setTimeout(done, 1000)
|
| 161 | })
|
| 162 | })
|
| 163 | })
|
| 164 | })
|
| 165 | })
|
| 166 |
|
| 167 | it('should update userlist on join and leave operations', function (done) {
|
| 168 | chatService = startService()
|
| 169 | chatService.addRoom(roomName1, null, () => parallel([
|
| 170 | cb => {
|
| 171 | socket1 = clientConnect(user1)
|
| 172 | socket1.on('loginConfirmed',
|
| 173 | () => socket1.emit('roomJoin', roomName1, cb))
|
| 174 | },
|
| 175 | cb => {
|
| 176 | socket2 = clientConnect(user2)
|
| 177 | socket2.on('loginConfirmed',
|
| 178 | () => socket2.emit('roomJoin', roomName1, cb))
|
| 179 | }
|
| 180 | ], error => {
|
| 181 | expect(error).not.ok
|
| 182 | socket1.emit(
|
| 183 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
| 184 | expect(error).not.ok
|
| 185 | expect(data).lengthOf(2)
|
| 186 | expect(data).include(user1)
|
| 187 | expect(data).include(user2)
|
| 188 | socket2.emit('roomLeave', roomName1, (error, data) => {
|
| 189 | expect(error).not.ok
|
| 190 | socket1.emit(
|
| 191 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
| 192 | expect(error).not.ok
|
| 193 | expect(data).lengthOf(1)
|
| 194 | expect(data).include(user1)
|
| 195 | expect(data).not.include(user2)
|
| 196 | done()
|
| 197 | })
|
| 198 | })
|
| 199 | })
|
| 200 | }))
|
| 201 | })
|
| 202 |
|
| 203 | it('should broadcast join and leave room messages', function (done) {
|
| 204 | chatService = startService({ enableUserlistUpdates: true })
|
| 205 | chatService.addRoom(roomName1, null, () => {
|
| 206 | socket1 = clientConnect(user1)
|
| 207 | socket1.on('loginConfirmed', () => {
|
| 208 | socket1.emit('roomJoin', roomName1, (error, njoined) => {
|
| 209 | expect(error).not.ok
|
| 210 | expect(njoined).equal(1)
|
| 211 | socket2 = clientConnect(user2)
|
| 212 | socket2.on('loginConfirmed', () => {
|
| 213 | socket2.emit('roomJoin', roomName1)
|
| 214 | socket1.on('roomUserJoined', (room, user) => {
|
| 215 | expect(room).equal(roomName1)
|
| 216 | expect(user).equal(user2)
|
| 217 | socket2.emit('roomLeave', roomName1)
|
| 218 | socket1.on('roomUserLeft', (room, user) => {
|
| 219 | expect(room).equal(roomName1)
|
| 220 | expect(user).equal(user2)
|
| 221 | done()
|
| 222 | })
|
| 223 | })
|
| 224 | })
|
| 225 | })
|
| 226 | })
|
| 227 | })
|
| 228 | })
|
| 229 |
|
| 230 | it('should update userlist on a disconnect', function (done) {
|
| 231 | chatService = startService({ enableUserlistUpdates: true })
|
| 232 | chatService.addRoom(roomName1, null, () => parallel([
|
| 233 | cb => {
|
| 234 | socket1 = clientConnect(user1)
|
| 235 | socket1.on('loginConfirmed',
|
| 236 | () => socket1.emit('roomJoin', roomName1, cb))
|
| 237 | },
|
| 238 | cb => {
|
| 239 | socket2 = clientConnect(user2)
|
| 240 | socket2.on('loginConfirmed',
|
| 241 | () => socket2.emit('roomJoin', roomName1, cb))
|
| 242 | }
|
| 243 | ], error => {
|
| 244 | expect(error).not.ok
|
| 245 | socket1.emit(
|
| 246 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
| 247 | expect(error).not.ok
|
| 248 | expect(data).lengthOf(2)
|
| 249 | expect(data).include(user1)
|
| 250 | expect(data).include(user2)
|
| 251 | socket2.disconnect()
|
| 252 | socket1.once('roomUserLeft', () => {
|
| 253 | socket1.emit(
|
| 254 | 'roomGetAccessList', roomName1, 'userlist', (error, data) => {
|
| 255 | expect(error).not.ok
|
| 256 | expect(data).lengthOf(1)
|
| 257 | expect(data).include(user1)
|
| 258 | expect(data).not.include(user2)
|
| 259 | done()
|
| 260 | })
|
| 261 | })
|
| 262 | })
|
| 263 | }))
|
| 264 | })
|
| 265 |
|
| 266 | it('should store and send a room history', function (done) {
|
| 267 | let txt = 'Test message.'
|
| 268 | let message = { textMessage: txt }
|
| 269 | chatService = startService()
|
| 270 | chatService.addRoom(roomName1, null, () => {
|
| 271 | socket1 = clientConnect(user1)
|
| 272 | socket1.on('loginConfirmed', () => {
|
| 273 | socket1.emit('roomJoin', roomName1, () => {
|
| 274 | socket1.emit('roomMessage', roomName1, message, (error, data) => {
|
| 275 | expect(error).not.ok
|
| 276 | expect(data).a('Number')
|
| 277 | socket1.emit('roomRecentHistory', roomName1, (error, data) => {
|
| 278 | expect(error).not.ok
|
| 279 | expect(data).length(1)
|
| 280 | let props = ['textMessage', 'author', 'timestamp', 'id']
|
| 281 | expect(data[0]).include.keys(...props)
|
| 282 | expect(data[0].textMessage).equal(txt)
|
| 283 | expect(data[0].author).equal(user1)
|
| 284 | expect(data[0].timestamp).a('Number')
|
| 285 | expect(data[0].id).equal(1)
|
| 286 | done()
|
| 287 | })
|
| 288 | })
|
| 289 | })
|
| 290 | })
|
| 291 | })
|
| 292 | })
|
| 293 |
|
| 294 | it('should send room messages to all joined users', function (done) {
|
| 295 | let txt = 'Test message.'
|
| 296 | let message = { textMessage: txt }
|
| 297 | chatService = startService()
|
| 298 | chatService.addRoom(roomName1, null, () => parallel([
|
| 299 | cb => {
|
| 300 | socket1 = clientConnect(user1)
|
| 301 | socket1.on('loginConfirmed',
|
| 302 | () => socket1.emit('roomJoin', roomName1, cb))
|
| 303 | },
|
| 304 | cb => {
|
| 305 | socket2 = clientConnect(user2)
|
| 306 | socket2.on('loginConfirmed',
|
| 307 | () => socket2.emit('roomJoin', roomName1, cb))
|
| 308 | }
|
| 309 | ], error => {
|
| 310 | expect(error).not.ok
|
| 311 | parallel([
|
| 312 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 313 | cb => socket1.on('roomMessage', (room, msg) => {
|
| 314 | expect(room).equal(roomName1)
|
| 315 | expect(msg.author).equal(user1)
|
| 316 | expect(msg.textMessage).equal(txt)
|
| 317 | expect(msg).ownProperty('timestamp')
|
| 318 | expect(msg).ownProperty('id')
|
| 319 | cb()
|
| 320 | }),
|
| 321 | cb => socket2.on('roomMessage', (room, msg) => {
|
| 322 | expect(room).equal(roomName1)
|
| 323 | expect(msg.author).equal(user1)
|
| 324 | expect(msg.textMessage).equal(txt)
|
| 325 | expect(msg).ownProperty('timestamp')
|
| 326 | expect(msg).ownProperty('id')
|
| 327 | cb()
|
| 328 | })
|
| 329 | ], done)
|
| 330 | }))
|
| 331 | })
|
| 332 |
|
| 333 | it('should drop a history if the limit is zero', function (done) {
|
| 334 | let txt = 'Test message.'
|
| 335 | let message = { textMessage: txt }
|
| 336 | chatService = startService({ historyMaxSize: 0 })
|
| 337 | chatService.addRoom(roomName1, null, () => {
|
| 338 | socket1 = clientConnect(user1)
|
| 339 | socket1.on('loginConfirmed', () => {
|
| 340 | socket1.emit('roomJoin', roomName1, () => {
|
| 341 | socket1.emit('roomMessage', roomName1, message, (error, id) => {
|
| 342 | expect(error).not.ok
|
| 343 | expect(id).equal(1)
|
| 344 | socket1.emit('roomRecentHistory', roomName1, (error, data) => {
|
| 345 | expect(error).not.ok
|
| 346 | expect(data).empty
|
| 347 | done()
|
| 348 | })
|
| 349 | })
|
| 350 | })
|
| 351 | })
|
| 352 | })
|
| 353 | })
|
| 354 |
|
| 355 | it('should not send a history if the limit is zero', function (done) {
|
| 356 | let txt = 'Test message.'
|
| 357 | let message = { textMessage: txt }
|
| 358 | chatService = startService({ historyMaxGetMessages: 0 })
|
| 359 | chatService.addRoom(roomName1, null, () => {
|
| 360 | socket1 = clientConnect(user1)
|
| 361 | socket1.on('loginConfirmed', () => {
|
| 362 | socket1.emit('roomJoin', roomName1, () => {
|
| 363 | socket1.emit('roomMessage', roomName1, message, () => {
|
| 364 | socket1.emit('roomRecentHistory', roomName1, (error, data) => {
|
| 365 | expect(error).not.ok
|
| 366 | expect(data).empty
|
| 367 | socket1.emit(
|
| 368 | 'roomHistoryGet', roomName1, 0, 10, (error, data) => {
|
| 369 | expect(error).not.ok
|
| 370 | expect(data).empty
|
| 371 | done()
|
| 372 | })
|
| 373 | })
|
| 374 | })
|
| 375 | })
|
| 376 | })
|
| 377 | })
|
| 378 | })
|
| 379 |
|
| 380 | it('should send a room history maximum size', function (done) {
|
| 381 | let sz = 1000
|
| 382 | chatService = startService({ historyMaxSize: sz })
|
| 383 | chatService.addRoom(roomName1, null, () => {
|
| 384 | socket1 = clientConnect(user1)
|
| 385 | socket1.on('loginConfirmed', () => {
|
| 386 | socket1.emit('roomJoin', roomName1, () => {
|
| 387 | socket1.emit('roomHistoryInfo', roomName1, (error, data) => {
|
| 388 | expect(error).not.ok
|
| 389 | expect(data.historyMaxSize).equal(sz)
|
| 390 | done()
|
| 391 | })
|
| 392 | })
|
| 393 | })
|
| 394 | })
|
| 395 | })
|
| 396 |
|
| 397 | it('should truncate a long history', function (done) {
|
| 398 | let txt1 = 'Test message 1.'
|
| 399 | let message1 = { textMessage: txt1 }
|
| 400 | let txt2 = 'Test message 2.'
|
| 401 | let message2 = { textMessage: txt2 }
|
| 402 | chatService = startService({ historyMaxSize: 1 })
|
| 403 | chatService.addRoom(roomName1, null, () => {
|
| 404 | socket1 = clientConnect(user1)
|
| 405 | socket1.on('loginConfirmed', () => {
|
| 406 | socket1.emit('roomJoin', roomName1, () => {
|
| 407 | socket1.emit('roomMessage', roomName1, message1, () => {
|
| 408 | socket1.emit('roomMessage', roomName1, message2, () => {
|
| 409 | socket1.emit('roomRecentHistory', roomName1, (error, data) => {
|
| 410 | expect(error).not.ok
|
| 411 | expect(data).length(1)
|
| 412 | let props = ['textMessage', 'author', 'timestamp', 'id']
|
| 413 | expect(data[0]).include.keys(...props)
|
| 414 | expect(data[0].textMessage).equal(txt2)
|
| 415 | expect(data[0].author).equal(user1)
|
| 416 | expect(data[0].timestamp).a('Number')
|
| 417 | expect(data[0].id).equal(2)
|
| 418 | done()
|
| 419 | })
|
| 420 | })
|
| 421 | })
|
| 422 | })
|
| 423 | })
|
| 424 | })
|
| 425 | })
|
| 426 |
|
| 427 | it('should support a history synchronisation', function (done) {
|
| 428 | let txt = 'Test message.'
|
| 429 | let message = { textMessage: txt }
|
| 430 | chatService = startService()
|
| 431 | chatService.addRoom(roomName1, null, () => {
|
| 432 | socket1 = clientConnect(user1)
|
| 433 | series([
|
| 434 | cb => socket1.on('loginConfirmed',
|
| 435 | () => socket1.emit('roomJoin', roomName1, cb)),
|
| 436 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 437 | cb => socket1.emit('roomMessage', roomName1, message, cb)
|
| 438 | ], error => {
|
| 439 | expect(error).not.ok
|
| 440 | parallel([
|
| 441 | cb =>
|
| 442 | socket1.emit('roomHistoryGet', roomName1, 0, 10, (error, data) => {
|
| 443 | expect(error).not.ok
|
| 444 | expect(data).lengthOf(2)
|
| 445 | let props = ['textMessage', 'author', 'timestamp', 'id']
|
| 446 | expect(data[0]).include.keys(...props)
|
| 447 | expect(data[0].textMessage).equal(txt)
|
| 448 | expect(data[0].author).equal(user1)
|
| 449 | expect(data[0].timestamp).a('Number')
|
| 450 | expect(data[0].id).equal(2)
|
| 451 | expect(data[1].id).equal(1)
|
| 452 | cb()
|
| 453 | }),
|
| 454 | cb =>
|
| 455 | socket1.emit('roomHistoryGet', roomName1, 1, 10, (error, data) => {
|
| 456 | expect(error).not.ok
|
| 457 | expect(data).lengthOf(1)
|
| 458 | expect(data[0].id).equal(2)
|
| 459 | cb()
|
| 460 | }),
|
| 461 | cb =>
|
| 462 | socket1.emit('roomHistoryGet', roomName1, 2, 10, (error, data) => {
|
| 463 | expect(error).not.ok
|
| 464 | expect(data).empty
|
| 465 | cb()
|
| 466 | })
|
| 467 | ], done)
|
| 468 | })
|
| 469 | })
|
| 470 | })
|
| 471 |
|
| 472 | it('should sync a history with respect to the limit', function (done) {
|
| 473 | let txt = 'Test message.'
|
| 474 | let message = { textMessage: txt }
|
| 475 | chatService = startService({ historyMaxGetMessages: 2 })
|
| 476 | chatService.addRoom(roomName1, null, () => {
|
| 477 | socket1 = clientConnect(user1)
|
| 478 | series([
|
| 479 | cb => socket1.on('loginConfirmed',
|
| 480 | () => socket1.emit('roomJoin', roomName1, cb)),
|
| 481 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 482 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 483 | cb => socket1.emit('roomMessage', roomName1, message, cb)
|
| 484 | ], error => {
|
| 485 | expect(error).not.ok
|
| 486 | parallel([
|
| 487 | cb =>
|
| 488 | socket1.emit('roomHistoryGet', roomName1, 0, 10, (error, data) => {
|
| 489 | expect(error).not.ok
|
| 490 | expect(data).lengthOf(2)
|
| 491 | expect(data[0].id).equal(2)
|
| 492 | expect(data[1].id).equal(1)
|
| 493 | cb()
|
| 494 | }),
|
| 495 | cb =>
|
| 496 | socket1.emit('roomHistoryGet', roomName1, 1, 10, (error, data) => {
|
| 497 | expect(error).not.ok
|
| 498 | expect(data).lengthOf(2)
|
| 499 | expect(data[0].id).equal(3)
|
| 500 | expect(data[1].id).equal(2)
|
| 501 | cb()
|
| 502 | }),
|
| 503 | cb =>
|
| 504 | socket1.emit('roomHistoryGet', roomName1, 2, 10, (error, data) => {
|
| 505 | expect(error).not.ok
|
| 506 | expect(data).lengthOf(1)
|
| 507 | expect(data[0].id).equal(3)
|
| 508 | cb()
|
| 509 | }),
|
| 510 | cb =>
|
| 511 | socket1.emit('roomHistoryGet', roomName1, 3, 10, (error, data) => {
|
| 512 | expect(error).not.ok
|
| 513 | expect(data).empty
|
| 514 | cb()
|
| 515 | })
|
| 516 | ], done)
|
| 517 | })
|
| 518 | })
|
| 519 | })
|
| 520 |
|
| 521 | it('should sync a history with respect to a history size', function (done) {
|
| 522 | let txt = 'Test message.'
|
| 523 | let message = { textMessage: txt }
|
| 524 | chatService = startService({ historyMaxSize: 2 })
|
| 525 | chatService.addRoom(roomName1, null, () => {
|
| 526 | socket1 = clientConnect(user1)
|
| 527 | series([
|
| 528 | cb => socket1.on('loginConfirmed',
|
| 529 | () => socket1.emit('roomJoin', roomName1, cb)),
|
| 530 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 531 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 532 | cb => socket1.emit('roomMessage', roomName1, message, cb)
|
| 533 | ], error => {
|
| 534 | expect(error).not.ok
|
| 535 | parallel([
|
| 536 | cb =>
|
| 537 | socket1.emit('roomHistoryGet', roomName1, 0, 10, (error, data) => {
|
| 538 | expect(error).not.ok
|
| 539 | expect(data).lengthOf(2)
|
| 540 | expect(data[0].id).equal(3)
|
| 541 | cb()
|
| 542 | }),
|
| 543 | cb =>
|
| 544 | socket1.emit('roomHistoryGet', roomName1, 1, 10, (error, data) => {
|
| 545 | expect(error).not.ok
|
| 546 | expect(data).lengthOf(2)
|
| 547 | expect(data[0].id).equal(3)
|
| 548 | cb()
|
| 549 | }),
|
| 550 | cb =>
|
| 551 | socket1.emit('roomHistoryGet', roomName1, 2, 10, (error, data) => {
|
| 552 | expect(error).not.ok
|
| 553 | expect(data).lengthOf(1)
|
| 554 | expect(data[0].id).equal(3)
|
| 555 | cb()
|
| 556 | }),
|
| 557 | cb =>
|
| 558 | socket1.emit('roomHistoryGet', roomName1, 3, 10, (error, data) => {
|
| 559 | expect(error).not.ok
|
| 560 | expect(data).empty
|
| 561 | cb()
|
| 562 | })
|
| 563 | ], done)
|
| 564 | })
|
| 565 | })
|
| 566 | })
|
| 567 |
|
| 568 | it('should trim history on size changes', function (done) {
|
| 569 | let txt = 'Test message.'
|
| 570 | let message = { textMessage: txt }
|
| 571 | chatService = startService({ historyMaxSize: 2 })
|
| 572 | socket1 = clientConnect(user1)
|
| 573 | chatService.addRoom(roomName1, null, () => {
|
| 574 | series([
|
| 575 | cb => socket1.on('loginConfirmed',
|
| 576 | () => socket1.emit('roomJoin', roomName1, cb)),
|
| 577 | cb => socket1.emit('roomMessage', roomName1, message, cb),
|
| 578 | cb => socket1.emit('roomMessage', roomName1, message, cb)
|
| 579 | ], error => {
|
| 580 | expect(error).not.ok
|
| 581 | chatService.changeRoomHistoryMaxSize(roomName1, 1, (error, data) => {
|
| 582 | expect(error).not.ok
|
| 583 | parallel([
|
| 584 | cb =>
|
| 585 | socket1.emit('roomHistoryGet', roomName1, 0, 9, (error, data) => {
|
| 586 | expect(error).not.ok
|
| 587 | expect(data).an.array
|
| 588 | expect(data).lengthOf(1)
|
| 589 | expect(data[0].id).equal(2)
|
| 590 | cb()
|
| 591 | }),
|
| 592 | cb =>
|
| 593 | socket1.emit('roomHistoryInfo', roomName1, (error, data) => {
|
| 594 | expect(error).not.ok
|
| 595 | expect(data).an.object
|
| 596 | expect(data.historySize).equal(1)
|
| 597 | expect(data.historyMaxSize).equal(1)
|
| 598 | cb()
|
| 599 | })
|
| 600 | ], done)
|
| 601 | })
|
| 602 | })
|
| 603 | })
|
| 604 | })
|
| 605 |
|
| 606 | it('should send and update a room sync info', function (done) {
|
| 607 | let txt = 'Test message.'
|
| 608 | let message = { textMessage: txt }
|
| 609 | chatService = startService()
|
| 610 | chatService.addRoom(roomName1, null, () => {
|
| 611 | socket1 = clientConnect(user1)
|
| 612 | socket1.on('loginConfirmed', () => {
|
| 613 | socket1.emit('roomJoin', roomName1, () => {
|
| 614 | socket1.emit('roomHistoryInfo', roomName1, (error, data) => {
|
| 615 | expect(error).not.ok
|
| 616 | expect(data).ownProperty('historyMaxGetMessages')
|
| 617 | expect(data).ownProperty('historyMaxSize')
|
| 618 | expect(data).ownProperty('historySize')
|
| 619 | expect(data).ownProperty('lastMessageId')
|
| 620 | expect(data.lastMessageId).equal(0)
|
| 621 | expect(data.historySize).equal(0)
|
| 622 | socket1.emit('roomMessage', roomName1, message, () => {
|
| 623 | socket1.emit('roomHistoryInfo', roomName1, (error, data) => {
|
| 624 | expect(error).not.ok
|
| 625 | expect(data.lastMessageId).equal(1)
|
| 626 | expect(data.historySize).equal(1)
|
| 627 | done()
|
| 628 | })
|
| 629 | })
|
| 630 | })
|
| 631 | })
|
| 632 | })
|
| 633 | })
|
| 634 | })
|
| 635 |
|
| 636 | it('should get and update an user seen info', function (done) {
|
| 637 | chatService = startService()
|
| 638 | chatService.addRoom(roomName1, null, () => {
|
| 639 | let ts = new Date().getTime()
|
| 640 | let tsmax = ts + 2000
|
| 641 | parallel([
|
| 642 | cb => {
|
| 643 | socket1 = clientConnect(user1)
|
| 644 | socket1.on('loginConfirmed',
|
| 645 | () => socket1.emit('roomJoin', roomName1, cb))
|
| 646 | },
|
| 647 | cb => {
|
| 648 | socket2 = clientConnect(user2)
|
| 649 | socket2.on('loginConfirmed',
|
| 650 | () => socket2.emit('roomJoin', roomName1, cb))
|
| 651 | }
|
| 652 | ], error => {
|
| 653 | expect(error).not.ok
|
| 654 | socket1.emit('roomUserSeen', roomName1, user2, (error, info1) => {
|
| 655 | expect(error).not.ok
|
| 656 | expect(info1).an('object')
|
| 657 | expect(info1.joined).true
|
| 658 | expect(info1.timestamp).a('Number')
|
| 659 | expect(info1.timestamp).within(ts, tsmax)
|
| 660 | socket2.emit('roomLeave', roomName1, () => {
|
| 661 | socket1.emit('roomUserSeen', roomName1, user2, (error, info2) => {
|
| 662 | expect(error).not.ok
|
| 663 | expect(info2).an('object')
|
| 664 | expect(info2.joined).false
|
| 665 | expect(info2.timestamp).a('Number')
|
| 666 | expect(info2.timestamp).within(ts, tsmax)
|
| 667 | expect(info2.timestamp).least(info1.timestamp)
|
| 668 | done()
|
| 669 | })
|
| 670 | })
|
| 671 | })
|
| 672 | })
|
| 673 | })
|
| 674 | })
|
| 675 |
|
| 676 | it('should send an empty seen info for unseen users', function (done) {
|
| 677 | chatService = startService()
|
| 678 | chatService.addRoom(roomName1, null, () => {
|
| 679 | socket1 = clientConnect(user1)
|
| 680 | socket1.on('loginConfirmed', () => {
|
| 681 | socket1.emit('roomJoin', roomName1, () => {
|
| 682 | socket1.emit('roomUserSeen', roomName1, user2, (error, info) => {
|
| 683 | expect(error).not.ok
|
| 684 | expect(info).an('object')
|
| 685 | expect(info.joined).false
|
| 686 | expect(info.timestamp).null
|
| 687 | done()
|
| 688 | })
|
| 689 | })
|
| 690 | })
|
| 691 | })
|
| 692 | })
|
| 693 |
|
| 694 | it('should include info in users\' sockets lists', function (done) {
|
| 695 | chatService = startService()
|
| 696 | let { sid1, sid2, sid3 } = {}
|
| 697 | chatService.addRoom(roomName1, null, () => {
|
| 698 | chatService.addRoom(roomName2, null, () => {
|
| 699 | parallel([
|
| 700 | cb => {
|
| 701 | socket1 = clientConnect(user1)
|
| 702 | socket1.on('loginConfirmed', (u, data) => {
|
| 703 | sid1 = data.id
|
| 704 | socket1.emit('roomJoin', roomName1,
|
| 705 | () => socket1.emit('roomJoin', roomName2, cb))
|
| 706 | })
|
| 707 | },
|
| 708 | cb => {
|
| 709 | socket2 = clientConnect(user1)
|
| 710 | socket2.on('loginConfirmed', (u, data) => {
|
| 711 | sid2 = data.id
|
| 712 | socket2.emit('roomJoin', roomName1, cb)
|
| 713 | })
|
| 714 | },
|
| 715 | cb => {
|
| 716 | socket3 = clientConnect(user1)
|
| 717 | socket3.on('loginConfirmed', (u, data) => {
|
| 718 | sid3 = data.id
|
| 719 | cb()
|
| 720 | })
|
| 721 | }
|
| 722 | ], error => {
|
| 723 | expect(error).not.ok
|
| 724 | socket2.emit('listOwnSockets', (error, data) => {
|
| 725 | expect(error).not.ok
|
| 726 | expect(data[sid1]).lengthOf(2)
|
| 727 | expect(data[sid2]).lengthOf(1)
|
| 728 | expect(data[sid3]).lengthOf(0)
|
| 729 | expect(data[sid1]).include.members([roomName1, roomName2])
|
| 730 | expect(data[sid1]).include(roomName1)
|
| 731 | done()
|
| 732 | })
|
| 733 | })
|
| 734 | })
|
| 735 | })
|
| 736 | })
|
| 737 |
|
| 738 | it('should send notifications configuration info', function (done) {
|
| 739 | chatService = startService()
|
| 740 | let config = {enableAccessListsUpdates: false, enableUserlistUpdates: true}
|
| 741 | chatService.addRoom(roomName1, config, () => {
|
| 742 | socket1 = clientConnect(user1)
|
| 743 | socket1.on('loginConfirmed', () => {
|
| 744 | socket1.emit('roomJoin', roomName1, () => {
|
| 745 | socket1.emit('roomNotificationsInfo', roomName1, (error, data) => {
|
| 746 | expect(error).not.ok
|
| 747 | expect(data).an.object
|
| 748 | expect(data.enableAccessListsUpdates).false
|
| 749 | expect(data.enableUserlistUpdates).true
|
| 750 | done()
|
| 751 | })
|
| 752 | })
|
| 753 | })
|
| 754 | })
|
| 755 | })
|
| 756 | }
|