1 | 'use strict'
|
2 |
|
3 |
|
4 | const { expect } = require('chai')
|
5 |
|
6 | const { cleanup, clientConnect, parallel, startService } =
|
7 | require('./testutils')
|
8 |
|
9 | const { cleanupTimeout, user1, user2, user3, roomName1 } =
|
10 | 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 be able to disconnect all user\'s sockets', function (done) {
|
22 | chatService = startService()
|
23 | socket1 = clientConnect(user1)
|
24 | socket1.on('loginConfirmed', u => {
|
25 | expect(u).equal(user1)
|
26 | socket2 = clientConnect(user1)
|
27 | socket2.on('loginConfirmed', u => {
|
28 | expect(u).equal(user1)
|
29 | parallel([
|
30 | cb => {
|
31 | chatService.disconnectUserSockets(user1)
|
32 | cb()
|
33 | },
|
34 | cb => socket1.on('disconnect', () => {
|
35 | expect(socket1.connected).not.ok
|
36 | cb()
|
37 | }),
|
38 | cb => socket2.on('disconnect', () => {
|
39 | expect(socket2.connected).not.ok
|
40 | cb()
|
41 | })
|
42 | ], done)
|
43 | })
|
44 | })
|
45 | })
|
46 |
|
47 | it('should be able to add users', function (done) {
|
48 | chatService = startService()
|
49 | chatService.addUser(user1, { whitelistOnly: true }, () => {
|
50 | socket1 = clientConnect(user1)
|
51 | socket1.on('loginConfirmed', () => {
|
52 | socket1.emit('directGetWhitelistMode', (error, data) => {
|
53 | expect(error).not.ok
|
54 | expect(data).true
|
55 | done()
|
56 | })
|
57 | })
|
58 | })
|
59 | })
|
60 |
|
61 | it('should be able to delete users', function (done) {
|
62 | chatService = startService()
|
63 | socket1 = clientConnect(user1)
|
64 | socket1.on('loginConfirmed', () => {
|
65 | chatService.disconnectUserSockets(user1)
|
66 | socket1.on('disconnect', () => {
|
67 | chatService.hasUser(user1, (error, data) => {
|
68 | expect(error).not.ok
|
69 | expect(data).true
|
70 | chatService.deleteUser(user1, error => {
|
71 | expect(error).not.ok
|
72 | chatService.hasUser(user1, (error, data) => {
|
73 | expect(error).not.ok
|
74 | expect(data).false
|
75 | done()
|
76 | })
|
77 | })
|
78 | })
|
79 | })
|
80 | })
|
81 | })
|
82 |
|
83 | it('should not delete connected users', function (done) {
|
84 | chatService = startService()
|
85 | socket1 = clientConnect(user1)
|
86 | socket1.on('loginConfirmed', () => {
|
87 | chatService.deleteUser(user1, error => {
|
88 | expect(error).ok
|
89 | done()
|
90 | })
|
91 | })
|
92 | })
|
93 |
|
94 | it('should be able to delete rooms', function (done) {
|
95 | chatService = startService()
|
96 | chatService.addRoom(roomName1, { owner: user1 }, () => {
|
97 | chatService.hasRoom(roomName1, (error, data) => {
|
98 | expect(error).not.ok
|
99 | expect(data).true
|
100 | chatService.deleteRoom(roomName1, (error, data) => {
|
101 | expect(error).not.ok
|
102 | expect(data).not.ok
|
103 | chatService.hasRoom(roomName1, (error, data) => {
|
104 | expect(error).not.ok
|
105 | expect(data).false
|
106 | done()
|
107 | })
|
108 | })
|
109 | })
|
110 | })
|
111 | })
|
112 |
|
113 | it('should check user names before adding a new user', function (done) {
|
114 | chatService = startService()
|
115 | chatService.addUser('user:1', null, (error, data) => {
|
116 | expect(error).ok
|
117 | expect(data).not.ok
|
118 | done()
|
119 | })
|
120 | })
|
121 |
|
122 | it('should check existing users before adding a new one', function (done) {
|
123 | chatService = startService()
|
124 | chatService.addUser(user1, null, () => {
|
125 | chatService.addUser(user1, null, (error, data) => {
|
126 | expect(error).ok
|
127 | expect(data).not.ok
|
128 | done()
|
129 | })
|
130 | })
|
131 | })
|
132 |
|
133 | it('should check commands for existence', function (done) {
|
134 | chatService = startService()
|
135 | chatService.addUser(user1, null, () => {
|
136 | chatService.execUserCommand(user1, 'nocmd', error => {
|
137 | expect(error).ok
|
138 | done()
|
139 | })
|
140 | })
|
141 | })
|
142 |
|
143 | it('should check for socket ids if required', function (done) {
|
144 | chatService = startService()
|
145 | chatService.addUser(user1, null, () => {
|
146 | chatService.addRoom(roomName1, null, () => {
|
147 | chatService.execUserCommand(user1, 'roomJoin', roomName1, error => {
|
148 | expect(error).ok
|
149 | done()
|
150 | })
|
151 | })
|
152 | })
|
153 | })
|
154 |
|
155 | it('should be able to change a room owner', function (done) {
|
156 | chatService = startService()
|
157 | chatService.addRoom(roomName1, { owner: user1 }, () => {
|
158 | socket1 = clientConnect(user1)
|
159 | socket1.on('loginConfirmed', () => {
|
160 | socket1.emit('roomJoin', roomName1, () => {
|
161 | chatService.changeRoomOwner(roomName1, user2, (error, data) => {
|
162 | expect(error).not.ok
|
163 | expect(data).not.ok
|
164 | socket1.emit('roomGetOwner', roomName1, (error, data) => {
|
165 | expect(error).not.ok
|
166 | expect(data).equal(user2)
|
167 | done()
|
168 | })
|
169 | })
|
170 | })
|
171 | })
|
172 | })
|
173 | })
|
174 |
|
175 | it('should be able to change a room history limit', function (done) {
|
176 | let sz = 100
|
177 | chatService = startService()
|
178 | chatService.addRoom(roomName1, null, () => {
|
179 | chatService.changeRoomHistoryMaxSize(roomName1, sz, (error, data) => {
|
180 | expect(error).not.ok
|
181 | expect(data).not.ok
|
182 | socket1 = clientConnect(user1)
|
183 | socket1.on('loginConfirmed', () => {
|
184 | socket1.emit('roomJoin', roomName1, () => {
|
185 | socket1.emit('roomHistoryInfo', roomName1, (error, data) => {
|
186 | expect(error).not.ok
|
187 | expect(data).ownProperty('historyMaxSize')
|
188 | expect(data.historyMaxSize).equal(sz)
|
189 | done()
|
190 | })
|
191 | })
|
192 | })
|
193 | })
|
194 | })
|
195 | })
|
196 |
|
197 | it('should be able to check room lists', function (done) {
|
198 | chatService = startService()
|
199 | chatService.addRoom(
|
200 | roomName1,
|
201 | { adminlist: [user1] },
|
202 | () => chatService.roomHasInList(
|
203 | roomName1, 'adminlist', user1, (error, data) => {
|
204 | expect(error).not.ok
|
205 | expect(data).true
|
206 | chatService.roomHasInList(
|
207 | roomName1, 'adminlist', user2, (error, data) => {
|
208 | expect(error).not.ok
|
209 | expect(data).false
|
210 | done()
|
211 | })
|
212 | }))
|
213 | })
|
214 |
|
215 | it('should be able to check user lists', function (done) {
|
216 | chatService = startService()
|
217 | chatService.addUser(
|
218 | user1, { blacklist: [user2] },
|
219 | () => chatService.userHasInList(
|
220 | user1, 'blacklist', user2, (error, data) => {
|
221 | expect(error).not.ok
|
222 | expect(data).true
|
223 | chatService.userHasInList(
|
224 | user1, 'blacklist', user3, (error, data) => {
|
225 | expect(error).not.ok
|
226 | expect(data).false
|
227 | done()
|
228 | })
|
229 | }))
|
230 | })
|
231 |
|
232 | it('should be able to leave and join sockets', function (done) {
|
233 | chatService = startService()
|
234 | chatService.addRoom(roomName1, null, () => {
|
235 | socket1 = clientConnect(user1)
|
236 | let context = { userName: user1 }
|
237 | socket1.on('loginConfirmed', (userName, {id}) => {
|
238 | context.id = id
|
239 | chatService.execUserCommand(context, 'roomJoin', roomName1)
|
240 | socket1.on('roomJoinedEcho', (roomName, id, njoined) => {
|
241 | expect(roomName).equal(roomName1)
|
242 | expect(id).equal(context.id)
|
243 | expect(njoined).equal(1)
|
244 | let msg = { textMessage: 'Text message' }
|
245 | chatService.execUserCommand(context, 'roomMessage', roomName1, msg)
|
246 | socket1.on('roomMessage', (roomName, message) => {
|
247 | expect(roomName).equal(roomName1)
|
248 | chatService.execUserCommand(context, 'roomLeave', roomName1)
|
249 | socket1.on('roomLeftEcho', (roomName, id, njoined) => {
|
250 | expect(roomName).equal(roomName1)
|
251 | expect(id).equal(context.id)
|
252 | expect(njoined).equal(0)
|
253 | done()
|
254 | })
|
255 | })
|
256 | })
|
257 | })
|
258 | })
|
259 | })
|
260 |
|
261 | it('should be able to enable access lists updates', function (done) {
|
262 | chatService = startService()
|
263 | chatService.addRoom(roomName1, { owner: user1 }, () => {
|
264 | socket1 = clientConnect(user1)
|
265 | socket1.on('loginConfirmed', () => {
|
266 | socket1.emit('roomJoin', roomName1, () => {
|
267 | chatService.changeAccessListsUpdates(roomName1, true, error => {
|
268 | expect(error).not.ok
|
269 | chatService.execUserCommand(
|
270 | user1, 'roomAddToList', roomName1, 'whitelist', [user2])
|
271 | socket1.on('roomAccessListAdded', (roomName, listName, names) => {
|
272 | expect(roomName).equal(roomName1)
|
273 | expect(listName).equal('whitelist')
|
274 | expect(names[0]).equal(user2)
|
275 | done()
|
276 | })
|
277 | })
|
278 | })
|
279 | })
|
280 | })
|
281 | })
|
282 |
|
283 | it('should be able to enable user list updates', function (done) {
|
284 | chatService = startService()
|
285 | chatService.addRoom(roomName1, { owner: user1 }, () => {
|
286 | socket1 = clientConnect(user1)
|
287 | socket1.on('loginConfirmed', () => {
|
288 | socket1.emit('roomJoin', roomName1, () => {
|
289 | chatService.changeUserlistUpdates(roomName1, true, error => {
|
290 | expect(error).not.ok
|
291 | socket1.on('roomUserJoined', (roomName, userName) => {
|
292 | expect(roomName).equal(roomName1)
|
293 | expect(userName).equal(user2)
|
294 | done()
|
295 | })
|
296 | socket2 = clientConnect(user2)
|
297 | socket2.on('loginConfirmed', () => {
|
298 | socket2.emit('roomJoin', roomName1)
|
299 | })
|
300 | })
|
301 | })
|
302 | })
|
303 | })
|
304 | })
|
305 | }
|