import 'mocha'
import * as chai from 'chai'
-import { LiveVideoCreate, VideoDetails, VideoPrivacy, VideoState } from '@shared/models'
+import { wait } from '@shared/core-utils'
+import { LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
import {
cleanupTests,
- createLive,
+ ConfigCommand,
+ createMultipleServers,
doubleFollow,
- flushAndRunMultipleServers,
- getLive,
- getPlaylistsCount,
- getVideo,
- sendRTMPStreamInVideo,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
- updateCustomSubConfig,
- updateLive,
- wait,
- waitJobs,
- waitUntilLiveStarts
-} from '../../../../shared/extra-utils'
+ waitJobs
+} from '@shared/server-commands'
const expect = chai.expect
-describe('Permenant live', function () {
- let servers: ServerInfo[] = []
+describe('Permanent live', function () {
+ let servers: PeerTubeServer[] = []
let videoUUID: string
async function createLiveWrapper (permanentLive: boolean) {
const attributes: LiveVideoCreate = {
- channelId: servers[0].videoChannel.id,
+ channelId: servers[0].store.channel.id,
privacy: VideoPrivacy.PUBLIC,
name: 'my super live',
saveReplay: false,
permanentLive
}
- const res = await createLive(servers[0].url, servers[0].accessToken, attributes)
- return res.body.video.uuid
+ const { uuid } = await servers[0].live.create({ fields: attributes })
+ return uuid
}
async function checkVideoState (videoId: string, state: VideoState) {
for (const server of servers) {
- const res = await getVideo(server.url, videoId)
- expect((res.body as VideoDetails).state.id).to.equal(state)
+ const video = await server.videos.get({ id: videoId })
+ expect(video.state.id).to.equal(state)
}
}
before(async function () {
this.timeout(120000)
- servers = await flushAndRunMultipleServers(2)
+ servers = await createMultipleServers(2)
// Get the access tokens
await setAccessTokensToServers(servers)
// Server 1 and server 2 follow each other
await doubleFollow(servers[0], servers[1])
- await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
- live: {
- enabled: true,
- allowReplay: true,
- maxDuration: null,
- transcoding: {
+ await servers[0].config.updateCustomSubConfig({
+ newConfig: {
+ live: {
enabled: true,
- resolutions: {
- '240p': true,
- '360p': true,
- '480p': true,
- '720p': true,
- '1080p': true,
- '2160p': true
+ allowReplay: true,
+ maxDuration: -1,
+ transcoding: {
+ enabled: true,
+ resolutions: ConfigCommand.getCustomConfigResolutions(true)
}
}
}
const videoUUID = await createLiveWrapper(false)
{
- const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
- expect(res.body.permanentLive).to.be.false
+ const live = await servers[0].live.get({ videoId: videoUUID })
+ expect(live.permanentLive).to.be.false
}
- await updateLive(servers[0].url, servers[0].accessToken, videoUUID, { permanentLive: true })
+ await servers[0].live.update({ videoId: videoUUID, fields: { permanentLive: true } })
{
- const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
- expect(res.body.permanentLive).to.be.true
+ const live = await servers[0].live.get({ videoId: videoUUID })
+ expect(live.permanentLive).to.be.true
}
})
videoUUID = await createLiveWrapper(true)
- const res = await getLive(servers[0].url, servers[0].accessToken, videoUUID)
- expect(res.body.permanentLive).to.be.true
+ const live = await servers[0].live.get({ videoId: videoUUID })
+ expect(live.permanentLive).to.be.true
await waitJobs(servers)
})
it('Should stream into this permanent live', async function () {
- this.timeout(40000)
+ this.timeout(120000)
- const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, videoUUID)
+ const beforePublication = new Date()
+ const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) {
- await waitUntilLiveStarts(server.url, server.accessToken, videoUUID)
+ await server.live.waitUntilPublished({ videoId: videoUUID })
}
await checkVideoState(videoUUID, VideoState.PUBLISHED)
- await stopFfmpeg(command)
+ for (const server of servers) {
+ const video = await server.videos.get({ id: videoUUID })
+ expect(new Date(video.publishedAt)).greaterThan(beforePublication)
+ }
+
+ await stopFfmpeg(ffmpegCommand)
+ await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
await waitJobs(servers)
})
- it('Should not have cleaned up this live', async function () {
+ it('Should have cleaned up this live', async function () {
this.timeout(40000)
await wait(5000)
await waitJobs(servers)
for (const server of servers) {
- const res = await getVideo(server.url, videoUUID)
+ const videoDetails = await server.videos.get({ id: videoUUID })
- const videoDetails = res.body as VideoDetails
- expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
+ expect(videoDetails.streamingPlaylists).to.have.lengthOf(0)
}
})
})
it('Should be able to stream again in the permanent live', async function () {
- this.timeout(20000)
+ this.timeout(60000)
- await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
- live: {
- enabled: true,
- allowReplay: true,
- maxDuration: null,
- transcoding: {
+ await servers[0].config.updateCustomSubConfig({
+ newConfig: {
+ live: {
enabled: true,
- resolutions: {
- '240p': false,
- '360p': false,
- '480p': false,
- '720p': false,
- '1080p': false,
- '2160p': false
+ allowReplay: true,
+ maxDuration: -1,
+ transcoding: {
+ enabled: true,
+ resolutions: ConfigCommand.getCustomConfigResolutions(false)
}
}
}
})
- const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, videoUUID)
+ const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) {
- await waitUntilLiveStarts(server.url, server.accessToken, videoUUID)
+ await server.live.waitUntilPublished({ videoId: videoUUID })
}
await checkVideoState(videoUUID, VideoState.PUBLISHED)
- const count = await getPlaylistsCount(servers[0], videoUUID)
+ const count = await servers[0].live.countPlaylists({ videoUUID })
// master playlist and 720p playlist
expect(count).to.equal(2)
- await stopFfmpeg(command)
+ await stopFfmpeg(ffmpegCommand)
+ })
+
+ it('Should have appropriate sessions', async function () {
+ this.timeout(60000)
+
+ await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
+
+ const { data, total } = await servers[0].live.listSessions({ videoId: videoUUID })
+ expect(total).to.equal(2)
+ expect(data).to.have.lengthOf(2)
+
+ for (const session of data) {
+ expect(session.startDate).to.exist
+ expect(session.endDate).to.exist
+
+ expect(session.error).to.not.exist
+ }
})
after(async function () {