]>
Commit | Line | Data |
---|---|---|
4f32032f C |
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ |
2 | ||
3 | import 'mocha' | |
4 | import * as chai from 'chai' | |
edbc9325 | 5 | import { AbuseFilter, AbusePredefinedReasonsString, AbuseState, Account, AdminAbuse, UserAbuse, VideoComment, AbuseMessage } from '@shared/models' |
4f32032f | 6 | import { |
310b5219 | 7 | addVideoCommentThread, |
4f32032f C |
8 | cleanupTests, |
9 | createUser, | |
310b5219 C |
10 | deleteAbuse, |
11 | deleteVideoComment, | |
4f32032f | 12 | flushAndRunMultipleServers, |
edbc9325 C |
13 | generateUserAccessToken, |
14 | getAccount, | |
15 | getAdminAbusesList, | |
16 | getUserAbusesList, | |
310b5219 C |
17 | getVideoCommentThreads, |
18 | getVideoIdFromUUID, | |
4f32032f | 19 | getVideosList, |
310b5219 | 20 | immutableAssign, |
edbc9325 | 21 | removeUser, |
4f32032f | 22 | removeVideo, |
310b5219 | 23 | reportAbuse, |
4f32032f C |
24 | ServerInfo, |
25 | setAccessTokensToServers, | |
310b5219 | 26 | updateAbuse, |
4f32032f | 27 | uploadVideo, |
310b5219 C |
28 | uploadVideoAndGetId, |
29 | userLogin, | |
edbc9325 C |
30 | addAbuseMessage, |
31 | listAbuseMessages, | |
32 | deleteAbuseMessage | |
4f32032f C |
33 | } from '../../../../shared/extra-utils/index' |
34 | import { doubleFollow } from '../../../../shared/extra-utils/server/follows' | |
35 | import { waitJobs } from '../../../../shared/extra-utils/server/jobs' | |
36 | import { | |
37 | addAccountToServerBlocklist, | |
38 | addServerToServerBlocklist, | |
39 | removeAccountFromServerBlocklist, | |
40 | removeServerFromServerBlocklist | |
41 | } from '../../../../shared/extra-utils/users/blocklist' | |
42 | ||
43 | const expect = chai.expect | |
44 | ||
45 | describe('Test abuses', function () { | |
46 | let servers: ServerInfo[] = [] | |
edbc9325 C |
47 | let abuseServer1: AdminAbuse |
48 | let abuseServer2: AdminAbuse | |
4f32032f C |
49 | |
50 | before(async function () { | |
51 | this.timeout(50000) | |
52 | ||
53 | // Run servers | |
54 | servers = await flushAndRunMultipleServers(2) | |
55 | ||
56 | // Get the access tokens | |
57 | await setAccessTokensToServers(servers) | |
58 | ||
59 | // Server 1 and server 2 follow each other | |
60 | await doubleFollow(servers[0], servers[1]) | |
310b5219 | 61 | }) |
4f32032f | 62 | |
310b5219 | 63 | describe('Video abuses', function () { |
4f32032f | 64 | |
310b5219 C |
65 | before(async function () { |
66 | this.timeout(50000) | |
4f32032f | 67 | |
310b5219 C |
68 | // Upload some videos on each servers |
69 | const video1Attributes = { | |
70 | name: 'my super name for server 1', | |
71 | description: 'my super description for server 1' | |
72 | } | |
73 | await uploadVideo(servers[0].url, servers[0].accessToken, video1Attributes) | |
4f32032f | 74 | |
310b5219 C |
75 | const video2Attributes = { |
76 | name: 'my super name for server 2', | |
77 | description: 'my super description for server 2' | |
78 | } | |
79 | await uploadVideo(servers[1].url, servers[1].accessToken, video2Attributes) | |
4f32032f | 80 | |
310b5219 C |
81 | // Wait videos propagation, server 2 has transcoding enabled |
82 | await waitJobs(servers) | |
4f32032f | 83 | |
310b5219 C |
84 | const res = await getVideosList(servers[0].url) |
85 | const videos = res.body.data | |
4f32032f | 86 | |
310b5219 | 87 | expect(videos.length).to.equal(2) |
4f32032f | 88 | |
310b5219 C |
89 | servers[0].video = videos.find(video => video.name === 'my super name for server 1') |
90 | servers[1].video = videos.find(video => video.name === 'my super name for server 2') | |
91 | }) | |
4f32032f | 92 | |
310b5219 | 93 | it('Should not have abuses', async function () { |
edbc9325 | 94 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
4f32032f | 95 | |
310b5219 C |
96 | expect(res.body.total).to.equal(0) |
97 | expect(res.body.data).to.be.an('array') | |
98 | expect(res.body.data.length).to.equal(0) | |
99 | }) | |
4f32032f | 100 | |
310b5219 C |
101 | it('Should report abuse on a local video', async function () { |
102 | this.timeout(15000) | |
4f32032f | 103 | |
310b5219 C |
104 | const reason = 'my super bad reason' |
105 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: servers[0].video.id, reason }) | |
4f32032f | 106 | |
310b5219 C |
107 | // We wait requests propagation, even if the server 1 is not supposed to make a request to server 2 |
108 | await waitJobs(servers) | |
109 | }) | |
4f32032f | 110 | |
310b5219 | 111 | it('Should have 1 video abuses on server 1 and 0 on server 2', async function () { |
edbc9325 | 112 | const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
4f32032f | 113 | |
310b5219 C |
114 | expect(res1.body.total).to.equal(1) |
115 | expect(res1.body.data).to.be.an('array') | |
116 | expect(res1.body.data.length).to.equal(1) | |
4f32032f | 117 | |
edbc9325 | 118 | const abuse: AdminAbuse = res1.body.data[0] |
310b5219 | 119 | expect(abuse.reason).to.equal('my super bad reason') |
4f32032f | 120 | |
310b5219 C |
121 | expect(abuse.reporterAccount.name).to.equal('root') |
122 | expect(abuse.reporterAccount.host).to.equal(servers[0].host) | |
4f32032f | 123 | |
310b5219 C |
124 | expect(abuse.video.id).to.equal(servers[0].video.id) |
125 | expect(abuse.video.channel).to.exist | |
4f32032f | 126 | |
310b5219 | 127 | expect(abuse.comment).to.be.null |
4f32032f | 128 | |
310b5219 C |
129 | expect(abuse.flaggedAccount.name).to.equal('root') |
130 | expect(abuse.flaggedAccount.host).to.equal(servers[0].host) | |
131 | ||
132 | expect(abuse.video.countReports).to.equal(1) | |
133 | expect(abuse.video.nthReport).to.equal(1) | |
134 | ||
135 | expect(abuse.countReportsForReporter).to.equal(1) | |
136 | expect(abuse.countReportsForReportee).to.equal(1) | |
4f32032f | 137 | |
edbc9325 | 138 | const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) |
310b5219 C |
139 | expect(res2.body.total).to.equal(0) |
140 | expect(res2.body.data).to.be.an('array') | |
141 | expect(res2.body.data.length).to.equal(0) | |
142 | }) | |
4f32032f | 143 | |
310b5219 C |
144 | it('Should report abuse on a remote video', async function () { |
145 | this.timeout(10000) | |
146 | ||
147 | const reason = 'my super bad reason 2' | |
edbc9325 C |
148 | const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid) |
149 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId, reason }) | |
310b5219 C |
150 | |
151 | // We wait requests propagation | |
4f32032f | 152 | await waitJobs(servers) |
310b5219 | 153 | }) |
4f32032f | 154 | |
310b5219 | 155 | it('Should have 2 video abuses on server 1 and 1 on server 2', async function () { |
edbc9325 | 156 | const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
4f32032f | 157 | |
310b5219 C |
158 | expect(res1.body.total).to.equal(2) |
159 | expect(res1.body.data.length).to.equal(2) | |
4f32032f | 160 | |
edbc9325 | 161 | const abuse1: AdminAbuse = res1.body.data[0] |
310b5219 C |
162 | expect(abuse1.reason).to.equal('my super bad reason') |
163 | expect(abuse1.reporterAccount.name).to.equal('root') | |
164 | expect(abuse1.reporterAccount.host).to.equal(servers[0].host) | |
4f32032f | 165 | |
310b5219 C |
166 | expect(abuse1.video.id).to.equal(servers[0].video.id) |
167 | expect(abuse1.video.countReports).to.equal(1) | |
168 | expect(abuse1.video.nthReport).to.equal(1) | |
4f32032f | 169 | |
310b5219 | 170 | expect(abuse1.comment).to.be.null |
4f32032f | 171 | |
310b5219 C |
172 | expect(abuse1.flaggedAccount.name).to.equal('root') |
173 | expect(abuse1.flaggedAccount.host).to.equal(servers[0].host) | |
4f32032f | 174 | |
310b5219 C |
175 | expect(abuse1.state.id).to.equal(AbuseState.PENDING) |
176 | expect(abuse1.state.label).to.equal('Pending') | |
177 | expect(abuse1.moderationComment).to.be.null | |
4f32032f | 178 | |
edbc9325 | 179 | const abuse2: AdminAbuse = res1.body.data[1] |
310b5219 | 180 | expect(abuse2.reason).to.equal('my super bad reason 2') |
4f32032f | 181 | |
310b5219 C |
182 | expect(abuse2.reporterAccount.name).to.equal('root') |
183 | expect(abuse2.reporterAccount.host).to.equal(servers[0].host) | |
4f32032f | 184 | |
310b5219 | 185 | expect(abuse2.video.id).to.equal(servers[1].video.id) |
4f32032f | 186 | |
310b5219 | 187 | expect(abuse2.comment).to.be.null |
4f32032f | 188 | |
310b5219 C |
189 | expect(abuse2.flaggedAccount.name).to.equal('root') |
190 | expect(abuse2.flaggedAccount.host).to.equal(servers[1].host) | |
4f32032f | 191 | |
310b5219 C |
192 | expect(abuse2.state.id).to.equal(AbuseState.PENDING) |
193 | expect(abuse2.state.label).to.equal('Pending') | |
194 | expect(abuse2.moderationComment).to.be.null | |
4f32032f | 195 | |
edbc9325 | 196 | const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) |
310b5219 C |
197 | expect(res2.body.total).to.equal(1) |
198 | expect(res2.body.data.length).to.equal(1) | |
4f32032f | 199 | |
310b5219 C |
200 | abuseServer2 = res2.body.data[0] |
201 | expect(abuseServer2.reason).to.equal('my super bad reason 2') | |
202 | expect(abuseServer2.reporterAccount.name).to.equal('root') | |
203 | expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host) | |
4f32032f | 204 | |
310b5219 C |
205 | expect(abuse2.flaggedAccount.name).to.equal('root') |
206 | expect(abuse2.flaggedAccount.host).to.equal(servers[1].host) | |
4f32032f | 207 | |
310b5219 C |
208 | expect(abuseServer2.state.id).to.equal(AbuseState.PENDING) |
209 | expect(abuseServer2.state.label).to.equal('Pending') | |
210 | expect(abuseServer2.moderationComment).to.be.null | |
211 | }) | |
4f32032f | 212 | |
310b5219 C |
213 | it('Should hide video abuses from blocked accounts', async function () { |
214 | this.timeout(10000) | |
4f32032f | 215 | |
310b5219 C |
216 | { |
217 | const videoId = await getVideoIdFromUUID(servers[1].url, servers[0].video.uuid) | |
218 | await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'will mute this' }) | |
219 | await waitJobs(servers) | |
4f32032f | 220 | |
edbc9325 | 221 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
222 | expect(res.body.total).to.equal(3) |
223 | } | |
4f32032f | 224 | |
310b5219 C |
225 | const accountToBlock = 'root@' + servers[1].host |
226 | ||
227 | { | |
228 | await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock) | |
229 | ||
edbc9325 | 230 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
231 | expect(res.body.total).to.equal(2) |
232 | ||
233 | const abuse = res.body.data.find(a => a.reason === 'will mute this') | |
234 | expect(abuse).to.be.undefined | |
235 | } | |
236 | ||
237 | { | |
238 | await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock) | |
239 | ||
edbc9325 | 240 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
241 | expect(res.body.total).to.equal(3) |
242 | } | |
243 | }) | |
244 | ||
245 | it('Should hide video abuses from blocked servers', async function () { | |
246 | const serverToBlock = servers[1].host | |
247 | ||
248 | { | |
249 | await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host) | |
250 | ||
edbc9325 | 251 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
252 | expect(res.body.total).to.equal(2) |
253 | ||
254 | const abuse = res.body.data.find(a => a.reason === 'will mute this') | |
255 | expect(abuse).to.be.undefined | |
256 | } | |
257 | ||
258 | { | |
259 | await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, serverToBlock) | |
260 | ||
edbc9325 | 261 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
262 | expect(res.body.total).to.equal(3) |
263 | } | |
264 | }) | |
265 | ||
266 | it('Should keep the video abuse when deleting the video', async function () { | |
267 | this.timeout(10000) | |
268 | ||
269 | await removeVideo(servers[1].url, servers[1].accessToken, abuseServer2.video.uuid) | |
270 | ||
271 | await waitJobs(servers) | |
272 | ||
edbc9325 | 273 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) |
310b5219 C |
274 | expect(res.body.total).to.equal(2, "wrong number of videos returned") |
275 | expect(res.body.data).to.have.lengthOf(2, "wrong number of videos returned") | |
276 | ||
edbc9325 | 277 | const abuse: AdminAbuse = res.body.data[0] |
310b5219 C |
278 | expect(abuse.id).to.equal(abuseServer2.id, "wrong origin server id for first video") |
279 | expect(abuse.video.id).to.equal(abuseServer2.video.id, "wrong video id") | |
280 | expect(abuse.video.channel).to.exist | |
281 | expect(abuse.video.deleted).to.be.true | |
282 | }) | |
283 | ||
284 | it('Should include counts of reports from reporter and reportee', async function () { | |
285 | this.timeout(10000) | |
286 | ||
287 | // register a second user to have two reporters/reportees | |
288 | const user = { username: 'user2', password: 'password' } | |
289 | await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, ...user }) | |
290 | const userAccessToken = await userLogin(servers[0], user) | |
291 | ||
292 | // upload a third video via this user | |
293 | const video3Attributes = { | |
294 | name: 'my second super name for server 1', | |
295 | description: 'my second super description for server 1' | |
296 | } | |
297 | await uploadVideo(servers[0].url, userAccessToken, video3Attributes) | |
298 | ||
299 | const res1 = await getVideosList(servers[0].url) | |
300 | const videos = res1.body.data | |
301 | const video3 = videos.find(video => video.name === 'my second super name for server 1') | |
302 | ||
303 | // resume with the test | |
304 | const reason3 = 'my super bad reason 3' | |
305 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video3.id, reason: reason3 }) | |
306 | ||
307 | const reason4 = 'my super bad reason 4' | |
308 | await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: reason4 }) | |
309 | ||
310 | { | |
edbc9325 C |
311 | const res2 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
312 | const abuses = res2.body.data as AdminAbuse[] | |
310b5219 C |
313 | |
314 | const abuseVideo3 = res2.body.data.find(a => a.video.id === video3.id) | |
315 | expect(abuseVideo3).to.not.be.undefined | |
316 | expect(abuseVideo3.video.countReports).to.equal(1, "wrong reports count for video 3") | |
317 | expect(abuseVideo3.video.nthReport).to.equal(1, "wrong report position in report list for video 3") | |
318 | expect(abuseVideo3.countReportsForReportee).to.equal(1, "wrong reports count for reporter on video 3 abuse") | |
319 | expect(abuseVideo3.countReportsForReporter).to.equal(3, "wrong reports count for reportee on video 3 abuse") | |
320 | ||
321 | const abuseServer1 = abuses.find(a => a.video.id === servers[0].video.id) | |
322 | expect(abuseServer1.countReportsForReportee).to.equal(3, "wrong reports count for reporter on video 1 abuse") | |
323 | } | |
324 | }) | |
325 | ||
326 | it('Should list predefined reasons as well as timestamps for the reported video', async function () { | |
327 | this.timeout(10000) | |
328 | ||
329 | const reason5 = 'my super bad reason 5' | |
330 | const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ] | |
331 | const createdAbuse = (await reportAbuse({ | |
332 | url: servers[0].url, | |
333 | token: servers[0].accessToken, | |
334 | videoId: servers[0].video.id, | |
335 | reason: reason5, | |
336 | predefinedReasons: predefinedReasons5, | |
337 | startAt: 1, | |
338 | endAt: 5 | |
339 | })).body.abuse | |
340 | ||
edbc9325 | 341 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
342 | |
343 | { | |
edbc9325 | 344 | const abuse = (res.body.data as AdminAbuse[]).find(a => a.id === createdAbuse.id) |
310b5219 C |
345 | expect(abuse.reason).to.equals(reason5) |
346 | expect(abuse.predefinedReasons).to.deep.equals(predefinedReasons5, "predefined reasons do not match the one reported") | |
347 | expect(abuse.video.startAt).to.equal(1, "starting timestamp doesn't match the one reported") | |
348 | expect(abuse.video.endAt).to.equal(5, "ending timestamp doesn't match the one reported") | |
349 | } | |
350 | }) | |
351 | ||
352 | it('Should delete the video abuse', async function () { | |
353 | this.timeout(10000) | |
354 | ||
355 | await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) | |
356 | ||
357 | await waitJobs(servers) | |
358 | ||
359 | { | |
edbc9325 | 360 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) |
310b5219 C |
361 | expect(res.body.total).to.equal(1) |
362 | expect(res.body.data.length).to.equal(1) | |
363 | expect(res.body.data[0].id).to.not.equal(abuseServer2.id) | |
364 | } | |
365 | ||
366 | { | |
edbc9325 | 367 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) |
310b5219 C |
368 | expect(res.body.total).to.equal(6) |
369 | } | |
370 | }) | |
371 | ||
372 | it('Should list and filter video abuses', async function () { | |
373 | this.timeout(10000) | |
374 | ||
edbc9325 | 375 | async function list (query: Omit<Parameters<typeof getAdminAbusesList>[0], 'url' | 'token'>) { |
310b5219 C |
376 | const options = { |
377 | url: servers[0].url, | |
378 | token: servers[0].accessToken | |
4f32032f | 379 | } |
310b5219 C |
380 | |
381 | Object.assign(options, query) | |
382 | ||
edbc9325 | 383 | const res = await getAdminAbusesList(options) |
310b5219 | 384 | |
edbc9325 | 385 | return res.body.data as AdminAbuse[] |
4f32032f | 386 | } |
4f32032f | 387 | |
310b5219 C |
388 | expect(await list({ id: 56 })).to.have.lengthOf(0) |
389 | expect(await list({ id: 1 })).to.have.lengthOf(1) | |
390 | ||
391 | expect(await list({ search: 'my super name for server 1' })).to.have.lengthOf(4) | |
392 | expect(await list({ search: 'aaaaaaaaaaaaaaaaaaaaaaaaaa' })).to.have.lengthOf(0) | |
393 | ||
394 | expect(await list({ searchVideo: 'my second super name for server 1' })).to.have.lengthOf(1) | |
395 | ||
396 | expect(await list({ searchVideoChannel: 'root' })).to.have.lengthOf(4) | |
397 | expect(await list({ searchVideoChannel: 'aaaa' })).to.have.lengthOf(0) | |
398 | ||
399 | expect(await list({ searchReporter: 'user2' })).to.have.lengthOf(1) | |
400 | expect(await list({ searchReporter: 'root' })).to.have.lengthOf(5) | |
401 | ||
402 | expect(await list({ searchReportee: 'root' })).to.have.lengthOf(5) | |
403 | expect(await list({ searchReportee: 'aaaa' })).to.have.lengthOf(0) | |
404 | ||
405 | expect(await list({ videoIs: 'deleted' })).to.have.lengthOf(1) | |
406 | expect(await list({ videoIs: 'blacklisted' })).to.have.lengthOf(0) | |
407 | ||
408 | expect(await list({ state: AbuseState.ACCEPTED })).to.have.lengthOf(0) | |
409 | expect(await list({ state: AbuseState.PENDING })).to.have.lengthOf(6) | |
410 | ||
411 | expect(await list({ predefinedReason: 'violentOrRepulsive' })).to.have.lengthOf(1) | |
412 | expect(await list({ predefinedReason: 'serverRules' })).to.have.lengthOf(0) | |
413 | }) | |
4f32032f C |
414 | }) |
415 | ||
310b5219 | 416 | describe('Comment abuses', function () { |
4f32032f | 417 | |
310b5219 C |
418 | async function getComment (url: string, videoIdArg: number | string) { |
419 | const videoId = typeof videoIdArg === 'string' | |
420 | ? await getVideoIdFromUUID(url, videoIdArg) | |
421 | : videoIdArg | |
4f32032f | 422 | |
310b5219 | 423 | const res = await getVideoCommentThreads(url, videoId, 0, 5) |
4f32032f | 424 | |
310b5219 | 425 | return res.body.data[0] as VideoComment |
4f32032f C |
426 | } |
427 | ||
310b5219 C |
428 | before(async function () { |
429 | this.timeout(50000) | |
4f32032f | 430 | |
310b5219 C |
431 | servers[0].video = await uploadVideoAndGetId({ server: servers[0], videoName: 'server 1' }) |
432 | servers[1].video = await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' }) | |
433 | ||
434 | await addVideoCommentThread(servers[0].url, servers[0].accessToken, servers[0].video.id, 'comment server 1') | |
435 | await addVideoCommentThread(servers[1].url, servers[1].accessToken, servers[1].video.id, 'comment server 2') | |
436 | ||
437 | await waitJobs(servers) | |
438 | }) | |
439 | ||
440 | it('Should report abuse on a comment', async function () { | |
441 | this.timeout(15000) | |
442 | ||
443 | const comment = await getComment(servers[0].url, servers[0].video.id) | |
444 | ||
445 | const reason = 'it is a bad comment' | |
446 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason }) | |
447 | ||
448 | await waitJobs(servers) | |
449 | }) | |
450 | ||
451 | it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () { | |
452 | { | |
453 | const comment = await getComment(servers[0].url, servers[0].video.id) | |
edbc9325 | 454 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) |
310b5219 C |
455 | |
456 | expect(res.body.total).to.equal(1) | |
457 | expect(res.body.data).to.have.lengthOf(1) | |
458 | ||
edbc9325 | 459 | const abuse: AdminAbuse = res.body.data[0] |
310b5219 C |
460 | expect(abuse.reason).to.equal('it is a bad comment') |
461 | ||
462 | expect(abuse.reporterAccount.name).to.equal('root') | |
463 | expect(abuse.reporterAccount.host).to.equal(servers[0].host) | |
464 | ||
465 | expect(abuse.video).to.be.null | |
466 | ||
467 | expect(abuse.comment.deleted).to.be.false | |
468 | expect(abuse.comment.id).to.equal(comment.id) | |
469 | expect(abuse.comment.text).to.equal(comment.text) | |
470 | expect(abuse.comment.video.name).to.equal('server 1') | |
471 | expect(abuse.comment.video.id).to.equal(servers[0].video.id) | |
472 | expect(abuse.comment.video.uuid).to.equal(servers[0].video.uuid) | |
473 | ||
474 | expect(abuse.countReportsForReporter).to.equal(5) | |
475 | expect(abuse.countReportsForReportee).to.equal(5) | |
476 | } | |
477 | ||
478 | { | |
edbc9325 | 479 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) |
310b5219 C |
480 | expect(res.body.total).to.equal(0) |
481 | expect(res.body.data.length).to.equal(0) | |
482 | } | |
483 | }) | |
484 | ||
485 | it('Should report abuse on a remote comment', async function () { | |
486 | this.timeout(10000) | |
487 | ||
488 | const comment = await getComment(servers[0].url, servers[1].video.uuid) | |
489 | ||
490 | const reason = 'it is a really bad comment' | |
491 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason }) | |
492 | ||
493 | await waitJobs(servers) | |
494 | }) | |
495 | ||
496 | it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () { | |
497 | const commentServer2 = await getComment(servers[0].url, servers[1].video.id) | |
498 | ||
edbc9325 | 499 | const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) |
310b5219 C |
500 | expect(res1.body.total).to.equal(2) |
501 | expect(res1.body.data.length).to.equal(2) | |
502 | ||
edbc9325 | 503 | const abuse: AdminAbuse = res1.body.data[0] |
310b5219 C |
504 | expect(abuse.reason).to.equal('it is a bad comment') |
505 | expect(abuse.countReportsForReporter).to.equal(6) | |
506 | expect(abuse.countReportsForReportee).to.equal(5) | |
507 | ||
edbc9325 | 508 | const abuse2: AdminAbuse = res1.body.data[1] |
310b5219 C |
509 | |
510 | expect(abuse2.reason).to.equal('it is a really bad comment') | |
511 | ||
512 | expect(abuse2.reporterAccount.name).to.equal('root') | |
513 | expect(abuse2.reporterAccount.host).to.equal(servers[0].host) | |
514 | ||
515 | expect(abuse2.video).to.be.null | |
516 | ||
517 | expect(abuse2.comment.deleted).to.be.false | |
518 | expect(abuse2.comment.id).to.equal(commentServer2.id) | |
519 | expect(abuse2.comment.text).to.equal(commentServer2.text) | |
520 | expect(abuse2.comment.video.name).to.equal('server 2') | |
521 | expect(abuse2.comment.video.uuid).to.equal(servers[1].video.uuid) | |
522 | ||
523 | expect(abuse2.state.id).to.equal(AbuseState.PENDING) | |
524 | expect(abuse2.state.label).to.equal('Pending') | |
525 | ||
526 | expect(abuse2.moderationComment).to.be.null | |
527 | ||
528 | expect(abuse2.countReportsForReporter).to.equal(6) | |
529 | expect(abuse2.countReportsForReportee).to.equal(2) | |
530 | ||
edbc9325 | 531 | const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) |
310b5219 C |
532 | expect(res2.body.total).to.equal(1) |
533 | expect(res2.body.data.length).to.equal(1) | |
534 | ||
535 | abuseServer2 = res2.body.data[0] | |
536 | expect(abuseServer2.reason).to.equal('it is a really bad comment') | |
537 | expect(abuseServer2.reporterAccount.name).to.equal('root') | |
538 | expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host) | |
539 | ||
540 | expect(abuseServer2.state.id).to.equal(AbuseState.PENDING) | |
541 | expect(abuseServer2.state.label).to.equal('Pending') | |
542 | ||
543 | expect(abuseServer2.moderationComment).to.be.null | |
544 | ||
545 | expect(abuseServer2.countReportsForReporter).to.equal(1) | |
546 | expect(abuseServer2.countReportsForReportee).to.equal(1) | |
547 | }) | |
548 | ||
549 | it('Should keep the comment abuse when deleting the comment', async function () { | |
550 | this.timeout(10000) | |
551 | ||
552 | const commentServer2 = await getComment(servers[0].url, servers[1].video.id) | |
553 | ||
554 | await deleteVideoComment(servers[0].url, servers[0].accessToken, servers[1].video.uuid, commentServer2.id) | |
555 | ||
556 | await waitJobs(servers) | |
557 | ||
edbc9325 | 558 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) |
310b5219 C |
559 | expect(res.body.total).to.equal(2) |
560 | expect(res.body.data).to.have.lengthOf(2) | |
561 | ||
edbc9325 | 562 | const abuse = (res.body.data as AdminAbuse[]).find(a => a.comment?.id === commentServer2.id) |
310b5219 C |
563 | expect(abuse).to.not.be.undefined |
564 | ||
565 | expect(abuse.comment.text).to.be.empty | |
566 | expect(abuse.comment.video.name).to.equal('server 2') | |
567 | expect(abuse.comment.deleted).to.be.true | |
568 | }) | |
569 | ||
570 | it('Should delete the comment abuse', async function () { | |
571 | this.timeout(10000) | |
572 | ||
573 | await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) | |
574 | ||
575 | await waitJobs(servers) | |
576 | ||
577 | { | |
edbc9325 | 578 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) |
310b5219 C |
579 | expect(res.body.total).to.equal(0) |
580 | expect(res.body.data.length).to.equal(0) | |
581 | } | |
582 | ||
583 | { | |
edbc9325 | 584 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) |
310b5219 C |
585 | expect(res.body.total).to.equal(2) |
586 | } | |
587 | }) | |
588 | ||
589 | it('Should list and filter video abuses', async function () { | |
590 | { | |
edbc9325 C |
591 | const res = await getAdminAbusesList({ |
592 | url: servers[0].url, | |
593 | token: servers[0].accessToken, | |
594 | filter: 'comment', | |
595 | searchReportee: 'foo' | |
596 | }) | |
310b5219 C |
597 | expect(res.body.total).to.equal(0) |
598 | } | |
599 | ||
600 | { | |
edbc9325 C |
601 | const res = await getAdminAbusesList({ |
602 | url: servers[0].url, | |
603 | token: servers[0].accessToken, | |
604 | filter: 'comment', | |
605 | searchReportee: 'ot' | |
606 | }) | |
310b5219 C |
607 | expect(res.body.total).to.equal(2) |
608 | } | |
609 | ||
610 | { | |
611 | const baseParams = { url: servers[0].url, token: servers[0].accessToken, filter: 'comment' as AbuseFilter, start: 1, count: 1 } | |
612 | ||
edbc9325 | 613 | const res1 = await getAdminAbusesList(immutableAssign(baseParams, { sort: 'createdAt' })) |
310b5219 C |
614 | expect(res1.body.data).to.have.lengthOf(1) |
615 | expect(res1.body.data[0].comment.text).to.be.empty | |
616 | ||
edbc9325 | 617 | const res2 = await getAdminAbusesList(immutableAssign(baseParams, { sort: '-createdAt' })) |
310b5219 C |
618 | expect(res2.body.data).to.have.lengthOf(1) |
619 | expect(res2.body.data[0].comment.text).to.equal('comment server 1') | |
4f32032f | 620 | } |
310b5219 C |
621 | }) |
622 | }) | |
4f32032f | 623 | |
310b5219 | 624 | describe('Account abuses', function () { |
4f32032f | 625 | |
310b5219 C |
626 | async function getAccountFromServer (url: string, name: string, server: ServerInfo) { |
627 | const res = await getAccount(url, name + '@' + server.host) | |
4f32032f | 628 | |
310b5219 | 629 | return res.body as Account |
4f32032f C |
630 | } |
631 | ||
310b5219 C |
632 | before(async function () { |
633 | this.timeout(50000) | |
634 | ||
635 | await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: 'user_1', password: 'donald' }) | |
636 | ||
637 | const token = await generateUserAccessToken(servers[1], 'user_2') | |
638 | await uploadVideo(servers[1].url, token, { name: 'super video' }) | |
639 | ||
640 | await waitJobs(servers) | |
641 | }) | |
642 | ||
643 | it('Should report abuse on an account', async function () { | |
644 | this.timeout(15000) | |
645 | ||
646 | const account = await getAccountFromServer(servers[0].url, 'user_1', servers[0]) | |
647 | ||
648 | const reason = 'it is a bad account' | |
649 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason }) | |
650 | ||
651 | await waitJobs(servers) | |
652 | }) | |
653 | ||
654 | it('Should have 1 account abuse on server 1 and 0 on server 2', async function () { | |
655 | { | |
edbc9325 | 656 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) |
310b5219 C |
657 | |
658 | expect(res.body.total).to.equal(1) | |
659 | expect(res.body.data).to.have.lengthOf(1) | |
660 | ||
edbc9325 | 661 | const abuse: AdminAbuse = res.body.data[0] |
310b5219 C |
662 | expect(abuse.reason).to.equal('it is a bad account') |
663 | ||
664 | expect(abuse.reporterAccount.name).to.equal('root') | |
665 | expect(abuse.reporterAccount.host).to.equal(servers[0].host) | |
666 | ||
667 | expect(abuse.video).to.be.null | |
668 | expect(abuse.comment).to.be.null | |
669 | ||
670 | expect(abuse.flaggedAccount.name).to.equal('user_1') | |
671 | expect(abuse.flaggedAccount.host).to.equal(servers[0].host) | |
672 | } | |
673 | ||
674 | { | |
edbc9325 | 675 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) |
310b5219 C |
676 | expect(res.body.total).to.equal(0) |
677 | expect(res.body.data.length).to.equal(0) | |
678 | } | |
679 | }) | |
680 | ||
681 | it('Should report abuse on a remote account', async function () { | |
682 | this.timeout(10000) | |
683 | ||
684 | const account = await getAccountFromServer(servers[0].url, 'user_2', servers[1]) | |
685 | ||
686 | const reason = 'it is a really bad account' | |
687 | await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason }) | |
688 | ||
689 | await waitJobs(servers) | |
690 | }) | |
691 | ||
692 | it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () { | |
edbc9325 | 693 | const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) |
310b5219 C |
694 | expect(res1.body.total).to.equal(2) |
695 | expect(res1.body.data.length).to.equal(2) | |
696 | ||
edbc9325 | 697 | const abuse: AdminAbuse = res1.body.data[0] |
310b5219 | 698 | expect(abuse.reason).to.equal('it is a bad account') |
4f32032f | 699 | |
edbc9325 | 700 | const abuse2: AdminAbuse = res1.body.data[1] |
310b5219 | 701 | expect(abuse2.reason).to.equal('it is a really bad account') |
4f32032f | 702 | |
310b5219 C |
703 | expect(abuse2.reporterAccount.name).to.equal('root') |
704 | expect(abuse2.reporterAccount.host).to.equal(servers[0].host) | |
4f32032f | 705 | |
310b5219 C |
706 | expect(abuse2.video).to.be.null |
707 | expect(abuse2.comment).to.be.null | |
708 | ||
709 | expect(abuse2.state.id).to.equal(AbuseState.PENDING) | |
710 | expect(abuse2.state.label).to.equal('Pending') | |
711 | ||
712 | expect(abuse2.moderationComment).to.be.null | |
713 | ||
edbc9325 | 714 | const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' }) |
310b5219 C |
715 | expect(res2.body.total).to.equal(1) |
716 | expect(res2.body.data.length).to.equal(1) | |
717 | ||
718 | abuseServer2 = res2.body.data[0] | |
719 | ||
720 | expect(abuseServer2.reason).to.equal('it is a really bad account') | |
721 | ||
722 | expect(abuseServer2.reporterAccount.name).to.equal('root') | |
723 | expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host) | |
724 | ||
725 | expect(abuseServer2.state.id).to.equal(AbuseState.PENDING) | |
726 | expect(abuseServer2.state.label).to.equal('Pending') | |
727 | ||
728 | expect(abuseServer2.moderationComment).to.be.null | |
729 | }) | |
730 | ||
731 | it('Should keep the account abuse when deleting the account', async function () { | |
732 | this.timeout(10000) | |
733 | ||
734 | const account = await getAccountFromServer(servers[1].url, 'user_2', servers[1]) | |
735 | await removeUser(servers[1].url, account.userId, servers[1].accessToken) | |
736 | ||
737 | await waitJobs(servers) | |
738 | ||
edbc9325 | 739 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) |
310b5219 C |
740 | expect(res.body.total).to.equal(2) |
741 | expect(res.body.data).to.have.lengthOf(2) | |
742 | ||
edbc9325 | 743 | const abuse = (res.body.data as AdminAbuse[]).find(a => a.reason === 'it is a really bad account') |
310b5219 C |
744 | expect(abuse).to.not.be.undefined |
745 | }) | |
746 | ||
747 | it('Should delete the account abuse', async function () { | |
748 | this.timeout(10000) | |
749 | ||
750 | await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) | |
751 | ||
752 | await waitJobs(servers) | |
753 | ||
754 | { | |
edbc9325 | 755 | const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' }) |
310b5219 C |
756 | expect(res.body.total).to.equal(0) |
757 | expect(res.body.data.length).to.equal(0) | |
758 | } | |
759 | ||
760 | { | |
edbc9325 | 761 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) |
310b5219 C |
762 | expect(res.body.total).to.equal(2) |
763 | ||
764 | abuseServer1 = res.body.data[0] | |
765 | } | |
766 | }) | |
767 | }) | |
4f32032f | 768 | |
310b5219 | 769 | describe('Common actions on abuses', function () { |
4f32032f | 770 | |
310b5219 C |
771 | it('Should update the state of an abuse', async function () { |
772 | const body = { state: AbuseState.REJECTED } | |
773 | await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body) | |
4f32032f | 774 | |
edbc9325 | 775 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id }) |
310b5219 C |
776 | expect(res.body.data[0].state.id).to.equal(AbuseState.REJECTED) |
777 | }) | |
4f32032f | 778 | |
310b5219 C |
779 | it('Should add a moderation comment', async function () { |
780 | const body = { state: AbuseState.ACCEPTED, moderationComment: 'It is valid' } | |
781 | await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body) | |
4f32032f | 782 | |
edbc9325 | 783 | const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id }) |
310b5219 C |
784 | expect(res.body.data[0].state.id).to.equal(AbuseState.ACCEPTED) |
785 | expect(res.body.data[0].moderationComment).to.equal('It is valid') | |
786 | }) | |
4f32032f C |
787 | }) |
788 | ||
edbc9325 C |
789 | describe('My abuses', async function () { |
790 | let abuseId1: number | |
791 | let userAccessToken: string | |
792 | ||
793 | before(async function () { | |
794 | userAccessToken = await generateUserAccessToken(servers[0], 'user_42') | |
795 | ||
796 | await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' }) | |
797 | ||
798 | const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid) | |
799 | await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId, reason: 'user reason 2' }) | |
800 | }) | |
801 | ||
802 | it('Should correctly list my abuses', async function () { | |
803 | { | |
804 | const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 5, sort: 'createdAt' }) | |
805 | expect(res.body.total).to.equal(2) | |
806 | ||
807 | const abuses: UserAbuse[] = res.body.data | |
808 | expect(abuses[0].reason).to.equal('user reason 1') | |
809 | expect(abuses[1].reason).to.equal('user reason 2') | |
810 | ||
811 | abuseId1 = abuses[0].id | |
812 | } | |
813 | ||
814 | { | |
815 | const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: 'createdAt' }) | |
816 | expect(res.body.total).to.equal(2) | |
817 | ||
818 | const abuses: UserAbuse[] = res.body.data | |
819 | expect(abuses[0].reason).to.equal('user reason 2') | |
820 | } | |
821 | ||
822 | { | |
823 | const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: '-createdAt' }) | |
824 | expect(res.body.total).to.equal(2) | |
825 | ||
826 | const abuses: UserAbuse[] = res.body.data | |
827 | expect(abuses[0].reason).to.equal('user reason 1') | |
828 | } | |
829 | }) | |
830 | ||
831 | it('Should correctly filter my abuses by id', async function () { | |
832 | const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, id: abuseId1 }) | |
833 | ||
834 | expect(res.body.total).to.equal(1) | |
835 | ||
836 | const abuses: UserAbuse[] = res.body.data | |
837 | expect(abuses[0].reason).to.equal('user reason 1') | |
838 | }) | |
839 | ||
840 | it('Should correctly filter my abuses by search', async function () { | |
841 | const res = await getUserAbusesList({ | |
842 | url: servers[0].url, | |
843 | token: userAccessToken, | |
844 | search: 'server 2' | |
845 | }) | |
846 | ||
847 | expect(res.body.total).to.equal(1) | |
848 | ||
849 | const abuses: UserAbuse[] = res.body.data | |
850 | expect(abuses[0].reason).to.equal('user reason 2') | |
851 | }) | |
852 | ||
853 | it('Should correctly filter my abuses by state', async function () { | |
854 | const body = { state: AbuseState.REJECTED } | |
855 | await updateAbuse(servers[0].url, servers[0].accessToken, abuseId1, body) | |
856 | ||
857 | const res = await getUserAbusesList({ | |
858 | url: servers[0].url, | |
859 | token: userAccessToken, | |
860 | state: AbuseState.REJECTED | |
861 | }) | |
862 | ||
863 | expect(res.body.total).to.equal(1) | |
864 | ||
865 | const abuses: UserAbuse[] = res.body.data | |
866 | expect(abuses[0].reason).to.equal('user reason 1') | |
867 | }) | |
868 | }) | |
869 | ||
870 | describe('Abuse messages', async function () { | |
871 | let abuseId: number | |
872 | let userAccessToken: string | |
873 | let abuseMessageUserId: number | |
874 | let abuseMessageModerationId: number | |
875 | ||
876 | before(async function () { | |
877 | userAccessToken = await generateUserAccessToken(servers[0], 'user_43') | |
878 | ||
879 | const res = await reportAbuse({ | |
880 | url: servers[0].url, | |
881 | token: userAccessToken, | |
882 | videoId: servers[0].video.id, | |
883 | reason: 'user 43 reason 1' | |
884 | }) | |
885 | ||
886 | abuseId = res.body.abuse.id | |
887 | }) | |
888 | ||
889 | it('Should create some messages on the abuse', async function () { | |
890 | await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 1') | |
891 | await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 2') | |
892 | await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 3') | |
893 | await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 4') | |
894 | }) | |
895 | ||
896 | it('Should have the correct messages count when listing abuses', async function () { | |
897 | const results = await Promise.all([ | |
898 | getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, start: 0, count: 50 }), | |
899 | getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 50 }) | |
900 | ]) | |
901 | ||
902 | for (const res of results) { | |
903 | const abuses: AdminAbuse[] = res.body.data | |
904 | const abuse = abuses.find(a => a.id === abuseId) | |
905 | expect(abuse.countMessages).to.equal(4) | |
906 | } | |
907 | }) | |
908 | ||
909 | it('Should correctly list messages of this abuse', async function () { | |
910 | const results = await Promise.all([ | |
911 | listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId), | |
912 | listAbuseMessages(servers[0].url, userAccessToken, abuseId) | |
913 | ]) | |
914 | ||
915 | for (const res of results) { | |
916 | expect(res.body.total).to.equal(4) | |
917 | ||
918 | const abuseMessages: AbuseMessage[] = res.body.data | |
919 | ||
920 | expect(abuseMessages[0].message).to.equal('message 1') | |
921 | expect(abuseMessages[0].byModerator).to.be.false | |
922 | expect(abuseMessages[0].account.name).to.equal('user_43') | |
923 | ||
924 | abuseMessageUserId = abuseMessages[0].id | |
925 | ||
926 | expect(abuseMessages[1].message).to.equal('message 2') | |
927 | expect(abuseMessages[1].byModerator).to.be.true | |
928 | expect(abuseMessages[1].account.name).to.equal('root') | |
929 | ||
930 | expect(abuseMessages[2].message).to.equal('message 3') | |
931 | expect(abuseMessages[2].byModerator).to.be.true | |
932 | expect(abuseMessages[2].account.name).to.equal('root') | |
933 | abuseMessageModerationId = abuseMessages[2].id | |
934 | ||
935 | expect(abuseMessages[3].message).to.equal('message 4') | |
936 | expect(abuseMessages[3].byModerator).to.be.false | |
937 | expect(abuseMessages[3].account.name).to.equal('user_43') | |
938 | } | |
939 | }) | |
940 | ||
941 | it('Should delete messages', async function () { | |
942 | await deleteAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, abuseMessageModerationId) | |
943 | await deleteAbuseMessage(servers[0].url, userAccessToken, abuseId, abuseMessageUserId) | |
944 | ||
945 | const results = await Promise.all([ | |
946 | listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId), | |
947 | listAbuseMessages(servers[0].url, userAccessToken, abuseId) | |
948 | ]) | |
949 | ||
950 | for (const res of results) { | |
951 | expect(res.body.total).to.equal(2) | |
952 | ||
953 | const abuseMessages: AbuseMessage[] = res.body.data | |
954 | ||
955 | expect(abuseMessages[0].message).to.equal('message 2') | |
956 | expect(abuseMessages[1].message).to.equal('message 4') | |
957 | } | |
958 | }) | |
959 | }) | |
960 | ||
4f32032f C |
961 | after(async function () { |
962 | await cleanupTests(servers) | |
963 | }) | |
964 | }) |