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

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import {
   5   addVideoInPlaylist,
   6   cleanupTests,
   7   createVideoPlaylist,
   8   deleteVideoPlaylist,
   9   flushAndRunServer,
  10   generateUserAccessToken,
  11   getAccountPlaylistsListWithToken,
  12   getVideoPlaylist,
  13   immutableAssign,
  14   makeGetRequest,
  15   removeVideoFromPlaylist,
  16   reorderVideosPlaylist,
  17   ServerInfo,
  18   setAccessTokensToServers,
  19   setDefaultVideoChannel,
  20   updateVideoPlaylist,
  21   updateVideoPlaylistElement,
  22   uploadVideoAndGetId
  23 } from '../../../../shared/extra-utils'
  24 import {
  25   checkBadCountPagination,
  26   checkBadSortPagination,
  27   checkBadStartPagination
  28 } from '../../../../shared/extra-utils/requests/check-api-params'
  29 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
  30 import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
  31 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
  32
  33 describe('Test video playlists API validator', function () {
  34   let server: ServerInfo
  35   let userAccessToken: string
  36   let playlistUUID: string
  37   let privatePlaylistUUID: string
  38   let watchLaterPlaylistId: number
  39   let videoId: number
  40   let playlistElementId: number
  41
  42   // ---------------------------------------------------------------
  43
  44   before(async function () {
  45     this.timeout(30000)
  46
  47     server = await flushAndRunServer(1)
  48
  49     await setAccessTokensToServers([ server ])
  50     await setDefaultVideoChannel([ server ])
  51
  52     userAccessToken = await generateUserAccessToken(server, 'user1')
  53     videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
  54
  55     {
  56       const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
  57       watchLaterPlaylistId = res.body.data[0].id
  58     }
  59
  60     {
  61       const res = await createVideoPlaylist({
  62         url: server.url,
  63         token: server.accessToken,
  64         playlistAttrs: {
  65           displayName: 'super playlist',
  66           privacy: VideoPlaylistPrivacy.PUBLIC,
  67           videoChannelId: server.videoChannel.id
  68         }
  69       })
  70       playlistUUID = res.body.videoPlaylist.uuid
  71     }
  72
  73     {
  74       const res = await createVideoPlaylist({
  75         url: server.url,
  76         token: server.accessToken,
  77         playlistAttrs: {
  78           displayName: 'private',
  79           privacy: VideoPlaylistPrivacy.PRIVATE
  80         }
  81       })
  82       privatePlaylistUUID = res.body.videoPlaylist.uuid
  83     }
  84   })
  85
  86   describe('When listing playlists', function () {
  87     const globalPath = '/api/v1/video-playlists'
  88     const accountPath = '/api/v1/accounts/root/video-playlists'
  89     const videoChannelPath = '/api/v1/video-channels/root_channel/video-playlists'
  90
  91     it('Should fail with a bad start pagination', async function () {
  92       await checkBadStartPagination(server.url, globalPath, server.accessToken)
  93       await checkBadStartPagination(server.url, accountPath, server.accessToken)
  94       await checkBadStartPagination(server.url, videoChannelPath, server.accessToken)
  95     })
  96
  97     it('Should fail with a bad count pagination', async function () {
  98       await checkBadCountPagination(server.url, globalPath, server.accessToken)
  99       await checkBadCountPagination(server.url, accountPath, server.accessToken)
 100       await checkBadCountPagination(server.url, videoChannelPath, server.accessToken)
 101     })
 102
 103     it('Should fail with an incorrect sort', async function () {
 104       await checkBadSortPagination(server.url, globalPath, server.accessToken)
 105       await checkBadSortPagination(server.url, accountPath, server.accessToken)
 106       await checkBadSortPagination(server.url, videoChannelPath, server.accessToken)
 107     })
 108
 109     it('Should fail with a bad playlist type', async function () {
 110       await makeGetRequest({ url: server.url, path: globalPath, query: { playlistType: 3 } })
 111       await makeGetRequest({ url: server.url, path: accountPath, query: { playlistType: 3 } })
 112       await makeGetRequest({ url: server.url, path: videoChannelPath, query: { playlistType: 3 } })
 113     })
 114
 115     it('Should fail with a bad account parameter', async function () {
 116       const accountPath = '/api/v1/accounts/root2/video-playlists'
 117
 118       await makeGetRequest({
 119         url: server.url,
 120         path: accountPath,
 121         statusCodeExpected: HttpStatusCode.NOT_FOUND_404,
 122         token: server.accessToken
 123       })
 124     })
 125
 126     it('Should fail with a bad video channel parameter', async function () {
 127       const accountPath = '/api/v1/video-channels/bad_channel/video-playlists'
 128
 129       await makeGetRequest({
 130         url: server.url,
 131         path: accountPath,
 132         statusCodeExpected: HttpStatusCode.NOT_FOUND_404,
 133         token: server.accessToken
 134       })
 135     })
 136
 137     it('Should success with the correct parameters', async function () {
 138       await makeGetRequest({ url: server.url, path: globalPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
 139       await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: HttpStatusCode.OK_200, token: server.accessToken })
 140       await makeGetRequest({
 141         url: server.url,
 142         path: videoChannelPath,
 143         statusCodeExpected: HttpStatusCode.OK_200,
 144         token: server.accessToken
 145       })
 146     })
 147   })
 148
 149   describe('When listing videos of a playlist', function () {
 150     const path = '/api/v1/video-playlists/'
 151
 152     it('Should fail with a bad start pagination', async function () {
 153       await checkBadStartPagination(server.url, path + playlistUUID + '/videos', server.accessToken)
 154     })
 155
 156     it('Should fail with a bad count pagination', async function () {
 157       await checkBadCountPagination(server.url, path + playlistUUID + '/videos', server.accessToken)
 158     })
 159
 160     it('Should success with the correct parameters', async function () {
 161       await makeGetRequest({ url: server.url, path: path + playlistUUID + '/videos', statusCodeExpected: HttpStatusCode.OK_200 })
 162     })
 163   })
 164
 165   describe('When getting a video playlist', function () {
 166     it('Should fail with a bad id or uuid', async function () {
 167       await getVideoPlaylist(server.url, 'toto', HttpStatusCode.BAD_REQUEST_400)
 168     })
 169
 170     it('Should fail with an unknown playlist', async function () {
 171       await getVideoPlaylist(server.url, 42, HttpStatusCode.NOT_FOUND_404)
 172     })
 173
 174     it('Should fail to get an unlisted playlist with the number id', async function () {
 175       const res = await createVideoPlaylist({
 176         url: server.url,
 177         token: server.accessToken,
 178         playlistAttrs: {
 179           displayName: 'super playlist',
 180           privacy: VideoPlaylistPrivacy.UNLISTED
 181         }
 182       })
 183       const playlist = res.body.videoPlaylist
 184
 185       await getVideoPlaylist(server.url, playlist.id, HttpStatusCode.NOT_FOUND_404)
 186       await getVideoPlaylist(server.url, playlist.uuid, HttpStatusCode.OK_200)
 187     })
 188
 189     it('Should succeed with the correct params', async function () {
 190       await getVideoPlaylist(server.url, playlistUUID, HttpStatusCode.OK_200)
 191     })
 192   })
 193
 194   describe('When creating/updating a video playlist', function () {
 195     const getBase = (playlistAttrs: any = {}, wrapper: any = {}) => {
 196       return Object.assign({
 197         expectedStatus: HttpStatusCode.BAD_REQUEST_400,
 198         url: server.url,
 199         token: server.accessToken,
 200         playlistAttrs: Object.assign({
 201           displayName: 'display name',
 202           privacy: VideoPlaylistPrivacy.UNLISTED,
 203           thumbnailfile: 'thumbnail.jpg',
 204           videoChannelId: server.videoChannel.id
 205         }, playlistAttrs)
 206       }, wrapper)
 207     }
 208     const getUpdate = (params: any, playlistId: number | string) => {
 209       return immutableAssign(params, { playlistId: playlistId })
 210     }
 211
 212     it('Should fail with an unauthenticated user', async function () {
 213       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 214
 215       await createVideoPlaylist(params)
 216       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 217     })
 218
 219     it('Should fail without displayName', async function () {
 220       const params = getBase({ displayName: undefined })
 221
 222       await createVideoPlaylist(params)
 223     })
 224
 225     it('Should fail with an incorrect display name', async function () {
 226       const params = getBase({ displayName: 's'.repeat(300) })
 227
 228       await createVideoPlaylist(params)
 229       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 230     })
 231
 232     it('Should fail with an incorrect description', async function () {
 233       const params = getBase({ description: 't' })
 234
 235       await createVideoPlaylist(params)
 236       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 237     })
 238
 239     it('Should fail with an incorrect privacy', async function () {
 240       const params = getBase({ privacy: 45 })
 241
 242       await createVideoPlaylist(params)
 243       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 244     })
 245
 246     it('Should fail with an unknown video channel id', async function () {
 247       const params = getBase({ videoChannelId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 248
 249       await createVideoPlaylist(params)
 250       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 251     })
 252
 253     it('Should fail with an incorrect thumbnail file', async function () {
 254       const params = getBase({ thumbnailfile: 'avatar.png' })
 255
 256       await createVideoPlaylist(params)
 257       await updateVideoPlaylist(getUpdate(params, playlistUUID))
 258     })
 259
 260     it('Should fail to set "public" a playlist not assigned to a channel', async function () {
 261       const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: undefined })
 262       const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' })
 263       const params3 = getBase({ privacy: undefined, videoChannelId: 'null' })
 264
 265       await createVideoPlaylist(params)
 266       await createVideoPlaylist(params2)
 267       await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
 268       await updateVideoPlaylist(getUpdate(params2, playlistUUID))
 269       await updateVideoPlaylist(getUpdate(params3, playlistUUID))
 270     })
 271
 272     it('Should fail with an unknown playlist to update', async function () {
 273       await updateVideoPlaylist(getUpdate(
 274         getBase({}, { expectedStatus: HttpStatusCode.NOT_FOUND_404 }),
 275         42
 276       ))
 277     })
 278
 279     it('Should fail to update a playlist of another user', async function () {
 280       await updateVideoPlaylist(getUpdate(
 281         getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 }),
 282         playlistUUID
 283       ))
 284     })
 285
 286     it('Should fail to update the watch later playlist', async function () {
 287       await updateVideoPlaylist(getUpdate(
 288         getBase({}, { expectedStatus: HttpStatusCode.BAD_REQUEST_400 }),
 289         watchLaterPlaylistId
 290       ))
 291     })
 292
 293     it('Should succeed with the correct params', async function () {
 294       {
 295         const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
 296         await createVideoPlaylist(params)
 297       }
 298
 299       {
 300         const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
 301         await updateVideoPlaylist(getUpdate(params, playlistUUID))
 302       }
 303     })
 304   })
 305
 306   describe('When adding an element in a playlist', function () {
 307     const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
 308       return Object.assign({
 309         expectedStatus: HttpStatusCode.BAD_REQUEST_400,
 310         url: server.url,
 311         token: server.accessToken,
 312         playlistId: playlistUUID,
 313         elementAttrs: Object.assign({
 314           videoId,
 315           startTimestamp: 2,
 316           stopTimestamp: 3
 317         }, elementAttrs)
 318       }, wrapper)
 319     }
 320
 321     it('Should fail with an unauthenticated user', async function () {
 322       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 323       await addVideoInPlaylist(params)
 324     })
 325
 326     it('Should fail with the playlist of another user', async function () {
 327       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 328       await addVideoInPlaylist(params)
 329     })
 330
 331     it('Should fail with an unknown or incorrect playlist id', async function () {
 332       {
 333         const params = getBase({}, { playlistId: 'toto' })
 334         await addVideoInPlaylist(params)
 335       }
 336
 337       {
 338         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 339         await addVideoInPlaylist(params)
 340       }
 341     })
 342
 343     it('Should fail with an unknown or incorrect video id', async function () {
 344       const params = getBase({ videoId: 42 }, { expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 345       await addVideoInPlaylist(params)
 346     })
 347
 348     it('Should fail with a bad start/stop timestamp', async function () {
 349       {
 350         const params = getBase({ startTimestamp: -42 })
 351         await addVideoInPlaylist(params)
 352       }
 353
 354       {
 355         const params = getBase({ stopTimestamp: 'toto' as any })
 356         await addVideoInPlaylist(params)
 357       }
 358     })
 359
 360     it('Succeed with the correct params', async function () {
 361       const params = getBase({}, { expectedStatus: HttpStatusCode.OK_200 })
 362       const res = await addVideoInPlaylist(params)
 363       playlistElementId = res.body.videoPlaylistElement.id
 364     })
 365   })
 366
 367   describe('When updating an element in a playlist', function () {
 368     const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
 369       return Object.assign({
 370         url: server.url,
 371         token: server.accessToken,
 372         elementAttrs: Object.assign({
 373           startTimestamp: 1,
 374           stopTimestamp: 2
 375         }, elementAttrs),
 376         playlistElementId,
 377         playlistId: playlistUUID,
 378         expectedStatus: HttpStatusCode.BAD_REQUEST_400
 379       }, wrapper)
 380     }
 381
 382     it('Should fail with an unauthenticated user', async function () {
 383       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 384       await updateVideoPlaylistElement(params)
 385     })
 386
 387     it('Should fail with the playlist of another user', async function () {
 388       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 389       await updateVideoPlaylistElement(params)
 390     })
 391
 392     it('Should fail with an unknown or incorrect playlist id', async function () {
 393       {
 394         const params = getBase({}, { playlistId: 'toto' })
 395         await updateVideoPlaylistElement(params)
 396       }
 397
 398       {
 399         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 400         await updateVideoPlaylistElement(params)
 401       }
 402     })
 403
 404     it('Should fail with an unknown or incorrect playlistElement id', async function () {
 405       {
 406         const params = getBase({}, { playlistElementId: 'toto' })
 407         await updateVideoPlaylistElement(params)
 408       }
 409
 410       {
 411         const params = getBase({}, { playlistElementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 412         await updateVideoPlaylistElement(params)
 413       }
 414     })
 415
 416     it('Should fail with a bad start/stop timestamp', async function () {
 417       {
 418         const params = getBase({ startTimestamp: 'toto' as any })
 419         await updateVideoPlaylistElement(params)
 420       }
 421
 422       {
 423         const params = getBase({ stopTimestamp: -42 })
 424         await updateVideoPlaylistElement(params)
 425       }
 426     })
 427
 428     it('Should fail with an unknown element', async function () {
 429       const params = getBase({}, { playlistElementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 430       await updateVideoPlaylistElement(params)
 431     })
 432
 433     it('Succeed with the correct params', async function () {
 434       const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
 435       await updateVideoPlaylistElement(params)
 436     })
 437   })
 438
 439   describe('When reordering elements of a playlist', function () {
 440     let videoId3: number
 441     let videoId4: number
 442
 443     const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
 444       return Object.assign({
 445         url: server.url,
 446         token: server.accessToken,
 447         playlistId: playlistUUID,
 448         elementAttrs: Object.assign({
 449           startPosition: 1,
 450           insertAfterPosition: 2,
 451           reorderLength: 3
 452         }, elementAttrs),
 453         expectedStatus: HttpStatusCode.BAD_REQUEST_400
 454       }, wrapper)
 455     }
 456
 457     before(async function () {
 458       videoId3 = (await uploadVideoAndGetId({ server, videoName: 'video 3' })).id
 459       videoId4 = (await uploadVideoAndGetId({ server, videoName: 'video 4' })).id
 460
 461       for (const id of [ videoId3, videoId4 ]) {
 462         await addVideoInPlaylist({
 463           url: server.url,
 464           token: server.accessToken,
 465           playlistId: playlistUUID,
 466           elementAttrs: { videoId: id }
 467         })
 468       }
 469     })
 470
 471     it('Should fail with an unauthenticated user', async function () {
 472       const params = getBase({}, { token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 473       await reorderVideosPlaylist(params)
 474     })
 475
 476     it('Should fail with the playlist of another user', async function () {
 477       const params = getBase({}, { token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 478       await reorderVideosPlaylist(params)
 479     })
 480
 481     it('Should fail with an invalid playlist', async function () {
 482       {
 483         const params = getBase({}, { playlistId: 'toto' })
 484         await reorderVideosPlaylist(params)
 485       }
 486
 487       {
 488         const params = getBase({}, { playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 489         await reorderVideosPlaylist(params)
 490       }
 491     })
 492
 493     it('Should fail with an invalid start position', async function () {
 494       {
 495         const params = getBase({ startPosition: -1 })
 496         await reorderVideosPlaylist(params)
 497       }
 498
 499       {
 500         const params = getBase({ startPosition: 'toto' as any })
 501         await reorderVideosPlaylist(params)
 502       }
 503
 504       {
 505         const params = getBase({ startPosition: 42 })
 506         await reorderVideosPlaylist(params)
 507       }
 508     })
 509
 510     it('Should fail with an invalid insert after position', async function () {
 511       {
 512         const params = getBase({ insertAfterPosition: 'toto' as any })
 513         await reorderVideosPlaylist(params)
 514       }
 515
 516       {
 517         const params = getBase({ insertAfterPosition: -2 })
 518         await reorderVideosPlaylist(params)
 519       }
 520
 521       {
 522         const params = getBase({ insertAfterPosition: 42 })
 523         await reorderVideosPlaylist(params)
 524       }
 525     })
 526
 527     it('Should fail with an invalid reorder length', async function () {
 528       {
 529         const params = getBase({ reorderLength: 'toto' as any })
 530         await reorderVideosPlaylist(params)
 531       }
 532
 533       {
 534         const params = getBase({ reorderLength: -2 })
 535         await reorderVideosPlaylist(params)
 536       }
 537
 538       {
 539         const params = getBase({ reorderLength: 42 })
 540         await reorderVideosPlaylist(params)
 541       }
 542     })
 543
 544     it('Succeed with the correct params', async function () {
 545       const params = getBase({}, { expectedStatus: HttpStatusCode.NO_CONTENT_204 })
 546       await reorderVideosPlaylist(params)
 547     })
 548   })
 549
 550   describe('When checking exists in playlist endpoint', function () {
 551     const path = '/api/v1/users/me/video-playlists/videos-exist'
 552
 553     it('Should fail with an unauthenticated user', async function () {
 554       await makeGetRequest({
 555         url: server.url,
 556         path,
 557         query: { videoIds: [ 1, 2 ] },
 558         statusCodeExpected: HttpStatusCode.UNAUTHORIZED_401
 559       })
 560     })
 561
 562     it('Should fail with invalid video ids', async function () {
 563       await makeGetRequest({
 564         url: server.url,
 565         token: server.accessToken,
 566         path,
 567         query: { videoIds: 'toto' }
 568       })
 569
 570       await makeGetRequest({
 571         url: server.url,
 572         token: server.accessToken,
 573         path,
 574         query: { videoIds: [ 'toto' ] }
 575       })
 576
 577       await makeGetRequest({
 578         url: server.url,
 579         token: server.accessToken,
 580         path,
 581         query: { videoIds: [ 1, 'toto' ] }
 582       })
 583     })
 584
 585     it('Should succeed with the correct params', async function () {
 586       await makeGetRequest({
 587         url: server.url,
 588         token: server.accessToken,
 589         path,
 590         query: { videoIds: [ 1, 2 ] },
 591         statusCodeExpected: HttpStatusCode.OK_200
 592       })
 593     })
 594   })
 595
 596   describe('When deleting an element in a playlist', function () {
 597     const getBase = (wrapper: any = {}) => {
 598       return Object.assign({
 599         url: server.url,
 600         token: server.accessToken,
 601         playlistElementId,
 602         playlistId: playlistUUID,
 603         expectedStatus: HttpStatusCode.BAD_REQUEST_400
 604       }, wrapper)
 605     }
 606
 607     it('Should fail with an unauthenticated user', async function () {
 608       const params = getBase({ token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
 609       await removeVideoFromPlaylist(params)
 610     })
 611
 612     it('Should fail with the playlist of another user', async function () {
 613       const params = getBase({ token: userAccessToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 614       await removeVideoFromPlaylist(params)
 615     })
 616
 617     it('Should fail with an unknown or incorrect playlist id', async function () {
 618       {
 619         const params = getBase({ playlistId: 'toto' })
 620         await removeVideoFromPlaylist(params)
 621       }
 622
 623       {
 624         const params = getBase({ playlistId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 625         await removeVideoFromPlaylist(params)
 626       }
 627     })
 628
 629     it('Should fail with an unknown or incorrect video id', async function () {
 630       {
 631         const params = getBase({ playlistElementId: 'toto' })
 632         await removeVideoFromPlaylist(params)
 633       }
 634
 635       {
 636         const params = getBase({ playlistElementId: 42, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 637         await removeVideoFromPlaylist(params)
 638       }
 639     })
 640
 641     it('Should fail with an unknown element', async function () {
 642       const params = getBase({ playlistElementId: 888, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 643       await removeVideoFromPlaylist(params)
 644     })
 645
 646     it('Succeed with the correct params', async function () {
 647       const params = getBase({ expectedStatus: HttpStatusCode.NO_CONTENT_204 })
 648       await removeVideoFromPlaylist(params)
 649     })
 650   })
 651
 652   describe('When deleting a playlist', function () {
 653     it('Should fail with an unknown playlist', async function () {
 654       await deleteVideoPlaylist(server.url, server.accessToken, 42, HttpStatusCode.NOT_FOUND_404)
 655     })
 656
 657     it('Should fail with a playlist of another user', async function () {
 658       await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, HttpStatusCode.FORBIDDEN_403)
 659     })
 660
 661     it('Should fail with the watch later playlist', async function () {
 662       await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, HttpStatusCode.BAD_REQUEST_400)
 663     })
 664
 665     it('Should succeed with the correct params', async function () {
 666       await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
 667     })
 668   })
 669
 670   after(async function () {
 671     await cleanupTests([ server ])
 672   })
 673 })