aboutsummaryrefslogtreecommitdiffhomepage
path: root/server
diff options
context:
space:
mode:
Diffstat (limited to 'server')
-rw-r--r--server/controllers/api/blacklist.ts60
-rw-r--r--server/controllers/api/index.ts2
-rw-r--r--server/helpers/utils.ts5
-rw-r--r--server/initializers/constants.ts3
-rw-r--r--server/lib/blacklist.ts20
-rw-r--r--server/lib/index.ts1
-rw-r--r--server/middlewares/sort.ts27
-rw-r--r--server/middlewares/validators/blacklist.ts35
-rw-r--r--server/middlewares/validators/index.ts1
-rw-r--r--server/middlewares/validators/sort.ts5
-rw-r--r--server/models/utils.ts10
-rw-r--r--server/models/video/video-blacklist-interface.ts6
-rw-r--r--server/models/video/video-blacklist.ts24
-rw-r--r--server/tests/api/check-params/index.ts2
-rw-r--r--server/tests/api/check-params/remotes.ts2
-rw-r--r--server/tests/api/check-params/request-schedulers.ts2
-rw-r--r--server/tests/api/check-params/video-blacklist.ts195
-rw-r--r--server/tests/api/check-params/video-blacklists.ts90
-rw-r--r--server/tests/api/index.ts1
-rw-r--r--server/tests/api/video-blacklist-management.ts162
-rw-r--r--server/tests/api/video-transcoder.ts2
-rw-r--r--server/tests/utils/index.ts2
-rw-r--r--server/tests/utils/video-blacklist.ts54
-rw-r--r--server/tests/utils/video-blacklists.ts17
24 files changed, 606 insertions, 122 deletions
diff --git a/server/controllers/api/blacklist.ts b/server/controllers/api/blacklist.ts
new file mode 100644
index 000000000..9b2d8017e
--- /dev/null
+++ b/server/controllers/api/blacklist.ts
@@ -0,0 +1,60 @@
1import * as express from 'express'
2
3import { database } from '../../initializers'
4import { getFormattedObjects } from '../../helpers'
5import { BlacklistedVideo } from '../../../shared'
6import { BlacklistedVideoInstance } from '../../models'
7
8import {
9 removeVideoFromBlacklist
10} from '../../lib'
11import {
12 authenticate,
13 ensureIsAdmin,
14 paginationValidator,
15 blacklistSortValidator,
16 setBlacklistSort,
17 setPagination,
18 blacklistRemoveValidator
19} from '../../middlewares'
20
21const blacklistRouter = express.Router()
22
23blacklistRouter.get('/',
24 authenticate,
25 ensureIsAdmin,
26 paginationValidator,
27 blacklistSortValidator,
28 setBlacklistSort,
29 setPagination,
30 listBlacklist
31)
32
33blacklistRouter.delete('/:id',
34 authenticate,
35 ensureIsAdmin,
36 blacklistRemoveValidator,
37 removeVideoFromBlacklistController
38)
39
40// ---------------------------------------------------------------------------
41
42export {
43 blacklistRouter
44}
45
46// ---------------------------------------------------------------------------
47
48function listBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
49 database.BlacklistedVideo.listForApi(req.query.start, req.query.count, req.query.sort)
50 .then(resultList => res.json(getFormattedObjects<BlacklistedVideo, BlacklistedVideoInstance>(resultList.data, resultList.total)))
51 .catch(err => next(err))
52}
53
54function removeVideoFromBlacklistController (req: express.Request, res: express.Response, next: express.NextFunction) {
55 const entry = res.locals.blacklistEntryToRemove as BlacklistedVideoInstance
56
57 removeVideoFromBlacklist(entry)
58 .then(() => res.sendStatus(204))
59 .catch(err => next(err))
60}
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
index a9205b33c..fdc887915 100644
--- a/server/controllers/api/index.ts
+++ b/server/controllers/api/index.ts
@@ -9,6 +9,7 @@ import { remoteRouter } from './remote'
9import { requestSchedulerRouter } from './request-schedulers' 9import { requestSchedulerRouter } from './request-schedulers'
10import { usersRouter } from './users' 10import { usersRouter } from './users'
11import { videosRouter } from './videos' 11import { videosRouter } from './videos'
12import { blacklistRouter } from './blacklist'
12 13
13const apiRouter = express.Router() 14const apiRouter = express.Router()
14 15
@@ -19,6 +20,7 @@ apiRouter.use('/remote', remoteRouter)
19apiRouter.use('/request-schedulers', requestSchedulerRouter) 20apiRouter.use('/request-schedulers', requestSchedulerRouter)
20apiRouter.use('/users', usersRouter) 21apiRouter.use('/users', usersRouter)
21apiRouter.use('/videos', videosRouter) 22apiRouter.use('/videos', videosRouter)
23apiRouter.use('/blacklist', blacklistRouter)
22apiRouter.use('/ping', pong) 24apiRouter.use('/ping', pong)
23apiRouter.use('/*', badRequest) 25apiRouter.use('/*', badRequest)
24 26
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index af5be0c69..ce07ceff9 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -47,11 +47,14 @@ function isSignupAllowed () {
47 }) 47 })
48} 48}
49 49
50type SortType = { sortModel: any, sortValue: string }
51
50// --------------------------------------------------------------------------- 52// ---------------------------------------------------------------------------
51 53
52export { 54export {
53 badRequest, 55 badRequest,
54 generateRandomString, 56 generateRandomString,
55 getFormattedObjects, 57 getFormattedObjects,
56 isSignupAllowed 58 isSignupAllowed,
59 SortType
57} 60}
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
index e01b6a4d4..54e91d35d 100644
--- a/server/initializers/constants.ts
+++ b/server/initializers/constants.ts
@@ -34,7 +34,8 @@ const SEARCHABLE_COLUMNS = {
34const SORTABLE_COLUMNS = { 34const SORTABLE_COLUMNS = {
35 USERS: [ 'id', 'username', 'createdAt' ], 35 USERS: [ 'id', 'username', 'createdAt' ],
36 VIDEO_ABUSES: [ 'id', 'createdAt' ], 36 VIDEO_ABUSES: [ 'id', 'createdAt' ],
37 VIDEOS: [ 'name', 'duration', 'createdAt', 'views', 'likes' ] 37 VIDEOS: [ 'name', 'duration', 'createdAt', 'views', 'likes' ],
38 BLACKLISTS: [ 'id', 'name', 'duration', 'views', 'likes', 'dislikes', 'uuid', 'createdAt' ]
38} 39}
39 40
40const OAUTH_LIFETIME = { 41const OAUTH_LIFETIME = {
diff --git a/server/lib/blacklist.ts b/server/lib/blacklist.ts
new file mode 100644
index 000000000..dcf8aa03c
--- /dev/null
+++ b/server/lib/blacklist.ts
@@ -0,0 +1,20 @@
1import { logger } from '../helpers'
2import { BlacklistedVideoInstance } from '../models'
3
4function removeVideoFromBlacklist (entry: BlacklistedVideoInstance) {
5 return entry.destroy()
6 .then(() => {
7 logger.info('Video removed from the blacklist')
8 })
9 .catch(err => {
10 logger.error('Some error while removing video from the blacklist.', err)
11 })
12}
13
14// ---------------------------------------------------------------------------
15
16export {
17 removeVideoFromBlacklist
18}
19
20// ---------------------------------------------------------------------------
diff --git a/server/lib/index.ts b/server/lib/index.ts
index 8628da4dd..df781f29f 100644
--- a/server/lib/index.ts
+++ b/server/lib/index.ts
@@ -3,3 +3,4 @@ export * from './jobs'
3export * from './request' 3export * from './request'
4export * from './friends' 4export * from './friends'
5export * from './oauth-model' 5export * from './oauth-model'
6export * from './blacklist'
diff --git a/server/middlewares/sort.ts b/server/middlewares/sort.ts
index 632b2fae4..687ce097b 100644
--- a/server/middlewares/sort.ts
+++ b/server/middlewares/sort.ts
@@ -1,6 +1,9 @@
1import 'express-validator' 1import 'express-validator'
2import * as express from 'express' 2import * as express from 'express'
3 3
4import { SortType } from '../helpers'
5import { database } from '../initializers'
6
4function setUsersSort (req: express.Request, res: express.Response, next: express.NextFunction) { 7function setUsersSort (req: express.Request, res: express.Response, next: express.NextFunction) {
5 if (!req.query.sort) req.query.sort = '-createdAt' 8 if (!req.query.sort) req.query.sort = '-createdAt'
6 9
@@ -19,10 +22,32 @@ function setVideosSort (req: express.Request, res: express.Response, next: expre
19 return next() 22 return next()
20} 23}
21 24
25function setBlacklistSort (req: express.Request, res: express.Response, next: express.NextFunction) {
26 let newSort: SortType = { sortModel: undefined, sortValue: undefined }
27
28 if (!req.query.sort) req.query.sort = '-createdAt'
29
30 // Set model we want to sort onto
31 if (req.query.sort === '-createdAt' || req.query.sort === 'createdAt' ||
32 req.query.sort === '-id' || req.query.sort === 'id') {
33 // If we want to sort onto the BlacklistedVideos relation, we won't specify it in the query parameter ...
34 newSort.sortModel = undefined
35 } else {
36 newSort.sortModel = database.Video
37 }
38
39 newSort.sortValue = req.query.sort
40
41 req.query.sort = newSort
42
43 return next()
44}
45
22// --------------------------------------------------------------------------- 46// ---------------------------------------------------------------------------
23 47
24export { 48export {
25 setUsersSort, 49 setUsersSort,
26 setVideoAbusesSort, 50 setVideoAbusesSort,
27 setVideosSort 51 setVideosSort,
52 setBlacklistSort
28} 53}
diff --git a/server/middlewares/validators/blacklist.ts b/server/middlewares/validators/blacklist.ts
new file mode 100644
index 000000000..fe8fa40a4
--- /dev/null
+++ b/server/middlewares/validators/blacklist.ts
@@ -0,0 +1,35 @@
1import { param } from 'express-validator/check'
2import * as express from 'express'
3
4import { database as db } from '../../initializers/database'
5import { checkErrors } from './utils'
6import { logger } from '../../helpers'
7
8const blacklistRemoveValidator = [
9 param('id').isNumeric().not().isEmpty().withMessage('Should have a valid id'),
10
11 (req: express.Request, res: express.Response, next: express.NextFunction) => {
12 logger.debug('Checking blacklistRemove parameters.', { parameters: req.params })
13
14 checkErrors(req, res, () => {
15 db.BlacklistedVideo.loadById(req.params.id)
16 .then(entry => {
17 if (!entry) return res.status(404).send('Blacklisted video not found')
18
19 res.locals.blacklistEntryToRemove = entry
20
21 next()
22 })
23 .catch(err => {
24 logger.error('Error in blacklistRemove request validator', { error: err })
25 return res.sendStatus(500)
26 })
27 })
28 }
29]
30
31// ---------------------------------------------------------------------------
32
33export {
34 blacklistRemoveValidator
35}
diff --git a/server/middlewares/validators/index.ts b/server/middlewares/validators/index.ts
index 42ba465ec..a6198e22c 100644
--- a/server/middlewares/validators/index.ts
+++ b/server/middlewares/validators/index.ts
@@ -4,3 +4,4 @@ export * from './pods'
4export * from './sort' 4export * from './sort'
5export * from './users' 5export * from './users'
6export * from './videos' 6export * from './videos'
7export * from './blacklist'
diff --git a/server/middlewares/validators/sort.ts b/server/middlewares/validators/sort.ts
index 71b18acb0..a6f5ccb6b 100644
--- a/server/middlewares/validators/sort.ts
+++ b/server/middlewares/validators/sort.ts
@@ -9,17 +9,20 @@ import { SORTABLE_COLUMNS } from '../../initializers'
9const SORTABLE_USERS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.USERS) 9const SORTABLE_USERS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.USERS)
10const SORTABLE_VIDEO_ABUSES_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_ABUSES) 10const SORTABLE_VIDEO_ABUSES_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_ABUSES)
11const SORTABLE_VIDEOS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEOS) 11const SORTABLE_VIDEOS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEOS)
12const SORTABLE_BLACKLISTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.BLACKLISTS)
12 13
13const usersSortValidator = checkSort(SORTABLE_USERS_COLUMNS) 14const usersSortValidator = checkSort(SORTABLE_USERS_COLUMNS)
14const videoAbusesSortValidator = checkSort(SORTABLE_VIDEO_ABUSES_COLUMNS) 15const videoAbusesSortValidator = checkSort(SORTABLE_VIDEO_ABUSES_COLUMNS)
15const videosSortValidator = checkSort(SORTABLE_VIDEOS_COLUMNS) 16const videosSortValidator = checkSort(SORTABLE_VIDEOS_COLUMNS)
17const blacklistSortValidator = checkSort(SORTABLE_BLACKLISTS_COLUMNS)
16 18
17// --------------------------------------------------------------------------- 19// ---------------------------------------------------------------------------
18 20
19export { 21export {
20 usersSortValidator, 22 usersSortValidator,
21 videoAbusesSortValidator, 23 videoAbusesSortValidator,
22 videosSortValidator 24 videosSortValidator,
25 blacklistSortValidator
23} 26}
24 27
25// --------------------------------------------------------------------------- 28// ---------------------------------------------------------------------------
diff --git a/server/models/utils.ts b/server/models/utils.ts
index 7ba96815e..1bf61d2a6 100644
--- a/server/models/utils.ts
+++ b/server/models/utils.ts
@@ -19,9 +19,17 @@ function addMethodsToModel (model: any, classMethods: Function[], instanceMethod
19 instanceMethods.forEach(m => model.prototype[m.name] = m) 19 instanceMethods.forEach(m => model.prototype[m.name] = m)
20} 20}
21 21
22function getSortOnModel (model: any, value: string) {
23 let sort = getSort(value)
24
25 if (model) return [ { model: model }, sort[0], sort[1] ]
26 return sort
27}
28
22// --------------------------------------------------------------------------- 29// ---------------------------------------------------------------------------
23 30
24export { 31export {
25 addMethodsToModel, 32 addMethodsToModel,
26 getSort 33 getSort,
34 getSortOnModel
27} 35}
diff --git a/server/models/video/video-blacklist-interface.ts b/server/models/video/video-blacklist-interface.ts
index ba48b1b6e..9d167c037 100644
--- a/server/models/video/video-blacklist-interface.ts
+++ b/server/models/video/video-blacklist-interface.ts
@@ -1,7 +1,9 @@
1import * as Sequelize from 'sequelize' 1import * as Sequelize from 'sequelize'
2import * as Promise from 'bluebird' 2import * as Promise from 'bluebird'
3 3
4import { SortType } from '../../helpers'
4import { ResultList } from '../../../shared' 5import { ResultList } from '../../../shared'
6import { VideoInstance } from './video-interface'
5 7
6// Don't use barrel, import just what we need 8// Don't use barrel, import just what we need
7import { BlacklistedVideo as FormattedBlacklistedVideo } from '../../../shared/models/videos/video-blacklist.model' 9import { BlacklistedVideo as FormattedBlacklistedVideo } from '../../../shared/models/videos/video-blacklist.model'
@@ -13,7 +15,7 @@ export namespace BlacklistedVideoMethods {
13 15
14 export type List = () => Promise<BlacklistedVideoInstance[]> 16 export type List = () => Promise<BlacklistedVideoInstance[]>
15 17
16 export type ListForApi = (start: number, count: number, sort: string) => Promise< ResultList<BlacklistedVideoInstance> > 18 export type ListForApi = (start: number, count: number, sort: SortType) => Promise< ResultList<BlacklistedVideoInstance> >
17 19
18 export type LoadById = (id: number) => Promise<BlacklistedVideoInstance> 20 export type LoadById = (id: number) => Promise<BlacklistedVideoInstance>
19 21
@@ -31,6 +33,8 @@ export interface BlacklistedVideoClass {
31 33
32export interface BlacklistedVideoAttributes { 34export interface BlacklistedVideoAttributes {
33 videoId: number 35 videoId: number
36
37 Video?: VideoInstance
34} 38}
35 39
36export interface BlacklistedVideoInstance 40export interface BlacklistedVideoInstance
diff --git a/server/models/video/video-blacklist.ts b/server/models/video/video-blacklist.ts
index dc49852b6..1c279b1ba 100644
--- a/server/models/video/video-blacklist.ts
+++ b/server/models/video/video-blacklist.ts
@@ -1,6 +1,8 @@
1import * as Sequelize from 'sequelize' 1import * as Sequelize from 'sequelize'
2 2
3import { addMethodsToModel, getSort } from '../utils' 3import { SortType } from '../../helpers'
4import { addMethodsToModel, getSortOnModel } from '../utils'
5import { VideoInstance } from './video-interface'
4import { 6import {
5 BlacklistedVideoInstance, 7 BlacklistedVideoInstance,
6 BlacklistedVideoAttributes, 8 BlacklistedVideoAttributes,
@@ -49,10 +51,23 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
49// ------------------------------ METHODS ------------------------------ 51// ------------------------------ METHODS ------------------------------
50 52
51toFormattedJSON = function (this: BlacklistedVideoInstance) { 53toFormattedJSON = function (this: BlacklistedVideoInstance) {
54 let video: VideoInstance
55
56 video = this.Video
57
52 return { 58 return {
53 id: this.id, 59 id: this.id,
54 videoId: this.videoId, 60 videoId: this.videoId,
55 createdAt: this.createdAt 61 createdAt: this.createdAt,
62 updatedAt: this.updatedAt,
63 name: video.name,
64 uuid: video.uuid,
65 description: video.description,
66 duration: video.duration,
67 views: video.views,
68 likes: video.likes,
69 dislikes: video.dislikes,
70 nsfw: video.nsfw
56 } 71 }
57} 72}
58 73
@@ -76,11 +91,12 @@ list = function () {
76 return BlacklistedVideo.findAll() 91 return BlacklistedVideo.findAll()
77} 92}
78 93
79listForApi = function (start: number, count: number, sort: string) { 94listForApi = function (start: number, count: number, sort: SortType) {
80 const query = { 95 const query = {
81 offset: start, 96 offset: start,
82 limit: count, 97 limit: count,
83 order: [ getSort(sort) ] 98 order: [ getSortOnModel(sort.sortModel, sort.sortValue) ],
99 include: [ { model: BlacklistedVideo['sequelize'].models.Video } ]
84 } 100 }
85 101
86 return BlacklistedVideo.findAndCountAll(query).then(({ rows, count }) => { 102 return BlacklistedVideo.findAndCountAll(query).then(({ rows, count }) => {
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index 97f2a19d7..399a05bc3 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -5,4 +5,4 @@ import './users'
5import './request-schedulers' 5import './request-schedulers'
6import './videos' 6import './videos'
7import './video-abuses' 7import './video-abuses'
8import './video-blacklists' 8import './video-blacklist'
diff --git a/server/tests/api/check-params/remotes.ts b/server/tests/api/check-params/remotes.ts
index b36f1c08b..9456ae665 100644
--- a/server/tests/api/check-params/remotes.ts
+++ b/server/tests/api/check-params/remotes.ts
@@ -14,7 +14,7 @@ describe('Test remote videos API validators', function () {
14 // --------------------------------------------------------------- 14 // ---------------------------------------------------------------
15 15
16 before(async function () { 16 before(async function () {
17 this.timeout(20000) 17 this.timeout(60000)
18 18
19 await flushTests() 19 await flushTests()
20 20
diff --git a/server/tests/api/check-params/request-schedulers.ts b/server/tests/api/check-params/request-schedulers.ts
index c39f5947b..01a54ffa1 100644
--- a/server/tests/api/check-params/request-schedulers.ts
+++ b/server/tests/api/check-params/request-schedulers.ts
@@ -20,7 +20,7 @@ describe('Test request schedulers stats API validators', function () {
20 // --------------------------------------------------------------- 20 // ---------------------------------------------------------------
21 21
22 before(async function () { 22 before(async function () {
23 this.timeout(20000) 23 this.timeout(60000)
24 24
25 await flushTests() 25 await flushTests()
26 26
diff --git a/server/tests/api/check-params/video-blacklist.ts b/server/tests/api/check-params/video-blacklist.ts
new file mode 100644
index 000000000..80e6f8011
--- /dev/null
+++ b/server/tests/api/check-params/video-blacklist.ts
@@ -0,0 +1,195 @@
1/* tslint:disable:no-unused-expression */
2
3import 'mocha'
4import * as request from 'supertest'
5
6import {
7 ServerInfo,
8 flushTests,
9 runServer,
10 uploadVideo,
11 getVideosList,
12 createUser,
13 setAccessTokensToServers,
14 killallServers,
15 makePostBodyRequest,
16 getUserAccessToken
17} from '../../utils'
18
19describe('Test video blacklist API validators', function () {
20 let server: ServerInfo
21 let userAccessToken = ''
22
23 // ---------------------------------------------------------------
24
25 before(async function () {
26 this.timeout(120000)
27
28 await flushTests()
29
30 server = await runServer(1)
31
32 await setAccessTokensToServers([ server ])
33
34 const username = 'user1'
35 const password = 'my super password'
36 await createUser(server.url, server.accessToken, username, password)
37 userAccessToken = await getUserAccessToken(server, { username, password })
38
39 // Upload a video
40 const videoAttributes = {}
41 await uploadVideo(server.url, server.accessToken, videoAttributes)
42
43 const res = await getVideosList(server.url)
44
45 const videos = res.body.data
46 server.video = videos[0]
47 })
48
49 describe('When adding a video in blacklist', function () {
50 const basePath = '/api/v1/videos/'
51
52 it('Should fail with nothing', async function () {
53 const path = basePath + server.video + '/blacklist'
54 const fields = {}
55 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
56 })
57
58 it('Should fail with a wrong video', async function () {
59 const wrongPath = '/api/v1/videos/blabla/blacklist'
60 const fields = {}
61 await makePostBodyRequest({ url: server.url, path: wrongPath, token: server.accessToken, fields })
62 })
63
64 it('Should fail with a non authenticated user', async function () {
65 const fields = {}
66 const path = basePath + server.video + '/blacklist'
67 await makePostBodyRequest({ url: server.url, path, token: 'hello', fields, statusCodeExpected: 401 })
68 })
69
70 it('Should fail with a non admin user', async function () {
71 const fields = {}
72 const path = basePath + server.video + '/blacklist'
73 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
74 })
75
76 it('Should fail with a local video', async function () {
77 const fields = {}
78 const path = basePath + server.video.id + '/blacklist'
79 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 403 })
80 })
81 })
82
83 describe('When removing a video in blacklist', function () {
84 const basePath = '/api/v1/blacklist/'
85
86 it('Should fail with a non authenticated user', async function () {
87 const path = basePath + server.video.id
88
89 await request(server.url)
90 .delete(path)
91 .set('Authorization', 'Bearer ' + 'fake token')
92 .set('Accept', 'application/json')
93 .expect(401)
94 })
95
96 it('Should fail with a non admin user', async function () {
97 const path = basePath + server.video.id
98
99 await request(server.url)
100 .delete(path)
101 .set('Authorization', 'Bearer ' + userAccessToken)
102 .set('Accept', 'application/json')
103 .expect(403)
104 })
105
106 it('Should fail with an incorrect id', async function () {
107 const path = basePath + 'foobar'
108
109 await request(server.url)
110 .delete(path)
111 .set('Authorization', 'Bearer ' + server.accessToken)
112 .set('Accept', 'application/json')
113 .expect(400)
114 })
115
116 it('Should fail with a not blacklisted video', async function () {
117 // The video was not added to the blacklist so it should fail
118 const path = basePath + server.video.id
119
120 await request(server.url)
121 .delete(path)
122 .set('Authorization', 'Bearer ' + server.accessToken)
123 .set('Accept', 'application/json')
124 .expect(404)
125 })
126 })
127
128 describe('When listing videos in blacklist', function () {
129 const basePath = '/api/v1/blacklist/'
130
131 it('Should fail with a non authenticated user', async function () {
132 const path = basePath
133
134 await request(server.url)
135 .get(path)
136 .query({ sort: 'createdAt' })
137 .set('Accept', 'application/json')
138 .set('Authorization', 'Bearer ' + 'fake token')
139 .expect(401)
140 })
141
142 it('Should fail with a non admin user', async function () {
143 const path = basePath
144
145 await request(server.url)
146 .get(path)
147 .query({ sort: 'createdAt' })
148 .set('Authorization', 'Bearer ' + userAccessToken)
149 .set('Accept', 'application/json')
150 .expect(403)
151 })
152
153 it('Should fail with a bad start pagination', async function () {
154 const path = basePath
155
156 await request(server.url)
157 .get(path)
158 .query({ start: 'foobar' })
159 .set('Accept', 'application/json')
160 .set('Authorization', 'Bearer ' + server.accessToken)
161 .expect(400)
162 })
163
164 it('Should fail with a bad count pagination', async function () {
165 const path = basePath
166
167 await request(server.url)
168 .get(path)
169 .query({ count: 'foobar' })
170 .set('Accept', 'application/json')
171 .set('Authorization', 'Bearer ' + server.accessToken)
172 .expect(400)
173 })
174
175 it('Should fail with an incorrect sort', async function () {
176 const path = basePath
177
178 await request(server.url)
179 .get(path)
180 .query({ sort: 'foobar' })
181 .set('Accept', 'application/json')
182 .set('Authorization', 'Bearer ' + server.accessToken)
183 .expect(400)
184 })
185 })
186
187 after(async function () {
188 killallServers([ server ])
189
190 // Keep the logs if the test failed
191 if (this['ok']) {
192 await flushTests()
193 }
194 })
195})
diff --git a/server/tests/api/check-params/video-blacklists.ts b/server/tests/api/check-params/video-blacklists.ts
deleted file mode 100644
index d0ad78ff1..000000000
--- a/server/tests/api/check-params/video-blacklists.ts
+++ /dev/null
@@ -1,90 +0,0 @@
1/* tslint:disable:no-unused-expression */
2
3import 'mocha'
4
5import {
6 ServerInfo,
7 flushTests,
8 runServer,
9 uploadVideo,
10 getVideosList,
11 createUser,
12 setAccessTokensToServers,
13 killallServers,
14 makePostBodyRequest,
15 getUserAccessToken
16} from '../../utils'
17
18describe('Test video blacklists API validators', function () {
19 let server: ServerInfo
20 let userAccessToken = ''
21
22 // ---------------------------------------------------------------
23
24 before(async function () {
25 this.timeout(120000)
26
27 await flushTests()
28
29 server = await runServer(1)
30
31 await setAccessTokensToServers([ server ])
32
33 const username = 'user1'
34 const password = 'my super password'
35 await createUser(server.url, server.accessToken, username, password)
36 userAccessToken = await getUserAccessToken(server, { username, password })
37
38 // Upload a video
39 const videoAttributes = {}
40 await uploadVideo(server.url, server.accessToken, videoAttributes)
41
42 const res = await getVideosList(server.url)
43
44 const videos = res.body.data
45 server.video = videos[0]
46 })
47
48 describe('When adding a video in blacklist', function () {
49 const basePath = '/api/v1/videos/'
50
51 it('Should fail with nothing', async function () {
52 const path = basePath + server.video + '/blacklist'
53 const fields = {}
54 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
55 })
56
57 it('Should fail with a wrong video', async function () {
58 const wrongPath = '/api/v1/videos/blabla/blacklist'
59 const fields = {}
60 await makePostBodyRequest({ url: server.url, path: wrongPath, token: server.accessToken, fields })
61 })
62
63 it('Should fail with a non authenticated user', async function () {
64 const fields = {}
65 const path = basePath + server.video + '/blacklist'
66 await makePostBodyRequest({ url: server.url, path, token: 'hello', fields, statusCodeExpected: 401 })
67 })
68
69 it('Should fail with a non admin user', async function () {
70 const fields = {}
71 const path = basePath + server.video + '/blacklist'
72 await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields, statusCodeExpected: 403 })
73 })
74
75 it('Should fail with a local video', async function () {
76 const fields = {}
77 const path = basePath + server.video.id + '/blacklist'
78 await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields, statusCodeExpected: 403 })
79 })
80 })
81
82 after(async function () {
83 killallServers([ server ])
84
85 // Keep the logs if the test failed
86 if (this['ok']) {
87 await flushTests()
88 }
89 })
90})
diff --git a/server/tests/api/index.ts b/server/tests/api/index.ts
index f60d709c8..03711e68a 100644
--- a/server/tests/api/index.ts
+++ b/server/tests/api/index.ts
@@ -6,6 +6,7 @@ import './users'
6import './single-pod' 6import './single-pod'
7import './video-abuse' 7import './video-abuse'
8import './video-blacklist' 8import './video-blacklist'
9import './video-blacklist-management'
9import './multiple-pods' 10import './multiple-pods'
10import './request-schedulers' 11import './request-schedulers'
11import './friends-advanced' 12import './friends-advanced'
diff --git a/server/tests/api/video-blacklist-management.ts b/server/tests/api/video-blacklist-management.ts
new file mode 100644
index 000000000..7057f4b23
--- /dev/null
+++ b/server/tests/api/video-blacklist-management.ts
@@ -0,0 +1,162 @@
1/* tslint:disable:no-unused-expressions */
2
3import 'mocha'
4import * as chai from 'chai'
5const expect = chai.expect
6import * as lodash from 'lodash'
7const orderBy = lodash.orderBy
8
9import {
10 ServerInfo,
11 flushTests,
12 wait,
13 setAccessTokensToServers,
14 flushAndRunMultipleServers,
15 killallServers,
16 makeFriends,
17 getVideosList,
18 uploadVideo,
19 addVideoToBlacklist,
20 removeVideoFromBlacklist,
21 getBlacklistedVideosList,
22 getSortedBlacklistedVideosList
23} from '../utils'
24
25describe('Test video blacklist management', function () {
26 let servers: ServerInfo[] = []
27
28 async function blacklistVideosOnPod (server: ServerInfo) {
29 const res = await getVideosList(server.url)
30
31 const videos = res.body.data
32 for (let video of videos) {
33 await addVideoToBlacklist(server.url, server.accessToken, video.id)
34 }
35 }
36
37 before(async function () {
38 this.timeout(120000)
39
40 // Run servers
41 servers = await flushAndRunMultipleServers(2)
42
43 // Get the access tokens
44 await setAccessTokensToServers(servers)
45
46 // Pod 1 makes friend with pod 2
47 await makeFriends(servers[0].url, servers[0].accessToken)
48
49 // Upload 2 videos on pod 2
50 await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 1st video', description: 'A video on pod 2' })
51 await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 2nd video', description: 'A video on pod 2' })
52
53 // Wait videos propagation
54 await wait(22000)
55
56 // Blacklist the two videos on pod 1
57 await blacklistVideosOnPod(servers[0])
58 })
59
60 describe('When listing blacklisted videos', function () {
61 it('Should display all the blacklisted videos', async function () {
62 const res = await getBlacklistedVideosList(servers[0].url, servers[0].accessToken)
63
64 expect(res.body.total).to.equal(2)
65
66 const videos = res.body.data
67 expect(videos).to.be.an('array')
68 expect(videos.length).to.equal(2)
69 })
70
71 it('Should get the correct sort when sorting by descending id', async function () {
72 const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-id')
73 expect(res.body.total).to.equal(2)
74
75 const videos = res.body.data
76 expect(videos).to.be.an('array')
77 expect(videos.length).to.equal(2)
78
79 const result = orderBy(res.body.data, [ 'id' ], [ 'desc' ])
80
81 expect(videos).to.deep.equal(result)
82 })
83
84 it('Should get the correct sort when sorting by descending video name', async function () {
85 const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
86 expect(res.body.total).to.equal(2)
87
88 const videos = res.body.data
89 expect(videos).to.be.an('array')
90 expect(videos.length).to.equal(2)
91
92 const result = orderBy(res.body.data, [ 'name' ], [ 'desc' ])
93
94 expect(videos).to.deep.equal(result)
95 })
96
97 it('Should get the correct sort when sorting by ascending creation date', async function () {
98 const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, 'createdAt')
99 expect(res.body.total).to.equal(2)
100
101 const videos = res.body.data
102 expect(videos).to.be.an('array')
103 expect(videos.length).to.equal(2)
104
105 const result = orderBy(res.body.data, [ 'createdAt' ])
106
107 expect(videos).to.deep.equal(result)
108 })
109 })
110
111 describe('When removing a blacklisted video', function () {
112 let videoToRemove
113 let blacklist = []
114
115 it('Should not have any video in videos list on pod 1', async function () {
116 const res = await getVideosList(servers[0].url)
117 expect(res.body.total).to.equal(0)
118 expect(res.body.data).to.be.an('array')
119 expect(res.body.data.length).to.equal(0)
120 })
121
122 it('Should remove a video from the blacklist on pod 1', async function () {
123 // Get one video in the blacklist
124 const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
125 videoToRemove = res.body.data[0]
126 blacklist = res.body.data.slice(1)
127
128 // Remove it
129 await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.videoId)
130 })
131
132 it('Should have the ex-blacklisted video in videos list on pod 1', async function () {
133 const res = await getVideosList(servers[0].url)
134 expect(res.body.total).to.equal(1)
135
136 const videos = res.body.data
137 expect(videos).to.be.an('array')
138 expect(videos.length).to.equal(1)
139
140 expect(videos[0].name).to.equal(videoToRemove.name)
141 expect(videos[0].id).to.equal(videoToRemove.videoId)
142 })
143
144 it('Should not have the ex-blacklisted video in videos blacklist list on pod 1', async function () {
145 const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
146 expect(res.body.total).to.equal(1)
147
148 const videos = res.body.data
149 expect(videos).to.be.an('array')
150 expect(videos.length).to.equal(1)
151 expect(videos).to.deep.equal(blacklist)
152 })
153 })
154
155 after(async function () {
156 killallServers(servers)
157
158 if (this['ok']) {
159 await flushTests()
160 }
161 })
162})
diff --git a/server/tests/api/video-transcoder.ts b/server/tests/api/video-transcoder.ts
index 228cef007..c6d4c61f5 100644
--- a/server/tests/api/video-transcoder.ts
+++ b/server/tests/api/video-transcoder.ts
@@ -20,7 +20,7 @@ describe('Test video transcoding', function () {
20 let servers: ServerInfo[] = [] 20 let servers: ServerInfo[] = []
21 21
22 before(async function () { 22 before(async function () {
23 this.timeout(30000) 23 this.timeout(60000)
24 24
25 // Run servers 25 // Run servers
26 servers = await flushAndRunMultipleServers(2) 26 servers = await flushAndRunMultipleServers(2)
diff --git a/server/tests/utils/index.ts b/server/tests/utils/index.ts
index 0fa28f2af..99c445887 100644
--- a/server/tests/utils/index.ts
+++ b/server/tests/utils/index.ts
@@ -9,5 +9,5 @@ export * from './requests'
9export * from './servers' 9export * from './servers'
10export * from './users' 10export * from './users'
11export * from './video-abuses' 11export * from './video-abuses'
12export * from './video-blacklists' 12export * from './video-blacklist'
13export * from './videos' 13export * from './videos'
diff --git a/server/tests/utils/video-blacklist.ts b/server/tests/utils/video-blacklist.ts
new file mode 100644
index 000000000..5729d13d8
--- /dev/null
+++ b/server/tests/utils/video-blacklist.ts
@@ -0,0 +1,54 @@
1import * as request from 'supertest'
2
3function addVideoToBlacklist (url: string, token: string, videoId: number, specialStatus = 204) {
4 const path = '/api/v1/videos/' + videoId + '/blacklist'
5
6 return request(url)
7 .post(path)
8 .set('Accept', 'application/json')
9 .set('Authorization', 'Bearer ' + token)
10 .expect(specialStatus)
11}
12
13function removeVideoFromBlacklist (url: string, token: string, videoId: number, specialStatus = 204) {
14 const path = '/api/v1/blacklist/' + videoId
15
16 return request(url)
17 .delete(path)
18 .set('Accept', 'application/json')
19 .set('Authorization', 'Bearer ' + token)
20 .expect(specialStatus)
21}
22
23function getBlacklistedVideosList (url: string, token: string, specialStatus = 200) {
24 const path = '/api/v1/blacklist/'
25
26 return request(url)
27 .get(path)
28 .query({ sort: 'createdAt' })
29 .set('Accept', 'application/json')
30 .set('Authorization', 'Bearer ' + token)
31 .expect(specialStatus)
32 .expect('Content-Type', /json/)
33}
34
35function getSortedBlacklistedVideosList (url: string, token: string, sort: string, specialStatus = 200) {
36 const path = '/api/v1/blacklist/'
37
38 return request(url)
39 .get(path)
40 .query({ sort: sort })
41 .set('Accept', 'application/json')
42 .set('Authorization', 'Bearer ' + token)
43 .expect(specialStatus)
44 .expect('Content-Type', /json/)
45}
46
47// ---------------------------------------------------------------------------
48
49export {
50 addVideoToBlacklist,
51 removeVideoFromBlacklist,
52 getBlacklistedVideosList,
53 getSortedBlacklistedVideosList
54}
diff --git a/server/tests/utils/video-blacklists.ts b/server/tests/utils/video-blacklists.ts
deleted file mode 100644
index 6812d3ad4..000000000
--- a/server/tests/utils/video-blacklists.ts
+++ /dev/null
@@ -1,17 +0,0 @@
1import * as request from 'supertest'
2
3function addVideoToBlacklist (url: string, token: string, videoId: number, specialStatus = 204) {
4 const path = '/api/v1/videos/' + videoId + '/blacklist'
5
6 return request(url)
7 .post(path)
8 .set('Accept', 'application/json')
9 .set('Authorization', 'Bearer ' + token)
10 .expect(specialStatus)
11}
12
13// ---------------------------------------------------------------------------
14
15export {
16 addVideoToBlacklist
17}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-14 20:36:59 +0000