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/extra-utils'
  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 ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 105
 106     for (const server of servers) {
 107       await server.live.waitUntilPublished({ videoId: videoUUID })
 108     }
 109
 110     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 111
 112     await stopFfmpeg(ffmpegCommand)
 113     await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
 114
 115     await waitJobs(servers)
 116   })
 117
 118   it('Should not have cleaned up this live', async function () {
 119     this.timeout(40000)
 120
 121     await wait(5000)
 122     await waitJobs(servers)
 123
 124     for (const server of servers) {
 125       const videoDetails = await server.videos.get({ id: videoUUID })
 126       expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
 127     }
 128   })
 129
 130   it('Should have set this live to waiting for live state', async function () {
 131     this.timeout(20000)
 132
 133     await checkVideoState(videoUUID, VideoState.WAITING_FOR_LIVE)
 134   })
 135
 136   it('Should be able to stream again in the permanent live', async function () {
 137     this.timeout(20000)
 138
 139     await servers[0].config.updateCustomSubConfig({
 140       newConfig: {
 141         live: {
 142           enabled: true,
 143           allowReplay: true,
 144           maxDuration: -1,
 145           transcoding: {
 146             enabled: true,
 147             resolutions: ConfigCommand.getCustomConfigResolutions(false)
 148           }
 149         }
 150       }
 151     })
 152
 153     const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
 154
 155     for (const server of servers) {
 156       await server.live.waitUntilPublished({ videoId: videoUUID })
 157     }
 158
 159     await checkVideoState(videoUUID, VideoState.PUBLISHED)
 160
 161     const count = await servers[0].live.countPlaylists({ videoUUID })
 162     // master playlist and 720p playlist
 163     expect(count).to.equal(2)
 164
 165     await stopFfmpeg(ffmpegCommand)
 166   })
 167
 168   after(async function () {
 169     await cleanupTests(servers)
 170   })
 171 })