interesting
/
PeerTube
mirror of https://github.com/Chocobozzz/PeerTube.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Shorter live methods

This commit is contained in:
Chocobozzz 2021-07-08 10:25:50 +02:00
parent d897210c2d
commit 04aed76711
No known key found for this signature in database
GPG Key ID: 583A612D890159BE
14 changed files with 96 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
server/tests/api/check-params/live.ts
View File

@ -337,72 +337,72 @@ describe('Test video lives API validator', function () {
describe('When getting live information', function () { describe('When getting live information', function () {
it('Should fail without access token', async function () { it('Should fail without access token', async function () {
await command.getLive({ token: '', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 }) await command.get({ token: '', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with a bad access token', async function () { it('Should fail with a bad access token', async function () {
await command.getLive({ token: 'toto', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 }) await command.get({ token: 'toto', videoId: video.id, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with access token of another user', async function () { it('Should fail with access token of another user', async function () {
await command.getLive({ token: userAccessToken, videoId: video.id, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) await command.get({ token: userAccessToken, videoId: video.id, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail with a bad video id', async function () { it('Should fail with a bad video id', async function () {
await command.getLive({ videoId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 }) await command.get({ videoId: 'toto', expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should fail with an unknown video id', async function () { it('Should fail with an unknown video id', async function () {
await command.getLive({ videoId: 454555, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) await command.get({ videoId: 454555, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a non live video', async function () { it('Should fail with a non live video', async function () {
await command.getLive({ videoId: videoIdNotLive, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) await command.get({ videoId: videoIdNotLive, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
await command.getLive({ videoId: video.id }) await command.get({ videoId: video.id })
await command.getLive({ videoId: video.uuid }) await command.get({ videoId: video.uuid })
await command.getLive({ videoId: video.shortUUID }) await command.get({ videoId: video.shortUUID })
}) })
}) })
describe('When updating live information', async function () { describe('When updating live information', async function () {
it('Should fail without access token', async function () { it('Should fail without access token', async function () {
await command.updateLive({ token: '', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 }) await command.update({ token: '', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with a bad access token', async function () { it('Should fail with a bad access token', async function () {
await command.updateLive({ token: 'toto', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 }) await command.update({ token: 'toto', videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
}) })
it('Should fail with access token of another user', async function () { it('Should fail with access token of another user', async function () {
await command.updateLive({ token: userAccessToken, videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) await command.update({ token: userAccessToken, videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail with a bad video id', async function () { it('Should fail with a bad video id', async function () {
await command.updateLive({ videoId: 'toto', fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }) await command.update({ videoId: 'toto', fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should fail with an unknown video id', async function () { it('Should fail with an unknown video id', async function () {
await command.updateLive({ videoId: 454555, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) await command.update({ videoId: 454555, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with a non live video', async function () { it('Should fail with a non live video', async function () {
await command.updateLive({ videoId: videoIdNotLive, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) await command.update({ videoId: videoIdNotLive, fields: {}, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
}) })
it('Should fail with save replay and permanent live set to true', async function () { it('Should fail with save replay and permanent live set to true', async function () {
const fields = { saveReplay: true, permanentLive: true } const fields = { saveReplay: true, permanentLive: true }
await command.updateLive({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }) await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
}) })
it('Should succeed with the correct params', async function () { it('Should succeed with the correct params', async function () {
await command.updateLive({ videoId: video.id, fields: { saveReplay: false } }) await command.update({ videoId: video.id, fields: { saveReplay: false } })
await command.updateLive({ videoId: video.uuid, fields: { saveReplay: false } }) await command.update({ videoId: video.uuid, fields: { saveReplay: false } })
await command.updateLive({ videoId: video.shortUUID, fields: { saveReplay: false } }) await command.update({ videoId: video.shortUUID, fields: { saveReplay: false } })
}) })
it('Should fail to update replay status if replay is not allowed on the instance', async function () { it('Should fail to update replay status if replay is not allowed on the instance', async function () {
@ -415,18 +415,18 @@ describe('Test video lives API validator', function () {
} }
}) })
await command.updateLive({ videoId: video.id, fields: { saveReplay: true }, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) await command.update({ videoId: video.id, fields: { saveReplay: true }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should fail to update a live if it has already started', async function () { it('Should fail to update a live if it has already started', async function () {
this.timeout(40000) this.timeout(40000)
const live = await command.getLive({ videoId: video.id }) const live = await command.get({ videoId: video.id })
const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey) const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
await command.waitUntilLivePublished({ videoId: video.id }) await command.waitUntilPublished({ videoId: video.id })
await command.updateLive({ videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 }) await command.update({ videoId: video.id, fields: {}, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
}) })
@ -434,13 +434,13 @@ describe('Test video lives API validator', function () {
it('Should fail to stream twice in the save live', async function () { it('Should fail to stream twice in the save live', async function () {
this.timeout(40000) this.timeout(40000)
const live = await command.getLive({ videoId: video.id }) const live = await command.get({ videoId: video.id })
const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey) const ffmpegCommand = sendRTMPStream(live.rtmpUrl, live.streamKey)
await command.waitUntilLivePublished({ videoId: video.id }) await command.waitUntilPublished({ videoId: video.id })
await command.runAndTestFfmpegStreamError({ videoId: video.id, shouldHaveError: true }) await command.runAndTestStreamError({ videoId: video.id, shouldHaveError: true })
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
}) })

14
server/tests/api/live/live-constraints.ts
View File

@ -35,7 +35,7 @@ describe('Test live constraints', function () {
saveReplay saveReplay
} }
const { uuid } = await servers[0].liveCommand.createLive({ token: userAccessToken, fields: liveAttributes }) const { uuid } = await servers[0].liveCommand.create({ token: userAccessToken, fields: liveAttributes })
return uuid return uuid
} }
@ -53,7 +53,7 @@ describe('Test live constraints', function () {
async function waitUntilLivePublishedOnAllServers (videoId: string) { async function waitUntilLivePublishedOnAllServers (videoId: string) {
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLivePublished({ videoId }) await server.liveCommand.waitUntilPublished({ videoId })
} }
} }
@ -105,7 +105,7 @@ describe('Test live constraints', function () {
this.timeout(60000) this.timeout(60000)
const userVideoLiveoId = await createLiveWrapper(false) const userVideoLiveoId = await createLiveWrapper(false)
await servers[0].liveCommand.runAndTestFfmpegStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false }) await servers[0].liveCommand.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
}) })
it('Should have size limit depending on user global quota if save replay is enabled', async function () { it('Should have size limit depending on user global quota if save replay is enabled', async function () {
@ -115,7 +115,7 @@ describe('Test live constraints', function () {
await wait(5000) await wait(5000)
const userVideoLiveoId = await createLiveWrapper(true) const userVideoLiveoId = await createLiveWrapper(true)
await servers[0].liveCommand.runAndTestFfmpegStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true }) await servers[0].liveCommand.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
await waitUntilLivePublishedOnAllServers(userVideoLiveoId) await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
await waitJobs(servers) await waitJobs(servers)
@ -132,7 +132,7 @@ describe('Test live constraints', function () {
await updateQuota({ total: -1, daily: 1 }) await updateQuota({ total: -1, daily: 1 })
const userVideoLiveoId = await createLiveWrapper(true) const userVideoLiveoId = await createLiveWrapper(true)
await servers[0].liveCommand.runAndTestFfmpegStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true }) await servers[0].liveCommand.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
await waitUntilLivePublishedOnAllServers(userVideoLiveoId) await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
await waitJobs(servers) await waitJobs(servers)
@ -149,7 +149,7 @@ describe('Test live constraints', function () {
await updateQuota({ total: 10 * 1000 * 1000, daily: -1 }) await updateQuota({ total: 10 * 1000 * 1000, daily: -1 })
const userVideoLiveoId = await createLiveWrapper(true) const userVideoLiveoId = await createLiveWrapper(true)
await servers[0].liveCommand.runAndTestFfmpegStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false }) await servers[0].liveCommand.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
}) })
it('Should have max duration limit', async function () { it('Should have max duration limit', async function () {
@ -170,7 +170,7 @@ describe('Test live constraints', function () {
}) })
const userVideoLiveoId = await createLiveWrapper(true) const userVideoLiveoId = await createLiveWrapper(true)
await servers[0].liveCommand.runAndTestFfmpegStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true }) await servers[0].liveCommand.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
await waitUntilLivePublishedOnAllServers(userVideoLiveoId) await waitUntilLivePublishedOnAllServers(userVideoLiveoId)
await waitJobs(servers) await waitJobs(servers)

18
server/tests/api/live/live-permanent.ts
View File

@ -32,7 +32,7 @@ describe('Permanent live', function () {
permanentLive permanentLive
} }
const { uuid } = await servers[0].liveCommand.createLive({ fields: attributes }) const { uuid } = await servers[0].liveCommand.create({ fields: attributes })
return uuid return uuid
} }
@ -76,14 +76,14 @@ describe('Permanent live', function () {
const videoUUID = await createLiveWrapper(false) const videoUUID = await createLiveWrapper(false)
{ {
const live = await servers[0].liveCommand.getLive({ videoId: videoUUID }) const live = await servers[0].liveCommand.get({ videoId: videoUUID })
expect(live.permanentLive).to.be.false expect(live.permanentLive).to.be.false
} }
await servers[0].liveCommand.updateLive({ videoId: videoUUID, fields: { permanentLive: true } }) await servers[0].liveCommand.update({ videoId: videoUUID, fields: { permanentLive: true } })
{ {
const live = await servers[0].liveCommand.getLive({ videoId: videoUUID }) const live = await servers[0].liveCommand.get({ videoId: videoUUID })
expect(live.permanentLive).to.be.true expect(live.permanentLive).to.be.true
} }
}) })
@ -93,7 +93,7 @@ describe('Permanent live', function () {
videoUUID = await createLiveWrapper(true) videoUUID = await createLiveWrapper(true)
const live = await servers[0].liveCommand.getLive({ videoId: videoUUID }) const live = await servers[0].liveCommand.get({ videoId: videoUUID })
expect(live.permanentLive).to.be.true expect(live.permanentLive).to.be.true
await waitJobs(servers) await waitJobs(servers)
@ -105,13 +105,13 @@ describe('Permanent live', function () {
const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID }) const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLivePublished({ videoId: videoUUID }) await server.liveCommand.waitUntilPublished({ videoId: videoUUID })
} }
await checkVideoState(videoUUID, VideoState.PUBLISHED) await checkVideoState(videoUUID, VideoState.PUBLISHED)
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
await servers[0].liveCommand.waitUntilLiveWaiting({ videoId: videoUUID }) await servers[0].liveCommand.waitUntilWaiting({ videoId: videoUUID })
await waitJobs(servers) await waitJobs(servers)
}) })
@ -156,12 +156,12 @@ describe('Permanent live', function () {
const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID }) const ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: videoUUID })
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLivePublished({ videoId: videoUUID }) await server.liveCommand.waitUntilPublished({ videoId: videoUUID })
} }
await checkVideoState(videoUUID, VideoState.PUBLISHED) await checkVideoState(videoUUID, VideoState.PUBLISHED)
const count = await servers[0].liveCommand.getPlaylistsCount({ videoUUID }) const count = await servers[0].liveCommand.countPlaylists({ videoUUID })
// master playlist and 720p playlist // master playlist and 720p playlist
expect(count).to.equal(2) expect(count).to.equal(2)

8
server/tests/api/live/live-save-replay.ts
View File

@ -47,7 +47,7 @@ describe('Save replay setting', function () {
saveReplay saveReplay
} }
const { uuid } = await servers[0].liveCommand.createLive({ fields: attributes }) const { uuid } = await servers[0].liveCommand.create({ fields: attributes })
return uuid return uuid
} }
@ -74,13 +74,13 @@ describe('Save replay setting', function () {
async function waitUntilLivePublishedOnAllServers (videoId: string) { async function waitUntilLivePublishedOnAllServers (videoId: string) {
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLivePublished({ videoId }) await server.liveCommand.waitUntilPublished({ videoId })
} }
} }
async function waitUntilLiveSavedOnAllServers (videoId: string) { async function waitUntilLiveSavedOnAllServers (videoId: string) {
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLiveSaved({ videoId }) await server.liveCommand.waitUntilSaved({ videoId })
} }
} }
@ -147,7 +147,7 @@ describe('Save replay setting', function () {
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLiveEnded({ videoId: liveVideoUUID }) await server.liveCommand.waitUntilEnded({ videoId: liveVideoUUID })
} }
await waitJobs(servers) await waitJobs(servers)

4
server/tests/api/live/live-socket-messages.ts
View File

@ -57,7 +57,7 @@ describe('Test live', function () {
privacy: VideoPrivacy.PUBLIC privacy: VideoPrivacy.PUBLIC
} }
const { uuid } = await servers[0].liveCommand.createLive({ fields: liveAttributes }) const { uuid } = await servers[0].liveCommand.create({ fields: liveAttributes })
return uuid return uuid
} }
@ -99,7 +99,7 @@ describe('Test live', function () {
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLiveEnded({ videoId: liveVideoUUID }) await server.liveCommand.waitUntilEnded({ videoId: liveVideoUUID })
} }
await waitJobs(servers) await waitJobs(servers)

2
server/tests/api/live/live-views.ts
View File

@ -71,7 +71,7 @@ describe('Test live', function () {
privacy: VideoPrivacy.PUBLIC privacy: VideoPrivacy.PUBLIC
} }
const live = await servers[0].liveCommand.createLive({ fields: liveAttributes }) const live = await servers[0].liveCommand.create({ fields: liveAttributes })
liveVideoId = live.uuid liveVideoId = live.uuid
command = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId }) command = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId })

42
server/tests/api/live/live.ts
View File

@ -96,7 +96,7 @@ describe('Test live', function () {
thumbnailfile: 'video_short1.webm.jpg' thumbnailfile: 'video_short1.webm.jpg'
} }
const live = await commands[0].createLive({ fields: attributes }) const live = await commands[0].create({ fields: attributes })
liveVideoUUID = live.uuid liveVideoUUID = live.uuid
await waitJobs(servers) await waitJobs(servers)
@ -127,7 +127,7 @@ describe('Test live', function () {
await testImage(server.url, 'video_short1-preview.webm', video.previewPath) await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
await testImage(server.url, 'video_short1.webm', video.thumbnailPath) await testImage(server.url, 'video_short1.webm', video.thumbnailPath)
const live = await server.liveCommand.getLive({ videoId: liveVideoUUID }) const live = await server.liveCommand.get({ videoId: liveVideoUUID })
if (server.url === servers[0].url) { if (server.url === servers[0].url) {
expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
@ -151,7 +151,7 @@ describe('Test live', function () {
nsfw: true nsfw: true
} }
const live = await commands[0].createLive({ fields: attributes }) const live = await commands[0].create({ fields: attributes })
const videoId = live.uuid const videoId = live.uuid
await waitJobs(servers) await waitJobs(servers)
@ -178,19 +178,19 @@ describe('Test live', function () {
}) })
it('Should not be able to update a live of another server', async function () { it('Should not be able to update a live of another server', async function () {
await commands[1].updateLive({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should update the live', async function () { it('Should update the live', async function () {
this.timeout(10000) this.timeout(10000)
await commands[0].updateLive({ videoId: liveVideoUUID, fields: { saveReplay: false } }) await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false } })
await waitJobs(servers) await waitJobs(servers)
}) })
it('Have the live updated', async function () { it('Have the live updated', async function () {
for (const server of servers) { for (const server of servers) {
const live = await server.liveCommand.getLive({ videoId: liveVideoUUID }) const live = await server.liveCommand.get({ videoId: liveVideoUUID })
if (server.url === servers[0].url) { if (server.url === servers[0].url) {
expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
@ -214,7 +214,7 @@ describe('Test live', function () {
it('Should have the live deleted', async function () { it('Should have the live deleted', async function () {
for (const server of servers) { for (const server of servers) {
await getVideo(server.url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404) await getVideo(server.url, liveVideoUUID, HttpStatusCode.NOT_FOUND_404)
await server.liveCommand.getLive({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) await server.liveCommand.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
} }
}) })
}) })
@ -230,7 +230,7 @@ describe('Test live', function () {
vodVideoId = (await uploadVideoAndGetId({ server: servers[0], videoName: 'vod video' })).uuid vodVideoId = (await uploadVideoAndGetId({ server: servers[0], videoName: 'vod video' })).uuid
const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].videoChannel.id } const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].videoChannel.id }
const live = await commands[0].createLive({ fields: liveOptions }) const live = await commands[0].create({ fields: liveOptions })
liveVideoId = live.uuid liveVideoId = live.uuid
ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId }) ffmpegCommand = await servers[0].liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId })
@ -297,9 +297,9 @@ describe('Test live', function () {
saveReplay: false saveReplay: false
} }
const { uuid } = await commands[0].createLive({ fields: liveAttributes }) const { uuid } = await commands[0].create({ fields: liveAttributes })
const live = await commands[0].getLive({ videoId: uuid }) const live = await commands[0].get({ videoId: uuid })
const resVideo = await getVideo(servers[0].url, uuid) const resVideo = await getVideo(servers[0].url, uuid)
return Object.assign(resVideo.body as VideoDetails, live) return Object.assign(resVideo.body as VideoDetails, live)
@ -376,7 +376,7 @@ describe('Test live', function () {
saveReplay saveReplay
} }
const { uuid } = await commands[0].createLive({ fields: liveAttributes }) const { uuid } = await commands[0].create({ fields: liveAttributes })
return uuid return uuid
} }
@ -403,7 +403,7 @@ describe('Test live', function () {
for (let i = 0; i < resolutions.length; i++) { for (let i = 0; i < resolutions.length; i++) {
const segmentNum = 3 const segmentNum = 3
const segmentName = `${i}-00000${segmentNum}.ts` const segmentName = `${i}-00000${segmentNum}.ts`
await commands[0].waitUntilLiveSegmentGeneration({ videoUUID: video.uuid, resolution: i, segment: segmentNum }) await commands[0].waitUntilSegmentGeneration({ videoUUID: video.uuid, resolution: i, segment: segmentNum })
const res = await getPlaylist(`${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`) const res = await getPlaylist(`${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`)
const subPlaylist = res.text const subPlaylist = res.text
@ -488,7 +488,7 @@ describe('Test live', function () {
await testVideoResolutions(liveVideoId, resolutions) await testVideoResolutions(liveVideoId, resolutions)
await stopFfmpeg(ffmpegCommand) await stopFfmpeg(ffmpegCommand)
await commands[0].waitUntilLiveEnded({ videoId: liveVideoId }) await commands[0].waitUntilEnded({ videoId: liveVideoId })
await waitJobs(servers) await waitJobs(servers)
@ -559,7 +559,7 @@ describe('Test live', function () {
saveReplay saveReplay
} }
const { uuid } = await commands[0].createLive({ fields: liveAttributes }) const { uuid } = await commands[0].create({ fields: liveAttributes })
return uuid return uuid
} }
@ -575,14 +575,14 @@ describe('Test live', function () {
]) ])
await Promise.all([ await Promise.all([
commands[0].waitUntilLivePublished({ videoId: liveVideoId }), commands[0].waitUntilPublished({ videoId: liveVideoId }),
commands[0].waitUntilLivePublished({ videoId: liveVideoReplayId }) commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
]) ])
await commands[0].waitUntilLiveSegmentGeneration({ videoUUID: liveVideoId, resolution: 0, segment: 2 }) await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoId, resolution: 0, segment: 2 })
await commands[0].waitUntilLiveSegmentGeneration({ videoUUID: liveVideoReplayId, resolution: 0, segment: 2 }) await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoReplayId, resolution: 0, segment: 2 })
await killallServers([ servers[0] ]) killallServers([ servers[0] ])
await reRunServer(servers[0]) await reRunServer(servers[0])
await wait(5000) await wait(5000)
@ -591,13 +591,13 @@ describe('Test live', function () {
it('Should cleanup lives', async function () { it('Should cleanup lives', async function () {
this.timeout(60000) this.timeout(60000)
await commands[0].waitUntilLiveEnded({ videoId: liveVideoId }) await commands[0].waitUntilEnded({ videoId: liveVideoId })
}) })
it('Should save a live replay', async function () { it('Should save a live replay', async function () {
this.timeout(120000) this.timeout(120000)
await commands[0].waitUntilLivePublished({ videoId: liveVideoReplayId }) await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
}) })
}) })

4
server/tests/api/search/search-videos.ts
View File

@ -502,10 +502,10 @@ describe('Test videos search', function () {
const liveCommand = server.liveCommand const liveCommand = server.liveCommand
const liveAttributes = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: server.videoChannel.id } const liveAttributes = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: server.videoChannel.id }
const live = await liveCommand.createLive({ fields: liveAttributes }) const live = await liveCommand.create({ fields: liveAttributes })
const ffmpegCommand = await liveCommand.sendRTMPStreamInVideo({ videoId: live.id }) const ffmpegCommand = await liveCommand.sendRTMPStreamInVideo({ videoId: live.id })
await liveCommand.waitUntilLivePublished({ videoId: live.id }) await liveCommand.waitUntilPublished({ videoId: live.id })
const body = await command.advancedVideoSearch({ search: { isLive: true } }) const body = await command.advancedVideoSearch({ search: { isLive: true } })

2
server/tests/api/videos/video-change-ownership.ts
View File

@ -111,7 +111,7 @@ describe('Test video change ownership - nominal', function () {
{ {
const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC } const attributes = { name: 'live', channelId: firstUserChannelId, privacy: VideoPrivacy.PUBLIC }
const video = await servers[0].liveCommand.createLive({ token: firstUserAccessToken, fields: attributes }) const video = await servers[0].liveCommand.create({ token: firstUserAccessToken, fields: attributes })
liveId = video.id liveId = video.id
} }

2
server/tests/plugins/action-hooks.ts
View File

@ -95,7 +95,7 @@ describe('Test plugin action hooks', function () {
channelId: servers[0].videoChannel.id channelId: servers[0].videoChannel.id
} }
await servers[0].liveCommand.createLive({ fields: attributes }) await servers[0].liveCommand.create({ fields: attributes })
await checkHook('action:api.live-video.created') await checkHook('action:api.live-video.created')
}) })

2
server/tests/plugins/filter-hooks.ts
View File

@ -155,7 +155,7 @@ describe('Test plugin filter hooks', function () {
channelId: servers[0].videoChannel.id channelId: servers[0].videoChannel.id
} }
await servers[0].liveCommand.createLive({ fields: attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 }) await servers[0].liveCommand.create({ fields: attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
}) })
it('Should run filter:api.video.pre-import-url.accept.result', async function () { it('Should run filter:api.video.pre-import-url.accept.result', async function () {

10
server/tests/plugins/plugin-transcoding.ts
View File

@ -26,7 +26,7 @@ async function createLiveWrapper (server: ServerInfo) {
privacy: VideoPrivacy.PUBLIC privacy: VideoPrivacy.PUBLIC
} }
const { uuid } = await server.liveCommand.createLive({ fields: liveAttributes }) const { uuid } = await server.liveCommand.create({ fields: liveAttributes })
return uuid return uuid
} }
@ -170,7 +170,7 @@ describe('Test transcoding plugins', function () {
const liveVideoId = await createLiveWrapper(server) const liveVideoId = await createLiveWrapper(server)
await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' }) await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
await server.liveCommand.waitUntilLivePublished({ videoId: liveVideoId }) await server.liveCommand.waitUntilPublished({ videoId: liveVideoId })
await waitJobs([ server ]) await waitJobs([ server ])
await checkLiveFPS(liveVideoId, 'above', 20) await checkLiveFPS(liveVideoId, 'above', 20)
@ -184,7 +184,7 @@ describe('Test transcoding plugins', function () {
const liveVideoId = await createLiveWrapper(server) const liveVideoId = await createLiveWrapper(server)
await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' }) await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
await server.liveCommand.waitUntilLivePublished({ videoId: liveVideoId }) await server.liveCommand.waitUntilPublished({ videoId: liveVideoId })
await waitJobs([ server ]) await waitJobs([ server ])
await checkLiveFPS(liveVideoId, 'below', 12) await checkLiveFPS(liveVideoId, 'below', 12)
@ -198,7 +198,7 @@ describe('Test transcoding plugins', function () {
const liveVideoId = await createLiveWrapper(server) const liveVideoId = await createLiveWrapper(server)
await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' }) await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
await server.liveCommand.waitUntilLivePublished({ videoId: liveVideoId }) await server.liveCommand.waitUntilPublished({ videoId: liveVideoId })
await waitJobs([ server ]) await waitJobs([ server ])
await checkLiveFPS(liveVideoId, 'below', 6) await checkLiveFPS(liveVideoId, 'below', 6)
@ -261,7 +261,7 @@ describe('Test transcoding plugins', function () {
const liveVideoId = await createLiveWrapper(server) const liveVideoId = await createLiveWrapper(server)
await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' }) await server.liveCommand.sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
await server.liveCommand.waitUntilLivePublished({ videoId: liveVideoId }) await server.liveCommand.waitUntilPublished({ videoId: liveVideoId })
await waitJobs([ server ]) await waitJobs([ server ])
const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8` const playlistUrl = `${server.url}/static/streaming-playlists/hls/${liveVideoId}/0.m3u8`

30
shared/extra-utils/videos/live-command.ts
View File

@ -14,7 +14,7 @@ import { getVideoWithToken } from './videos'
export class LiveCommand extends AbstractCommand { export class LiveCommand extends AbstractCommand {
getLive (options: OverrideCommandOptions & { get (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
}) { }) {
const path = '/api/v1/videos/live' const path = '/api/v1/videos/live'
@ -27,7 +27,7 @@ export class LiveCommand extends AbstractCommand {
}) })
} }
updateLive (options: OverrideCommandOptions & { update (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
fields: LiveVideoUpdate fields: LiveVideoUpdate
}) { }) {
@ -43,7 +43,7 @@ export class LiveCommand extends AbstractCommand {
}) })
} }
async createLive (options: OverrideCommandOptions & { async create (options: OverrideCommandOptions & {
fields: LiveVideoCreate fields: LiveVideoCreate
}) { }) {
const { fields } = options const { fields } = options
@ -70,12 +70,12 @@ export class LiveCommand extends AbstractCommand {
fixtureName?: string fixtureName?: string
}) { }) {
const { videoId, fixtureName } = options const { videoId, fixtureName } = options
const videoLive = await this.getLive({ videoId }) const videoLive = await this.get({ videoId })
return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName) return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName)
} }
async runAndTestFfmpegStreamError (options: OverrideCommandOptions & { async runAndTestStreamError (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
shouldHaveError: boolean shouldHaveError: boolean
}) { }) {
@ -84,28 +84,28 @@ export class LiveCommand extends AbstractCommand {
return testFfmpegStreamError(command, options.shouldHaveError) return testFfmpegStreamError(command, options.shouldHaveError)
} }
waitUntilLivePublished (options: OverrideCommandOptions & { waitUntilPublished (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
}) { }) {
const { videoId } = options const { videoId } = options
return this.waitUntilLiveState({ videoId, state: VideoState.PUBLISHED }) return this.waitUntilState({ videoId, state: VideoState.PUBLISHED })
} }
waitUntilLiveWaiting (options: OverrideCommandOptions & { waitUntilWaiting (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
}) { }) {
const { videoId } = options const { videoId } = options
return this.waitUntilLiveState({ videoId, state: VideoState.WAITING_FOR_LIVE }) return this.waitUntilState({ videoId, state: VideoState.WAITING_FOR_LIVE })
} }
waitUntilLiveEnded (options: OverrideCommandOptions & { waitUntilEnded (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
}) { }) {
const { videoId } = options const { videoId } = options
return this.waitUntilLiveState({ videoId, state: VideoState.LIVE_ENDED }) return this.waitUntilState({ videoId, state: VideoState.LIVE_ENDED })
} }
waitUntilLiveSegmentGeneration (options: OverrideCommandOptions & { waitUntilSegmentGeneration (options: OverrideCommandOptions & {
videoUUID: string videoUUID: string
resolution: number resolution: number
segment: number segment: number
@ -116,7 +116,7 @@ export class LiveCommand extends AbstractCommand {
return waitUntilLog(this.server, `${videoUUID}/${segmentName}`, 2, false) return waitUntilLog(this.server, `${videoUUID}/${segmentName}`, 2, false)
} }
async waitUntilLiveSaved (options: OverrideCommandOptions & { async waitUntilSaved (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
}) { }) {
let video: VideoDetails let video: VideoDetails
@ -129,7 +129,7 @@ export class LiveCommand extends AbstractCommand {
} while (video.isLive === true && video.state.id !== VideoState.PUBLISHED) } while (video.isLive === true && video.state.id !== VideoState.PUBLISHED)
} }
async getPlaylistsCount (options: OverrideCommandOptions & { async countPlaylists (options: OverrideCommandOptions & {
videoUUID: string videoUUID: string
}) { }) {
const basePath = buildServerDirectory(this.server, 'streaming-playlists') const basePath = buildServerDirectory(this.server, 'streaming-playlists')
@ -140,7 +140,7 @@ export class LiveCommand extends AbstractCommand {
return files.filter(f => f.endsWith('.m3u8')).length return files.filter(f => f.endsWith('.m3u8')).length
} }
private async waitUntilLiveState (options: OverrideCommandOptions & { private async waitUntilState (options: OverrideCommandOptions & {
videoId: number | string videoId: number | string
state: VideoState state: VideoState
}) { }) {

2
shared/extra-utils/videos/live.ts
View File

@ -72,7 +72,7 @@ async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
async function waitUntilLivePublishedOnAllServers (servers: ServerInfo[], videoId: string) { async function waitUntilLivePublishedOnAllServers (servers: ServerInfo[], videoId: string) {
for (const server of servers) { for (const server of servers) {
await server.liveCommand.waitUntilLivePublished({ videoId }) await server.liveCommand.waitUntilPublished({ videoId })
} }
} }