import 'mocha'
import * as chai from 'chai'
-import { FfmpegCommand } from 'fluent-ffmpeg'
import { join } from 'path'
import { ffprobePromise, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
-import { getLiveNotificationSocket } from '@shared/extra-utils/socket/socket-io'
import { LiveVideo, LiveVideoCreate, Video, VideoDetails, VideoPrivacy, VideoState, VideoStreamingPlaylistType } from '@shared/models'
import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
import {
doubleFollow,
flushAndRunMultipleServers,
getLive,
+ getMyVideosWithFilter,
getPlaylist,
getVideo,
- getVideoIdFromUUID,
getVideosList,
+ getVideosWithFilters,
killallServers,
makeRawRequest,
removeVideo,
testImage,
updateCustomSubConfig,
updateLive,
- viewVideo,
+ uploadVideoAndGetId,
wait,
waitJobs,
waitUntilLiveEnded,
waitUntilLivePublished,
+ waitUntilLivePublishedOnAllServers,
waitUntilLiveSegmentGeneration
} from '../../../../shared/extra-utils'
expect(video.channel.name).to.equal(servers[0].videoChannel.name)
expect(video.channel.host).to.equal(servers[0].videoChannel.host)
+ expect(video.isLive).to.be.true
+
expect(video.nsfw).to.be.false
expect(video.waitTranscoding).to.be.false
expect(video.name).to.equal('my super live')
})
})
+ describe('Live filters', function () {
+ let command: any
+ let liveVideoId: string
+ let vodVideoId: string
+
+ before(async function () {
+ this.timeout(120000)
+
+ vodVideoId = (await uploadVideoAndGetId({ server: servers[0], videoName: 'vod video' })).uuid
+
+ const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].videoChannel.id }
+ const resLive = await createLive(servers[0].url, servers[0].accessToken, liveOptions)
+ liveVideoId = resLive.body.video.uuid
+
+ command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+ await waitJobs(servers)
+ })
+
+ it('Should only display lives', async function () {
+ const res = await getVideosWithFilters(servers[0].url, { isLive: true })
+
+ expect(res.body.total).to.equal(1)
+ expect(res.body.data).to.have.lengthOf(1)
+ expect(res.body.data[0].name).to.equal('live')
+ })
+
+ it('Should not display lives', async function () {
+ const res = await getVideosWithFilters(servers[0].url, { isLive: false })
+
+ expect(res.body.total).to.equal(1)
+ expect(res.body.data).to.have.lengthOf(1)
+ expect(res.body.data[0].name).to.equal('vod video')
+ })
+
+ it('Should display my lives', async function () {
+ this.timeout(60000)
+
+ await stopFfmpeg(command)
+ await waitJobs(servers)
+
+ const res = await getMyVideosWithFilter(servers[0].url, servers[0].accessToken, { isLive: true })
+ const videos = res.body.data as Video[]
+
+ const result = videos.every(v => v.isLive)
+ expect(result).to.be.true
+ })
+
+ it('Should not display my lives', async function () {
+ const res = await getMyVideosWithFilter(servers[0].url, servers[0].accessToken, { isLive: false })
+ const videos = res.body.data as Video[]
+
+ const result = videos.every(v => !v.isLive)
+ expect(result).to.be.true
+ })
+
+ after(async function () {
+ await removeVideo(servers[0].url, servers[0].accessToken, vodVideoId)
+ await removeVideo(servers[0].url, servers[0].accessToken, liveVideoId)
+ })
+ })
+
describe('Stream checks', function () {
let liveVideo: LiveVideo & VideoDetails
let rtmpUrl: string
}
it('Should not allow a stream without the appropriate path', async function () {
- this.timeout(30000)
+ this.timeout(60000)
liveVideo = await createLiveWrapper()
})
it('Should not allow a stream without the appropriate stream key', async function () {
- this.timeout(30000)
+ this.timeout(60000)
const command = sendRTMPStream(rtmpUrl + '/live', 'bad-stream-key')
await testFfmpegStreamError(command, true)
})
it('Should succeed with the correct params', async function () {
- this.timeout(30000)
+ this.timeout(60000)
const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey)
await testFfmpegStreamError(command, false)
})
+ it('Should list this live now someone stream into it', async function () {
+ for (const server of servers) {
+ const res = await getVideosList(server.url)
+
+ expect(res.body.total).to.equal(1)
+ expect(res.body.data).to.have.lengthOf(1)
+
+ const video: Video = res.body.data[0]
+
+ expect(video.name).to.equal('user live')
+ expect(video.isLive).to.be.true
+ }
+ })
+
it('Should not allow a stream on a live that was blacklisted', async function () {
- this.timeout(30000)
+ this.timeout(60000)
liveVideo = await createLiveWrapper()
})
it('Should not allow a stream on a live that was deleted', async function () {
- this.timeout(30000)
+ this.timeout(60000)
liveVideo = await createLiveWrapper()
live: {
enabled: true,
allowReplay: true,
- maxDuration: null,
+ maxDuration: -1,
transcoding: {
enabled: true,
resolutions: {
})
it('Should enable transcoding without additional resolutions', async function () {
- this.timeout(30000)
+ this.timeout(60000)
liveVideoId = await createLiveWrapper(false)
const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId)
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
await waitJobs(servers)
await testVideoResolutions(liveVideoId, [ 720 ])
})
it('Should enable transcoding with some resolutions', async function () {
- this.timeout(30000)
+ this.timeout(60000)
const resolutions = [ 240, 480 ]
await updateConf(resolutions)
liveVideoId = await createLiveWrapper(false)
const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId)
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
await waitJobs(servers)
await testVideoResolutions(liveVideoId, resolutions)
})
it('Should enable transcoding with some resolutions and correctly save them', async function () {
- this.timeout(120000)
+ this.timeout(200000)
const resolutions = [ 240, 360, 720 ]
liveVideoId = await createLiveWrapper(true)
const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId, 'video_short2.webm')
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId)
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
await waitJobs(servers)
await testVideoResolutions(liveVideoId, resolutions)
await stopFfmpeg(command)
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId)
+ await waitUntilLiveEnded(servers[0].url, servers[0].accessToken, liveVideoId)
await waitJobs(servers)
+ await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+
const bitrateLimits = {
720: 5000 * 1000, // 60FPS
360: 1100 * 1000,
const resVideo = await getVideo(server.url, liveVideoId)
const video: VideoDetails = resVideo.body
+ expect(video.state.id).to.equal(VideoState.PUBLISHED)
expect(video.duration).to.be.greaterThan(1)
expect(video.files).to.have.lengthOf(0)
})
})
- describe('Live views', function () {
- let liveVideoId: string
- let command: FfmpegCommand
-
- async function countViews (expected: number) {
- for (const server of servers) {
- const res = await getVideo(server.url, liveVideoId)
- const video: VideoDetails = res.body
-
- expect(video.views).to.equal(expected)
- }
- }
-
- before(async function () {
- this.timeout(30000)
-
- const liveAttributes = {
- name: 'live video',
- channelId: servers[0].videoChannel.id,
- privacy: VideoPrivacy.PUBLIC
- }
-
- const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
- liveVideoId = res.body.video.uuid
-
- command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId)
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId)
- await waitJobs(servers)
- })
-
- it('Should display no views for a live', async function () {
- await countViews(0)
- })
-
- it('Should view a live twice and display 1 view', async function () {
- this.timeout(30000)
-
- await viewVideo(servers[0].url, liveVideoId)
- await viewVideo(servers[0].url, liveVideoId)
-
- await wait(7000)
-
- await waitJobs(servers)
-
- await countViews(1)
- })
-
- it('Should wait and display 0 views', async function () {
- this.timeout(30000)
-
- await wait(7000)
- await waitJobs(servers)
-
- await countViews(0)
- })
-
- it('Should view a live on a remote and on local and display 2 views', async function () {
- this.timeout(30000)
-
- await viewVideo(servers[0].url, liveVideoId)
- await viewVideo(servers[1].url, liveVideoId)
- await viewVideo(servers[1].url, liveVideoId)
-
- await wait(7000)
- await waitJobs(servers)
-
- await countViews(2)
- })
-
- after(async function () {
- await stopFfmpeg(command)
- })
- })
-
- describe('Live socket messages', function () {
-
- async function createLiveWrapper () {
- const liveAttributes = {
- name: 'live video',
- channelId: servers[0].videoChannel.id,
- privacy: VideoPrivacy.PUBLIC
- }
-
- const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes)
- return res.body.video.uuid
- }
-
- it('Should correctly send a message when the live starts and ends', async function () {
- this.timeout(60000)
-
- const localStateChanges: VideoState[] = []
- const remoteStateChanges: VideoState[] = []
-
- const liveVideoUUID = await createLiveWrapper()
- await waitJobs(servers)
-
- {
- const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
-
- const localSocket = getLiveNotificationSocket(servers[0].url)
- localSocket.on('state-change', data => localStateChanges.push(data.state))
- localSocket.emit('subscribe', { videoId })
- }
-
- {
- const videoId = await getVideoIdFromUUID(servers[1].url, liveVideoUUID)
-
- const remoteSocket = getLiveNotificationSocket(servers[1].url)
- remoteSocket.on('state-change', data => remoteStateChanges.push(data.state))
- remoteSocket.emit('subscribe', { videoId })
- }
-
- const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
-
- for (const server of servers) {
- await waitUntilLivePublished(server.url, server.accessToken, liveVideoUUID)
- }
-
- await waitJobs(servers)
-
- for (const stateChanges of [ localStateChanges, remoteStateChanges ]) {
- expect(stateChanges).to.have.length.at.least(1)
- expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.PUBLISHED)
- }
-
- await stopFfmpeg(command)
-
- for (const server of servers) {
- await waitUntilLiveEnded(server.url, server.accessToken, liveVideoUUID)
- }
-
- await waitJobs(servers)
-
- for (const stateChanges of [ localStateChanges, remoteStateChanges ]) {
- expect(stateChanges).to.have.length.at.least(2)
- expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.LIVE_ENDED)
- }
- })
-
- it('Should correctly send views change notification', async function () {
- this.timeout(60000)
-
- let localLastVideoViews = 0
- let remoteLastVideoViews = 0
-
- const liveVideoUUID = await createLiveWrapper()
- await waitJobs(servers)
-
- {
- const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
-
- const localSocket = getLiveNotificationSocket(servers[0].url)
- localSocket.on('views-change', data => { localLastVideoViews = data.views })
- localSocket.emit('subscribe', { videoId })
- }
-
- {
- const videoId = await getVideoIdFromUUID(servers[1].url, liveVideoUUID)
-
- const remoteSocket = getLiveNotificationSocket(servers[1].url)
- remoteSocket.on('views-change', data => { remoteLastVideoViews = data.views })
- remoteSocket.emit('subscribe', { videoId })
- }
-
- const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
-
- for (const server of servers) {
- await waitUntilLivePublished(server.url, server.accessToken, liveVideoUUID)
- }
-
- await waitJobs(servers)
-
- expect(localLastVideoViews).to.equal(0)
- expect(remoteLastVideoViews).to.equal(0)
-
- await viewVideo(servers[0].url, liveVideoUUID)
- await viewVideo(servers[1].url, liveVideoUUID)
-
- await waitJobs(servers)
- await wait(5000)
- await waitJobs(servers)
-
- expect(localLastVideoViews).to.equal(2)
- expect(remoteLastVideoViews).to.equal(2)
-
- await stopFfmpeg(command)
- })
-
- it('Should not receive a notification after unsubscribe', async function () {
- this.timeout(60000)
-
- const stateChanges: VideoState[] = []
-
- const liveVideoUUID = await createLiveWrapper()
- await waitJobs(servers)
-
- const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID)
-
- const socket = getLiveNotificationSocket(servers[0].url)
- socket.on('state-change', data => stateChanges.push(data.state))
- socket.emit('subscribe', { videoId })
-
- const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID)
- await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoUUID)
- await waitJobs(servers)
-
- expect(stateChanges).to.have.lengthOf(1)
- socket.emit('unsubscribe', { videoId })
-
- await stopFfmpeg(command)
- await waitJobs(servers)
-
- expect(stateChanges).to.have.lengthOf(1)
- })
- })
-
describe('After a server restart', function () {
let liveVideoId: string
let liveVideoReplayId: string