X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Flive%2Flive.ts;h=2d47c131b0d0530811f782acb429d478b692cf43;hb=64324ac646b0938e35cd88771492623b640bd0d8;hp=6a1f6e759cb8f765b1f38dbc68b3c7d742f19416;hpb=e0783718079c1fcb6554ea20e762cfb0592de5b0;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts index 6a1f6e759..2d47c131b 100644 --- a/server/tests/api/live/live.ts +++ b/server/tests/api/live/live.ts @@ -2,75 +2,71 @@ 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 { basename, join } from 'path' +import { ffprobePromise, getVideoStream } from '@server/helpers/ffmpeg' +import { checkLiveCleanup, checkLiveSegmentHash, checkResolutionsInMasterPlaylist, testImage } from '@server/tests/shared' +import { wait } from '@shared/core-utils' +import { + HttpStatusCode, + LiveVideo, + LiveVideoCreate, + LiveVideoLatencyMode, + VideoDetails, + VideoPrivacy, + VideoState, + VideoStreamingPlaylistType +} from '@shared/models' import { - addVideoToBlacklist, - buildServerDirectory, - checkLiveCleanup, - checkLiveSegmentHash, - checkResolutionsInMasterPlaylist, cleanupTests, - createLive, + createMultipleServers, doubleFollow, - flushAndRunMultipleServers, - getLive, - getPlaylist, - getVideo, - getVideoIdFromUUID, - getVideosList, killallServers, + LiveCommand, makeRawRequest, - removeVideo, - reRunServer, + PeerTubeServer, sendRTMPStream, - sendRTMPStreamInVideo, - ServerInfo, setAccessTokensToServers, setDefaultVideoChannel, stopFfmpeg, testFfmpegStreamError, - testImage, - updateCustomSubConfig, - updateLive, - viewVideo, - wait, waitJobs, - waitUntilLiveEnded, - waitUntilLivePublished, - waitUntilLiveSegmentGeneration -} from '../../../../shared/extra-utils' + waitUntilLivePublishedOnAllServers +} from '@shared/server-commands' const expect = chai.expect describe('Test live', function () { - let servers: ServerInfo[] = [] + let servers: PeerTubeServer[] = [] + let commands: LiveCommand[] before(async function () { this.timeout(120000) - servers = await flushAndRunMultipleServers(2) + servers = await createMultipleServers(2) // Get the access tokens await setAccessTokensToServers(servers) await setDefaultVideoChannel(servers) - await updateCustomSubConfig(servers[0].url, servers[0].accessToken, { - live: { - enabled: true, - allowReplay: true, - transcoding: { - enabled: false + await servers[0].config.updateCustomSubConfig({ + newConfig: { + live: { + enabled: true, + allowReplay: true, + latencySetting: { + enabled: true + }, + transcoding: { + enabled: false + } } } }) // Server 1 and server 2 follow each other await doubleFollow(servers[0], servers[1]) + + commands = servers.map(s => s.live) }) describe('Live creation, update and delete', function () { @@ -85,7 +81,7 @@ describe('Test live', function () { language: 'fr', description: 'super live description', support: 'support field', - channelId: servers[0].videoChannel.id, + channelId: servers[0].store.channel.id, nsfw: false, waitTranscoding: false, name: 'my super live', @@ -93,19 +89,19 @@ describe('Test live', function () { commentsEnabled: false, downloadEnabled: false, saveReplay: true, + latencyMode: LiveVideoLatencyMode.SMALL_LATENCY, privacy: VideoPrivacy.PUBLIC, previewfile: 'video_short1-preview.webm.jpg', thumbnailfile: 'video_short1.webm.jpg' } - const res = await createLive(servers[0].url, servers[0].accessToken, attributes) - liveVideoUUID = res.body.video.uuid + const live = await commands[0].create({ fields: attributes }) + liveVideoUUID = live.uuid await waitJobs(servers) for (const server of servers) { - const resVideo = await getVideo(server.url, liveVideoUUID) - const video: VideoDetails = resVideo.body + const video = await server.videos.get({ id: liveVideoUUID }) expect(video.category.id).to.equal(1) expect(video.licence.id).to.equal(2) @@ -113,8 +109,10 @@ describe('Test live', function () { expect(video.description).to.equal('super live description') expect(video.support).to.equal('support field') - expect(video.channel.name).to.equal(servers[0].videoChannel.name) - expect(video.channel.host).to.equal(servers[0].videoChannel.host) + expect(video.channel.name).to.equal(servers[0].store.channel.name) + expect(video.channel.host).to.equal(servers[0].store.channel.host) + + expect(video.isLive).to.be.true expect(video.nsfw).to.be.false expect(video.waitTranscoding).to.be.false @@ -127,18 +125,18 @@ describe('Test live', function () { await testImage(server.url, 'video_short1-preview.webm', video.previewPath) await testImage(server.url, 'video_short1.webm', video.thumbnailPath) - const resLive = await getLive(server.url, server.accessToken, liveVideoUUID) - const live: LiveVideo = resLive.body + const live = await server.live.get({ videoId: liveVideoUUID }) if (server.url === servers[0].url) { expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') expect(live.streamKey).to.not.be.empty } else { - expect(live.rtmpUrl).to.be.null - expect(live.streamKey).to.be.null + expect(live.rtmpUrl).to.not.exist + expect(live.streamKey).to.not.exist } expect(live.saveReplay).to.be.true + expect(live.latencyMode).to.equal(LiveVideoLatencyMode.SMALL_LATENCY) } }) @@ -147,20 +145,18 @@ describe('Test live', function () { const attributes: LiveVideoCreate = { name: 'default live thumbnail', - channelId: servers[0].videoChannel.id, + channelId: servers[0].store.channel.id, privacy: VideoPrivacy.UNLISTED, nsfw: true } - const res = await createLive(servers[0].url, servers[0].accessToken, attributes) - const videoId = res.body.video.uuid + const live = await commands[0].create({ fields: attributes }) + const videoId = live.uuid await waitJobs(servers) for (const server of servers) { - const resVideo = await getVideo(server.url, videoId) - const video: VideoDetails = resVideo.body - + const video = await server.videos.get({ id: videoId }) expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED) expect(video.nsfw).to.be.true @@ -171,56 +167,116 @@ describe('Test live', function () { it('Should not have the live listed since nobody streams into', async function () { for (const server of servers) { - const res = await getVideosList(server.url) + const { total, data } = await server.videos.list() - expect(res.body.total).to.equal(0) - expect(res.body.data).to.have.lengthOf(0) + expect(total).to.equal(0) + expect(data).to.have.lengthOf(0) } }) it('Should not be able to update a live of another server', async function () { - await updateLive(servers[1].url, servers[1].accessToken, liveVideoUUID, { saveReplay: false }, HttpStatusCode.FORBIDDEN_403) + await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) }) it('Should update the live', async function () { this.timeout(10000) - await updateLive(servers[0].url, servers[0].accessToken, liveVideoUUID, { saveReplay: false }) + await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false, latencyMode: LiveVideoLatencyMode.DEFAULT } }) await waitJobs(servers) }) it('Have the live updated', async function () { for (const server of servers) { - const res = await getLive(server.url, server.accessToken, liveVideoUUID) - const live: LiveVideo = res.body + const live = await server.live.get({ videoId: liveVideoUUID }) if (server.url === servers[0].url) { expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') expect(live.streamKey).to.not.be.empty } else { - expect(live.rtmpUrl).to.be.null - expect(live.streamKey).to.be.null + expect(live.rtmpUrl).to.not.exist + expect(live.streamKey).to.not.exist } expect(live.saveReplay).to.be.false + expect(live.latencyMode).to.equal(LiveVideoLatencyMode.DEFAULT) } }) it('Delete the live', async function () { this.timeout(10000) - await removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID) + await servers[0].videos.remove({ id: liveVideoUUID }) await waitJobs(servers) }) it('Should have the live deleted', async function () { for (const server of servers) { - await getVideo(server.url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404) - await getLive(server.url, server.accessToken, liveVideoUUID, HttpStatusCode.NOT_FOUND_404) + await server.videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) + await server.live.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) } }) }) + describe('Live filters', function () { + let ffmpegCommand: any + let liveVideoId: string + let vodVideoId: string + + before(async function () { + this.timeout(120000) + + vodVideoId = (await servers[0].videos.quickUpload({ name: 'vod video' })).uuid + + const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].store.channel.id } + const live = await commands[0].create({ fields: liveOptions }) + liveVideoId = live.uuid + + ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId }) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) + await waitJobs(servers) + }) + + it('Should only display lives', async function () { + const { data, total } = await servers[0].videos.list({ isLive: true }) + + expect(total).to.equal(1) + expect(data).to.have.lengthOf(1) + expect(data[0].name).to.equal('live') + }) + + it('Should not display lives', async function () { + const { data, total } = await servers[0].videos.list({ isLive: false }) + + expect(total).to.equal(1) + expect(data).to.have.lengthOf(1) + expect(data[0].name).to.equal('vod video') + }) + + it('Should display my lives', async function () { + this.timeout(60000) + + await stopFfmpeg(ffmpegCommand) + await waitJobs(servers) + + const { data } = await servers[0].videos.listMyVideos({ isLive: true }) + + const result = data.every(v => v.isLive) + expect(result).to.be.true + }) + + it('Should not display my lives', async function () { + const { data } = await servers[0].videos.listMyVideos({ isLive: false }) + + const result = data.every(v => !v.isLive) + expect(result).to.be.true + }) + + after(async function () { + await servers[0].videos.remove({ id: vodVideoId }) + await servers[0].videos.remove({ id: liveVideoId }) + }) + }) + describe('Stream checks', function () { let liveVideo: LiveVideo & VideoDetails let rtmpUrl: string @@ -232,62 +288,74 @@ describe('Test live', function () { async function createLiveWrapper () { const liveAttributes = { name: 'user live', - channelId: servers[0].videoChannel.id, + channelId: servers[0].store.channel.id, privacy: VideoPrivacy.PUBLIC, saveReplay: false } - const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) - const uuid = res.body.video.uuid + const { uuid } = await commands[0].create({ fields: liveAttributes }) - const resLive = await getLive(servers[0].url, servers[0].accessToken, uuid) - const resVideo = await getVideo(servers[0].url, uuid) + const live = await commands[0].get({ videoId: uuid }) + const video = await servers[0].videos.get({ id: uuid }) - return Object.assign(resVideo.body, resLive.body) as LiveVideo & VideoDetails + return Object.assign(video, live) } it('Should not allow a stream without the appropriate path', async function () { - this.timeout(30000) + this.timeout(60000) liveVideo = await createLiveWrapper() - const command = sendRTMPStream(rtmpUrl + '/bad-live', liveVideo.streamKey) + const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/bad-live', streamKey: liveVideo.streamKey }) await testFfmpegStreamError(command, true) }) 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') + const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: '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) + const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey }) await testFfmpegStreamError(command, false) }) + it('Should list this live now someone stream into it', async function () { + for (const server of servers) { + const { total, data } = await server.videos.list() + + expect(total).to.equal(1) + expect(data).to.have.lengthOf(1) + + const video = 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() - await addVideoToBlacklist(servers[0].url, servers[0].accessToken, liveVideo.uuid) + await servers[0].blacklist.add({ videoId: liveVideo.uuid }) - const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey) + const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey }) await testFfmpegStreamError(command, true) }) it('Should not allow a stream on a live that was deleted', async function () { - this.timeout(30000) + this.timeout(60000) liveVideo = await createLiveWrapper() - await removeVideo(servers[0].url, servers[0].accessToken, liveVideo.uuid) + await servers[0].videos.remove({ id: liveVideo.uuid }) - const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey) + const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey }) await testFfmpegStreamError(command, true) }) }) @@ -298,24 +366,21 @@ describe('Test live', function () { async function createLiveWrapper (saveReplay: boolean) { const liveAttributes = { name: 'live video', - channelId: servers[0].videoChannel.id, + channelId: servers[0].store.channel.id, privacy: VideoPrivacy.PUBLIC, saveReplay } - const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) - return res.body.video.uuid + const { uuid } = await commands[0].create({ fields: liveAttributes }) + return uuid } async function testVideoResolutions (liveVideoId: string, resolutions: number[]) { for (const server of servers) { - const resList = await getVideosList(server.url) - const videos: Video[] = resList.body.data - - expect(videos.find(v => v.uuid === liveVideoId)).to.exist + const { data } = await server.videos.list() + expect(data.find(v => v.uuid === liveVideoId)).to.exist - const resVideo = await getVideo(server.url, liveVideoId) - const video: VideoDetails = resVideo.body + const video = await server.videos.get({ id: liveVideoId }) expect(video.streamingPlaylists).to.have.lengthOf(1) @@ -325,39 +390,49 @@ describe('Test live', function () { // Only finite files are displayed expect(hlsPlaylist.files).to.have.lengthOf(0) - await checkResolutionsInMasterPlaylist(hlsPlaylist.playlistUrl, resolutions) + await checkResolutionsInMasterPlaylist({ server, playlistUrl: hlsPlaylist.playlistUrl, resolutions }) for (let i = 0; i < resolutions.length; i++) { const segmentNum = 3 const segmentName = `${i}-00000${segmentNum}.ts` - await waitUntilLiveSegmentGeneration(servers[0], video.uuid, i, segmentNum) + await commands[0].waitUntilSegmentGeneration({ videoUUID: video.uuid, playlistNumber: i, segment: segmentNum }) - const res = await getPlaylist(`${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`) - const subPlaylist = res.text + const subPlaylist = await servers[0].streamingPlaylists.get({ + url: `${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8` + }) expect(subPlaylist).to.contain(segmentName) const baseUrlAndPath = servers[0].url + '/static/streaming-playlists/hls' - await checkLiveSegmentHash(baseUrlAndPath, video.uuid, segmentName, hlsPlaylist) + await checkLiveSegmentHash({ + server, + baseUrlSegment: baseUrlAndPath, + videoUUID: video.uuid, + segmentName, + hlsPlaylist + }) } } } function updateConf (resolutions: number[]) { - return updateCustomSubConfig(servers[0].url, servers[0].accessToken, { - live: { - enabled: true, - allowReplay: true, - maxDuration: null, - transcoding: { + return servers[0].config.updateCustomSubConfig({ + newConfig: { + live: { enabled: true, - resolutions: { - '240p': resolutions.includes(240), - '360p': resolutions.includes(360), - '480p': resolutions.includes(480), - '720p': resolutions.includes(720), - '1080p': resolutions.includes(1080), - '2160p': resolutions.includes(2160) + allowReplay: true, + maxDuration: -1, + transcoding: { + enabled: true, + resolutions: { + '144p': resolutions.includes(144), + '240p': resolutions.includes(240), + '360p': resolutions.includes(360), + '480p': resolutions.includes(480), + '720p': resolutions.includes(720), + '1080p': resolutions.includes(1080), + '2160p': resolutions.includes(2160) + } } } } @@ -369,63 +444,98 @@ describe('Test live', function () { }) it('Should enable transcoding without additional resolutions', async function () { - this.timeout(30000) + this.timeout(120000) liveVideoId = await createLiveWrapper(false) - const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId) - await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId) + const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) await waitJobs(servers) await testVideoResolutions(liveVideoId, [ 720 ]) - await stopFfmpeg(command) + await stopFfmpeg(ffmpegCommand) }) it('Should enable transcoding with some resolutions', async function () { - this.timeout(30000) + this.timeout(120000) 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) + const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) await waitJobs(servers) await testVideoResolutions(liveVideoId, resolutions) - await stopFfmpeg(command) + await stopFfmpeg(ffmpegCommand) }) - it('Should enable transcoding with some resolutions and correctly save them', async function () { + it('Should correctly set the appropriate bitrate depending on the input', async function () { this.timeout(120000) + liveVideoId = await createLiveWrapper(false) + + const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ + videoId: liveVideoId, + fixtureName: 'video_short.mp4', + copyCodecs: true + }) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) + await waitJobs(servers) + + const video = await servers[0].videos.get({ id: liveVideoId }) + + const masterPlaylist = video.streamingPlaylists[0].playlistUrl + const probe = await ffprobePromise(masterPlaylist) + + const bitrates = probe.streams.map(s => parseInt(s.tags.variant_bitrate)) + for (const bitrate of bitrates) { + expect(bitrate).to.exist + expect(isNaN(bitrate)).to.be.false + expect(bitrate).to.be.below(61_000_000) // video_short.mp4 bitrate + } + + await stopFfmpeg(ffmpegCommand) + }) + + it('Should enable transcoding with some resolutions and correctly save them', async function () { + this.timeout(400_000) + const resolutions = [ 240, 360, 720 ] await updateConf(resolutions) 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) + const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' }) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) await waitJobs(servers) await testVideoResolutions(liveVideoId, resolutions) - await stopFfmpeg(command) + await stopFfmpeg(ffmpegCommand) + await commands[0].waitUntilEnded({ videoId: liveVideoId }) + await waitJobs(servers) - await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId) + await waitUntilLivePublishedOnAllServers(servers, liveVideoId) + + const maxBitrateLimits = { + 720: 6500 * 1000, // 60FPS + 360: 1250 * 1000, + 240: 700 * 1000 + } - const bitrateLimits = { - 720: 5000 * 1000, // 60FPS - 360: 1100 * 1000, - 240: 600 * 1000 + const minBitrateLimits = { + 720: 5500 * 1000, + 360: 1000 * 1000, + 240: 550 * 1000 } for (const server of servers) { - const resVideo = await getVideo(server.url, liveVideoId) - const video: VideoDetails = resVideo.body + const video = await server.videos.get({ id: liveVideoId }) expect(video.state.id).to.equal(VideoState.PUBLISHED) expect(video.duration).to.be.greaterThan(1) @@ -435,6 +545,10 @@ describe('Test live', function () { await makeRawRequest(hlsPlaylist.playlistUrl, HttpStatusCode.OK_200) await makeRawRequest(hlsPlaylist.segmentsSha256Url, HttpStatusCode.OK_200) + // We should have generated random filenames + expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8') + expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json') + expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length) for (const resolution of resolutions) { @@ -449,13 +563,16 @@ describe('Test live', function () { expect(file.fps).to.be.approximately(30, 2) } - const filename = `${video.uuid}-${resolution}-fragmented.mp4` - const segmentPath = buildServerDirectory(servers[0], join('streaming-playlists', 'hls', video.uuid, filename)) + const filename = basename(file.fileUrl) + expect(filename).to.not.contain(video.uuid) + + const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename)) const probe = await ffprobePromise(segmentPath) - const videoStream = await getVideoStreamFromFile(segmentPath, probe) + const videoStream = await getVideoStream(segmentPath, probe) - expect(probe.format.bit_rate).to.be.below(bitrateLimits[videoStream.height]) + expect(probe.format.bit_rate).to.be.below(maxBitrateLimits[videoStream.height]) + expect(probe.format.bit_rate).to.be.at.least(minBitrateLimits[videoStream.height]) await makeRawRequest(file.torrentUrl, HttpStatusCode.OK_200) await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200) @@ -470,273 +587,87 @@ describe('Test live', function () { }) }) - describe('Live views', function () { + describe('After a server restart', 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) - }) + let liveVideoReplayId: string + let permanentLiveVideoReplayId: string - after(async function () { - await stopFfmpeg(command) - }) - }) + let permanentLiveReplayName: string - describe('Live socket messages', function () { + let beforeServerRestart: Date - async function createLiveWrapper () { - const liveAttributes = { + async function createLiveWrapper (options: { saveReplay: boolean, permanent: boolean }) { + const liveAttributes: LiveVideoCreate = { name: 'live video', - channelId: servers[0].videoChannel.id, - privacy: VideoPrivacy.PUBLIC + channelId: servers[0].store.channel.id, + privacy: VideoPrivacy.PUBLIC, + saveReplay: options.saveReplay, + permanentLive: options.permanent } - const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) - return res.body.video.uuid + const { uuid } = await commands[0].create({ fields: liveAttributes }) + return 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) + before(async function () { + this.timeout(300000) - for (const stateChanges of [ localStateChanges, remoteStateChanges ]) { - expect(stateChanges).to.have.length.at.least(2) - expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.LIVE_ENDED) - } - }) + liveVideoId = await createLiveWrapper({ saveReplay: false, permanent: false }) + liveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: false }) + permanentLiveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: true }) - it('Should correctly send views change notification', async function () { - this.timeout(60000) + await Promise.all([ + commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }), + commands[0].sendRTMPStreamInVideo({ videoId: permanentLiveVideoReplayId }), + commands[0].sendRTMPStreamInVideo({ videoId: liveVideoReplayId }) + ]) - let localLastVideoViews = 0 - let remoteLastVideoViews = 0 + await Promise.all([ + commands[0].waitUntilPublished({ videoId: liveVideoId }), + commands[0].waitUntilPublished({ videoId: permanentLiveVideoReplayId }), + commands[0].waitUntilPublished({ videoId: liveVideoReplayId }) + ]) - const liveVideoUUID = await createLiveWrapper() - await waitJobs(servers) + await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoId, playlistNumber: 0, segment: 2 }) + await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoReplayId, playlistNumber: 0, segment: 2 }) + await commands[0].waitUntilSegmentGeneration({ videoUUID: permanentLiveVideoReplayId, playlistNumber: 0, segment: 2 }) { - 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 video = await servers[0].videos.get({ id: permanentLiveVideoReplayId }) + permanentLiveReplayName = video.name + ' - ' + new Date(video.publishedAt).toLocaleString() } - { - 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 killallServers([ servers[0] ]) - await viewVideo(servers[0].url, liveVideoUUID) - await viewVideo(servers[1].url, liveVideoUUID) + beforeServerRestart = new Date() + await servers[0].run() - 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 () { + it('Should cleanup lives', 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) + await commands[0].waitUntilEnded({ videoId: liveVideoId }) + await commands[0].waitUntilWaiting({ videoId: permanentLiveVideoReplayId }) }) - }) - describe('After a server restart', function () { - let liveVideoId: string - let liveVideoReplayId: string + it('Should save a non permanent live replay', async function () { + this.timeout(240000) - async function createLiveWrapper (saveReplay: boolean) { - const liveAttributes = { - name: 'live video', - channelId: servers[0].videoChannel.id, - privacy: VideoPrivacy.PUBLIC, - saveReplay - } - - const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) - return res.body.video.uuid - } - - before(async function () { - this.timeout(120000) - - liveVideoId = await createLiveWrapper(false) - liveVideoReplayId = await createLiveWrapper(true) - - await Promise.all([ - sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId), - sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoReplayId) - ]) - - await Promise.all([ - waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoId), - waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoReplayId) - ]) - - await waitUntilLiveSegmentGeneration(servers[0], liveVideoId, 0, 2) - await waitUntilLiveSegmentGeneration(servers[0], liveVideoReplayId, 0, 2) - - await killallServers([ servers[0] ]) - await reRunServer(servers[0]) - - await wait(5000) - }) - - it('Should cleanup lives', async function () { - this.timeout(60000) + await commands[0].waitUntilPublished({ videoId: liveVideoReplayId }) - await waitUntilLiveEnded(servers[0].url, servers[0].accessToken, liveVideoId) + const session = await commands[0].getReplaySession({ videoId: liveVideoReplayId }) + expect(session.endDate).to.exist + expect(new Date(session.endDate)).to.be.above(beforeServerRestart) }) - it('Should save a live replay', async function () { + it('Should have saved a permanent live replay', async function () { this.timeout(120000) - await waitUntilLivePublished(servers[0].url, servers[0].accessToken, liveVideoReplayId) + const { data } = await servers[0].videos.listMyVideos({ sort: '-publishedAt' }) + expect(data.find(v => v.name === permanentLiveReplayName)).to.exist }) })