server/tests/api/check-params/video-imports.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import { omit } from 'lodash'
   5 import { HttpStatusCode } from '@shared/core-utils'
   6 import {
   7   buildAbsoluteFixturePath,
   8   checkBadCountPagination,
   9   checkBadSortPagination,
  10   checkBadStartPagination,
  11   cleanupTests,
  12   flushAndRunServer,
  13   ImportsCommand,
  14   makeGetRequest,
  15   makePostBodyRequest,
  16   makeUploadRequest,
  17   ServerInfo,
  18   setAccessTokensToServers
  19 } from '@shared/extra-utils'
  20 import { VideoPrivacy } from '@shared/models'
  21
  22 describe('Test video imports API validator', function () {
  23   const path = '/api/v1/videos/imports'
  24   let server: ServerInfo
  25   let userAccessToken = ''
  26   let channelId: number
  27
  28   // ---------------------------------------------------------------
  29
  30   before(async function () {
  31     this.timeout(30000)
  32
  33     server = await flushAndRunServer(1)
  34
  35     await setAccessTokensToServers([ server ])
  36
  37     const username = 'user1'
  38     const password = 'my super password'
  39     await server.usersCommand.create({ username: username, password: password })
  40     userAccessToken = await server.loginCommand.getAccessToken({ username, password })
  41
  42     {
  43       const { videoChannels } = await server.usersCommand.getMyInfo()
  44       channelId = videoChannels[0].id
  45     }
  46   })
  47
  48   describe('When listing my video imports', function () {
  49     const myPath = '/api/v1/users/me/videos/imports'
  50
  51     it('Should fail with a bad start pagination', async function () {
  52       await checkBadStartPagination(server.url, myPath, server.accessToken)
  53     })
  54
  55     it('Should fail with a bad count pagination', async function () {
  56       await checkBadCountPagination(server.url, myPath, server.accessToken)
  57     })
  58
  59     it('Should fail with an incorrect sort', async function () {
  60       await checkBadSortPagination(server.url, myPath, server.accessToken)
  61     })
  62
  63     it('Should success with the correct parameters', async function () {
  64       await makeGetRequest({ url: server.url, path: myPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
  65     })
  66   })
  67
  68   describe('When adding a video import', function () {
  69     let baseCorrectParams
  70
  71     before(function () {
  72       baseCorrectParams = {
  73         targetUrl: ImportsCommand.getGoodVideoUrl(),
  74         name: 'my super name',
  75         category: 5,
  76         licence: 1,
  77         language: 'pt',
  78         nsfw: false,
  79         commentsEnabled: true,
  80         downloadEnabled: true,
  81         waitTranscoding: true,
  82         description: 'my super description',
  83         support: 'my super support text',
  84         tags: [ 'tag1', 'tag2' ],
  85         privacy: VideoPrivacy.PUBLIC,
  86         channelId
  87       }
  88     })
  89
  90     it('Should fail with nothing', async function () {
  91       const fields = {}
  92       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
  93     })
  94
  95     it('Should fail without a target url', async function () {
  96       const fields = omit(baseCorrectParams, 'targetUrl')
  97       await makePostBodyRequest({
  98         url: server.url,
  99         path,
 100         token: server.accessToken,
 101         fields,
 102         statusCodeExpected: HttpStatusCode.BAD_REQUEST_400
 103       })
 104     })
 105
 106     it('Should fail with a bad target url', async function () {
 107       const fields = { ...baseCorrectParams, targetUrl: 'htt://hello' }
 108
 109       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 110     })
 111
 112     it('Should fail with a long name', async function () {
 113       const fields = { ...baseCorrectParams, name: 'super'.repeat(65) }
 114
 115       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 116     })
 117
 118     it('Should fail with a bad category', async function () {
 119       const fields = { ...baseCorrectParams, category: 125 }
 120
 121       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 122     })
 123
 124     it('Should fail with a bad licence', async function () {
 125       const fields = { ...baseCorrectParams, licence: 125 }
 126
 127       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 128     })
 129
 130     it('Should fail with a bad language', async function () {
 131       const fields = { ...baseCorrectParams, language: 'a'.repeat(15) }
 132
 133       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 134     })
 135
 136     it('Should fail with a long description', async function () {
 137       const fields = { ...baseCorrectParams, description: 'super'.repeat(2500) }
 138
 139       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 140     })
 141
 142     it('Should fail with a long support text', async function () {
 143       const fields = { ...baseCorrectParams, support: 'super'.repeat(201) }
 144
 145       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 146     })
 147
 148     it('Should fail without a channel', async function () {
 149       const fields = omit(baseCorrectParams, 'channelId')
 150
 151       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 152     })
 153
 154     it('Should fail with a bad channel', async function () {
 155       const fields = { ...baseCorrectParams, channelId: 545454 }
 156
 157       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 158     })
 159
 160     it('Should fail with another user channel', async function () {
 161       const user = {
 162         username: 'fake',
 163         password: 'fake_password'
 164       }
 165       await server.usersCommand.create({ username: user.username, password: user.password })
 166
 167       const accessTokenUser = await server.loginCommand.getAccessToken(user)
 168       const { videoChannels } = await server.usersCommand.getMyInfo({ token: accessTokenUser })
 169       const customChannelId = videoChannels[0].id
 170
 171       const fields = { ...baseCorrectParams, channelId: customChannelId }
 172
 173       await makePostBodyRequest({ url: server.url, path, token: userAccessToken, fields })
 174     })
 175
 176     it('Should fail with too many tags', async function () {
 177       const fields = { ...baseCorrectParams, tags: [ 'tag1', 'tag2', 'tag3', 'tag4', 'tag5', 'tag6' ] }
 178
 179       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 180     })
 181
 182     it('Should fail with a tag length too low', async function () {
 183       const fields = { ...baseCorrectParams, tags: [ 'tag1', 't' ] }
 184
 185       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 186     })
 187
 188     it('Should fail with a tag length too big', async function () {
 189       const fields = { ...baseCorrectParams, tags: [ 'tag1', 'my_super_tag_too_long_long_long_long_long_long' ] }
 190
 191       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 192     })
 193
 194     it('Should fail with an incorrect thumbnail file', async function () {
 195       const fields = baseCorrectParams
 196       const attaches = {
 197         thumbnailfile: buildAbsoluteFixturePath('video_short.mp4')
 198       }
 199
 200       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
 201     })
 202
 203     it('Should fail with a big thumbnail file', async function () {
 204       const fields = baseCorrectParams
 205       const attaches = {
 206         thumbnailfile: buildAbsoluteFixturePath('preview-big.png')
 207       }
 208
 209       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
 210     })
 211
 212     it('Should fail with an incorrect preview file', async function () {
 213       const fields = baseCorrectParams
 214       const attaches = {
 215         previewfile: buildAbsoluteFixturePath('video_short.mp4')
 216       }
 217
 218       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
 219     })
 220
 221     it('Should fail with a big preview file', async function () {
 222       const fields = baseCorrectParams
 223       const attaches = {
 224         previewfile: buildAbsoluteFixturePath('preview-big.png')
 225       }
 226
 227       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
 228     })
 229
 230     it('Should fail with an invalid torrent file', async function () {
 231       const fields = omit(baseCorrectParams, 'targetUrl')
 232       const attaches = {
 233         torrentfile: buildAbsoluteFixturePath('avatar-big.png')
 234       }
 235
 236       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
 237     })
 238
 239     it('Should fail with an invalid magnet URI', async function () {
 240       let fields = omit(baseCorrectParams, 'targetUrl')
 241       fields = { ...fields, magnetUri: 'blabla' }
 242
 243       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
 244     })
 245
 246     it('Should succeed with the correct parameters', async function () {
 247       this.timeout(30000)
 248
 249       await makePostBodyRequest({
 250         url: server.url,
 251         path,
 252         token: server.accessToken,
 253         fields: baseCorrectParams,
 254         statusCodeExpected: HttpStatusCode.OK_200
 255       })
 256     })
 257
 258     it('Should forbid to import http videos', async function () {
 259       await server.configCommand.updateCustomSubConfig({
 260         newConfig: {
 261           import: {
 262             videos: {
 263               http: {
 264                 enabled: false
 265               },
 266               torrent: {
 267                 enabled: true
 268               }
 269             }
 270           }
 271         }
 272       })
 273
 274       await makePostBodyRequest({
 275         url: server.url,
 276         path,
 277         token: server.accessToken,
 278         fields: baseCorrectParams,
 279         statusCodeExpected: HttpStatusCode.CONFLICT_409
 280       })
 281     })
 282
 283     it('Should forbid to import torrent videos', async function () {
 284       await server.configCommand.updateCustomSubConfig({
 285         newConfig: {
 286           import: {
 287             videos: {
 288               http: {
 289                 enabled: true
 290               },
 291               torrent: {
 292                 enabled: false
 293               }
 294             }
 295           }
 296         }
 297       })
 298
 299       let fields = omit(baseCorrectParams, 'targetUrl')
 300       fields = { ...fields, magnetUri: ImportsCommand.getMagnetURI() }
 301
 302       await makePostBodyRequest({
 303         url: server.url,
 304         path,
 305         token: server.accessToken,
 306         fields,
 307         statusCodeExpected: HttpStatusCode.CONFLICT_409
 308       })
 309
 310       fields = omit(fields, 'magnetUri')
 311       const attaches = {
 312         torrentfile: buildAbsoluteFixturePath('video-720p.torrent')
 313       }
 314
 315       await makeUploadRequest({
 316         url: server.url,
 317         path,
 318         token: server.accessToken,
 319         fields,
 320         attaches,
 321         statusCodeExpected: HttpStatusCode.CONFLICT_409
 322       })
 323     })
 324   })
 325
 326   after(async function () {
 327     await cleanupTests([ server ])
 328   })
 329 })