import 'mocha'
import * as chai from 'chai'
-import { LiveVideoCreate, VideoDetails, VideoPrivacy, VideoState } from '@shared/models'
+import { LiveVideoCreate, VideoPrivacy, VideoState } from '@shared/models'
import {
cleanupTests,
ConfigCommand,
+ createMultipleServers,
doubleFollow,
- flushAndRunMultipleServers,
- getVideo,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
setDefaultVideoChannel,
stopFfmpeg,
const expect = chai.expect
describe('Permanent live', function () {
- let servers: ServerInfo[] = []
+ 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 { uuid } = await servers[0].liveCommand.create({ fields: attributes })
+ 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 servers[0].configCommand.updateCustomSubConfig({
+ await servers[0].config.updateCustomSubConfig({
newConfig: {
live: {
enabled: true,
const videoUUID = await createLiveWrapper(false)
{
- const live = await servers[0].liveCommand.get({ videoId: videoUUID })
+ const live = await servers[0].live.get({ videoId: videoUUID })
expect(live.permanentLive).to.be.false
}
- await servers[0].liveCommand.update({ videoId: videoUUID, fields: { permanentLive: true } })
+ await servers[0].live.update({ videoId: videoUUID, fields: { permanentLive: true } })
{
- const live = await servers[0].liveCommand.get({ videoId: videoUUID })
+ const live = await servers[0].live.get({ videoId: videoUUID })
expect(live.permanentLive).to.be.true
}
})
videoUUID = await createLiveWrapper(true)
- const live = await servers[0].liveCommand.get({ videoId: videoUUID })
+ 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(120000)
- const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID })
+ const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) {
- await server.liveCommand.waitUntilPublished({ videoId: videoUUID })
+ await server.live.waitUntilPublished({ videoId: videoUUID })
}
await checkVideoState(videoUUID, VideoState.PUBLISHED)
await stopFfmpeg(ffmpegCommand)
- await servers[0].liveCommand.waitUntilWaiting({ videoId: videoUUID })
+ await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
await waitJobs(servers)
})
await waitJobs(servers)
for (const server of servers) {
- const res = await getVideo(server.url, videoUUID)
-
- const videoDetails = res.body as VideoDetails
+ const videoDetails = await server.videos.get({ id: videoUUID })
expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
}
})
it('Should be able to stream again in the permanent live', async function () {
this.timeout(20000)
- await servers[0].configCommand.updateCustomSubConfig({
+ await servers[0].config.updateCustomSubConfig({
newConfig: {
live: {
enabled: true,
}
})
- const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID })
+ const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) {
- await server.liveCommand.waitUntilPublished({ videoId: videoUUID })
+ await server.live.waitUntilPublished({ videoId: videoUUID })
}
await checkVideoState(videoUUID, VideoState.PUBLISHED)
- const count = await servers[0].liveCommand.countPlaylists({ videoUUID })
+ const count = await servers[0].live.countPlaylists({ videoUUID })
// master playlist and 720p playlist
expect(count).to.equal(2)