server/tests/api/videos/video-playlists.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import 'mocha'
   5 import {
   6   addVideoChannel,
   7   addVideoInPlaylist,
   8   addVideoToBlacklist,
   9   checkPlaylistFilesWereRemoved,
  10   cleanupTests,
  11   createUser,
  12   createVideoPlaylist,
  13   deleteVideoChannel,
  14   deleteVideoPlaylist,
  15   doubleFollow,
  16   doVideosExistInMyPlaylist,
  17   flushAndRunMultipleServers,
  18   generateUserAccessToken,
  19   getAccessToken,
  20   getAccountPlaylistsList,
  21   getAccountPlaylistsListWithToken,
  22   getMyUserInformation,
  23   getPlaylistVideos,
  24   getVideoChannelPlaylistsList,
  25   getVideoPlaylist,
  26   getVideoPlaylistPrivacies,
  27   getVideoPlaylistsList,
  28   getVideoPlaylistWithToken,
  29   removeUser,
  30   removeVideoFromBlacklist,
  31   removeVideoFromPlaylist,
  32   reorderVideosPlaylist,
  33   ServerInfo,
  34   setAccessTokensToServers,
  35   setDefaultVideoChannel,
  36   testImage,
  37   unfollow,
  38   updateVideo,
  39   updateVideoPlaylist,
  40   updateVideoPlaylistElement,
  41   uploadVideo,
  42   uploadVideoAndGetId,
  43   userLogin,
  44   waitJobs
  45 } from '../../../../shared/extra-utils'
  46 import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
  47 import { VideoPlaylist } from '../../../../shared/models/videos/playlist/video-playlist.model'
  48 import { VideoPrivacy } from '../../../../shared/models/videos'
  49 import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
  50 import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
  51 import { User } from '../../../../shared/models/users'
  52 import { VideoPlaylistElement, VideoPlaylistElementType } from '../../../../shared/models/videos/playlist/video-playlist-element.model'
  53 import {
  54   addAccountToAccountBlocklist,
  55   addAccountToServerBlocklist,
  56   addServerToAccountBlocklist,
  57   addServerToServerBlocklist,
  58   removeAccountFromAccountBlocklist,
  59   removeAccountFromServerBlocklist,
  60   removeServerFromAccountBlocklist,
  61   removeServerFromServerBlocklist
  62 } from '../../../../shared/extra-utils/users/blocklist'
  63
  64 const expect = chai.expect
  65
  66 async function checkPlaylistElementType (
  67   servers: ServerInfo[],
  68   playlistId: string,
  69   type: VideoPlaylistElementType,
  70   position: number,
  71   name: string,
  72   total: number
  73 ) {
  74   for (const server of servers) {
  75     const res = await getPlaylistVideos(server.url, server.accessToken, playlistId, 0, 10)
  76     expect(res.body.total).to.equal(total)
  77
  78     const videoElement: VideoPlaylistElement = res.body.data.find((e: VideoPlaylistElement) => e.position === position)
  79     expect(videoElement.type).to.equal(type, 'On server ' + server.url)
  80
  81     if (type === VideoPlaylistElementType.REGULAR) {
  82       expect(videoElement.video).to.not.be.null
  83       expect(videoElement.video.name).to.equal(name)
  84     } else {
  85       expect(videoElement.video).to.be.null
  86     }
  87   }
  88 }
  89
  90 describe('Test video playlists', function () {
  91   let servers: ServerInfo[] = []
  92
  93   let playlistServer2Id1: number
  94   let playlistServer2Id2: number
  95   let playlistServer2UUID2: number
  96
  97   let playlistServer1Id: number
  98   let playlistServer1UUID: string
  99   let playlistServer1UUID2: string
 100
 101   let playlistElementServer1Video4: number
 102   let playlistElementServer1Video5: number
 103   let playlistElementNSFW: number
 104
 105   let nsfwVideoServer1: number
 106
 107   let userAccessTokenServer1: string
 108
 109   before(async function () {
 110     this.timeout(120000)
 111
 112     servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
 113
 114     // Get the access tokens
 115     await setAccessTokensToServers(servers)
 116     await setDefaultVideoChannel(servers)
 117
 118     // Server 1 and server 2 follow each other
 119     await doubleFollow(servers[0], servers[1])
 120     // Server 1 and server 3 follow each other
 121     await doubleFollow(servers[0], servers[2])
 122
 123     {
 124       const serverPromises: Promise<any>[][] = []
 125
 126       for (const server of servers) {
 127         const videoPromises: Promise<any>[] = []
 128
 129         for (let i = 0; i < 7; i++) {
 130           videoPromises.push(
 131             uploadVideo(server.url, server.accessToken, { name: `video ${i} server ${server.serverNumber}`, nsfw: false })
 132               .then(res => res.body.video)
 133           )
 134         }
 135
 136         serverPromises.push(videoPromises)
 137       }
 138
 139       servers[0].videos = await Promise.all(serverPromises[0])
 140       servers[1].videos = await Promise.all(serverPromises[1])
 141       servers[2].videos = await Promise.all(serverPromises[2])
 142     }
 143
 144     nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'NSFW video', nsfw: true })).id
 145
 146     {
 147       await createUser({
 148         url: servers[0].url,
 149         accessToken: servers[0].accessToken,
 150         username: 'user1',
 151         password: 'password'
 152       })
 153       userAccessTokenServer1 = await getAccessToken(servers[0].url, 'user1', 'password')
 154     }
 155
 156     await waitJobs(servers)
 157   })
 158
 159   describe('Get default playlists', function () {
 160     it('Should list video playlist privacies', async function () {
 161       const res = await getVideoPlaylistPrivacies(servers[0].url)
 162
 163       const privacies = res.body
 164       expect(Object.keys(privacies)).to.have.length.at.least(3)
 165
 166       expect(privacies[3]).to.equal('Private')
 167     })
 168
 169     it('Should list watch later playlist', async function () {
 170       const url = servers[0].url
 171       const accessToken = servers[0].accessToken
 172
 173       {
 174         const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
 175
 176         expect(res.body.total).to.equal(1)
 177         expect(res.body.data).to.have.lengthOf(1)
 178
 179         const playlist: VideoPlaylist = res.body.data[0]
 180         expect(playlist.displayName).to.equal('Watch later')
 181         expect(playlist.type.id).to.equal(VideoPlaylistType.WATCH_LATER)
 182         expect(playlist.type.label).to.equal('Watch later')
 183       }
 184
 185       {
 186         const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.REGULAR)
 187
 188         expect(res.body.total).to.equal(0)
 189         expect(res.body.data).to.have.lengthOf(0)
 190       }
 191
 192       {
 193         const res = await getAccountPlaylistsList(url, 'root', 0, 5)
 194         expect(res.body.total).to.equal(0)
 195         expect(res.body.data).to.have.lengthOf(0)
 196       }
 197     })
 198
 199     it('Should get private playlist for a classic user', async function () {
 200       const token = await generateUserAccessToken(servers[0], 'toto')
 201
 202       const res = await getAccountPlaylistsListWithToken(servers[0].url, token, 'toto', 0, 5)
 203
 204       expect(res.body.total).to.equal(1)
 205       expect(res.body.data).to.have.lengthOf(1)
 206
 207       const playlistId = res.body.data[0].id
 208       await getPlaylistVideos(servers[0].url, token, playlistId, 0, 5)
 209     })
 210   })
 211
 212   describe('Create and federate playlists', function () {
 213
 214     it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
 215       this.timeout(30000)
 216
 217       await createVideoPlaylist({
 218         url: servers[0].url,
 219         token: servers[0].accessToken,
 220         playlistAttrs: {
 221           displayName: 'my super playlist',
 222           privacy: VideoPlaylistPrivacy.PUBLIC,
 223           description: 'my super description',
 224           thumbnailfile: 'thumbnail.jpg',
 225           videoChannelId: servers[0].videoChannel.id
 226         }
 227       })
 228
 229       await waitJobs(servers)
 230
 231       for (const server of servers) {
 232         const res = await getVideoPlaylistsList(server.url, 0, 5)
 233         expect(res.body.total).to.equal(1)
 234         expect(res.body.data).to.have.lengthOf(1)
 235
 236         const playlistFromList = res.body.data[0] as VideoPlaylist
 237
 238         const res2 = await getVideoPlaylist(server.url, playlistFromList.uuid)
 239         const playlistFromGet = res2.body as VideoPlaylist
 240
 241         for (const playlist of [ playlistFromGet, playlistFromList ]) {
 242           expect(playlist.id).to.be.a('number')
 243           expect(playlist.uuid).to.be.a('string')
 244
 245           expect(playlist.isLocal).to.equal(server.serverNumber === 1)
 246
 247           expect(playlist.displayName).to.equal('my super playlist')
 248           expect(playlist.description).to.equal('my super description')
 249           expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.PUBLIC)
 250           expect(playlist.privacy.label).to.equal('Public')
 251           expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
 252           expect(playlist.type.label).to.equal('Regular')
 253           expect(playlist.embedPath).to.equal('/video-playlists/embed/' + playlist.uuid)
 254
 255           expect(playlist.videosLength).to.equal(0)
 256
 257           expect(playlist.ownerAccount.name).to.equal('root')
 258           expect(playlist.ownerAccount.displayName).to.equal('root')
 259           expect(playlist.videoChannel.name).to.equal('root_channel')
 260           expect(playlist.videoChannel.displayName).to.equal('Main root channel')
 261         }
 262       }
 263     })
 264
 265     it('Should create a playlist on server 2 and have the playlist on server 1 but not on server 3', async function () {
 266       this.timeout(30000)
 267
 268       {
 269         const res = await createVideoPlaylist({
 270           url: servers[1].url,
 271           token: servers[1].accessToken,
 272           playlistAttrs: {
 273             displayName: 'playlist 2',
 274             privacy: VideoPlaylistPrivacy.PUBLIC,
 275             videoChannelId: servers[1].videoChannel.id
 276           }
 277         })
 278         playlistServer2Id1 = res.body.videoPlaylist.id
 279       }
 280
 281       {
 282         const res = await createVideoPlaylist({
 283           url: servers[1].url,
 284           token: servers[1].accessToken,
 285           playlistAttrs: {
 286             displayName: 'playlist 3',
 287             privacy: VideoPlaylistPrivacy.PUBLIC,
 288             thumbnailfile: 'thumbnail.jpg',
 289             videoChannelId: servers[1].videoChannel.id
 290           }
 291         })
 292
 293         playlistServer2Id2 = res.body.videoPlaylist.id
 294         playlistServer2UUID2 = res.body.videoPlaylist.uuid
 295       }
 296
 297       for (const id of [ playlistServer2Id1, playlistServer2Id2 ]) {
 298         await addVideoInPlaylist({
 299           url: servers[1].url,
 300           token: servers[1].accessToken,
 301           playlistId: id,
 302           elementAttrs: { videoId: servers[1].videos[0].id, startTimestamp: 1, stopTimestamp: 2 }
 303         })
 304         await addVideoInPlaylist({
 305           url: servers[1].url,
 306           token: servers[1].accessToken,
 307           playlistId: id,
 308           elementAttrs: { videoId: servers[1].videos[1].id }
 309         })
 310       }
 311
 312       await waitJobs(servers)
 313
 314       for (const server of [ servers[0], servers[1] ]) {
 315         const res = await getVideoPlaylistsList(server.url, 0, 5)
 316
 317         const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
 318         expect(playlist2).to.not.be.undefined
 319         await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
 320
 321         const playlist3 = res.body.data.find(p => p.displayName === 'playlist 3')
 322         expect(playlist3).to.not.be.undefined
 323         await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
 324       }
 325
 326       const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
 327       expect(res.body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
 328       expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
 329     })
 330
 331     it('Should have the playlist on server 3 after a new follow', async function () {
 332       this.timeout(30000)
 333
 334       // Server 2 and server 3 follow each other
 335       await doubleFollow(servers[1], servers[2])
 336
 337       const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
 338
 339       const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
 340       expect(playlist2).to.not.be.undefined
 341       await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
 342
 343       expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
 344     })
 345   })
 346
 347   describe('List playlists', function () {
 348
 349     it('Should correctly list the playlists', async function () {
 350       this.timeout(30000)
 351
 352       {
 353         const res = await getVideoPlaylistsList(servers[2].url, 1, 2, 'createdAt')
 354
 355         expect(res.body.total).to.equal(3)
 356
 357         const data: VideoPlaylist[] = res.body.data
 358         expect(data).to.have.lengthOf(2)
 359         expect(data[0].displayName).to.equal('playlist 2')
 360         expect(data[1].displayName).to.equal('playlist 3')
 361       }
 362
 363       {
 364         const res = await getVideoPlaylistsList(servers[2].url, 1, 2, '-createdAt')
 365
 366         expect(res.body.total).to.equal(3)
 367
 368         const data: VideoPlaylist[] = res.body.data
 369         expect(data).to.have.lengthOf(2)
 370         expect(data[0].displayName).to.equal('playlist 2')
 371         expect(data[1].displayName).to.equal('my super playlist')
 372       }
 373     })
 374
 375     it('Should list video channel playlists', async function () {
 376       this.timeout(30000)
 377
 378       {
 379         const res = await getVideoChannelPlaylistsList(servers[0].url, 'root_channel', 0, 2, '-createdAt')
 380
 381         expect(res.body.total).to.equal(1)
 382
 383         const data: VideoPlaylist[] = res.body.data
 384         expect(data).to.have.lengthOf(1)
 385         expect(data[0].displayName).to.equal('my super playlist')
 386       }
 387     })
 388
 389     it('Should list account playlists', async function () {
 390       this.timeout(30000)
 391
 392       {
 393         const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, '-createdAt')
 394
 395         expect(res.body.total).to.equal(2)
 396
 397         const data: VideoPlaylist[] = res.body.data
 398         expect(data).to.have.lengthOf(1)
 399         expect(data[0].displayName).to.equal('playlist 2')
 400       }
 401
 402       {
 403         const res = await getAccountPlaylistsList(servers[1].url, 'root', 1, 2, 'createdAt')
 404
 405         expect(res.body.total).to.equal(2)
 406
 407         const data: VideoPlaylist[] = res.body.data
 408         expect(data).to.have.lengthOf(1)
 409         expect(data[0].displayName).to.equal('playlist 3')
 410       }
 411
 412       {
 413         const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '3')
 414
 415         expect(res.body.total).to.equal(1)
 416
 417         const data: VideoPlaylist[] = res.body.data
 418         expect(data).to.have.lengthOf(1)
 419         expect(data[0].displayName).to.equal('playlist 3')
 420       }
 421
 422       {
 423         const res = await getAccountPlaylistsList(servers[1].url, 'root', 0, 10, 'createdAt', '4')
 424
 425         expect(res.body.total).to.equal(0)
 426
 427         const data: VideoPlaylist[] = res.body.data
 428         expect(data).to.have.lengthOf(0)
 429       }
 430     })
 431
 432     it('Should not list unlisted or private playlists', async function () {
 433       this.timeout(30000)
 434
 435       await createVideoPlaylist({
 436         url: servers[1].url,
 437         token: servers[1].accessToken,
 438         playlistAttrs: {
 439           displayName: 'playlist unlisted',
 440           privacy: VideoPlaylistPrivacy.UNLISTED
 441         }
 442       })
 443
 444       await createVideoPlaylist({
 445         url: servers[1].url,
 446         token: servers[1].accessToken,
 447         playlistAttrs: {
 448           displayName: 'playlist private',
 449           privacy: VideoPlaylistPrivacy.PRIVATE
 450         }
 451       })
 452
 453       await waitJobs(servers)
 454
 455       for (const server of servers) {
 456         const results = [
 457           await getAccountPlaylistsList(server.url, 'root@localhost:' + servers[1].port, 0, 5, '-createdAt'),
 458           await getVideoPlaylistsList(server.url, 0, 2, '-createdAt')
 459         ]
 460
 461         expect(results[0].body.total).to.equal(2)
 462         expect(results[1].body.total).to.equal(3)
 463
 464         for (const res of results) {
 465           const data: VideoPlaylist[] = res.body.data
 466           expect(data).to.have.lengthOf(2)
 467           expect(data[0].displayName).to.equal('playlist 3')
 468           expect(data[1].displayName).to.equal('playlist 2')
 469         }
 470       }
 471     })
 472   })
 473
 474   describe('Update playlists', function () {
 475
 476     it('Should update a playlist', async function () {
 477       this.timeout(30000)
 478
 479       await updateVideoPlaylist({
 480         url: servers[1].url,
 481         token: servers[1].accessToken,
 482         playlistAttrs: {
 483           displayName: 'playlist 3 updated',
 484           description: 'description updated',
 485           privacy: VideoPlaylistPrivacy.UNLISTED,
 486           thumbnailfile: 'thumbnail.jpg',
 487           videoChannelId: servers[1].videoChannel.id
 488         },
 489         playlistId: playlistServer2Id2
 490       })
 491
 492       await waitJobs(servers)
 493
 494       for (const server of servers) {
 495         const res = await getVideoPlaylist(server.url, playlistServer2UUID2)
 496         const playlist: VideoPlaylist = res.body
 497
 498         expect(playlist.displayName).to.equal('playlist 3 updated')
 499         expect(playlist.description).to.equal('description updated')
 500
 501         expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.UNLISTED)
 502         expect(playlist.privacy.label).to.equal('Unlisted')
 503
 504         expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
 505         expect(playlist.type.label).to.equal('Regular')
 506
 507         expect(playlist.videosLength).to.equal(2)
 508
 509         expect(playlist.ownerAccount.name).to.equal('root')
 510         expect(playlist.ownerAccount.displayName).to.equal('root')
 511         expect(playlist.videoChannel.name).to.equal('root_channel')
 512         expect(playlist.videoChannel.displayName).to.equal('Main root channel')
 513       }
 514     })
 515   })
 516
 517   describe('Element timestamps', function () {
 518
 519     it('Should create a playlist containing different startTimestamp/endTimestamp videos', async function () {
 520       this.timeout(30000)
 521
 522       const addVideo = (elementAttrs: any) => {
 523         return addVideoInPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: playlistServer1Id, elementAttrs })
 524       }
 525
 526       const res = await createVideoPlaylist({
 527         url: servers[0].url,
 528         token: servers[0].accessToken,
 529         playlistAttrs: {
 530           displayName: 'playlist 4',
 531           privacy: VideoPlaylistPrivacy.PUBLIC,
 532           videoChannelId: servers[0].videoChannel.id
 533         }
 534       })
 535
 536       playlistServer1Id = res.body.videoPlaylist.id
 537       playlistServer1UUID = res.body.videoPlaylist.uuid
 538
 539       await addVideo({ videoId: servers[0].videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
 540       await addVideo({ videoId: servers[2].videos[1].uuid, startTimestamp: 35 })
 541       await addVideo({ videoId: servers[2].videos[2].uuid })
 542       {
 543         const res = await addVideo({ videoId: servers[0].videos[3].uuid, stopTimestamp: 35 })
 544         playlistElementServer1Video4 = res.body.videoPlaylistElement.id
 545       }
 546
 547       {
 548         const res = await addVideo({ videoId: servers[0].videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
 549         playlistElementServer1Video5 = res.body.videoPlaylistElement.id
 550       }
 551
 552       {
 553         const res = await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
 554         playlistElementNSFW = res.body.videoPlaylistElement.id
 555
 556         await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 4 })
 557         await addVideo({ videoId: nsfwVideoServer1 })
 558       }
 559
 560       await waitJobs(servers)
 561     })
 562
 563     it('Should correctly list playlist videos', async function () {
 564       this.timeout(30000)
 565
 566       for (const server of servers) {
 567         const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
 568
 569         expect(res.body.total).to.equal(8)
 570
 571         const videoElements: VideoPlaylistElement[] = res.body.data
 572         expect(videoElements).to.have.lengthOf(8)
 573
 574         expect(videoElements[0].video.name).to.equal('video 0 server 1')
 575         expect(videoElements[0].position).to.equal(1)
 576         expect(videoElements[0].startTimestamp).to.equal(15)
 577         expect(videoElements[0].stopTimestamp).to.equal(28)
 578
 579         expect(videoElements[1].video.name).to.equal('video 1 server 3')
 580         expect(videoElements[1].position).to.equal(2)
 581         expect(videoElements[1].startTimestamp).to.equal(35)
 582         expect(videoElements[1].stopTimestamp).to.be.null
 583
 584         expect(videoElements[2].video.name).to.equal('video 2 server 3')
 585         expect(videoElements[2].position).to.equal(3)
 586         expect(videoElements[2].startTimestamp).to.be.null
 587         expect(videoElements[2].stopTimestamp).to.be.null
 588
 589         expect(videoElements[3].video.name).to.equal('video 3 server 1')
 590         expect(videoElements[3].position).to.equal(4)
 591         expect(videoElements[3].startTimestamp).to.be.null
 592         expect(videoElements[3].stopTimestamp).to.equal(35)
 593
 594         expect(videoElements[4].video.name).to.equal('video 4 server 1')
 595         expect(videoElements[4].position).to.equal(5)
 596         expect(videoElements[4].startTimestamp).to.equal(45)
 597         expect(videoElements[4].stopTimestamp).to.equal(60)
 598
 599         expect(videoElements[5].video.name).to.equal('NSFW video')
 600         expect(videoElements[5].position).to.equal(6)
 601         expect(videoElements[5].startTimestamp).to.equal(5)
 602         expect(videoElements[5].stopTimestamp).to.be.null
 603
 604         expect(videoElements[6].video.name).to.equal('NSFW video')
 605         expect(videoElements[6].position).to.equal(7)
 606         expect(videoElements[6].startTimestamp).to.equal(4)
 607         expect(videoElements[6].stopTimestamp).to.be.null
 608
 609         expect(videoElements[7].video.name).to.equal('NSFW video')
 610         expect(videoElements[7].position).to.equal(8)
 611         expect(videoElements[7].startTimestamp).to.be.null
 612         expect(videoElements[7].stopTimestamp).to.be.null
 613
 614         const res3 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 2)
 615         expect(res3.body.data).to.have.lengthOf(2)
 616       }
 617     })
 618   })
 619
 620   describe('Element type', function () {
 621     let groupUser1: ServerInfo[]
 622     let groupWithoutToken1: ServerInfo[]
 623     let group1: ServerInfo[]
 624     let group2: ServerInfo[]
 625
 626     let video1: string
 627     let video2: string
 628     let video3: string
 629
 630     before(async function () {
 631       this.timeout(60000)
 632
 633       groupUser1 = [ Object.assign({}, servers[0], { accessToken: userAccessTokenServer1 }) ]
 634       groupWithoutToken1 = [ Object.assign({}, servers[0], { accessToken: undefined }) ]
 635       group1 = [ servers[0] ]
 636       group2 = [ servers[1], servers[2] ]
 637
 638       const res = await createVideoPlaylist({
 639         url: servers[0].url,
 640         token: userAccessTokenServer1,
 641         playlistAttrs: {
 642           displayName: 'playlist 56',
 643           privacy: VideoPlaylistPrivacy.PUBLIC,
 644           videoChannelId: servers[0].videoChannel.id
 645         }
 646       })
 647
 648       const playlistServer1Id2 = res.body.videoPlaylist.id
 649       playlistServer1UUID2 = res.body.videoPlaylist.uuid
 650
 651       const addVideo = (elementAttrs: any) => {
 652         return addVideoInPlaylist({ url: servers[0].url, token: userAccessTokenServer1, playlistId: playlistServer1Id2, elementAttrs })
 653       }
 654
 655       video1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 89', token: userAccessTokenServer1 })).uuid
 656       video2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 90' })).uuid
 657       video3 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video 91', nsfw: true })).uuid
 658
 659       await waitJobs(servers)
 660
 661       await addVideo({ videoId: video1, startTimestamp: 15, stopTimestamp: 28 })
 662       await addVideo({ videoId: video2, startTimestamp: 35 })
 663       await addVideo({ videoId: video3 })
 664
 665       await waitJobs(servers)
 666     })
 667
 668     it('Should update the element type if the video is private', async function () {
 669       this.timeout(20000)
 670
 671       const name = 'video 89'
 672       const position = 1
 673
 674       {
 675         await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PRIVATE })
 676         await waitJobs(servers)
 677
 678         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 679         await checkPlaylistElementType(groupWithoutToken1, playlistServer1UUID2, VideoPlaylistElementType.PRIVATE, position, name, 3)
 680         await checkPlaylistElementType(group1, playlistServer1UUID2, VideoPlaylistElementType.PRIVATE, position, name, 3)
 681         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.DELETED, position, name, 3)
 682       }
 683
 684       {
 685         await updateVideo(servers[0].url, servers[0].accessToken, video1, { privacy: VideoPrivacy.PUBLIC })
 686         await waitJobs(servers)
 687
 688         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 689         await checkPlaylistElementType(groupWithoutToken1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 690         await checkPlaylistElementType(group1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 691         // We deleted the video, so even if we recreated it, the old entry is still deleted
 692         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.DELETED, position, name, 3)
 693       }
 694     })
 695
 696     it('Should update the element type if the video is blacklisted', async function () {
 697       this.timeout(20000)
 698
 699       const name = 'video 89'
 700       const position = 1
 701
 702       {
 703         await addVideoToBlacklist(servers[0].url, servers[0].accessToken, video1, 'reason', true)
 704         await waitJobs(servers)
 705
 706         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 707         await checkPlaylistElementType(groupWithoutToken1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 708         await checkPlaylistElementType(group1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 709         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.DELETED, position, name, 3)
 710       }
 711
 712       {
 713         await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, video1)
 714         await waitJobs(servers)
 715
 716         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 717         await checkPlaylistElementType(groupWithoutToken1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 718         await checkPlaylistElementType(group1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 719         // We deleted the video (because unfederated), so even if we recreated it, the old entry is still deleted
 720         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.DELETED, position, name, 3)
 721       }
 722     })
 723
 724     it('Should update the element type if the account or server of the video is blocked', async function () {
 725       this.timeout(90000)
 726
 727       const name = 'video 90'
 728       const position = 2
 729
 730       {
 731         await addAccountToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
 732         await waitJobs(servers)
 733
 734         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 735         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 736
 737         await removeAccountFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'root@localhost:' + servers[1].port)
 738         await waitJobs(servers)
 739
 740         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 741       }
 742
 743       {
 744         await addServerToAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
 745         await waitJobs(servers)
 746
 747         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 748         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 749
 750         await removeServerFromAccountBlocklist(servers[0].url, userAccessTokenServer1, 'localhost:' + servers[1].port)
 751         await waitJobs(servers)
 752
 753         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 754       }
 755
 756       {
 757         await addAccountToServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
 758         await waitJobs(servers)
 759
 760         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 761         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 762
 763         await removeAccountFromServerBlocklist(servers[0].url, servers[0].accessToken, 'root@localhost:' + servers[1].port)
 764         await waitJobs(servers)
 765
 766         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 767       }
 768
 769       {
 770         await addServerToServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
 771         await waitJobs(servers)
 772
 773         await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.UNAVAILABLE, position, name, 3)
 774         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 775
 776         await removeServerFromServerBlocklist(servers[0].url, servers[0].accessToken, 'localhost:' + servers[1].port)
 777         await waitJobs(servers)
 778
 779         await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
 780       }
 781     })
 782
 783     it('Should hide the video if it is NSFW', async function () {
 784       const res = await getPlaylistVideos(servers[0].url, userAccessTokenServer1, playlistServer1UUID2, 0, 10, { nsfw: false })
 785       expect(res.body.total).to.equal(3)
 786
 787       const elements: VideoPlaylistElement[] = res.body.data
 788       const element = elements.find(e => e.position === 3)
 789
 790       expect(element).to.exist
 791       expect(element.video).to.be.null
 792       expect(element.type).to.equal(VideoPlaylistElementType.UNAVAILABLE)
 793     })
 794
 795   })
 796
 797   describe('Managing playlist elements', function () {
 798
 799     it('Should reorder the playlist', async function () {
 800       this.timeout(30000)
 801
 802       {
 803         await reorderVideosPlaylist({
 804           url: servers[0].url,
 805           token: servers[0].accessToken,
 806           playlistId: playlistServer1Id,
 807           elementAttrs: {
 808             startPosition: 2,
 809             insertAfterPosition: 3
 810           }
 811         })
 812
 813         await waitJobs(servers)
 814
 815         for (const server of servers) {
 816           const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
 817           const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
 818
 819           expect(names).to.deep.equal([
 820             'video 0 server 1',
 821             'video 2 server 3',
 822             'video 1 server 3',
 823             'video 3 server 1',
 824             'video 4 server 1',
 825             'NSFW video',
 826             'NSFW video',
 827             'NSFW video'
 828           ])
 829         }
 830       }
 831
 832       {
 833         await reorderVideosPlaylist({
 834           url: servers[0].url,
 835           token: servers[0].accessToken,
 836           playlistId: playlistServer1Id,
 837           elementAttrs: {
 838             startPosition: 1,
 839             reorderLength: 3,
 840             insertAfterPosition: 4
 841           }
 842         })
 843
 844         await waitJobs(servers)
 845
 846         for (const server of servers) {
 847           const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
 848           const names = (res.body.data as VideoPlaylistElement[]).map(v => v.video.name)
 849
 850           expect(names).to.deep.equal([
 851             'video 3 server 1',
 852             'video 0 server 1',
 853             'video 2 server 3',
 854             'video 1 server 3',
 855             'video 4 server 1',
 856             'NSFW video',
 857             'NSFW video',
 858             'NSFW video'
 859           ])
 860         }
 861       }
 862
 863       {
 864         await reorderVideosPlaylist({
 865           url: servers[0].url,
 866           token: servers[0].accessToken,
 867           playlistId: playlistServer1Id,
 868           elementAttrs: {
 869             startPosition: 6,
 870             insertAfterPosition: 3
 871           }
 872         })
 873
 874         await waitJobs(servers)
 875
 876         for (const server of servers) {
 877           const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
 878           const elements: VideoPlaylistElement[] = res.body.data
 879           const names = elements.map(v => v.video.name)
 880
 881           expect(names).to.deep.equal([
 882             'video 3 server 1',
 883             'video 0 server 1',
 884             'video 2 server 3',
 885             'NSFW video',
 886             'video 1 server 3',
 887             'video 4 server 1',
 888             'NSFW video',
 889             'NSFW video'
 890           ])
 891
 892           for (let i = 1; i <= elements.length; i++) {
 893             expect(elements[i - 1].position).to.equal(i)
 894           }
 895         }
 896       }
 897     })
 898
 899     it('Should update startTimestamp/endTimestamp of some elements', async function () {
 900       this.timeout(30000)
 901
 902       await updateVideoPlaylistElement({
 903         url: servers[0].url,
 904         token: servers[0].accessToken,
 905         playlistId: playlistServer1Id,
 906         playlistElementId: playlistElementServer1Video4,
 907         elementAttrs: {
 908           startTimestamp: 1
 909         }
 910       })
 911
 912       await updateVideoPlaylistElement({
 913         url: servers[0].url,
 914         token: servers[0].accessToken,
 915         playlistId: playlistServer1Id,
 916         playlistElementId: playlistElementServer1Video5,
 917         elementAttrs: {
 918           stopTimestamp: null
 919         }
 920       })
 921
 922       await waitJobs(servers)
 923
 924       for (const server of servers) {
 925         const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
 926         const elements: VideoPlaylistElement[] = res.body.data
 927
 928         expect(elements[0].video.name).to.equal('video 3 server 1')
 929         expect(elements[0].position).to.equal(1)
 930         expect(elements[0].startTimestamp).to.equal(1)
 931         expect(elements[0].stopTimestamp).to.equal(35)
 932
 933         expect(elements[5].video.name).to.equal('video 4 server 1')
 934         expect(elements[5].position).to.equal(6)
 935         expect(elements[5].startTimestamp).to.equal(45)
 936         expect(elements[5].stopTimestamp).to.be.null
 937       }
 938     })
 939
 940     it('Should check videos existence in my playlist', async function () {
 941       const videoIds = [
 942         servers[0].videos[0].id,
 943         42000,
 944         servers[0].videos[3].id,
 945         43000,
 946         servers[0].videos[4].id
 947       ]
 948       const res = await doVideosExistInMyPlaylist(servers[0].url, servers[0].accessToken, videoIds)
 949       const obj = res.body as VideoExistInPlaylist
 950
 951       {
 952         const elem = obj[servers[0].videos[0].id]
 953         expect(elem).to.have.lengthOf(1)
 954         expect(elem[0].playlistElementId).to.exist
 955         expect(elem[0].playlistId).to.equal(playlistServer1Id)
 956         expect(elem[0].startTimestamp).to.equal(15)
 957         expect(elem[0].stopTimestamp).to.equal(28)
 958       }
 959
 960       {
 961         const elem = obj[servers[0].videos[3].id]
 962         expect(elem).to.have.lengthOf(1)
 963         expect(elem[0].playlistElementId).to.equal(playlistElementServer1Video4)
 964         expect(elem[0].playlistId).to.equal(playlistServer1Id)
 965         expect(elem[0].startTimestamp).to.equal(1)
 966         expect(elem[0].stopTimestamp).to.equal(35)
 967       }
 968
 969       {
 970         const elem = obj[servers[0].videos[4].id]
 971         expect(elem).to.have.lengthOf(1)
 972         expect(elem[0].playlistId).to.equal(playlistServer1Id)
 973         expect(elem[0].startTimestamp).to.equal(45)
 974         expect(elem[0].stopTimestamp).to.equal(null)
 975       }
 976
 977       expect(obj[42000]).to.have.lengthOf(0)
 978       expect(obj[43000]).to.have.lengthOf(0)
 979     })
 980
 981     it('Should automatically update updatedAt field of playlists', async function () {
 982       const server = servers[1]
 983       const videoId = servers[1].videos[5].id
 984
 985       async function getPlaylistNames () {
 986         const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, undefined, '-updatedAt')
 987
 988         return (res.body.data as VideoPlaylist[]).map(p => p.displayName)
 989       }
 990
 991       const elementAttrs = { videoId }
 992       const res1 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id1, elementAttrs })
 993       const res2 = await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id2, elementAttrs })
 994
 995       const element1 = res1.body.videoPlaylistElement.id
 996       const element2 = res2.body.videoPlaylistElement.id
 997
 998       const names1 = await getPlaylistNames()
 999       expect(names1[0]).to.equal('playlist 3 updated')
1000       expect(names1[1]).to.equal('playlist 2')
1001
1002       await removeVideoFromPlaylist({
1003         url: server.url,
1004         token: server.accessToken,
1005         playlistId: playlistServer2Id1,
1006         playlistElementId: element1
1007       })
1008
1009       const names2 = await getPlaylistNames()
1010       expect(names2[0]).to.equal('playlist 2')
1011       expect(names2[1]).to.equal('playlist 3 updated')
1012
1013       await removeVideoFromPlaylist({
1014         url: server.url,
1015         token: server.accessToken,
1016         playlistId: playlistServer2Id2,
1017         playlistElementId: element2
1018       })
1019
1020       const names3 = await getPlaylistNames()
1021       expect(names3[0]).to.equal('playlist 3 updated')
1022       expect(names3[1]).to.equal('playlist 2')
1023     })
1024
1025     it('Should delete some elements', async function () {
1026       this.timeout(30000)
1027
1028       await removeVideoFromPlaylist({
1029         url: servers[0].url,
1030         token: servers[0].accessToken,
1031         playlistId: playlistServer1Id,
1032         playlistElementId: playlistElementServer1Video4
1033       })
1034
1035       await removeVideoFromPlaylist({
1036         url: servers[0].url,
1037         token: servers[0].accessToken,
1038         playlistId: playlistServer1Id,
1039         playlistElementId: playlistElementNSFW
1040       })
1041
1042       await waitJobs(servers)
1043
1044       for (const server of servers) {
1045         const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
1046
1047         expect(res.body.total).to.equal(6)
1048
1049         const elements: VideoPlaylistElement[] = res.body.data
1050         expect(elements).to.have.lengthOf(6)
1051
1052         expect(elements[0].video.name).to.equal('video 0 server 1')
1053         expect(elements[0].position).to.equal(1)
1054
1055         expect(elements[1].video.name).to.equal('video 2 server 3')
1056         expect(elements[1].position).to.equal(2)
1057
1058         expect(elements[2].video.name).to.equal('video 1 server 3')
1059         expect(elements[2].position).to.equal(3)
1060
1061         expect(elements[3].video.name).to.equal('video 4 server 1')
1062         expect(elements[3].position).to.equal(4)
1063
1064         expect(elements[4].video.name).to.equal('NSFW video')
1065         expect(elements[4].position).to.equal(5)
1066
1067         expect(elements[5].video.name).to.equal('NSFW video')
1068         expect(elements[5].position).to.equal(6)
1069       }
1070     })
1071
1072     it('Should be able to create a public playlist, and set it to private', async function () {
1073       this.timeout(30000)
1074
1075       const res = await createVideoPlaylist({
1076         url: servers[0].url,
1077         token: servers[0].accessToken,
1078         playlistAttrs: {
1079           displayName: 'my super public playlist',
1080           privacy: VideoPlaylistPrivacy.PUBLIC,
1081           videoChannelId: servers[0].videoChannel.id
1082         }
1083       })
1084       const videoPlaylistIds = res.body.videoPlaylist
1085
1086       await waitJobs(servers)
1087
1088       for (const server of servers) {
1089         await getVideoPlaylist(server.url, videoPlaylistIds.uuid, 200)
1090       }
1091
1092       const playlistAttrs = { privacy: VideoPlaylistPrivacy.PRIVATE }
1093       await updateVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: videoPlaylistIds.id, playlistAttrs })
1094
1095       await waitJobs(servers)
1096
1097       for (const server of [ servers[1], servers[2] ]) {
1098         await getVideoPlaylist(server.url, videoPlaylistIds.uuid, 404)
1099       }
1100       await getVideoPlaylist(servers[0].url, videoPlaylistIds.uuid, 401)
1101
1102       await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistIds.uuid, 200)
1103     })
1104   })
1105
1106   describe('Playlist deletion', function () {
1107
1108     it('Should delete the playlist on server 1 and delete on server 2 and 3', async function () {
1109       this.timeout(30000)
1110
1111       await deleteVideoPlaylist(servers[0].url, servers[0].accessToken, playlistServer1Id)
1112
1113       await waitJobs(servers)
1114
1115       for (const server of servers) {
1116         await getVideoPlaylist(server.url, playlistServer1UUID, 404)
1117       }
1118     })
1119
1120     it('Should have deleted the thumbnail on server 1, 2 and 3', async function () {
1121       this.timeout(30000)
1122
1123       for (const server of servers) {
1124         await checkPlaylistFilesWereRemoved(playlistServer1UUID, server.internalServerNumber)
1125       }
1126     })
1127
1128     it('Should unfollow servers 1 and 2 and hide their playlists', async function () {
1129       this.timeout(30000)
1130
1131       const finder = data => data.find(p => p.displayName === 'my super playlist')
1132
1133       {
1134         const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
1135         expect(res.body.total).to.equal(3)
1136         expect(finder(res.body.data)).to.not.be.undefined
1137       }
1138
1139       await unfollow(servers[2].url, servers[2].accessToken, servers[0])
1140
1141       {
1142         const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
1143         expect(res.body.total).to.equal(1)
1144
1145         expect(finder(res.body.data)).to.be.undefined
1146       }
1147     })
1148
1149     it('Should delete a channel and put the associated playlist in private mode', async function () {
1150       this.timeout(30000)
1151
1152       const res = await addVideoChannel(servers[0].url, servers[0].accessToken, { name: 'super_channel', displayName: 'super channel' })
1153       const videoChannelId = res.body.videoChannel.id
1154
1155       const res2 = await createVideoPlaylist({
1156         url: servers[0].url,
1157         token: servers[0].accessToken,
1158         playlistAttrs: {
1159           displayName: 'channel playlist',
1160           privacy: VideoPlaylistPrivacy.PUBLIC,
1161           videoChannelId
1162         }
1163       })
1164       const videoPlaylistUUID = res2.body.videoPlaylist.uuid
1165
1166       await waitJobs(servers)
1167
1168       await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
1169
1170       await waitJobs(servers)
1171
1172       const res3 = await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistUUID)
1173       expect(res3.body.displayName).to.equal('channel playlist')
1174       expect(res3.body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
1175
1176       await getVideoPlaylist(servers[1].url, videoPlaylistUUID, 404)
1177     })
1178
1179     it('Should delete an account and delete its playlists', async function () {
1180       this.timeout(30000)
1181
1182       const user = { username: 'user_1', password: 'password' }
1183       const res = await createUser({
1184         url: servers[0].url,
1185         accessToken: servers[0].accessToken,
1186         username: user.username,
1187         password: user.password
1188       })
1189
1190       const userId = res.body.user.id
1191       const userAccessToken = await userLogin(servers[0], user)
1192
1193       const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
1194       const userChannel = (resChannel.body as User).videoChannels[0]
1195
1196       await createVideoPlaylist({
1197         url: servers[0].url,
1198         token: userAccessToken,
1199         playlistAttrs: {
1200           displayName: 'playlist to be deleted',
1201           privacy: VideoPlaylistPrivacy.PUBLIC,
1202           videoChannelId: userChannel.id
1203         }
1204       })
1205
1206       await waitJobs(servers)
1207
1208       const finder = data => data.find(p => p.displayName === 'playlist to be deleted')
1209
1210       {
1211         for (const server of [ servers[0], servers[1] ]) {
1212           const res = await getVideoPlaylistsList(server.url, 0, 15)
1213           expect(finder(res.body.data)).to.not.be.undefined
1214         }
1215       }
1216
1217       await removeUser(servers[0].url, userId, servers[0].accessToken)
1218       await waitJobs(servers)
1219
1220       {
1221         for (const server of [ servers[0], servers[1] ]) {
1222           const res = await getVideoPlaylistsList(server.url, 0, 15)
1223           expect(finder(res.body.data)).to.be.undefined
1224         }
1225       }
1226     })
1227   })
1228
1229   after(async function () {
1230     await cleanupTests(servers)
1231   })
1232 })