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 get a user mode', function (done) {
|
22 | chatService = startService()
|
23 | chatService.addUser(user1, { whitelistOnly: true }, () => {
|
24 | chatService.execUserCommand(
|
25 | user1, 'directGetWhitelistMode', (error, data) => {
|
26 | expect(error).not.ok
|
27 | expect(data).true
|
28 | done()
|
29 | })
|
30 | })
|
31 | })
|
32 |
|
33 | it('should be able to change user lists', function (done) {
|
34 | chatService = startService()
|
35 | chatService.addUser(user1, null, () => {
|
36 | chatService.execUserCommand(
|
37 | user1, 'directAddToList', 'whitelist', [user2], (error, data) => {
|
38 | expect(error).not.ok
|
39 | expect(data).not.ok
|
40 | chatService.execUserCommand(
|
41 | user1, 'directGetAccessList', 'whitelist', (error, data) => {
|
42 | expect(error).not.ok
|
43 | expect(data).lengthOf(1)
|
44 | expect(data[0]).equal(user2)
|
45 | done()
|
46 | })
|
47 | })
|
48 | })
|
49 | })
|
50 |
|
51 | it('should check room names before adding a new room', function (done) {
|
52 | chatService = startService()
|
53 | chatService.addRoom('room:1', null, (error, data) => {
|
54 | expect(error).ok
|
55 | expect(data).not.ok
|
56 | done()
|
57 | })
|
58 | })
|
59 |
|
60 | it('should be able to get a room mode', function (done) {
|
61 | chatService = startService()
|
62 | chatService.addRoom(roomName1, { whitelistOnly: true }, () => {
|
63 | chatService.execUserCommand(
|
64 | true, 'roomGetWhitelistMode', roomName1, (error, data) => {
|
65 | expect(error).not.ok
|
66 | expect(data).true
|
67 | done()
|
68 | })
|
69 | })
|
70 | })
|
71 |
|
72 | it('should be able to change room lists', function (done) {
|
73 | chatService = startService()
|
74 | chatService.addRoom(roomName1, null, () => {
|
75 | chatService.execUserCommand(
|
76 | true, 'roomAddToList', roomName1, 'whitelist', [user2],
|
77 | (error, data) => {
|
78 | expect(error).not.ok
|
79 | expect(data).not.ok
|
80 | chatService.execUserCommand(
|
81 | true, 'roomGetAccessList', roomName1, 'whitelist',
|
82 | (error, data) => {
|
83 | expect(error).not.ok
|
84 | expect(data).lengthOf(1)
|
85 | expect(data[0]).equal(user2)
|
86 | done()
|
87 | })
|
88 | })
|
89 | })
|
90 | })
|
91 |
|
92 | it('should send system messages to all user\'s sockets', function (done) {
|
93 | let data = 'some data.'
|
94 | chatService = startService()
|
95 | socket1 = clientConnect(user1)
|
96 | socket1.on('loginConfirmed', () => {
|
97 | socket2 = clientConnect(user1)
|
98 | socket2.on('loginConfirmed', () => parallel([
|
99 | cb => chatService.execUserCommand(user1, 'systemMessage', data, cb),
|
100 | cb => socket1.on('systemMessage', d => {
|
101 | expect(d).equal(data)
|
102 | cb()
|
103 | }),
|
104 | cb => socket2.on('systemMessage', d => {
|
105 | expect(d).equal(data)
|
106 | cb()
|
107 | })
|
108 | ], done))
|
109 | })
|
110 | })
|
111 |
|
112 | it('should be able to bypass command hooks', function (done) {
|
113 | let before, after
|
114 | let roomAddToListBefore = (callInfo, args, cb) => {
|
115 | before = true
|
116 | cb()
|
117 | }
|
118 | let roomAddToListAfter = (callInfo, args, results, cb) => {
|
119 | after = true
|
120 | cb()
|
121 | }
|
122 | chatService = startService(null, {roomAddToListBefore, roomAddToListAfter})
|
123 | chatService.addRoom(
|
124 | roomName1, { owner: user1 },
|
125 | () => {
|
126 | chatService.addUser(user2, null, () => {
|
127 | socket1 = clientConnect(user1)
|
128 | socket1.on('loginConfirmed', () => {
|
129 | socket1.emit('roomJoin', roomName1, () => {
|
130 | chatService.execUserCommand(
|
131 | { userName: user1, bypassHooks: true },
|
132 | 'roomAddToList', roomName1, 'whitelist', [user1]
|
133 | , (error, data) => {
|
134 | expect(error).not.ok
|
135 | expect(before).undefined
|
136 | expect(after).undefined
|
137 | expect(data).not.ok
|
138 | done()
|
139 | })
|
140 | })
|
141 | })
|
142 | })
|
143 | })
|
144 | })
|
145 |
|
146 | it('should be able to bypass user messaging permissions', function (done) {
|
147 | let txt = 'Test message.'
|
148 | let message = { textMessage: txt }
|
149 | chatService = startService({ enableDirectMessages: true })
|
150 | chatService.addUser(user1, null, () => {
|
151 | chatService.addUser(user2, {whitelistOnly: true}, () => {
|
152 | socket2 = clientConnect(user2)
|
153 | socket2.on('loginConfirmed', () => {
|
154 | chatService.execUserCommand(
|
155 | { userName: user1, bypassPermissions: true },
|
156 | 'directMessage', user2, message)
|
157 | socket2.on('directMessage', msg => {
|
158 | expect(msg).include.keys('textMessage', 'author', 'timestamp')
|
159 | expect(msg.textMessage).equal(txt)
|
160 | expect(msg.author).equal(user1)
|
161 | expect(msg.timestamp).a('Number')
|
162 | done()
|
163 | })
|
164 | })
|
165 | })
|
166 | })
|
167 | })
|
168 |
|
169 | it('should be able to bypass room messaging permissions', function (done) {
|
170 | let txt = 'Test message.'
|
171 | let message = { textMessage: txt }
|
172 | chatService = startService()
|
173 | chatService.addRoom(
|
174 | roomName1,
|
175 | { whitelistOnly: true, whitelist: [user1] },
|
176 | () =>
|
177 | chatService.addUser(
|
178 | user2, null, () => {
|
179 | socket1 = clientConnect(user1)
|
180 | socket1.on('loginConfirmed', () => {
|
181 | socket1.emit('roomJoin', roomName1, () => {
|
182 | chatService.execUserCommand(
|
183 | { userName: user2, bypassPermissions: true },
|
184 | 'roomMessage', roomName1, message)
|
185 | socket1.on('roomMessage', (room, msg) => {
|
186 | expect(room).equal(roomName1)
|
187 | expect(msg.author).equal(user2)
|
188 | expect(msg.textMessage).equal(txt)
|
189 | expect(msg).ownProperty('timestamp')
|
190 | expect(msg).ownProperty('id')
|
191 | done()
|
192 | })
|
193 | })
|
194 | })
|
195 | }))
|
196 | })
|
197 |
|
198 | it('should be able to send room messages without an user', function (done) {
|
199 | let txt = 'Test message.'
|
200 | let message = { textMessage: txt }
|
201 | chatService = startService()
|
202 | chatService.addRoom(roomName1, null, () => {
|
203 | socket1 = clientConnect(user1)
|
204 | socket1.on('loginConfirmed', () => {
|
205 | socket1.emit('roomJoin', roomName1, () => {
|
206 | chatService.execUserCommand(
|
207 | true, 'roomMessage', roomName1, message,
|
208 | (error, data) => expect(error).not.ok)
|
209 | socket1.on('roomMessage', (room, msg) => {
|
210 | expect(room).equal(roomName1)
|
211 | expect(room).equal(roomName1)
|
212 | expect(msg.author).undefined
|
213 | expect(msg.textMessage).equal(txt)
|
214 | expect(msg).ownProperty('timestamp')
|
215 | expect(msg).ownProperty('id')
|
216 | done()
|
217 | })
|
218 | })
|
219 | })
|
220 | })
|
221 | })
|
222 |
|
223 | it('should not allow using non-existing users', function (done) {
|
224 | let txt = 'Test message.'
|
225 | let message = { textMessage: txt }
|
226 | chatService = startService()
|
227 | chatService.addRoom(roomName1, null, () => {
|
228 | chatService.execUserCommand(
|
229 | user1, 'roomMessage', roomName1, message, (error, data) => {
|
230 | expect(error).ok
|
231 | expect(data).not.ok
|
232 | done()
|
233 | })
|
234 | })
|
235 | })
|
236 |
|
237 | it('should be able to check direct messaging permissions', function (done) {
|
238 | chatService = startService()
|
239 | socket1 = clientConnect(user1)
|
240 | socket1.on('loginConfirmed', () => {
|
241 | socket1.emit('directAddToList', 'blacklist', [user3], error => {
|
242 | expect(error).not.ok
|
243 | parallel([
|
244 | cb => {
|
245 | chatService.hasDirectAccess(user1, user2, (error, data) => {
|
246 | expect(error).not.ok
|
247 | expect(data).true
|
248 | cb()
|
249 | })
|
250 | chatService.hasDirectAccess(user1, user3, (error, data) => {
|
251 | expect(error).not.ok
|
252 | expect(data).false
|
253 | cb()
|
254 | })
|
255 | }
|
256 | ], done)
|
257 | })
|
258 | })
|
259 | })
|
260 |
|
261 | it('should be able to check room messaging permissions', function (done) {
|
262 | chatService = startService()
|
263 | chatService.addRoom(roomName1, {blacklist: [user3]}, () => parallel([
|
264 | cb => {
|
265 | chatService.hasRoomAccess(roomName1, user2, (error, data) => {
|
266 | expect(error).not.ok
|
267 | expect(data).true
|
268 | cb()
|
269 | })
|
270 | chatService.hasRoomAccess(roomName1, user3, (error, data) => {
|
271 | expect(error).not.ok
|
272 | expect(data).false
|
273 | cb()
|
274 | })
|
275 | }
|
276 | ], done))
|
277 | })
|
278 | }
|