server/tests/api/live/live.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import { basename, join } from 'path'
   5 import { SQLCommand, testImage, testLiveVideoResolutions } from '@server/tests/shared'
   6 import { getAllFiles, wait } from '@shared/core-utils'
   7 import { ffprobePromise, getVideoStream } from '@shared/ffmpeg'
   8 import {
   9   HttpStatusCode,
  10   LiveVideo,
  11   LiveVideoCreate,
  12   LiveVideoLatencyMode,
  13   VideoDetails,
  14   VideoPrivacy,
  15   VideoState,
  16   VideoStreamingPlaylistType
  17 } from '@shared/models'
  18 import {
  19   cleanupTests,
  20   createMultipleServers,
  21   doubleFollow,
  22   killallServers,
  23   LiveCommand,
  24   makeGetRequest,
  25   makeRawRequest,
  26   PeerTubeServer,
  27   sendRTMPStream,
  28   setAccessTokensToServers,
  29   setDefaultVideoChannel,
  30   stopFfmpeg,
  31   testFfmpegStreamError,
  32   waitJobs,
  33   waitUntilLivePublishedOnAllServers
  34 } from '@shared/server-commands'
  35
  36 describe('Test live', function () {
  37   let servers: PeerTubeServer[] = []
  38   let commands: LiveCommand[]
  39
  40   before(async function () {
  41     this.timeout(120000)
  42
  43     servers = await createMultipleServers(2)
  44
  45     // Get the access tokens
  46     await setAccessTokensToServers(servers)
  47     await setDefaultVideoChannel(servers)
  48
  49     await servers[0].config.updateCustomSubConfig({
  50       newConfig: {
  51         live: {
  52           enabled: true,
  53           allowReplay: true,
  54           latencySetting: {
  55             enabled: true
  56           },
  57           transcoding: {
  58             enabled: false
  59           }
  60         }
  61       }
  62     })
  63
  64     // Server 1 and server 2 follow each other
  65     await doubleFollow(servers[0], servers[1])
  66
  67     commands = servers.map(s => s.live)
  68   })
  69
  70   describe('Live creation, update and delete', function () {
  71     let liveVideoUUID: string
  72
  73     it('Should create a live with the appropriate parameters', async function () {
  74       this.timeout(20000)
  75
  76       const attributes: LiveVideoCreate = {
  77         category: 1,
  78         licence: 2,
  79         language: 'fr',
  80         description: 'super live description',
  81         support: 'support field',
  82         channelId: servers[0].store.channel.id,
  83         nsfw: false,
  84         waitTranscoding: false,
  85         name: 'my super live',
  86         tags: [ 'tag1', 'tag2' ],
  87         commentsEnabled: false,
  88         downloadEnabled: false,
  89         saveReplay: true,
  90         replaySettings: { privacy: VideoPrivacy.PUBLIC },
  91         latencyMode: LiveVideoLatencyMode.SMALL_LATENCY,
  92         privacy: VideoPrivacy.PUBLIC,
  93         previewfile: 'video_short1-preview.webm.jpg',
  94         thumbnailfile: 'video_short1.webm.jpg'
  95       }
  96
  97       const live = await commands[0].create({ fields: attributes })
  98       liveVideoUUID = live.uuid
  99
 100       await waitJobs(servers)
 101
 102       for (const server of servers) {
 103         const video = await server.videos.get({ id: liveVideoUUID })
 104
 105         expect(video.category.id).to.equal(1)
 106         expect(video.licence.id).to.equal(2)
 107         expect(video.language.id).to.equal('fr')
 108         expect(video.description).to.equal('super live description')
 109         expect(video.support).to.equal('support field')
 110
 111         expect(video.channel.name).to.equal(servers[0].store.channel.name)
 112         expect(video.channel.host).to.equal(servers[0].store.channel.host)
 113
 114         expect(video.isLive).to.be.true
 115
 116         expect(video.nsfw).to.be.false
 117         expect(video.waitTranscoding).to.be.false
 118         expect(video.name).to.equal('my super live')
 119         expect(video.tags).to.deep.equal([ 'tag1', 'tag2' ])
 120         expect(video.commentsEnabled).to.be.false
 121         expect(video.downloadEnabled).to.be.false
 122         expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
 123
 124         await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
 125         await testImage(server.url, 'video_short1.webm', video.thumbnailPath)
 126
 127         const live = await server.live.get({ videoId: liveVideoUUID })
 128
 129         if (server.url === servers[0].url) {
 130           expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
 131           expect(live.streamKey).to.not.be.empty
 132
 133           expect(live.replaySettings).to.exist
 134           expect(live.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
 135         } else {
 136           expect(live.rtmpUrl).to.not.exist
 137           expect(live.streamKey).to.not.exist
 138         }
 139
 140         expect(live.saveReplay).to.be.true
 141         expect(live.latencyMode).to.equal(LiveVideoLatencyMode.SMALL_LATENCY)
 142       }
 143     })
 144
 145     it('Should have a default preview and thumbnail', async function () {
 146       this.timeout(20000)
 147
 148       const attributes: LiveVideoCreate = {
 149         name: 'default live thumbnail',
 150         channelId: servers[0].store.channel.id,
 151         privacy: VideoPrivacy.UNLISTED,
 152         nsfw: true
 153       }
 154
 155       const live = await commands[0].create({ fields: attributes })
 156       const videoId = live.uuid
 157
 158       await waitJobs(servers)
 159
 160       for (const server of servers) {
 161         const video = await server.videos.get({ id: videoId })
 162         expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
 163         expect(video.nsfw).to.be.true
 164
 165         await makeGetRequest({ url: server.url, path: video.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
 166         await makeGetRequest({ url: server.url, path: video.previewPath, expectedStatus: HttpStatusCode.OK_200 })
 167       }
 168     })
 169
 170     it('Should not have the live listed since nobody streams into', async function () {
 171       for (const server of servers) {
 172         const { total, data } = await server.videos.list()
 173
 174         expect(total).to.equal(0)
 175         expect(data).to.have.lengthOf(0)
 176       }
 177     })
 178
 179     it('Should not be able to update a live of another server', async function () {
 180       await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
 181     })
 182
 183     it('Should update the live', async function () {
 184       this.timeout(10000)
 185
 186       await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false, latencyMode: LiveVideoLatencyMode.DEFAULT } })
 187       await waitJobs(servers)
 188     })
 189
 190     it('Have the live updated', async function () {
 191       for (const server of servers) {
 192         const live = await server.live.get({ videoId: liveVideoUUID })
 193
 194         if (server.url === servers[0].url) {
 195           expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
 196           expect(live.streamKey).to.not.be.empty
 197         } else {
 198           expect(live.rtmpUrl).to.not.exist
 199           expect(live.streamKey).to.not.exist
 200         }
 201
 202         expect(live.saveReplay).to.be.false
 203         expect(live.replaySettings).to.not.exist
 204         expect(live.latencyMode).to.equal(LiveVideoLatencyMode.DEFAULT)
 205       }
 206     })
 207
 208     it('Delete the live', async function () {
 209       this.timeout(10000)
 210
 211       await servers[0].videos.remove({ id: liveVideoUUID })
 212       await waitJobs(servers)
 213     })
 214
 215     it('Should have the live deleted', async function () {
 216       for (const server of servers) {
 217         await server.videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 218         await server.live.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
 219       }
 220     })
 221   })
 222
 223   describe('Live filters', function () {
 224     let ffmpegCommand: any
 225     let liveVideoId: string
 226     let vodVideoId: string
 227
 228     before(async function () {
 229       this.timeout(240000)
 230
 231       vodVideoId = (await servers[0].videos.quickUpload({ name: 'vod video' })).uuid
 232
 233       const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].store.channel.id }
 234       const live = await commands[0].create({ fields: liveOptions })
 235       liveVideoId = live.uuid
 236
 237       ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
 238       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 239       await waitJobs(servers)
 240     })
 241
 242     it('Should only display lives', async function () {
 243       const { data, total } = await servers[0].videos.list({ isLive: true })
 244
 245       expect(total).to.equal(1)
 246       expect(data).to.have.lengthOf(1)
 247       expect(data[0].name).to.equal('live')
 248     })
 249
 250     it('Should not display lives', async function () {
 251       const { data, total } = await servers[0].videos.list({ isLive: false })
 252
 253       expect(total).to.equal(1)
 254       expect(data).to.have.lengthOf(1)
 255       expect(data[0].name).to.equal('vod video')
 256     })
 257
 258     it('Should display my lives', async function () {
 259       this.timeout(60000)
 260
 261       await stopFfmpeg(ffmpegCommand)
 262       await waitJobs(servers)
 263
 264       const { data } = await servers[0].videos.listMyVideos({ isLive: true })
 265
 266       const result = data.every(v => v.isLive)
 267       expect(result).to.be.true
 268     })
 269
 270     it('Should not display my lives', async function () {
 271       const { data } = await servers[0].videos.listMyVideos({ isLive: false })
 272
 273       const result = data.every(v => !v.isLive)
 274       expect(result).to.be.true
 275     })
 276
 277     after(async function () {
 278       await servers[0].videos.remove({ id: vodVideoId })
 279       await servers[0].videos.remove({ id: liveVideoId })
 280     })
 281   })
 282
 283   describe('Stream checks', function () {
 284     let liveVideo: LiveVideo & VideoDetails
 285     let rtmpUrl: string
 286
 287     before(function () {
 288       rtmpUrl = 'rtmp://' + servers[0].hostname + ':' + servers[0].rtmpPort + ''
 289     })
 290
 291     async function createLiveWrapper () {
 292       const liveAttributes = {
 293         name: 'user live',
 294         channelId: servers[0].store.channel.id,
 295         privacy: VideoPrivacy.PUBLIC,
 296         saveReplay: false
 297       }
 298
 299       const { uuid } = await commands[0].create({ fields: liveAttributes })
 300
 301       const live = await commands[0].get({ videoId: uuid })
 302       const video = await servers[0].videos.get({ id: uuid })
 303
 304       return Object.assign(video, live)
 305     }
 306
 307     it('Should not allow a stream without the appropriate path', async function () {
 308       this.timeout(60000)
 309
 310       liveVideo = await createLiveWrapper()
 311
 312       const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/bad-live', streamKey: liveVideo.streamKey })
 313       await testFfmpegStreamError(command, true)
 314     })
 315
 316     it('Should not allow a stream without the appropriate stream key', async function () {
 317       this.timeout(60000)
 318
 319       const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: 'bad-stream-key' })
 320       await testFfmpegStreamError(command, true)
 321     })
 322
 323     it('Should succeed with the correct params', async function () {
 324       this.timeout(60000)
 325
 326       const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
 327       await testFfmpegStreamError(command, false)
 328     })
 329
 330     it('Should list this live now someone stream into it', async function () {
 331       for (const server of servers) {
 332         const { total, data } = await server.videos.list()
 333
 334         expect(total).to.equal(1)
 335         expect(data).to.have.lengthOf(1)
 336
 337         const video = data[0]
 338         expect(video.name).to.equal('user live')
 339         expect(video.isLive).to.be.true
 340       }
 341     })
 342
 343     it('Should not allow a stream on a live that was blacklisted', async function () {
 344       this.timeout(60000)
 345
 346       liveVideo = await createLiveWrapper()
 347
 348       await servers[0].blacklist.add({ videoId: liveVideo.uuid })
 349
 350       const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
 351       await testFfmpegStreamError(command, true)
 352     })
 353
 354     it('Should not allow a stream on a live that was deleted', async function () {
 355       this.timeout(60000)
 356
 357       liveVideo = await createLiveWrapper()
 358
 359       await servers[0].videos.remove({ id: liveVideo.uuid })
 360
 361       const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
 362       await testFfmpegStreamError(command, true)
 363     })
 364   })
 365
 366   describe('Live transcoding', function () {
 367     let liveVideoId: string
 368     let sqlCommandServer1: SQLCommand
 369
 370     async function createLiveWrapper (saveReplay: boolean) {
 371       const liveAttributes = {
 372         name: 'live video',
 373         channelId: servers[0].store.channel.id,
 374         privacy: VideoPrivacy.PUBLIC,
 375         saveReplay,
 376         replaySettings: saveReplay
 377           ? { privacy: VideoPrivacy.PUBLIC }
 378           : undefined
 379       }
 380
 381       const { uuid } = await commands[0].create({ fields: liveAttributes })
 382       return uuid
 383     }
 384
 385     function updateConf (resolutions: number[]) {
 386       return servers[0].config.updateCustomSubConfig({
 387         newConfig: {
 388           live: {
 389             enabled: true,
 390             allowReplay: true,
 391             maxDuration: -1,
 392             transcoding: {
 393               enabled: true,
 394               resolutions: {
 395                 '144p': resolutions.includes(144),
 396                 '240p': resolutions.includes(240),
 397                 '360p': resolutions.includes(360),
 398                 '480p': resolutions.includes(480),
 399                 '720p': resolutions.includes(720),
 400                 '1080p': resolutions.includes(1080),
 401                 '2160p': resolutions.includes(2160)
 402               }
 403             }
 404           }
 405         }
 406       })
 407     }
 408
 409     before(async function () {
 410       await updateConf([])
 411
 412       sqlCommandServer1 = new SQLCommand(servers[0])
 413     })
 414
 415     it('Should enable transcoding without additional resolutions', async function () {
 416       this.timeout(120000)
 417
 418       liveVideoId = await createLiveWrapper(false)
 419
 420       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
 421       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 422       await waitJobs(servers)
 423
 424       await testLiveVideoResolutions({
 425         originServer: servers[0],
 426         sqlCommand: sqlCommandServer1,
 427         servers,
 428         liveVideoId,
 429         resolutions: [ 720 ],
 430         objectStorage: false,
 431         transcoded: true
 432       })
 433
 434       await stopFfmpeg(ffmpegCommand)
 435     })
 436
 437     it('Should transcode audio only RTMP stream', async function () {
 438       this.timeout(120000)
 439
 440       liveVideoId = await createLiveWrapper(false)
 441
 442       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short_no_audio.mp4' })
 443       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 444       await waitJobs(servers)
 445
 446       await stopFfmpeg(ffmpegCommand)
 447     })
 448
 449     it('Should enable transcoding with some resolutions', async function () {
 450       this.timeout(240000)
 451
 452       const resolutions = [ 240, 480 ]
 453       await updateConf(resolutions)
 454       liveVideoId = await createLiveWrapper(false)
 455
 456       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
 457       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 458       await waitJobs(servers)
 459
 460       await testLiveVideoResolutions({
 461         originServer: servers[0],
 462         sqlCommand: sqlCommandServer1,
 463         servers,
 464         liveVideoId,
 465         resolutions: resolutions.concat([ 720 ]),
 466         objectStorage: false,
 467         transcoded: true
 468       })
 469
 470       await stopFfmpeg(ffmpegCommand)
 471     })
 472
 473     it('Should correctly set the appropriate bitrate depending on the input', async function () {
 474       this.timeout(120000)
 475
 476       liveVideoId = await createLiveWrapper(false)
 477
 478       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({
 479         videoId: liveVideoId,
 480         fixtureName: 'video_short.mp4',
 481         copyCodecs: true
 482       })
 483       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 484       await waitJobs(servers)
 485
 486       const video = await servers[0].videos.get({ id: liveVideoId })
 487
 488       const masterPlaylist = video.streamingPlaylists[0].playlistUrl
 489       const probe = await ffprobePromise(masterPlaylist)
 490
 491       const bitrates = probe.streams.map(s => parseInt(s.tags.variant_bitrate))
 492       for (const bitrate of bitrates) {
 493         expect(bitrate).to.exist
 494         expect(isNaN(bitrate)).to.be.false
 495         expect(bitrate).to.be.below(61_000_000) // video_short.mp4 bitrate
 496       }
 497
 498       await stopFfmpeg(ffmpegCommand)
 499     })
 500
 501     it('Should enable transcoding with some resolutions and correctly save them', async function () {
 502       this.timeout(500_000)
 503
 504       const resolutions = [ 240, 360, 720 ]
 505
 506       await updateConf(resolutions)
 507       liveVideoId = await createLiveWrapper(true)
 508
 509       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
 510       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 511       await waitJobs(servers)
 512
 513       await testLiveVideoResolutions({
 514         originServer: servers[0],
 515         sqlCommand: sqlCommandServer1,
 516         servers,
 517         liveVideoId,
 518         resolutions,
 519         objectStorage: false,
 520         transcoded: true
 521       })
 522
 523       await stopFfmpeg(ffmpegCommand)
 524       await commands[0].waitUntilEnded({ videoId: liveVideoId })
 525
 526       await waitJobs(servers)
 527
 528       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 529
 530       const maxBitrateLimits = {
 531         720: 6500 * 1000, // 60FPS
 532         360: 1250 * 1000,
 533         240: 700 * 1000
 534       }
 535
 536       const minBitrateLimits = {
 537         720: 4800 * 1000,
 538         360: 1000 * 1000,
 539         240: 550 * 1000
 540       }
 541
 542       for (const server of servers) {
 543         const video = await server.videos.get({ id: liveVideoId })
 544
 545         expect(video.state.id).to.equal(VideoState.PUBLISHED)
 546         expect(video.duration).to.be.greaterThan(1)
 547         expect(video.files).to.have.lengthOf(0)
 548
 549         const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS)
 550         await makeRawRequest({ url: hlsPlaylist.playlistUrl, expectedStatus: HttpStatusCode.OK_200 })
 551         await makeRawRequest({ url: hlsPlaylist.segmentsSha256Url, expectedStatus: HttpStatusCode.OK_200 })
 552
 553         // We should have generated random filenames
 554         expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8')
 555         expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json')
 556
 557         expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length)
 558
 559         for (const resolution of resolutions) {
 560           const file = hlsPlaylist.files.find(f => f.resolution.id === resolution)
 561
 562           expect(file).to.exist
 563           expect(file.size).to.be.greaterThan(1)
 564
 565           if (resolution >= 720) {
 566             expect(file.fps).to.be.approximately(60, 10)
 567           } else {
 568             expect(file.fps).to.be.approximately(30, 3)
 569           }
 570
 571           const filename = basename(file.fileUrl)
 572           expect(filename).to.not.contain(video.uuid)
 573
 574           const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
 575
 576           const probe = await ffprobePromise(segmentPath)
 577           const videoStream = await getVideoStream(segmentPath, probe)
 578
 579           expect(probe.format.bit_rate).to.be.below(maxBitrateLimits[videoStream.height])
 580           expect(probe.format.bit_rate).to.be.at.least(minBitrateLimits[videoStream.height])
 581
 582           await makeRawRequest({ url: file.torrentUrl, expectedStatus: HttpStatusCode.OK_200 })
 583           await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
 584         }
 585       }
 586     })
 587
 588     it('Should not generate an upper resolution than original file', async function () {
 589       this.timeout(500_000)
 590
 591       const resolutions = [ 240, 480 ]
 592       await updateConf(resolutions)
 593
 594       await servers[0].config.updateExistingSubConfig({
 595         newConfig: {
 596           live: {
 597             transcoding: {
 598               alwaysTranscodeOriginalResolution: false
 599             }
 600           }
 601         }
 602       })
 603
 604       liveVideoId = await createLiveWrapper(true)
 605
 606       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
 607       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 608       await waitJobs(servers)
 609
 610       await testLiveVideoResolutions({
 611         originServer: servers[0],
 612         sqlCommand: sqlCommandServer1,
 613         servers,
 614         liveVideoId,
 615         resolutions,
 616         objectStorage: false,
 617         transcoded: true
 618       })
 619
 620       await stopFfmpeg(ffmpegCommand)
 621       await commands[0].waitUntilEnded({ videoId: liveVideoId })
 622
 623       await waitJobs(servers)
 624
 625       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 626
 627       const video = await servers[0].videos.get({ id: liveVideoId })
 628       const hlsFiles = video.streamingPlaylists[0].files
 629
 630       expect(video.files).to.have.lengthOf(0)
 631       expect(hlsFiles).to.have.lengthOf(resolutions.length)
 632
 633       // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
 634       expect(getAllFiles(video).map(f => f.resolution.id).sort()).to.deep.equal(resolutions)
 635     })
 636
 637     it('Should only keep the original resolution if all resolutions are disabled', async function () {
 638       this.timeout(600_000)
 639
 640       await updateConf([])
 641       liveVideoId = await createLiveWrapper(true)
 642
 643       const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
 644       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 645       await waitJobs(servers)
 646
 647       await testLiveVideoResolutions({
 648         originServer: servers[0],
 649         sqlCommand: sqlCommandServer1,
 650         servers,
 651         liveVideoId,
 652         resolutions: [ 720 ],
 653         objectStorage: false,
 654         transcoded: true
 655       })
 656
 657       await stopFfmpeg(ffmpegCommand)
 658       await commands[0].waitUntilEnded({ videoId: liveVideoId })
 659
 660       await waitJobs(servers)
 661
 662       await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
 663
 664       const video = await servers[0].videos.get({ id: liveVideoId })
 665       const hlsFiles = video.streamingPlaylists[0].files
 666
 667       expect(video.files).to.have.lengthOf(0)
 668       expect(hlsFiles).to.have.lengthOf(1)
 669
 670       expect(hlsFiles[0].resolution.id).to.equal(720)
 671     })
 672
 673     after(async function () {
 674       await sqlCommandServer1.cleanup()
 675     })
 676   })
 677
 678   describe('After a server restart', function () {
 679     let liveVideoId: string
 680     let liveVideoReplayId: string
 681     let permanentLiveVideoReplayId: string
 682
 683     let permanentLiveReplayName: string
 684
 685     let beforeServerRestart: Date
 686
 687     async function createLiveWrapper (options: { saveReplay: boolean, permanent: boolean }) {
 688       const liveAttributes: LiveVideoCreate = {
 689         name: 'live video',
 690         channelId: servers[0].store.channel.id,
 691         privacy: VideoPrivacy.PUBLIC,
 692         saveReplay: options.saveReplay,
 693         replaySettings: options.saveReplay
 694           ? { privacy: VideoPrivacy.PUBLIC }
 695           : undefined,
 696         permanentLive: options.permanent
 697       }
 698
 699       const { uuid } = await commands[0].create({ fields: liveAttributes })
 700       return uuid
 701     }
 702
 703     before(async function () {
 704       this.timeout(600_000)
 705
 706       liveVideoId = await createLiveWrapper({ saveReplay: false, permanent: false })
 707       liveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: false })
 708       permanentLiveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: true })
 709
 710       await Promise.all([
 711         commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }),
 712         commands[0].sendRTMPStreamInVideo({ videoId: permanentLiveVideoReplayId }),
 713         commands[0].sendRTMPStreamInVideo({ videoId: liveVideoReplayId })
 714       ])
 715
 716       await Promise.all([
 717         commands[0].waitUntilPublished({ videoId: liveVideoId }),
 718         commands[0].waitUntilPublished({ videoId: permanentLiveVideoReplayId }),
 719         commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
 720       ])
 721
 722       for (const videoUUID of [ liveVideoId, liveVideoReplayId, permanentLiveVideoReplayId ]) {
 723         await commands[0].waitUntilSegmentGeneration({
 724           server: servers[0],
 725           videoUUID,
 726           playlistNumber: 0,
 727           segment: 2,
 728           objectStorage: false
 729         })
 730       }
 731
 732       {
 733         const video = await servers[0].videos.get({ id: permanentLiveVideoReplayId })
 734         permanentLiveReplayName = video.name + ' - ' + new Date(video.publishedAt).toLocaleString()
 735       }
 736
 737       await killallServers([ servers[0] ])
 738
 739       beforeServerRestart = new Date()
 740       await servers[0].run()
 741
 742       await wait(5000)
 743       await waitJobs(servers)
 744     })
 745
 746     it('Should cleanup lives', async function () {
 747       this.timeout(60000)
 748
 749       await commands[0].waitUntilEnded({ videoId: liveVideoId })
 750       await commands[0].waitUntilWaiting({ videoId: permanentLiveVideoReplayId })
 751     })
 752
 753     it('Should save a non permanent live replay', async function () {
 754       this.timeout(240000)
 755
 756       await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
 757
 758       const session = await commands[0].getReplaySession({ videoId: liveVideoReplayId })
 759       expect(session.endDate).to.exist
 760       expect(new Date(session.endDate)).to.be.above(beforeServerRestart)
 761     })
 762
 763     it('Should have saved a permanent live replay', async function () {
 764       this.timeout(120000)
 765
 766       const { data } = await servers[0].videos.listMyVideos({ sort: '-publishedAt' })
 767       expect(data.find(v => v.name === permanentLiveReplayName)).to.exist
 768     })
 769   })
 770
 771   after(async function () {
 772     await cleanupTests(servers)
 773   })
 774 })