borekon/PeerTube_original
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Introduce abuse command

Browse Source
This commit is contained in:
Chocobozzz 2021-07-06 12:01:59 +02:00
parent 8ef9457fde
commit 0c1a77e9cc
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
12 changed files with 633 additions and 729 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
server/tests/api/check-params/abuses.ts
View File

@ -1,46 +1,40 @@
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import 'mocha' import 'mocha'
import { AbuseCreate, AbuseState } from '@shared/models' import { HttpStatusCode } from '@shared/core-utils'
import { import {
addAbuseMessage, AbusesCommand,
checkBadCountPagination,
checkBadSortPagination,
checkBadStartPagination,
cleanupTests, cleanupTests,
createUser, createUser,
deleteAbuse,
deleteAbuseMessage,
doubleFollow, doubleFollow,
flushAndRunServer, flushAndRunServer,
generateUserAccessToken, generateUserAccessToken,
getAdminAbusesList,
getVideoIdFromUUID, getVideoIdFromUUID,
listAbuseMessages,
makeGetRequest, makeGetRequest,
makePostBodyRequest, makePostBodyRequest,
reportAbuse,
ServerInfo, ServerInfo,
setAccessTokensToServers, setAccessTokensToServers,
updateAbuse,
uploadVideo, uploadVideo,
userLogin, userLogin,
waitJobs waitJobs
} from '../../../../shared/extra-utils' } from '@shared/extra-utils'
import { import { AbuseCreate, AbuseState } from '@shared/models'
checkBadCountPagination,
checkBadSortPagination,
checkBadStartPagination
} from '../../../../shared/extra-utils/requests/check-api-params'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
describe('Test abuses API validators', function () { describe('Test abuses API validators', function () {
const basePath = '/api/v1/abuses/' const basePath = '/api/v1/abuses/'
let server: ServerInfo let server: ServerInfo
let userAccessToken = '' let userToken = ''
let userAccessToken2 = '' let userToken2 = ''
let abuseId: number let abuseId: number
let messageId: number let messageId: number
let command: AbusesCommand
// --------------------------------------------------------------- // ---------------------------------------------------------------
before(async function () { before(async function () {
@ -53,14 +47,14 @@ describe('Test abuses API validators', function () {
const username = 'user1' const username = 'user1'
const password = 'my super password' const password = 'my super password'
await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password }) await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
userAccessToken = await userLogin(server, { username, password }) userToken = await userLogin(server, { username, password })
{ userToken2 = await generateUserAccessToken(server, 'user_2')
userAccessToken2 = await generateUserAccessToken(server, 'user_2')
}
const res = await uploadVideo(server.url, server.accessToken, {}) const res = await uploadVideo(server.url, server.accessToken, {})
server.video = res.body.video server.video = res.body.video
command = server.abusesCommand
}) })
describe('When listing abuses for admins', function () { describe('When listing abuses for admins', function () {
@ -90,7 +84,7 @@ describe('Test abuses API validators', function () {
await makeGetRequest({ await makeGetRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
statusCodeExpected: HttpStatusCode.FORBIDDEN_403 statusCodeExpected: HttpStatusCode.FORBIDDEN_403
}) })
}) })
@ -134,15 +128,15 @@ describe('Test abuses API validators', function () {
const path = '/api/v1/users/me/abuses' const path = '/api/v1/users/me/abuses'
it('Should fail with a bad start pagination', async function () { it('Should fail with a bad start pagination', async function () {
await checkBadStartPagination(server.url, path, userAccessToken) await checkBadStartPagination(server.url, path, userToken)
}) })
it('Should fail with a bad count pagination', async function () { it('Should fail with a bad count pagination', async function () {
await checkBadCountPagination(server.url, path, userAccessToken) await checkBadCountPagination(server.url, path, userToken)
}) })
it('Should fail with an incorrect sort', async function () { it('Should fail with an incorrect sort', async function () {
await checkBadSortPagination(server.url, path, userAccessToken) await checkBadSortPagination(server.url, path, userToken)
}) })
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
@ -154,12 +148,12 @@ describe('Test abuses API validators', function () {
}) })
it('Should fail with a bad id filter', async function () { it('Should fail with a bad id filter', async function () {
await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { id: 'toto' } }) await makeGetRequest({ url: server.url, path, token: userToken, query: { id: 'toto' } })
}) })
it('Should fail with a bad state filter', async function () { it('Should fail with a bad state filter', async function () {
await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { state: 'toto' } }) await makeGetRequest({ url: server.url, path, token: userToken, query: { state: 'toto' } })
await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { state: 0 } }) await makeGetRequest({ url: server.url, path, token: userToken, query: { state: 0 } })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
@ -168,7 +162,7 @@ describe('Test abuses API validators', function () {
state: 2 state: 2
} }
await makeGetRequest({ url: server.url, path, token: userAccessToken, query, statusCodeExpected: HttpStatusCode.OK_200 }) await makeGetRequest({ url: server.url, path, token: userToken, query, statusCodeExpected: HttpStatusCode.OK_200 })
}) })
}) })
@ -177,12 +171,12 @@ describe('Test abuses API validators', function () {
it('Should fail with nothing', async function () { it('Should fail with nothing', async function () {
const fields = {} const fields = {}
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should fail with a wrong video', async function () { it('Should fail with a wrong video', async function () {
const fields = { video: { id: 'blabla' }, reason: 'my super reason' } const fields = { video: { id: 'blabla' }, reason: 'my super reason' }
await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
}) })
it('Should fail with an unknown video', async function () { it('Should fail with an unknown video', async function () {
@ -190,7 +184,7 @@ describe('Test abuses API validators', function () {
await makePostBodyRequest({ await makePostBodyRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
fields, fields,
statusCodeExpected: HttpStatusCode.NOT_FOUND_404 statusCodeExpected: HttpStatusCode.NOT_FOUND_404
}) })
@ -198,7 +192,7 @@ describe('Test abuses API validators', function () {
it('Should fail with a wrong comment', async function () { it('Should fail with a wrong comment', async function () {
const fields = { comment: { id: 'blabla' }, reason: 'my super reason' } const fields = { comment: { id: 'blabla' }, reason: 'my super reason' }
await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
}) })
it('Should fail with an unknown comment', async function () { it('Should fail with an unknown comment', async function () {
@ -206,7 +200,7 @@ describe('Test abuses API validators', function () {
await makePostBodyRequest({ await makePostBodyRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
fields, fields,
statusCodeExpected: HttpStatusCode.NOT_FOUND_404 statusCodeExpected: HttpStatusCode.NOT_FOUND_404
}) })
@ -214,7 +208,7 @@ describe('Test abuses API validators', function () {
it('Should fail with a wrong account', async function () { it('Should fail with a wrong account', async function () {
const fields = { account: { id: 'blabla' }, reason: 'my super reason' } const fields = { account: { id: 'blabla' }, reason: 'my super reason' }
await makePostBodyRequest({ url: server.url, path: path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path: path, token: userToken, fields })
}) })
it('Should fail with an unknown account', async function () { it('Should fail with an unknown account', async function () {
@ -222,7 +216,7 @@ describe('Test abuses API validators', function () {
await makePostBodyRequest({ await makePostBodyRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
fields, fields,
statusCodeExpected: HttpStatusCode.NOT_FOUND_404 statusCodeExpected: HttpStatusCode.NOT_FOUND_404
}) })
@ -233,7 +227,7 @@ describe('Test abuses API validators', function () {
await makePostBodyRequest({ await makePostBodyRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
fields, fields,
statusCodeExpected: HttpStatusCode.BAD_REQUEST_400 statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
}) })
@ -248,13 +242,13 @@ describe('Test abuses API validators', function () {
it('Should fail with a reason too short', async function () { it('Should fail with a reason too short', async function () {
const fields = { video: { id: server.video.id }, reason: 'h' } const fields = { video: { id: server.video.id }, reason: 'h' }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should fail with a too big reason', async function () { it('Should fail with a too big reason', async function () {
const fields = { video: { id: server.video.id }, reason: 'super'.repeat(605) } const fields = { video: { id: server.video.id }, reason: 'super'.repeat(605) }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should succeed with the correct parameters (basic)', async function () { it('Should succeed with the correct parameters (basic)', async function () {
@ -263,7 +257,7 @@ describe('Test abuses API validators', function () {
const res = await makePostBodyRequest({ const res = await makePostBodyRequest({
url: server.url, url: server.url,
path, path,
token: userAccessToken, token: userToken,
fields, fields,
statusCodeExpected: HttpStatusCode.OK_200 statusCodeExpected: HttpStatusCode.OK_200
}) })
@ -273,19 +267,19 @@ describe('Test abuses API validators', function () {
it('Should fail with a wrong predefined reason', async function () { it('Should fail with a wrong predefined reason', async function () {
const fields = { video: { id: server.video.id }, reason: 'my super reason', predefinedReasons: [ 'wrongPredefinedReason' ] } const fields = { video: { id: server.video.id }, reason: 'my super reason', predefinedReasons: [ 'wrongPredefinedReason' ] }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should fail with negative timestamps', async function () { it('Should fail with negative timestamps', async function () {
const fields = { video: { id: server.video.id, startAt: -1 }, reason: 'my super reason' } const fields = { video: { id: server.video.id, startAt: -1 }, reason: 'my super reason' }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should fail mith misordered startAt/endAt', async function () { it('Should fail mith misordered startAt/endAt', async function () {
const fields = { video: { id: server.video.id, startAt: 5, endAt: 1 }, reason: 'my super reason' } const fields = { video: { id: server.video.id, startAt: 5, endAt: 1 }, reason: 'my super reason' }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
}) })
it('Should succeed with the corret parameters (advanced)', async function () { it('Should succeed with the corret parameters (advanced)', async function () {
@ -299,37 +293,37 @@ describe('Test abuses API validators', function () {
predefinedReasons: [ 'serverRules' ] predefinedReasons: [ 'serverRules' ]
} }
await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: HttpStatusCode.OK_200 }) await makePostBodyRequest({ url: server.url, path, token: userToken, fields, statusCodeExpected: HttpStatusCode.OK_200 })
}) })
}) })
describe('When updating an abuse', function () { describe('When updating an abuse', function () {
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await updateAbuse(server.url, 'blabla', abuseId, {}, HttpStatusCode.UNAUTHORIZED_401) await command.update({ token: 'blabla', abuseId, body: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with a non admin user', async function () { it('Should fail with a non admin user', async function () {
await updateAbuse(server.url, userAccessToken, abuseId, {}, HttpStatusCode.FORBIDDEN_403) await command.update({ token: userToken, abuseId, body: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail with a bad abuse id', async function () { it('Should fail with a bad abuse id', async function () {
await updateAbuse(server.url, server.accessToken, 45, {}, HttpStatusCode.NOT_FOUND_404) await command.update({ abuseId: 45, body: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a bad state', async function () { it('Should fail with a bad state', async function () {
const body = { state: 5 } const body = { state: 5 }
await updateAbuse(server.url, server.accessToken, abuseId, body, HttpStatusCode.BAD_REQUEST_400) await command.update({ abuseId, body, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should fail with a bad moderation comment', async function () { it('Should fail with a bad moderation comment', async function () {
const body = { moderationComment: 'b'.repeat(3001) } const body = { moderationComment: 'b'.repeat(3001) }
await updateAbuse(server.url, server.accessToken, abuseId, body, HttpStatusCode.BAD_REQUEST_400) await command.update({ abuseId, body, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
const body = { state: AbuseState.ACCEPTED } const body = { state: AbuseState.ACCEPTED }
await updateAbuse(server.url, server.accessToken, abuseId, body) await command.update({ abuseId, body })
}) })
}) })
@ -337,23 +331,23 @@ describe('Test abuses API validators', function () {
const message = 'my super message' const message = 'my super message'
it('Should fail with an invalid abuse id', async function () { it('Should fail with an invalid abuse id', async function () {
await addAbuseMessage(server.url, userAccessToken2, 888, message, HttpStatusCode.NOT_FOUND_404) await command.addMessage({ token: userToken2, abuseId: 888, message, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await addAbuseMessage(server.url, 'fake_token', abuseId, message, HttpStatusCode.UNAUTHORIZED_401) await command.addMessage({ token: 'fake_token', abuseId, message, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with an invalid logged in user', async function () { it('Should fail with an invalid logged in user', async function () {
await addAbuseMessage(server.url, userAccessToken2, abuseId, message, HttpStatusCode.FORBIDDEN_403) await command.addMessage({ token: userToken2, abuseId, message, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail with an invalid message', async function () { it('Should fail with an invalid message', async function () {
await addAbuseMessage(server.url, userAccessToken, abuseId, 'a'.repeat(5000), HttpStatusCode.BAD_REQUEST_400) await command.addMessage({ token: userToken, abuseId, message: 'a'.repeat(5000), expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should suceed with the correct params', async function () { it('Should suceed with the correct params', async function () {
const res = await addAbuseMessage(server.url, userAccessToken, abuseId, message) const res = await command.addMessage({ token: userToken, abuseId, message })
messageId = res.body.abuseMessage.id messageId = res.body.abuseMessage.id
}) })
}) })
@ -361,61 +355,60 @@ describe('Test abuses API validators', function () {
describe('When listing abuse messages', function () { describe('When listing abuse messages', function () {
it('Should fail with an invalid abuse id', async function () { it('Should fail with an invalid abuse id', async function () {
await listAbuseMessages(server.url, userAccessToken, 888, HttpStatusCode.NOT_FOUND_404) await command.listMessages({ token: userToken, abuseId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await listAbuseMessages(server.url, 'fake_token', abuseId, HttpStatusCode.UNAUTHORIZED_401) await command.listMessages({ token: 'fake_token', abuseId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with an invalid logged in user', async function () { it('Should fail with an invalid logged in user', async function () {
await listAbuseMessages(server.url, userAccessToken2, abuseId, HttpStatusCode.FORBIDDEN_403) await command.listMessages({ token: userToken2, abuseId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
await listAbuseMessages(server.url, userAccessToken, abuseId) await command.listMessages({ token: userToken, abuseId })
}) })
}) })
describe('When deleting an abuse message', function () { describe('When deleting an abuse message', function () {
it('Should fail with an invalid abuse id', async function () { it('Should fail with an invalid abuse id', async function () {
await deleteAbuseMessage(server.url, userAccessToken, 888, messageId, HttpStatusCode.NOT_FOUND_404) await command.deleteMessage({ token: userToken, abuseId: 888, messageId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with an invalid message id', async function () { it('Should fail with an invalid message id', async function () {
await deleteAbuseMessage(server.url, userAccessToken, abuseId, 888, HttpStatusCode.NOT_FOUND_404) await command.deleteMessage({ token: userToken, abuseId, messageId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await deleteAbuseMessage(server.url, 'fake_token', abuseId, messageId, HttpStatusCode.UNAUTHORIZED_401) await command.deleteMessage({ token: 'fake_token', abuseId, messageId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with an invalid logged in user', async function () { it('Should fail with an invalid logged in user', async function () {
await deleteAbuseMessage(server.url, userAccessToken2, abuseId, messageId, HttpStatusCode.FORBIDDEN_403) await command.deleteMessage({ token: userToken2, abuseId, messageId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
await deleteAbuseMessage(server.url, userAccessToken, abuseId, messageId) await command.deleteMessage({ token: userToken, abuseId, messageId })
}) })
}) })
describe('When deleting a video abuse', function () { describe('When deleting a video abuse', function () {
it('Should fail with a non authenticated user', async function () { it('Should fail with a non authenticated user', async function () {
await deleteAbuse(server.url, 'blabla', abuseId, HttpStatusCode.UNAUTHORIZED_401) await command.delete({ token: 'blabla', abuseId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with a non admin user', async function () { it('Should fail with a non admin user', async function () {
await deleteAbuse(server.url, userAccessToken, abuseId, HttpStatusCode.FORBIDDEN_403) await command.delete({ token: userToken, abuseId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail with a bad abuse id', async function () { it('Should fail with a bad abuse id', async function () {
await deleteAbuse(server.url, server.accessToken, 45, HttpStatusCode.NOT_FOUND_404) await command.delete({ abuseId: 45, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
await deleteAbuse(server.url, server.accessToken, abuseId) await command.delete({ abuseId })
}) })
}) })
@ -432,25 +425,20 @@ describe('Test abuses API validators', function () {
await doubleFollow(anotherServer, server) await doubleFollow(anotherServer, server)
const server2VideoId = await getVideoIdFromUUID(anotherServer.url, server.video.uuid) const server2VideoId = await getVideoIdFromUUID(anotherServer.url, server.video.uuid)
await reportAbuse({ await anotherServer.abusesCommand.report({ reason: 'remote server', videoId: server2VideoId })
url: anotherServer.url,
token: anotherServer.accessToken,
reason: 'remote server',
videoId: server2VideoId
})
await waitJobs([ server, anotherServer ]) await waitJobs([ server, anotherServer ])
const res = await getAdminAbusesList({ url: server.url, token: server.accessToken, sort: '-createdAt' }) const body = await command.getAdminList({ sort: '-createdAt' })
remoteAbuseId = res.body.data[0].id remoteAbuseId = body.data[0].id
}) })
it('Should fail when listing abuse messages of a remote abuse', async function () { it('Should fail when listing abuse messages of a remote abuse', async function () {
await listAbuseMessages(server.url, server.accessToken, remoteAbuseId, HttpStatusCode.BAD_REQUEST_400) await command.listMessages({ abuseId: remoteAbuseId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should fail when creating abuse message of a remote abuse', async function () { it('Should fail when creating abuse message of a remote abuse', async function () {
await addAbuseMessage(server.url, server.accessToken, remoteAbuseId, 'message', HttpStatusCode.BAD_REQUEST_400) await command.addMessage({ abuseId: remoteAbuseId, message: 'message', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
after(async function () { after(async function () {

471
server/tests/api/moderation/abuses.ts
View File

@ -3,51 +3,32 @@
import 'mocha' import 'mocha'
import * as chai from 'chai' import * as chai from 'chai'
import { import {
AbuseFilter, AbusesCommand,
AbuseMessage, addAccountToServerBlocklist,
AbusePredefinedReasonsString, addServerToServerBlocklist,
AbuseState,
Account,
AdminAbuse,
UserAbuse,
VideoComment
} from '@shared/models'
import {
addAbuseMessage,
addVideoCommentThread, addVideoCommentThread,
cleanupTests, cleanupTests,
createUser, createUser,
deleteAbuse,
deleteAbuseMessage,
deleteVideoComment, deleteVideoComment,
doubleFollow,
flushAndRunMultipleServers, flushAndRunMultipleServers,
generateUserAccessToken, generateUserAccessToken,
getAccount, getAccount,
getAdminAbusesList,
getUserAbusesList,
getVideoCommentThreads, getVideoCommentThreads,
getVideoIdFromUUID, getVideoIdFromUUID,
getVideosList, getVideosList,
immutableAssign, removeAccountFromServerBlocklist,
listAbuseMessages, removeServerFromServerBlocklist,
removeUser, removeUser,
removeVideo, removeVideo,
reportAbuse,
ServerInfo, ServerInfo,
setAccessTokensToServers, setAccessTokensToServers,
updateAbuse,
uploadVideo, uploadVideo,
uploadVideoAndGetId, uploadVideoAndGetId,
userLogin userLogin,
} from '../../../../shared/extra-utils/index' waitJobs
import { doubleFollow } from '../../../../shared/extra-utils/server/follows' } from '@shared/extra-utils'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs' import { AbuseMessage, AbusePredefinedReasonsString, AbuseState, Account, AdminAbuse, UserAbuse, VideoComment } from '@shared/models'
import {
addAccountToServerBlocklist,
addServerToServerBlocklist,
removeAccountFromServerBlocklist,
removeServerFromServerBlocklist
} from '../../../../shared/extra-utils/users/blocklist'
const expect = chai.expect const expect = chai.expect
@ -55,6 +36,7 @@ describe('Test abuses', function () {
let servers: ServerInfo[] = [] let servers: ServerInfo[] = []
let abuseServer1: AdminAbuse let abuseServer1: AdminAbuse
let abuseServer2: AdminAbuse let abuseServer2: AdminAbuse
let commands: AbusesCommand[]
before(async function () { before(async function () {
this.timeout(50000) this.timeout(50000)
@ -67,6 +49,8 @@ describe('Test abuses', function () {
// Server 1 and server 2 follow each other // Server 1 and server 2 follow each other
await doubleFollow(servers[0], servers[1]) await doubleFollow(servers[0], servers[1])
commands = servers.map(s => s.abusesCommand)
}) })
describe('Video abuses', function () { describe('Video abuses', function () {
@ -100,31 +84,32 @@ describe('Test abuses', function () {
}) })
it('Should not have abuses', async function () { it('Should not have abuses', async function () {
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(0) expect(body.total).to.equal(0)
expect(res.body.data).to.be.an('array') expect(body.data).to.be.an('array')
expect(res.body.data.length).to.equal(0) expect(body.data.length).to.equal(0)
}) })
it('Should report abuse on a local video', async function () { it('Should report abuse on a local video', async function () {
this.timeout(15000) this.timeout(15000)
const reason = 'my super bad reason' const reason = 'my super bad reason'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: servers[0].video.id, reason }) await commands[0].report({ videoId: servers[0].video.id, reason })
// We wait requests propagation, even if the server 1 is not supposed to make a request to server 2 // We wait requests propagation, even if the server 1 is not supposed to make a request to server 2
await waitJobs(servers) await waitJobs(servers)
}) })
it('Should have 1 video abuses on server 1 and 0 on server 2', async function () { it('Should have 1 video abuses on server 1 and 0 on server 2', async function () {
const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) {
const body = await commands[0].getAdminList()
expect(res1.body.total).to.equal(1) expect(body.total).to.equal(1)
expect(res1.body.data).to.be.an('array') expect(body.data).to.be.an('array')
expect(res1.body.data.length).to.equal(1) expect(body.data.length).to.equal(1)
const abuse: AdminAbuse = res1.body.data[0] const abuse = body.data[0]
expect(abuse.reason).to.equal('my super bad reason') expect(abuse.reason).to.equal('my super bad reason')
expect(abuse.reporterAccount.name).to.equal('root') expect(abuse.reporterAccount.name).to.equal('root')
@ -143,11 +128,14 @@ describe('Test abuses', function () {
expect(abuse.countReportsForReporter).to.equal(1) expect(abuse.countReportsForReporter).to.equal(1)
expect(abuse.countReportsForReportee).to.equal(1) expect(abuse.countReportsForReportee).to.equal(1)
}
const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) {
expect(res2.body.total).to.equal(0) const body = await commands[1].getAdminList()
expect(res2.body.data).to.be.an('array') expect(body.total).to.equal(0)
expect(res2.body.data.length).to.equal(0) expect(body.data).to.be.an('array')
expect(body.data.length).to.equal(0)
}
}) })
it('Should report abuse on a remote video', async function () { it('Should report abuse on a remote video', async function () {
@ -155,19 +143,20 @@ describe('Test abuses', function () {
const reason = 'my super bad reason 2' const reason = 'my super bad reason 2'
const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid) const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId, reason }) await commands[0].report({ videoId, reason })
// We wait requests propagation // We wait requests propagation
await waitJobs(servers) await waitJobs(servers)
}) })
it('Should have 2 video abuses on server 1 and 1 on server 2', async function () { it('Should have 2 video abuses on server 1 and 1 on server 2', async function () {
const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) {
const body = await commands[0].getAdminList()
expect(res1.body.total).to.equal(2) expect(body.total).to.equal(2)
expect(res1.body.data.length).to.equal(2) expect(body.data.length).to.equal(2)
const abuse1: AdminAbuse = res1.body.data[0] const abuse1 = body.data[0]
expect(abuse1.reason).to.equal('my super bad reason') expect(abuse1.reason).to.equal('my super bad reason')
expect(abuse1.reporterAccount.name).to.equal('root') expect(abuse1.reporterAccount.name).to.equal('root')
expect(abuse1.reporterAccount.host).to.equal(servers[0].host) expect(abuse1.reporterAccount.host).to.equal(servers[0].host)
@ -185,7 +174,7 @@ describe('Test abuses', function () {
expect(abuse1.state.label).to.equal('Pending') expect(abuse1.state.label).to.equal('Pending')
expect(abuse1.moderationComment).to.be.null expect(abuse1.moderationComment).to.be.null
const abuse2: AdminAbuse = res1.body.data[1] const abuse2 = body.data[1]
expect(abuse2.reason).to.equal('my super bad reason 2') expect(abuse2.reason).to.equal('my super bad reason 2')
expect(abuse2.reporterAccount.name).to.equal('root') expect(abuse2.reporterAccount.name).to.equal('root')
@ -201,22 +190,25 @@ describe('Test abuses', function () {
expect(abuse2.state.id).to.equal(AbuseState.PENDING) expect(abuse2.state.id).to.equal(AbuseState.PENDING)
expect(abuse2.state.label).to.equal('Pending') expect(abuse2.state.label).to.equal('Pending')
expect(abuse2.moderationComment).to.be.null expect(abuse2.moderationComment).to.be.null
}
const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) {
expect(res2.body.total).to.equal(1) const body = await commands[1].getAdminList()
expect(res2.body.data.length).to.equal(1) expect(body.total).to.equal(1)
expect(body.data.length).to.equal(1)
abuseServer2 = res2.body.data[0] abuseServer2 = body.data[0]
expect(abuseServer2.reason).to.equal('my super bad reason 2') expect(abuseServer2.reason).to.equal('my super bad reason 2')
expect(abuseServer2.reporterAccount.name).to.equal('root') expect(abuseServer2.reporterAccount.name).to.equal('root')
expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host) expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
expect(abuse2.flaggedAccount.name).to.equal('root') expect(abuseServer2.flaggedAccount.name).to.equal('root')
expect(abuse2.flaggedAccount.host).to.equal(servers[1].host) expect(abuseServer2.flaggedAccount.host).to.equal(servers[1].host)
expect(abuseServer2.state.id).to.equal(AbuseState.PENDING) expect(abuseServer2.state.id).to.equal(AbuseState.PENDING)
expect(abuseServer2.state.label).to.equal('Pending') expect(abuseServer2.state.label).to.equal('Pending')
expect(abuseServer2.moderationComment).to.be.null expect(abuseServer2.moderationComment).to.be.null
}
}) })
it('Should hide video abuses from blocked accounts', async function () { it('Should hide video abuses from blocked accounts', async function () {
@ -224,11 +216,11 @@ describe('Test abuses', function () {
{ {
const videoId = await getVideoIdFromUUID(servers[1].url, servers[0].video.uuid) const videoId = await getVideoIdFromUUID(servers[1].url, servers[0].video.uuid)
await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'will mute this' }) await commands[1].report({ videoId, reason: 'will mute this' })
await waitJobs(servers) await waitJobs(servers)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(3) expect(body.total).to.equal(3)
} }
const accountToBlock = 'root@' + servers[1].host const accountToBlock = 'root@' + servers[1].host
@ -236,18 +228,18 @@ describe('Test abuses', function () {
{ {
await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock) await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuse = res.body.data.find(a => a.reason === 'will mute this') const abuse = body.data.find(a => a.reason === 'will mute this')
expect(abuse).to.be.undefined expect(abuse).to.be.undefined
} }
{ {
await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock) await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, accountToBlock)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(3) expect(body.total).to.equal(3)
} }
}) })
@ -257,18 +249,18 @@ describe('Test abuses', function () {
{ {
await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host) await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, servers[1].host)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuse = res.body.data.find(a => a.reason === 'will mute this') const abuse = body.data.find(a => a.reason === 'will mute this')
expect(abuse).to.be.undefined expect(abuse).to.be.undefined
} }
{ {
await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, serverToBlock) await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, serverToBlock)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(3) expect(body.total).to.equal(3)
} }
}) })
@ -279,11 +271,11 @@ describe('Test abuses', function () {
await waitJobs(servers) await waitJobs(servers)
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) const body = await commands[1].getAdminList()
expect(res.body.total).to.equal(2, "wrong number of videos returned") expect(body.total).to.equal(2, "wrong number of videos returned")
expect(res.body.data).to.have.lengthOf(2, "wrong number of videos returned") expect(body.data).to.have.lengthOf(2, "wrong number of videos returned")
const abuse: AdminAbuse = res.body.data[0] const abuse = body.data[0]
expect(abuse.id).to.equal(abuseServer2.id, "wrong origin server id for first video") expect(abuse.id).to.equal(abuseServer2.id, "wrong origin server id for first video")
expect(abuse.video.id).to.equal(abuseServer2.video.id, "wrong video id") expect(abuse.video.id).to.equal(abuseServer2.video.id, "wrong video id")
expect(abuse.video.channel).to.exist expect(abuse.video.channel).to.exist
@ -303,24 +295,21 @@ describe('Test abuses', function () {
name: 'my second super name for server 1', name: 'my second super name for server 1',
description: 'my second super description for server 1' description: 'my second super description for server 1'
} }
await uploadVideo(servers[0].url, userAccessToken, video3Attributes) const resUpload = await uploadVideo(servers[0].url, userAccessToken, video3Attributes)
const video3Id = resUpload.body.video.id
const res1 = await getVideosList(servers[0].url)
const videos = res1.body.data
const video3 = videos.find(video => video.name === 'my second super name for server 1')
// resume with the test // resume with the test
const reason3 = 'my super bad reason 3' const reason3 = 'my super bad reason 3'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video3.id, reason: reason3 }) await commands[0].report({ videoId: video3Id, reason: reason3 })
const reason4 = 'my super bad reason 4' const reason4 = 'my super bad reason 4'
await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: reason4 }) await commands[0].report({ token: userAccessToken, videoId: servers[0].video.id, reason: reason4 })
{ {
const res2 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
const abuses = res2.body.data as AdminAbuse[] const abuses = body.data
const abuseVideo3 = res2.body.data.find(a => a.video.id === video3.id) const abuseVideo3 = body.data.find(a => a.video.id === video3Id)
expect(abuseVideo3).to.not.be.undefined expect(abuseVideo3).to.not.be.undefined
expect(abuseVideo3.video.countReports).to.equal(1, "wrong reports count for video 3") expect(abuseVideo3.video.countReports).to.equal(1, "wrong reports count for video 3")
expect(abuseVideo3.video.nthReport).to.equal(1, "wrong report position in report list for video 3") expect(abuseVideo3.video.nthReport).to.equal(1, "wrong report position in report list for video 3")
@ -337,20 +326,18 @@ describe('Test abuses', function () {
const reason5 = 'my super bad reason 5' const reason5 = 'my super bad reason 5'
const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ] const predefinedReasons5: AbusePredefinedReasonsString[] = [ 'violentOrRepulsive', 'captions' ]
const createdAbuse = (await reportAbuse({ const createRes = await commands[0].report({
url: servers[0].url,
token: servers[0].accessToken,
videoId: servers[0].video.id, videoId: servers[0].video.id,
reason: reason5, reason: reason5,
predefinedReasons: predefinedReasons5, predefinedReasons: predefinedReasons5,
startAt: 1, startAt: 1,
endAt: 5 endAt: 5
})).body.abuse })
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
{ {
const abuse = (res.body.data as AdminAbuse[]).find(a => a.id === createdAbuse.id) const abuse = body.data.find(a => a.id === createRes.abuse.id)
expect(abuse.reason).to.equals(reason5) expect(abuse.reason).to.equals(reason5)
expect(abuse.predefinedReasons).to.deep.equals(predefinedReasons5, "predefined reasons do not match the one reported") expect(abuse.predefinedReasons).to.deep.equals(predefinedReasons5, "predefined reasons do not match the one reported")
expect(abuse.video.startAt).to.equal(1, "starting timestamp doesn't match the one reported") expect(abuse.video.startAt).to.equal(1, "starting timestamp doesn't match the one reported")
@ -361,37 +348,30 @@ describe('Test abuses', function () {
it('Should delete the video abuse', async function () { it('Should delete the video abuse', async function () {
this.timeout(10000) this.timeout(10000)
await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) await commands[1].delete({ abuseId: abuseServer2.id })
await waitJobs(servers) await waitJobs(servers)
{ {
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken }) const body = await commands[1].getAdminList()
expect(res.body.total).to.equal(1) expect(body.total).to.equal(1)
expect(res.body.data.length).to.equal(1) expect(body.data.length).to.equal(1)
expect(res.body.data[0].id).to.not.equal(abuseServer2.id) expect(body.data[0].id).to.not.equal(abuseServer2.id)
} }
{ {
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken }) const body = await commands[0].getAdminList()
expect(res.body.total).to.equal(6) expect(body.total).to.equal(6)
} }
}) })
it('Should list and filter video abuses', async function () { it('Should list and filter video abuses', async function () {
this.timeout(10000) this.timeout(10000)
async function list (query: Omit<Parameters<typeof getAdminAbusesList>[0], 'url' | 'token'>) { async function list (query: Parameters<AbusesCommand['getAdminList']>[0]) {
const options = { const body = await commands[0].getAdminList(query)
url: servers[0].url,
token: servers[0].accessToken
}
Object.assign(options, query) return body.data
const res = await getAdminAbusesList(options)
return res.body.data as AdminAbuse[]
} }
expect(await list({ id: 56 })).to.have.lengthOf(0) expect(await list({ id: 56 })).to.have.lengthOf(0)
@ -452,7 +432,7 @@ describe('Test abuses', function () {
const comment = await getComment(servers[0].url, servers[0].video.id) const comment = await getComment(servers[0].url, servers[0].video.id)
const reason = 'it is a bad comment' const reason = 'it is a bad comment'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason }) await commands[0].report({ commentId: comment.id, reason })
await waitJobs(servers) await waitJobs(servers)
}) })
@ -460,12 +440,12 @@ describe('Test abuses', function () {
it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () { it('Should have 1 comment abuse on server 1 and 0 on server 2', async function () {
{ {
const comment = await getComment(servers[0].url, servers[0].video.id) const comment = await getComment(servers[0].url, servers[0].video.id)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) const body = await commands[0].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(1) expect(body.total).to.equal(1)
expect(res.body.data).to.have.lengthOf(1) expect(body.data).to.have.lengthOf(1)
const abuse: AdminAbuse = res.body.data[0] const abuse = body.data[0]
expect(abuse.reason).to.equal('it is a bad comment') expect(abuse.reason).to.equal('it is a bad comment')
expect(abuse.reporterAccount.name).to.equal('root') expect(abuse.reporterAccount.name).to.equal('root')
@ -485,9 +465,9 @@ describe('Test abuses', function () {
} }
{ {
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) const body = await commands[1].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(0) expect(body.total).to.equal(0)
expect(res.body.data.length).to.equal(0) expect(body.data.length).to.equal(0)
} }
}) })
@ -497,7 +477,7 @@ describe('Test abuses', function () {
const comment = await getComment(servers[0].url, servers[1].video.uuid) const comment = await getComment(servers[0].url, servers[1].video.uuid)
const reason = 'it is a really bad comment' const reason = 'it is a really bad comment'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason }) await commands[0].report({ commentId: comment.id, reason })
await waitJobs(servers) await waitJobs(servers)
}) })
@ -505,16 +485,17 @@ describe('Test abuses', function () {
it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () { it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
const commentServer2 = await getComment(servers[0].url, servers[1].video.id) const commentServer2 = await getComment(servers[0].url, servers[1].video.id)
const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) {
expect(res1.body.total).to.equal(2) const body = await commands[0].getAdminList({ filter: 'comment' })
expect(res1.body.data.length).to.equal(2) expect(body.total).to.equal(2)
expect(body.data.length).to.equal(2)
const abuse: AdminAbuse = res1.body.data[0] const abuse = body.data[0]
expect(abuse.reason).to.equal('it is a bad comment') expect(abuse.reason).to.equal('it is a bad comment')
expect(abuse.countReportsForReporter).to.equal(6) expect(abuse.countReportsForReporter).to.equal(6)
expect(abuse.countReportsForReportee).to.equal(5) expect(abuse.countReportsForReportee).to.equal(5)
const abuse2: AdminAbuse = res1.body.data[1] const abuse2 = body.data[1]
expect(abuse2.reason).to.equal('it is a really bad comment') expect(abuse2.reason).to.equal('it is a really bad comment')
@ -536,12 +517,14 @@ describe('Test abuses', function () {
expect(abuse2.countReportsForReporter).to.equal(6) expect(abuse2.countReportsForReporter).to.equal(6)
expect(abuse2.countReportsForReportee).to.equal(2) expect(abuse2.countReportsForReportee).to.equal(2)
}
const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) {
expect(res2.body.total).to.equal(1) const body = await commands[1].getAdminList({ filter: 'comment' })
expect(res2.body.data.length).to.equal(1) expect(body.total).to.equal(1)
expect(body.data.length).to.equal(1)
abuseServer2 = res2.body.data[0] abuseServer2 = body.data[0]
expect(abuseServer2.reason).to.equal('it is a really bad comment') expect(abuseServer2.reason).to.equal('it is a really bad comment')
expect(abuseServer2.reporterAccount.name).to.equal('root') expect(abuseServer2.reporterAccount.name).to.equal('root')
expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host) expect(abuseServer2.reporterAccount.host).to.equal(servers[0].host)
@ -553,6 +536,7 @@ describe('Test abuses', function () {
expect(abuseServer2.countReportsForReporter).to.equal(1) expect(abuseServer2.countReportsForReporter).to.equal(1)
expect(abuseServer2.countReportsForReportee).to.equal(1) expect(abuseServer2.countReportsForReportee).to.equal(1)
}
}) })
it('Should keep the comment abuse when deleting the comment', async function () { it('Should keep the comment abuse when deleting the comment', async function () {
@ -564,11 +548,11 @@ describe('Test abuses', function () {
await waitJobs(servers) await waitJobs(servers)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) const body = await commands[0].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
expect(res.body.data).to.have.lengthOf(2) expect(body.data).to.have.lengthOf(2)
const abuse = (res.body.data as AdminAbuse[]).find(a => a.comment?.id === commentServer2.id) const abuse = body.data.find(a => a.comment?.id === commentServer2.id)
expect(abuse).to.not.be.undefined expect(abuse).to.not.be.undefined
expect(abuse.comment.text).to.be.empty expect(abuse.comment.text).to.be.empty
@ -579,53 +563,43 @@ describe('Test abuses', function () {
it('Should delete the comment abuse', async function () { it('Should delete the comment abuse', async function () {
this.timeout(10000) this.timeout(10000)
await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) await commands[1].delete({ abuseId: abuseServer2.id })
await waitJobs(servers) await waitJobs(servers)
{ {
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) const body = await commands[1].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(0) expect(body.total).to.equal(0)
expect(res.body.data.length).to.equal(0) expect(body.data.length).to.equal(0)
} }
{ {
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'comment' }) const body = await commands[0].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
} }
}) })
it('Should list and filter video abuses', async function () { it('Should list and filter video abuses', async function () {
{ {
const res = await getAdminAbusesList({ const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'foo' })
url: servers[0].url, expect(body.total).to.equal(0)
token: servers[0].accessToken,
filter: 'comment',
searchReportee: 'foo'
})
expect(res.body.total).to.equal(0)
} }
{ {
const res = await getAdminAbusesList({ const body = await commands[0].getAdminList({ filter: 'comment', searchReportee: 'ot' })
url: servers[0].url, expect(body.total).to.equal(2)
token: servers[0].accessToken,
filter: 'comment',
searchReportee: 'ot'
})
expect(res.body.total).to.equal(2)
} }
{ {
const baseParams = { url: servers[0].url, token: servers[0].accessToken, filter: 'comment' as AbuseFilter, start: 1, count: 1 } const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: 'createdAt' })
expect(body.data).to.have.lengthOf(1)
expect(body.data[0].comment.text).to.be.empty
}
const res1 = await getAdminAbusesList(immutableAssign(baseParams, { sort: 'createdAt' })) {
expect(res1.body.data).to.have.lengthOf(1) const body = await commands[0].getAdminList({ filter: 'comment', start: 1, count: 1, sort: '-createdAt' })
expect(res1.body.data[0].comment.text).to.be.empty expect(body.data).to.have.lengthOf(1)
expect(body.data[0].comment.text).to.equal('comment server 1')
const res2 = await getAdminAbusesList(immutableAssign(baseParams, { sort: '-createdAt' }))
expect(res2.body.data).to.have.lengthOf(1)
expect(res2.body.data[0].comment.text).to.equal('comment server 1')
} }
}) })
}) })
@ -655,19 +629,19 @@ describe('Test abuses', function () {
const account = await getAccountFromServer(servers[0].url, 'user_1', servers[0]) const account = await getAccountFromServer(servers[0].url, 'user_1', servers[0])
const reason = 'it is a bad account' const reason = 'it is a bad account'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason }) await commands[0].report({ accountId: account.id, reason })
await waitJobs(servers) await waitJobs(servers)
}) })
it('Should have 1 account abuse on server 1 and 0 on server 2', async function () { it('Should have 1 account abuse on server 1 and 0 on server 2', async function () {
{ {
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) const body = await commands[0].getAdminList({ filter: 'account' })
expect(res.body.total).to.equal(1) expect(body.total).to.equal(1)
expect(res.body.data).to.have.lengthOf(1) expect(body.data).to.have.lengthOf(1)
const abuse: AdminAbuse = res.body.data[0] const abuse = body.data[0]
expect(abuse.reason).to.equal('it is a bad account') expect(abuse.reason).to.equal('it is a bad account')
expect(abuse.reporterAccount.name).to.equal('root') expect(abuse.reporterAccount.name).to.equal('root')
@ -681,9 +655,9 @@ describe('Test abuses', function () {
} }
{ {
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'comment' }) const body = await commands[1].getAdminList({ filter: 'comment' })
expect(res.body.total).to.equal(0) expect(body.total).to.equal(0)
expect(res.body.data.length).to.equal(0) expect(body.data.length).to.equal(0)
} }
}) })
@ -693,20 +667,21 @@ describe('Test abuses', function () {
const account = await getAccountFromServer(servers[0].url, 'user_2', servers[1]) const account = await getAccountFromServer(servers[0].url, 'user_2', servers[1])
const reason = 'it is a really bad account' const reason = 'it is a really bad account'
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId: account.id, reason }) await commands[0].report({ accountId: account.id, reason })
await waitJobs(servers) await waitJobs(servers)
}) })
it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () { it('Should have 2 comment abuses on server 1 and 1 on server 2', async function () {
const res1 = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) {
expect(res1.body.total).to.equal(2) const body = await commands[0].getAdminList({ filter: 'account' })
expect(res1.body.data.length).to.equal(2) expect(body.total).to.equal(2)
expect(body.data.length).to.equal(2)
const abuse: AdminAbuse = res1.body.data[0] const abuse: AdminAbuse = body.data[0]
expect(abuse.reason).to.equal('it is a bad account') expect(abuse.reason).to.equal('it is a bad account')
const abuse2: AdminAbuse = res1.body.data[1] const abuse2: AdminAbuse = body.data[1]
expect(abuse2.reason).to.equal('it is a really bad account') expect(abuse2.reason).to.equal('it is a really bad account')
expect(abuse2.reporterAccount.name).to.equal('root') expect(abuse2.reporterAccount.name).to.equal('root')
@ -719,12 +694,14 @@ describe('Test abuses', function () {
expect(abuse2.state.label).to.equal('Pending') expect(abuse2.state.label).to.equal('Pending')
expect(abuse2.moderationComment).to.be.null expect(abuse2.moderationComment).to.be.null
}
const res2 = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' }) {
expect(res2.body.total).to.equal(1) const body = await commands[1].getAdminList({ filter: 'account' })
expect(res2.body.data.length).to.equal(1) expect(body.total).to.equal(1)
expect(body.data.length).to.equal(1)
abuseServer2 = res2.body.data[0] abuseServer2 = body.data[0]
expect(abuseServer2.reason).to.equal('it is a really bad account') expect(abuseServer2.reason).to.equal('it is a really bad account')
@ -735,6 +712,7 @@ describe('Test abuses', function () {
expect(abuseServer2.state.label).to.equal('Pending') expect(abuseServer2.state.label).to.equal('Pending')
expect(abuseServer2.moderationComment).to.be.null expect(abuseServer2.moderationComment).to.be.null
}
}) })
it('Should keep the account abuse when deleting the account', async function () { it('Should keep the account abuse when deleting the account', async function () {
@ -745,32 +723,32 @@ describe('Test abuses', function () {
await waitJobs(servers) await waitJobs(servers)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) const body = await commands[0].getAdminList({ filter: 'account' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
expect(res.body.data).to.have.lengthOf(2) expect(body.data).to.have.lengthOf(2)
const abuse = (res.body.data as AdminAbuse[]).find(a => a.reason === 'it is a really bad account') const abuse = body.data.find(a => a.reason === 'it is a really bad account')
expect(abuse).to.not.be.undefined expect(abuse).to.not.be.undefined
}) })
it('Should delete the account abuse', async function () { it('Should delete the account abuse', async function () {
this.timeout(10000) this.timeout(10000)
await deleteAbuse(servers[1].url, servers[1].accessToken, abuseServer2.id) await commands[1].delete({ abuseId: abuseServer2.id })
await waitJobs(servers) await waitJobs(servers)
{ {
const res = await getAdminAbusesList({ url: servers[1].url, token: servers[1].accessToken, filter: 'account' }) const body = await commands[1].getAdminList({ filter: 'account' })
expect(res.body.total).to.equal(0) expect(body.total).to.equal(0)
expect(res.body.data.length).to.equal(0) expect(body.data.length).to.equal(0)
} }
{ {
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, filter: 'account' }) const body = await commands[0].getAdminList({ filter: 'account' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
abuseServer1 = res.body.data[0] abuseServer1 = body.data[0]
} }
}) })
}) })
@ -778,20 +756,18 @@ describe('Test abuses', function () {
describe('Common actions on abuses', function () { describe('Common actions on abuses', function () {
it('Should update the state of an abuse', async function () { it('Should update the state of an abuse', async function () {
const body = { state: AbuseState.REJECTED } await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.REJECTED } })
await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id }) const body = await commands[0].getAdminList({ id: abuseServer1.id })
expect(res.body.data[0].state.id).to.equal(AbuseState.REJECTED) expect(body.data[0].state.id).to.equal(AbuseState.REJECTED)
}) })
it('Should add a moderation comment', async function () { it('Should add a moderation comment', async function () {
const body = { state: AbuseState.ACCEPTED, moderationComment: 'It is valid' } await commands[0].update({ abuseId: abuseServer1.id, body: { state: AbuseState.ACCEPTED, moderationComment: 'Valid' } })
await updateAbuse(servers[0].url, servers[0].accessToken, abuseServer1.id, body)
const res = await getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, id: abuseServer1.id }) const body = await commands[0].getAdminList({ id: abuseServer1.id })
expect(res.body.data[0].state.id).to.equal(AbuseState.ACCEPTED) expect(body.data[0].state.id).to.equal(AbuseState.ACCEPTED)
expect(res.body.data[0].moderationComment).to.equal('It is valid') expect(body.data[0].moderationComment).to.equal('Valid')
}) })
}) })
@ -802,18 +778,18 @@ describe('Test abuses', function () {
before(async function () { before(async function () {
userAccessToken = await generateUserAccessToken(servers[0], 'user_42') userAccessToken = await generateUserAccessToken(servers[0], 'user_42')
await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' }) await commands[0].report({ token: userAccessToken, videoId: servers[0].video.id, reason: 'user reason 1' })
const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid) const videoId = await getVideoIdFromUUID(servers[0].url, servers[1].video.uuid)
await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId, reason: 'user reason 2' }) await commands[0].report({ token: userAccessToken, videoId, reason: 'user reason 2' })
}) })
it('Should correctly list my abuses', async function () { it('Should correctly list my abuses', async function () {
{ {
const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 5, sort: 'createdAt' }) const body = await commands[0].getUserList({ token: userAccessToken, start: 0, count: 5, sort: 'createdAt' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuses: UserAbuse[] = res.body.data const abuses = body.data
expect(abuses[0].reason).to.equal('user reason 1') expect(abuses[0].reason).to.equal('user reason 1')
expect(abuses[1].reason).to.equal('user reason 2') expect(abuses[1].reason).to.equal('user reason 2')
@ -821,95 +797,77 @@ describe('Test abuses', function () {
} }
{ {
const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: 'createdAt' }) const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: 'createdAt' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuses: UserAbuse[] = res.body.data const abuses: UserAbuse[] = body.data
expect(abuses[0].reason).to.equal('user reason 2') expect(abuses[0].reason).to.equal('user reason 2')
} }
{ {
const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 1, count: 1, sort: '-createdAt' }) const body = await commands[0].getUserList({ token: userAccessToken, start: 1, count: 1, sort: '-createdAt' })
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuses: UserAbuse[] = res.body.data const abuses: UserAbuse[] = body.data
expect(abuses[0].reason).to.equal('user reason 1') expect(abuses[0].reason).to.equal('user reason 1')
} }
}) })
it('Should correctly filter my abuses by id', async function () { it('Should correctly filter my abuses by id', async function () {
const res = await getUserAbusesList({ url: servers[0].url, token: userAccessToken, id: abuseId1 }) const body = await commands[0].getUserList({ token: userAccessToken, id: abuseId1 })
expect(body.total).to.equal(1)
expect(res.body.total).to.equal(1) const abuses: UserAbuse[] = body.data
const abuses: UserAbuse[] = res.body.data
expect(abuses[0].reason).to.equal('user reason 1') expect(abuses[0].reason).to.equal('user reason 1')
}) })
it('Should correctly filter my abuses by search', async function () { it('Should correctly filter my abuses by search', async function () {
const res = await getUserAbusesList({ const body = await commands[0].getUserList({ token: userAccessToken, search: 'server 2' })
url: servers[0].url, expect(body.total).to.equal(1)
token: userAccessToken,
search: 'server 2'
})
expect(res.body.total).to.equal(1) const abuses: UserAbuse[] = body.data
const abuses: UserAbuse[] = res.body.data
expect(abuses[0].reason).to.equal('user reason 2') expect(abuses[0].reason).to.equal('user reason 2')
}) })
it('Should correctly filter my abuses by state', async function () { it('Should correctly filter my abuses by state', async function () {
const body = { state: AbuseState.REJECTED } await commands[0].update({ abuseId: abuseId1, body: { state: AbuseState.REJECTED } })
await updateAbuse(servers[0].url, servers[0].accessToken, abuseId1, body)
const res = await getUserAbusesList({ const body = await commands[0].getUserList({ token: userAccessToken, state: AbuseState.REJECTED })
url: servers[0].url, expect(body.total).to.equal(1)
token: userAccessToken,
state: AbuseState.REJECTED
})
expect(res.body.total).to.equal(1) const abuses: UserAbuse[] = body.data
const abuses: UserAbuse[] = res.body.data
expect(abuses[0].reason).to.equal('user reason 1') expect(abuses[0].reason).to.equal('user reason 1')
}) })
}) })
describe('Abuse messages', async function () { describe('Abuse messages', async function () {
let abuseId: number let abuseId: number
let userAccessToken: string let userToken: string
let abuseMessageUserId: number let abuseMessageUserId: number
let abuseMessageModerationId: number let abuseMessageModerationId: number
before(async function () { before(async function () {
userAccessToken = await generateUserAccessToken(servers[0], 'user_43') userToken = await generateUserAccessToken(servers[0], 'user_43')
const res = await reportAbuse({ const body = await commands[0].report({ token: userToken, videoId: servers[0].video.id, reason: 'user 43 reason 1' })
url: servers[0].url, abuseId = body.abuse.id
token: userAccessToken,
videoId: servers[0].video.id,
reason: 'user 43 reason 1'
})
abuseId = res.body.abuse.id
}) })
it('Should create some messages on the abuse', async function () { it('Should create some messages on the abuse', async function () {
await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 1') await commands[0].addMessage({ token: userToken, abuseId, message: 'message 1' })
await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 2') await commands[0].addMessage({ abuseId, message: 'message 2' })
await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, 'message 3') await commands[0].addMessage({ abuseId, message: 'message 3' })
await addAbuseMessage(servers[0].url, userAccessToken, abuseId, 'message 4') await commands[0].addMessage({ token: userToken, abuseId, message: 'message 4' })
}) })
it('Should have the correct messages count when listing abuses', async function () { it('Should have the correct messages count when listing abuses', async function () {
const results = await Promise.all([ const results = await Promise.all([
getAdminAbusesList({ url: servers[0].url, token: servers[0].accessToken, start: 0, count: 50 }), commands[0].getAdminList({ start: 0, count: 50 }),
getUserAbusesList({ url: servers[0].url, token: userAccessToken, start: 0, count: 50 }) commands[0].getUserList({ token: userToken, start: 0, count: 50 })
]) ])
for (const res of results) { for (const body of results) {
const abuses: AdminAbuse[] = res.body.data const abuses = body.data
const abuse = abuses.find(a => a.id === abuseId) const abuse = abuses.find(a => a.id === abuseId)
expect(abuse.countMessages).to.equal(4) expect(abuse.countMessages).to.equal(4)
} }
@ -917,14 +875,14 @@ describe('Test abuses', function () {
it('Should correctly list messages of this abuse', async function () { it('Should correctly list messages of this abuse', async function () {
const results = await Promise.all([ const results = await Promise.all([
listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId), commands[0].listMessages({ abuseId }),
listAbuseMessages(servers[0].url, userAccessToken, abuseId) commands[0].listMessages({ token: userToken, abuseId })
]) ])
for (const res of results) { for (const body of results) {
expect(res.body.total).to.equal(4) expect(body.total).to.equal(4)
const abuseMessages: AbuseMessage[] = res.body.data const abuseMessages: AbuseMessage[] = body.data
expect(abuseMessages[0].message).to.equal('message 1') expect(abuseMessages[0].message).to.equal('message 1')
expect(abuseMessages[0].byModerator).to.be.false expect(abuseMessages[0].byModerator).to.be.false
@ -948,19 +906,18 @@ describe('Test abuses', function () {
}) })
it('Should delete messages', async function () { it('Should delete messages', async function () {
await deleteAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, abuseMessageModerationId) await commands[0].deleteMessage({ abuseId, messageId: abuseMessageModerationId })
await deleteAbuseMessage(servers[0].url, userAccessToken, abuseId, abuseMessageUserId) await commands[0].deleteMessage({ token: userToken, abuseId, messageId: abuseMessageUserId })
const results = await Promise.all([ const results = await Promise.all([
listAbuseMessages(servers[0].url, servers[0].accessToken, abuseId), commands[0].listMessages({ abuseId }),
listAbuseMessages(servers[0].url, userAccessToken, abuseId) commands[0].listMessages({ token: userToken, abuseId })
]) ])
for (const res of results) { for (const body of results) {
expect(res.body.total).to.equal(2) expect(body.total).to.equal(2)
const abuseMessages: AbuseMessage[] = res.body.data
const abuseMessages: AbuseMessage[] = body.data
expect(abuseMessages[0].message).to.equal('message 2') expect(abuseMessages[0].message).to.equal('message 2')
expect(abuseMessages[1].message).to.equal('message 4') expect(abuseMessages[1].message).to.equal('message 4')
} }

92
server/tests/api/notifications/moderation-notifications.ts
View File

@ -2,34 +2,10 @@
import 'mocha' import 'mocha'
import { buildUUID } from '@server/helpers/uuid' import { buildUUID } from '@server/helpers/uuid'
import { AbuseState } from '@shared/models'
import { import {
addAbuseMessage, addUserSubscription,
addVideoCommentThread, addVideoCommentThread,
addVideoToBlacklist, addVideoToBlacklist,
cleanupTests,
createUser,
follow,
generateUserAccessToken,
getAccount,
getCustomConfig,
getVideoCommentThreads,
getVideoIdFromUUID,
immutableAssign,
MockInstancesIndex,
registerUser,
removeVideoFromBlacklist,
reportAbuse,
unfollow,
updateAbuse,
updateCustomConfig,
updateCustomSubConfig,
wait
} from '../../../../shared/extra-utils'
import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
import {
checkAbuseStateChange, checkAbuseStateChange,
checkAutoInstanceFollowing, checkAutoInstanceFollowing,
CheckerBaseParams, CheckerBaseParams,
@ -43,12 +19,30 @@ import {
checkUserRegistered, checkUserRegistered,
checkVideoAutoBlacklistForModerators, checkVideoAutoBlacklistForModerators,
checkVideoIsPublished, checkVideoIsPublished,
prepareNotificationsTest cleanupTests,
} from '../../../../shared/extra-utils/users/user-notifications' createUser,
import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions' follow,
import { CustomConfig } from '../../../../shared/models/server' generateUserAccessToken,
import { UserNotification } from '../../../../shared/models/users' getAccount,
import { VideoPrivacy } from '../../../../shared/models/videos' getCustomConfig,
getVideoCommentThreads,
getVideoIdFromUUID,
immutableAssign,
MockInstancesIndex,
MockSmtpServer,
prepareNotificationsTest,
registerUser,
removeUserSubscription,
removeVideoFromBlacklist,
ServerInfo,
unfollow,
updateCustomConfig,
updateCustomSubConfig,
uploadVideo,
wait,
waitJobs
} from '@shared/extra-utils'
import { AbuseState, CustomConfig, UserNotification, VideoPrivacy } from '@shared/models'
describe('Test moderation notifications', function () { describe('Test moderation notifications', function () {
let servers: ServerInfo[] = [] let servers: ServerInfo[] = []
@ -89,7 +83,7 @@ describe('Test moderation notifications', function () {
const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
const video = resVideo.body.video const video = resVideo.body.video
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, videoId: video.id, reason: 'super reason' }) await servers[0].abusesCommand.report({ videoId: video.id, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence') await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence')
@ -105,7 +99,7 @@ describe('Test moderation notifications', function () {
await waitJobs(servers) await waitJobs(servers)
const videoId = await getVideoIdFromUUID(servers[1].url, video.uuid) const videoId = await getVideoIdFromUUID(servers[1].url, video.uuid)
await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, videoId, reason: 'super reason' }) await servers[1].abusesCommand.report({ videoId, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence') await checkNewVideoAbuseForModerators(baseParams, video.uuid, name, 'presence')
@ -122,7 +116,7 @@ describe('Test moderation notifications', function () {
await waitJobs(servers) await waitJobs(servers)
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, commentId: comment.id, reason: 'super reason' }) await servers[0].abusesCommand.report({ commentId: comment.id, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence') await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence')
@ -140,7 +134,7 @@ describe('Test moderation notifications', function () {
const resComments = await getVideoCommentThreads(servers[1].url, video.uuid, 0, 5) const resComments = await getVideoCommentThreads(servers[1].url, video.uuid, 0, 5)
const commentId = resComments.body.data[0].id const commentId = resComments.body.data[0].id
await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, commentId, reason: 'super reason' }) await servers[1].abusesCommand.report({ commentId, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence') await checkNewCommentAbuseForModerators(baseParams, video.uuid, name, 'presence')
@ -153,7 +147,7 @@ describe('Test moderation notifications', function () {
const resUser = await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username, password: 'donald' }) const resUser = await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username, password: 'donald' })
const accountId = resUser.body.user.account.id const accountId = resUser.body.user.account.id
await reportAbuse({ url: servers[0].url, token: servers[0].accessToken, accountId, reason: 'super reason' }) await servers[0].abusesCommand.report({ accountId, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewAccountAbuseForModerators(baseParams, username, 'presence') await checkNewAccountAbuseForModerators(baseParams, username, 'presence')
@ -169,7 +163,7 @@ describe('Test moderation notifications', function () {
await waitJobs(servers) await waitJobs(servers)
const resAccount = await getAccount(servers[1].url, username + '@' + servers[0].host) const resAccount = await getAccount(servers[1].url, username + '@' + servers[0].host)
await reportAbuse({ url: servers[1].url, token: servers[1].accessToken, accountId: resAccount.body.id, reason: 'super reason' }) await servers[1].abusesCommand.report({ accountId: resAccount.body.id, reason: 'super reason' })
await waitJobs(servers) await waitJobs(servers)
await checkNewAccountAbuseForModerators(baseParams, username, 'presence') await checkNewAccountAbuseForModerators(baseParams, username, 'presence')
@ -192,14 +186,14 @@ describe('Test moderation notifications', function () {
const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name }) const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name })
const video = resVideo.body.video const video = resVideo.body.video
const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason' }) const body = await servers[0].abusesCommand.report({ token: userAccessToken, videoId: video.id, reason: 'super reason' })
abuseId = res.body.abuse.id abuseId = body.abuse.id
}) })
it('Should send a notification to reporter if the abuse has been accepted', async function () { it('Should send a notification to reporter if the abuse has been accepted', async function () {
this.timeout(10000) this.timeout(10000)
await updateAbuse(servers[0].url, servers[0].accessToken, abuseId, { state: AbuseState.ACCEPTED }) await servers[0].abusesCommand.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
await waitJobs(servers) await waitJobs(servers)
await checkAbuseStateChange(baseParams, abuseId, AbuseState.ACCEPTED, 'presence') await checkAbuseStateChange(baseParams, abuseId, AbuseState.ACCEPTED, 'presence')
@ -208,7 +202,7 @@ describe('Test moderation notifications', function () {
it('Should send a notification to reporter if the abuse has been rejected', async function () { it('Should send a notification to reporter if the abuse has been rejected', async function () {
this.timeout(10000) this.timeout(10000)
await updateAbuse(servers[0].url, servers[0].accessToken, abuseId, { state: AbuseState.REJECTED }) await servers[0].abusesCommand.update({ abuseId, body: { state: AbuseState.REJECTED } })
await waitJobs(servers) await waitJobs(servers)
await checkAbuseStateChange(baseParams, abuseId, AbuseState.REJECTED, 'presence') await checkAbuseStateChange(baseParams, abuseId, AbuseState.REJECTED, 'presence')
@ -241,13 +235,13 @@ describe('Test moderation notifications', function () {
const video = resVideo.body.video const video = resVideo.body.video
{ {
const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason' }) const body = await servers[0].abusesCommand.report({ token: userAccessToken, videoId: video.id, reason: 'super reason' })
abuseId = res.body.abuse.id abuseId = body.abuse.id
} }
{ {
const res = await reportAbuse({ url: servers[0].url, token: userAccessToken, videoId: video.id, reason: 'super reason 2' }) const body = await servers[0].abusesCommand.report({ token: userAccessToken, videoId: video.id, reason: 'super reason 2' })
abuseId2 = res.body.abuse.id abuseId2 = body.abuse.id
} }
}) })
@ -255,7 +249,7 @@ describe('Test moderation notifications', function () {
this.timeout(10000) this.timeout(10000)
const message = 'my super message to users' const message = 'my super message to users'
await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, message) await servers[0].abusesCommand.addMessage({ abuseId, message })
await waitJobs(servers) await waitJobs(servers)
await checkNewAbuseMessage(baseParamsUser, abuseId, message, 'user_1@example.com', 'presence') await checkNewAbuseMessage(baseParamsUser, abuseId, message, 'user_1@example.com', 'presence')
@ -265,7 +259,7 @@ describe('Test moderation notifications', function () {
this.timeout(10000) this.timeout(10000)
const message = 'my super message that should not be sent to the admin' const message = 'my super message that should not be sent to the admin'
await addAbuseMessage(servers[0].url, servers[0].accessToken, abuseId, message) await servers[0].abusesCommand.addMessage({ abuseId, message })
await waitJobs(servers) await waitJobs(servers)
await checkNewAbuseMessage(baseParamsAdmin, abuseId, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'absence') await checkNewAbuseMessage(baseParamsAdmin, abuseId, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'absence')
@ -275,7 +269,7 @@ describe('Test moderation notifications', function () {
this.timeout(10000) this.timeout(10000)
const message = 'my super message to moderators' const message = 'my super message to moderators'
await addAbuseMessage(servers[0].url, userAccessToken, abuseId2, message) await servers[0].abusesCommand.addMessage({ token: userAccessToken, abuseId: abuseId2, message })
await waitJobs(servers) await waitJobs(servers)
await checkNewAbuseMessage(baseParamsAdmin, abuseId2, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'presence') await checkNewAbuseMessage(baseParamsAdmin, abuseId2, message, 'admin' + servers[0].internalServerNumber + '@example.com', 'presence')
@ -285,7 +279,7 @@ describe('Test moderation notifications', function () {
this.timeout(10000) this.timeout(10000)
const message = 'my super message that should not be sent to reporter' const message = 'my super message that should not be sent to reporter'
await addAbuseMessage(servers[0].url, userAccessToken, abuseId2, message) await servers[0].abusesCommand.addMessage({ token: userAccessToken, abuseId: abuseId2, message })
await waitJobs(servers) await waitJobs(servers)
await checkNewAbuseMessage(baseParamsUser, abuseId2, message, 'user_1@example.com', 'absence') await checkNewAbuseMessage(baseParamsUser, abuseId2, message, 'user_1@example.com', 'absence')

3
server/tests/api/server/email.ts
View File

@ -12,7 +12,6 @@ import {
createUser, createUser,
flushAndRunServer, flushAndRunServer,
removeVideoFromBlacklist, removeVideoFromBlacklist,
reportAbuse,
resetPassword, resetPassword,
ServerInfo, ServerInfo,
setAccessTokensToServers, setAccessTokensToServers,
@ -190,7 +189,7 @@ describe('Test emails', function () {
this.timeout(10000) this.timeout(10000)
const reason = 'my super bad reason' const reason = 'my super bad reason'
await reportAbuse({ url: server.url, token: server.accessToken, videoId, reason }) await server.abusesCommand.report({ videoId, reason })
await waitJobs(server) await waitJobs(server)
expect(emails).to.have.lengthOf(3) expect(emails).to.have.lengthOf(3)

28
server/tests/api/users/users.ts
View File

@ -2,9 +2,7 @@
import 'mocha' import 'mocha'
import * as chai from 'chai' import * as chai from 'chai'
import { AbuseState, AbuseUpdate, MyUser, User, UserRole, Video, VideoPlaylistType } from '@shared/models' import { HttpStatusCode } from '@shared/core-utils'
import { CustomConfig, OAuth2ErrorCode } from '@shared/models/server'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import { import {
addVideoCommentThread, addVideoCommentThread,
blockUser, blockUser,
@ -13,13 +11,14 @@ import {
createUser, createUser,
deleteMe, deleteMe,
flushAndRunServer, flushAndRunServer,
follow,
getAccountRatings, getAccountRatings,
getAdminAbusesList,
getBlacklistedVideosList, getBlacklistedVideosList,
getCustomConfig, getCustomConfig,
getMyUserInformation, getMyUserInformation,
getMyUserVideoQuotaUsed, getMyUserVideoQuotaUsed,
getMyUserVideoRating, getMyUserVideoRating,
getMyVideos,
getUserInformation, getUserInformation,
getUsersList, getUsersList,
getUsersListPaginationAndSort, getUsersListPaginationAndSort,
@ -28,18 +27,19 @@ import {
installPlugin, installPlugin,
killallServers, killallServers,
login, login,
logout,
makePutBodyRequest, makePutBodyRequest,
rateVideo, rateVideo,
refreshToken,
registerUserWithChannel, registerUserWithChannel,
removeUser, removeUser,
removeVideo, removeVideo,
reportAbuse,
reRunServer, reRunServer,
ServerInfo, ServerInfo,
setAccessTokensToServers,
setTokenField, setTokenField,
testImage, testImage,
unblockUser, unblockUser,
updateAbuse,
updateCustomSubConfig, updateCustomSubConfig,
updateMyAvatar, updateMyAvatar,
updateMyUser, updateMyUser,
@ -47,11 +47,8 @@ import {
uploadVideo, uploadVideo,
userLogin, userLogin,
waitJobs waitJobs
} from '../../../../shared/extra-utils' } from '@shared/extra-utils'
import { follow } from '../../../../shared/extra-utils/server/follows' import { AbuseState, CustomConfig, MyUser, OAuth2ErrorCode, User, UserAdminFlag, UserRole, Video, VideoPlaylistType } from '@shared/models'
import { logout, refreshToken, setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
const expect = chai.expect const expect = chai.expect
@ -1002,10 +999,10 @@ describe('Test users', function () {
it('Should report correct abuses counts', async function () { it('Should report correct abuses counts', async function () {
const reason = 'my super bad reason' const reason = 'my super bad reason'
await reportAbuse({ url: server.url, token: user17AccessToken, videoId, reason }) await server.abusesCommand.report({ token: user17AccessToken, videoId, reason })
const res1 = await getAdminAbusesList({ url: server.url, token: server.accessToken }) const body1 = await server.abusesCommand.getAdminList()
const abuseId = res1.body.data[0].id const abuseId = body1.data[0].id
const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true) const res2 = await getUserInformation(server.url, server.accessToken, user17Id, true)
const user2: User = res2.body const user2: User = res2.body
@ -1013,8 +1010,7 @@ describe('Test users', function () {
expect(user2.abusesCount).to.equal(1) // number of incriminations expect(user2.abusesCount).to.equal(1) // number of incriminations
expect(user2.abusesCreatedCount).to.equal(1) // number of reports created expect(user2.abusesCreatedCount).to.equal(1) // number of reports created
const body: AbuseUpdate = { state: AbuseState.ACCEPTED } await server.abusesCommand.update({ abuseId, body: { state: AbuseState.ACCEPTED } })
await updateAbuse(server.url, server.accessToken, abuseId, body)
const res3 = await getUserInformation(server.url, server.accessToken, user17Id, true) const res3 = await getUserInformation(server.url, server.accessToken, user17Id, true)
const user3: User = res3.body const user3: User = res3.body

2
shared/extra-utils/index.ts
View File

@ -5,8 +5,8 @@ export * from './feeds'
export * from './logs' export * from './logs'
export * from './miscs' export * from './miscs'
export * from './mock-servers' export * from './mock-servers'
export * from './moderation'
export * from './moderation/abuses'
export * from './plugins/mock-blocklist' export * from './plugins/mock-blocklist'
export * from './requests/check-api-params' export * from './requests/check-api-params'

205
shared/extra-utils/moderation/abuses-command.ts Normal file
View File

@ -0,0 +1,205 @@
import { pick } from 'lodash'
import {
AbuseFilter,
AbuseMessage,
AbusePredefinedReasonsString,
AbuseState,
AbuseUpdate,
AbuseVideoIs,
AdminAbuse,
ResultList,
UserAbuse
} from '@shared/models'
import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
import { AbstractCommand, OverrideCommandOptions } from '../shared'
import { unwrapBody } from '../requests/requests'
export class AbusesCommand extends AbstractCommand {
report (options: OverrideCommandOptions & {
reason: string
accountId?: number
videoId?: number
commentId?: number
predefinedReasons?: AbusePredefinedReasonsString[]
startAt?: number
endAt?: number
}) {
const path = '/api/v1/abuses'
const video = options.videoId
? {
id: options.videoId,
startAt: options.startAt,
endAt: options.endAt
}
: undefined
const comment = options.commentId
? { id: options.commentId }
: undefined
const account = options.accountId
? { id: options.accountId }
: undefined
const body = {
account,
video,
comment,
reason: options.reason,
predefinedReasons: options.predefinedReasons
}
return unwrapBody<{ abuse: { id: number } }>(this.postBodyRequest({
...options,
path,
fields: body,
defaultExpectedStatus: HttpStatusCode.OK_200
}))
}
getAdminList (options: OverrideCommandOptions & {
start?: number
count?: number
sort?: string
id?: number
predefinedReason?: AbusePredefinedReasonsString
search?: string
filter?: AbuseFilter
state?: AbuseState
videoIs?: AbuseVideoIs
searchReporter?: string
searchReportee?: string
searchVideo?: string
searchVideoChannel?: string
} = {}) {
const toPick = [
'count',
'filter',
'id',
'predefinedReason',
'search',
'searchReportee',
'searchReporter',
'searchVideo',
'searchVideoChannel',
'sort',
'start',
'state',
'videoIs'
]
const path = '/api/v1/abuses'
const defaultQuery = { sort: 'createdAt' }
const query = { ...defaultQuery, ...pick(options, toPick) }
return this.getRequestBody<ResultList<AdminAbuse>>({
...options,
path,
query,
defaultExpectedStatus: HttpStatusCode.OK_200
})
}
getUserList (options: OverrideCommandOptions & {
start?: number
count?: number
sort?: string
id?: number
search?: string
state?: AbuseState
}) {
const toPick = [
'id',
'search',
'state',
'start',
'count',
'sort'
]
const path = '/api/v1/users/me/abuses'
const defaultQuery = { sort: 'createdAt' }
const query = { ...defaultQuery, ...pick(options, toPick) }
return this.getRequestBody<ResultList<UserAbuse>>({
...options,
path,
query,
defaultExpectedStatus: HttpStatusCode.OK_200
})
}
update (options: OverrideCommandOptions & {
abuseId: number
body: AbuseUpdate
}) {
const { abuseId, body } = options
const path = '/api/v1/abuses/' + abuseId
return this.putBodyRequest({
...options,
path,
fields: body,
defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
})
}
delete (options: OverrideCommandOptions & {
abuseId: number
}) {
const { abuseId } = options
const path = '/api/v1/abuses/' + abuseId
return this.deleteRequest({ ...options, path, defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204 })
}
listMessages (options: OverrideCommandOptions & {
abuseId: number
}) {
const { abuseId } = options
const path = '/api/v1/abuses/' + abuseId + '/messages'
return this.getRequestBody<ResultList<AbuseMessage>>({ ...options, path, defaultExpectedStatus: HttpStatusCode.OK_200 })
}
deleteMessage (options: OverrideCommandOptions & {
abuseId: number
messageId: number
}) {
const { abuseId, messageId } = options
const path = '/api/v1/abuses/' + abuseId + '/messages/' + messageId
return this.deleteRequest({ ...options, path, defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204 })
}
addMessage (options: OverrideCommandOptions & {
abuseId: number
message: string
}) {
const { abuseId, message } = options
const path = '/api/v1/abuses/' + abuseId + '/messages'
return this.postBodyRequest({
...options,
path,
fields: { message },
defaultExpectedStatus: HttpStatusCode.OK_200
})
}
}

244
shared/extra-utils/moderation/abuses.ts
View File

@ -1,244 +0,0 @@
import { AbuseFilter, AbusePredefinedReasonsString, AbuseState, AbuseUpdate, AbuseVideoIs } from '@shared/models'
import { makeDeleteRequest, makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
function reportAbuse (options: {
url: string
token: string
reason: string
accountId?: number
videoId?: number
commentId?: number
predefinedReasons?: AbusePredefinedReasonsString[]
startAt?: number
endAt?: number
statusCodeExpected?: number
}) {
const path = '/api/v1/abuses'
const video = options.videoId
? {
id: options.videoId,
startAt: options.startAt,
endAt: options.endAt
}
: undefined
const comment = options.commentId
? { id: options.commentId }
: undefined
const account = options.accountId
? { id: options.accountId }
: undefined
const body = {
account,
video,
comment,
reason: options.reason,
predefinedReasons: options.predefinedReasons
}
return makePostBodyRequest({
url: options.url,
path,
token: options.token,
fields: body,
statusCodeExpected: options.statusCodeExpected || HttpStatusCode.OK_200
})
}
function getAdminAbusesList (options: {
url: string
token: string
start?: number
count?: number
sort?: string
id?: number
predefinedReason?: AbusePredefinedReasonsString
search?: string
filter?: AbuseFilter
state?: AbuseState
videoIs?: AbuseVideoIs
searchReporter?: string
searchReportee?: string
searchVideo?: string
searchVideoChannel?: string
}) {
const {
url,
token,
start,
count,
sort,
id,
predefinedReason,
search,
filter,
state,
videoIs,
searchReporter,
searchReportee,
searchVideo,
searchVideoChannel
} = options
const path = '/api/v1/abuses'
const query = {
id,
predefinedReason,
search,
state,
filter,
videoIs,
start,
count,
sort: sort || 'createdAt',
searchReporter,
searchReportee,
searchVideo,
searchVideoChannel
}
return makeGetRequest({
url,
path,
token,
query,
statusCodeExpected: HttpStatusCode.OK_200
})
}
function getUserAbusesList (options: {
url: string
token: string
start?: number
count?: number
sort?: string
id?: number
search?: string
state?: AbuseState
}) {
const {
url,
token,
start,
count,
sort,
id,
search,
state
} = options
const path = '/api/v1/users/me/abuses'
const query = {
id,
search,
state,
start,
count,
sort: sort || 'createdAt'
}
return makeGetRequest({
url,
path,
token,
query,
statusCodeExpected: HttpStatusCode.OK_200
})
}
function updateAbuse (
url: string,
token: string,
abuseId: number,
body: AbuseUpdate,
statusCodeExpected = HttpStatusCode.NO_CONTENT_204
) {
const path = '/api/v1/abuses/' + abuseId
return makePutBodyRequest({
url,
token,
path,
fields: body,
statusCodeExpected
})
}
function deleteAbuse (url: string, token: string, abuseId: number, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
const path = '/api/v1/abuses/' + abuseId
return makeDeleteRequest({
url,
token,
path,
statusCodeExpected
})
}
function listAbuseMessages (url: string, token: string, abuseId: number, statusCodeExpected = HttpStatusCode.OK_200) {
const path = '/api/v1/abuses/' + abuseId + '/messages'
return makeGetRequest({
url,
token,
path,
statusCodeExpected
})
}
function deleteAbuseMessage (
url: string,
token: string,
abuseId: number,
messageId: number,
statusCodeExpected = HttpStatusCode.NO_CONTENT_204
) {
const path = '/api/v1/abuses/' + abuseId + '/messages/' + messageId
return makeDeleteRequest({
url,
token,
path,
statusCodeExpected
})
}
function addAbuseMessage (url: string, token: string, abuseId: number, message: string, statusCodeExpected = HttpStatusCode.OK_200) {
const path = '/api/v1/abuses/' + abuseId + '/messages'
return makePostBodyRequest({
url,
token,
path,
fields: { message },
statusCodeExpected
})
}
// ---------------------------------------------------------------------------
export {
reportAbuse,
getAdminAbusesList,
updateAbuse,
deleteAbuse,
getUserAbusesList,
listAbuseMessages,
deleteAbuseMessage,
addAbuseMessage
}

1
shared/extra-utils/moderation/index.ts Normal file
View File

@ -0,0 +1 @@
export * from './abuses-command'

3
shared/extra-utils/server/servers.ts
View File

@ -12,6 +12,7 @@ import { CustomPagesCommand } from '../custom-pages'
import { FeedCommand } from '../feeds' import { FeedCommand } from '../feeds'
import { LogsCommand } from '../logs' import { LogsCommand } from '../logs'
import { buildServerDirectory, getFileSize, isGithubCI, root, wait } from '../miscs/miscs' import { buildServerDirectory, getFileSize, isGithubCI, root, wait } from '../miscs/miscs'
import { AbusesCommand } from '../moderation'
import { makeGetRequest } from '../requests/requests' import { makeGetRequest } from '../requests/requests'
interface ServerInfo { interface ServerInfo {
@ -71,6 +72,7 @@ interface ServerInfo {
customPageCommand?: CustomPagesCommand customPageCommand?: CustomPagesCommand
feedCommand?: FeedCommand feedCommand?: FeedCommand
logsCommand?: LogsCommand logsCommand?: LogsCommand
abusesCommand?: AbusesCommand
} }
function parallelTests () { function parallelTests () {
@ -281,6 +283,7 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
server.customPageCommand = new CustomPagesCommand(server) server.customPageCommand = new CustomPagesCommand(server)
server.feedCommand = new FeedCommand(server) server.feedCommand = new FeedCommand(server)
server.logsCommand = new LogsCommand(server) server.logsCommand = new LogsCommand(server)
server.abusesCommand = new AbusesCommand(server)
res(server) res(server)
}) })

6
shared/extra-utils/shared/abstract-command.ts
View File

@ -1,5 +1,5 @@
import { HttpStatusCode } from '@shared/core-utils' import { HttpStatusCode } from '@shared/core-utils'
import { makeGetRequest, makePostBodyRequest, makePutBodyRequest, unwrapBody, unwrapText } from '../requests/requests' import { makeDeleteRequest, makeGetRequest, makePostBodyRequest, makePutBodyRequest, unwrapBody, unwrapText } from '../requests/requests'
import { ServerInfo } from '../server/servers' import { ServerInfo } from '../server/servers'
export interface OverrideCommandOptions { export interface OverrideCommandOptions {
@ -44,6 +44,10 @@ abstract class AbstractCommand {
return unwrapText(this.getRequest(options)) return unwrapText(this.getRequest(options))
} }
protected deleteRequest (options: CommonCommandOptions) {
return makeDeleteRequest(this.buildCommonRequestOptions(options))
}
protected putBodyRequest (options: CommonCommandOptions & { protected putBodyRequest (options: CommonCommandOptions & {
fields?: { [ fieldName: string ]: any } fields?: { [ fieldName: string ]: any }
}) { }) {

1
tsconfig.json
View File

@ -8,6 +8,7 @@
"emitDecoratorMetadata": true, "emitDecoratorMetadata": true,
"importHelpers": true, "importHelpers": true,
"removeComments": true, "removeComments": true,
"strictBindCallApply": true,
"outDir": "./dist", "outDir": "./dist",
"lib": [ "lib": [
"dom", "dom",