server/tests/api/live/live-permanent.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import { LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
   6 import {
   7   cleanupTests,
   8   ConfigCommand,
   9   createMultipleServers,
  10   doubleFollow,
  11   PeerTubeServer,
  12   setAccessTokensToServers,
  13   setDefaultVideoChannel,
  14   stopFfmpeg,
  15   wait,
  16   waitJobs
  17 } from '../../../../shared/server-commands'
  18
  19 const expect = chai.expect
  20
  21 describe('Permanent live', function () {
  22   let servers: PeerTubeServer[] = []
  23   let videoUUID: string
  24
  25   async function createLiveWrapper (permanentLive: boolean) {
  26     const attributes: LiveVideoCreate = {
  27       channelId: servers[0].store.channel.id,
  28       privacy: VideoPrivacy.PUBLIC,
  29       name: 'my super live',
  30       saveReplay: false,
  31       permanentLive
  32     }
  33
  34     const { uuid } = await servers[0].live.create({ fields: attributes })
  35     return uuid
  36   }
  37
  38   async function checkVideoState (videoId: string, state: VideoState) {
  39     for (const server of servers) {
  40       const video = await server.videos.get({ id: videoId })
  41       expect(video.state.id).to.equal(state)
  42     }
  43   }
  44
  45   before(async function () {
  46     this.timeout(120000)
  47
  48     servers = await createMultipleServers(2)
  49
  50     // Get the access tokens
  51     await setAccessTokensToServers(servers)
  52     await setDefaultVideoChannel(servers)
  53
  54     // Server 1 and server 2 follow each other
  55     await doubleFollow(servers[0], servers[1])
  56
  57     await servers[0].config.updateCustomSubConfig({
  58       newConfig: {
  59         live: {
  60           enabled: true,
  61           allowReplay: true,
  62           maxDuration: -1,
  63           transcoding: {
  64             enabled: true,
  65             resolutions: ConfigCommand.getCustomConfigResolutions(true)
  66           }
  67         }
  68       }
  69     })
  70   })
  71
  72   it('Should create a non permanent live and update it to be a permanent live', async function () {
  73     this.timeout(20000)
  74
  75     const videoUUID = await createLiveWrapper(false)
  76
  77     {
  78       const live = await servers[0].live.get({ videoId: videoUUID })
  79       expect(live.permanentLive).to.be.false
  80     }
  81
  82     await servers[0].live.update({ videoId: videoUUID, fields: { permanentLive: true } })
  83
  84     {
  85       const live = await servers[0].live.get({ videoId: videoUUID })
  86       expect(live.permanentLive).to.be.true
  87     }
  88   })
  89
  90   it('Should create a permanent live', async function () {
  91     this.timeout(20000)
  92
  93     videoUUID = await createLiveWrapper(true)
  94
  95     const live = await servers[0].live.get({ videoId: videoUUID })
  96     expect(live.permanentLive).to.be.true
  97
  98     await waitJobs(servers)
  99   })
 100
 101   it('Should stream into this permanent live', async function () {
 102     this.timeout(120000)
 103
 104     const beforePublication = new Date()
 105     const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 106
 107     for (const server of servers) {
 108       await server.live.waitUntilPublished({ videoId: videoUUID })
 109     }
 110
 111     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 112
 113     for (const server of servers) {
 114       const video = await server.videos.get({ id: videoUUID })
 115       expect(new Date(video.publishedAt)).greaterThan(beforePublication)
 116     }
 117
 118     await stopFfmpeg(ffmpegCommand)
 119     await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
 120
 121     await waitJobs(servers)
 122   })
 123
 124   it('Should not have cleaned up this live', async function () {
 125     this.timeout(40000)
 126
 127     await wait(5000)
 128     await waitJobs(servers)
 129
 130     for (const server of servers) {
 131       const videoDetails = await server.videos.get({ id: videoUUID })
 132       expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
 133     }
 134   })
 135
 136   it('Should have set this live to waiting for live state', async function () {
 137     this.timeout(20000)
 138
 139     await checkVideoState(videoUUID, VideoState.WAITING_FOR_LIVE)
 140   })
 141
 142   it('Should be able to stream again in the permanent live', async function () {
 143     this.timeout(20000)
 144
 145     await servers[0].config.updateCustomSubConfig({
 146       newConfig: {
 147         live: {
 148           enabled: true,
 149           allowReplay: true,
 150           maxDuration: -1,
 151           transcoding: {
 152             enabled: true,
 153             resolutions: ConfigCommand.getCustomConfigResolutions(false)
 154           }
 155         }
 156       }
 157     })
 158
 159     const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 160
 161     for (const server of servers) {
 162       await server.live.waitUntilPublished({ videoId: videoUUID })
 163     }
 164
 165     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 166
 167     const count = await servers[0].live.countPlaylists({ videoUUID })
 168     // master playlist and 720p playlist
 169     expect(count).to.equal(2)
 170
 171     await stopFfmpeg(ffmpegCommand)
 172   })
 173
 174   after(async function () {
 175     await cleanupTests(servers)
 176   })
 177 })