]>
Commit | Line | Data |
---|---|---|
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ | |
2 | ||
3 | import 'mocha' | |
4 | import * as chai from 'chai' | |
5 | import { FfmpegCommand } from 'fluent-ffmpeg' | |
6 | import { getLiveNotificationSocket } from '@shared/extra-utils/socket/socket-io' | |
7 | import { LiveVideo, LiveVideoCreate, Video, VideoDetails, VideoPrivacy, VideoState, VideoStreamingPlaylistType } from '@shared/models' | |
8 | import { | |
9 | addVideoToBlacklist, | |
10 | checkLiveCleanup, | |
11 | checkLiveSegmentHash, | |
12 | checkResolutionsInMasterPlaylist, | |
13 | cleanupTests, | |
14 | createLive, | |
15 | doubleFollow, | |
16 | flushAndRunMultipleServers, | |
17 | getLive, | |
18 | getPlaylist, | |
19 | getVideo, | |
20 | getVideoIdFromUUID, | |
21 | getVideosList, | |
22 | killallServers, | |
23 | makeRawRequest, | |
24 | removeVideo, | |
25 | reRunServer, | |
26 | sendRTMPStream, | |
27 | sendRTMPStreamInVideo, | |
28 | ServerInfo, | |
29 | setAccessTokensToServers, | |
30 | setDefaultVideoChannel, | |
31 | stopFfmpeg, | |
32 | testFfmpegStreamError, | |
33 | testImage, | |
34 | updateCustomSubConfig, | |
35 | updateLive, | |
36 | viewVideo, | |
37 | wait, | |
38 | waitJobs, | |
39 | waitUntilLiveStarts, | |
40 | waitUntilLog | |
41 | } from '../../../../shared/extra-utils' | |
42 | ||
43 | const expect = chai.expect | |
44 | ||
45 | describe('Test live', function () { | |
46 | let servers: ServerInfo[] = [] | |
47 | ||
48 | before(async function () { | |
49 | this.timeout(120000) | |
50 | ||
51 | servers = await flushAndRunMultipleServers(2) | |
52 | ||
53 | // Get the access tokens | |
54 | await setAccessTokensToServers(servers) | |
55 | await setDefaultVideoChannel(servers) | |
56 | ||
57 | await updateCustomSubConfig(servers[0].url, servers[0].accessToken, { | |
58 | live: { | |
59 | enabled: true, | |
60 | allowReplay: true, | |
61 | transcoding: { | |
62 | enabled: false | |
63 | } | |
64 | } | |
65 | }) | |
66 | ||
67 | // Server 1 and server 2 follow each other | |
68 | await doubleFollow(servers[0], servers[1]) | |
69 | }) | |
70 | ||
71 | describe('Live creation, update and delete', function () { | |
72 | let liveVideoUUID: string | |
73 | ||
74 | it('Should create a live with the appropriate parameters', async function () { | |
75 | this.timeout(20000) | |
76 | ||
77 | const attributes: LiveVideoCreate = { | |
78 | category: 1, | |
79 | licence: 2, | |
80 | language: 'fr', | |
81 | description: 'super live description', | |
82 | support: 'support field', | |
83 | channelId: servers[0].videoChannel.id, | |
84 | nsfw: false, | |
85 | waitTranscoding: false, | |
86 | name: 'my super live', | |
87 | tags: [ 'tag1', 'tag2' ], | |
88 | commentsEnabled: false, | |
89 | downloadEnabled: false, | |
90 | saveReplay: true, | |
91 | privacy: VideoPrivacy.PUBLIC, | |
92 | previewfile: 'video_short1-preview.webm.jpg', | |
93 | thumbnailfile: 'video_short1.webm.jpg' | |
94 | } | |
95 | ||
96 | const res = await createLive(servers[0].url, servers[0].accessToken, attributes) | |
97 | liveVideoUUID = res.body.video.uuid | |
98 | ||
99 | await waitJobs(servers) | |
100 | ||
101 | for (const server of servers) { | |
102 | const resVideo = await getVideo(server.url, liveVideoUUID) | |
103 | const video: VideoDetails = resVideo.body | |
104 | ||
105 | expect(video.category.id).to.equal(1) | |
106 | expect(video.licence.id).to.equal(2) | |
107 | expect(video.language.id).to.equal('fr') | |
108 | expect(video.description).to.equal('super live description') | |
109 | expect(video.support).to.equal('support field') | |
110 | ||
111 | expect(video.channel.name).to.equal(servers[0].videoChannel.name) | |
112 | expect(video.channel.host).to.equal(servers[0].videoChannel.host) | |
113 | ||
114 | expect(video.nsfw).to.be.false | |
115 | expect(video.waitTranscoding).to.be.false | |
116 | expect(video.name).to.equal('my super live') | |
117 | expect(video.tags).to.deep.equal([ 'tag1', 'tag2' ]) | |
118 | expect(video.commentsEnabled).to.be.false | |
119 | expect(video.downloadEnabled).to.be.false | |
120 | expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC) | |
121 | ||
122 | await testImage(server.url, 'video_short1-preview.webm', video.previewPath) | |
123 | await testImage(server.url, 'video_short1.webm', video.thumbnailPath) | |
124 | ||
125 | const resLive = await getLive(server.url, server.accessToken, liveVideoUUID) | |
126 | const live: LiveVideo = resLive.body | |
127 | ||
128 | if (server.url === servers[0].url) { | |
129 | expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') | |
130 | expect(live.streamKey).to.not.be.empty | |
131 | } else { | |
132 | expect(live.rtmpUrl).to.be.null | |
133 | expect(live.streamKey).to.be.null | |
134 | } | |
135 | ||
136 | expect(live.saveReplay).to.be.true | |
137 | } | |
138 | }) | |
139 | ||
140 | it('Should have a default preview and thumbnail', async function () { | |
141 | this.timeout(20000) | |
142 | ||
143 | const attributes: LiveVideoCreate = { | |
144 | name: 'default live thumbnail', | |
145 | channelId: servers[0].videoChannel.id, | |
146 | privacy: VideoPrivacy.UNLISTED, | |
147 | nsfw: true | |
148 | } | |
149 | ||
150 | const res = await createLive(servers[0].url, servers[0].accessToken, attributes) | |
151 | const videoId = res.body.video.uuid | |
152 | ||
153 | await waitJobs(servers) | |
154 | ||
155 | for (const server of servers) { | |
156 | const resVideo = await getVideo(server.url, videoId) | |
157 | const video: VideoDetails = resVideo.body | |
158 | ||
159 | expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED) | |
160 | expect(video.nsfw).to.be.true | |
161 | ||
162 | await makeRawRequest(server.url + video.thumbnailPath, 200) | |
163 | await makeRawRequest(server.url + video.previewPath, 200) | |
164 | } | |
165 | }) | |
166 | ||
167 | it('Should not have the live listed since nobody streams into', async function () { | |
168 | for (const server of servers) { | |
169 | const res = await getVideosList(server.url) | |
170 | ||
171 | expect(res.body.total).to.equal(0) | |
172 | expect(res.body.data).to.have.lengthOf(0) | |
173 | } | |
174 | }) | |
175 | ||
176 | it('Should not be able to update a live of another server', async function () { | |
177 | await updateLive(servers[1].url, servers[1].accessToken, liveVideoUUID, { saveReplay: false }, 403) | |
178 | }) | |
179 | ||
180 | it('Should update the live', async function () { | |
181 | this.timeout(10000) | |
182 | ||
183 | await updateLive(servers[0].url, servers[0].accessToken, liveVideoUUID, { saveReplay: false }) | |
184 | await waitJobs(servers) | |
185 | }) | |
186 | ||
187 | it('Have the live updated', async function () { | |
188 | for (const server of servers) { | |
189 | const res = await getLive(server.url, server.accessToken, liveVideoUUID) | |
190 | const live: LiveVideo = res.body | |
191 | ||
192 | if (server.url === servers[0].url) { | |
193 | expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live') | |
194 | expect(live.streamKey).to.not.be.empty | |
195 | } else { | |
196 | expect(live.rtmpUrl).to.be.null | |
197 | expect(live.streamKey).to.be.null | |
198 | } | |
199 | ||
200 | expect(live.saveReplay).to.be.false | |
201 | } | |
202 | }) | |
203 | ||
204 | it('Delete the live', async function () { | |
205 | this.timeout(10000) | |
206 | ||
207 | await removeVideo(servers[0].url, servers[0].accessToken, liveVideoUUID) | |
208 | await waitJobs(servers) | |
209 | }) | |
210 | ||
211 | it('Should have the live deleted', async function () { | |
212 | for (const server of servers) { | |
213 | await getVideo(server.url, liveVideoUUID, 404) | |
214 | await getLive(server.url, server.accessToken, liveVideoUUID, 404) | |
215 | } | |
216 | }) | |
217 | }) | |
218 | ||
219 | describe('Stream checks', function () { | |
220 | let liveVideo: LiveVideo & VideoDetails | |
221 | let rtmpUrl: string | |
222 | ||
223 | before(function () { | |
224 | rtmpUrl = 'rtmp://' + servers[0].hostname + ':' + servers[0].rtmpPort + '' | |
225 | }) | |
226 | ||
227 | async function createLiveWrapper () { | |
228 | const liveAttributes = { | |
229 | name: 'user live', | |
230 | channelId: servers[0].videoChannel.id, | |
231 | privacy: VideoPrivacy.PUBLIC, | |
232 | saveReplay: false | |
233 | } | |
234 | ||
235 | const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) | |
236 | const uuid = res.body.video.uuid | |
237 | ||
238 | const resLive = await getLive(servers[0].url, servers[0].accessToken, uuid) | |
239 | const resVideo = await getVideo(servers[0].url, uuid) | |
240 | ||
241 | return Object.assign(resVideo.body, resLive.body) as LiveVideo & VideoDetails | |
242 | } | |
243 | ||
244 | it('Should not allow a stream without the appropriate path', async function () { | |
245 | this.timeout(30000) | |
246 | ||
247 | liveVideo = await createLiveWrapper() | |
248 | ||
249 | const command = sendRTMPStream(rtmpUrl + '/bad-live', liveVideo.streamKey) | |
250 | await testFfmpegStreamError(command, true) | |
251 | }) | |
252 | ||
253 | it('Should not allow a stream without the appropriate stream key', async function () { | |
254 | this.timeout(30000) | |
255 | ||
256 | const command = sendRTMPStream(rtmpUrl + '/live', 'bad-stream-key') | |
257 | await testFfmpegStreamError(command, true) | |
258 | }) | |
259 | ||
260 | it('Should succeed with the correct params', async function () { | |
261 | this.timeout(30000) | |
262 | ||
263 | const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey) | |
264 | await testFfmpegStreamError(command, false) | |
265 | }) | |
266 | ||
267 | it('Should not allow a stream on a live that was blacklisted', async function () { | |
268 | this.timeout(30000) | |
269 | ||
270 | liveVideo = await createLiveWrapper() | |
271 | ||
272 | await addVideoToBlacklist(servers[0].url, servers[0].accessToken, liveVideo.uuid) | |
273 | ||
274 | const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey) | |
275 | await testFfmpegStreamError(command, true) | |
276 | }) | |
277 | ||
278 | it('Should not allow a stream on a live that was deleted', async function () { | |
279 | this.timeout(30000) | |
280 | ||
281 | liveVideo = await createLiveWrapper() | |
282 | ||
283 | await removeVideo(servers[0].url, servers[0].accessToken, liveVideo.uuid) | |
284 | ||
285 | const command = sendRTMPStream(rtmpUrl + '/live', liveVideo.streamKey) | |
286 | await testFfmpegStreamError(command, true) | |
287 | }) | |
288 | }) | |
289 | ||
290 | describe('Live transcoding', function () { | |
291 | let liveVideoId: string | |
292 | ||
293 | async function createLiveWrapper (saveReplay: boolean) { | |
294 | const liveAttributes = { | |
295 | name: 'live video', | |
296 | channelId: servers[0].videoChannel.id, | |
297 | privacy: VideoPrivacy.PUBLIC, | |
298 | saveReplay | |
299 | } | |
300 | ||
301 | const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) | |
302 | return res.body.video.uuid | |
303 | } | |
304 | ||
305 | async function testVideoResolutions (liveVideoId: string, resolutions: number[]) { | |
306 | for (const server of servers) { | |
307 | const resList = await getVideosList(server.url) | |
308 | const videos: Video[] = resList.body.data | |
309 | ||
310 | expect(videos.find(v => v.uuid === liveVideoId)).to.exist | |
311 | ||
312 | const resVideo = await getVideo(server.url, liveVideoId) | |
313 | const video: VideoDetails = resVideo.body | |
314 | ||
315 | expect(video.streamingPlaylists).to.have.lengthOf(1) | |
316 | ||
317 | const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS) | |
318 | expect(hlsPlaylist).to.exist | |
319 | ||
320 | // Only finite files are displayed | |
321 | expect(hlsPlaylist.files).to.have.lengthOf(0) | |
322 | ||
323 | await checkResolutionsInMasterPlaylist(hlsPlaylist.playlistUrl, resolutions) | |
324 | ||
325 | for (let i = 0; i < resolutions.length; i++) { | |
326 | const segmentName = `${i}-000001.ts` | |
327 | await waitUntilLog(servers[0], `${video.uuid}/${segmentName}`, 1, false) | |
328 | ||
329 | const res = await getPlaylist(`${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`) | |
330 | const subPlaylist = res.text | |
331 | ||
332 | expect(subPlaylist).to.contain(segmentName) | |
333 | ||
334 | const baseUrlAndPath = servers[0].url + '/static/streaming-playlists/hls' | |
335 | await checkLiveSegmentHash(baseUrlAndPath, video.uuid, segmentName, hlsPlaylist) | |
336 | } | |
337 | } | |
338 | } | |
339 | ||
340 | function updateConf (resolutions: number[]) { | |
341 | return updateCustomSubConfig(servers[0].url, servers[0].accessToken, { | |
342 | live: { | |
343 | enabled: true, | |
344 | allowReplay: true, | |
345 | maxDuration: null, | |
346 | transcoding: { | |
347 | enabled: true, | |
348 | resolutions: { | |
349 | '240p': resolutions.includes(240), | |
350 | '360p': resolutions.includes(360), | |
351 | '480p': resolutions.includes(480), | |
352 | '720p': resolutions.includes(720), | |
353 | '1080p': resolutions.includes(1080), | |
354 | '2160p': resolutions.includes(2160) | |
355 | } | |
356 | } | |
357 | } | |
358 | }) | |
359 | } | |
360 | ||
361 | before(async function () { | |
362 | await updateConf([]) | |
363 | }) | |
364 | ||
365 | it('Should enable transcoding without additional resolutions', async function () { | |
366 | this.timeout(30000) | |
367 | ||
368 | liveVideoId = await createLiveWrapper(false) | |
369 | ||
370 | const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId) | |
371 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoId) | |
372 | await waitJobs(servers) | |
373 | ||
374 | await testVideoResolutions(liveVideoId, [ 720 ]) | |
375 | ||
376 | await stopFfmpeg(command) | |
377 | }) | |
378 | ||
379 | it('Should enable transcoding with some resolutions', async function () { | |
380 | this.timeout(30000) | |
381 | ||
382 | const resolutions = [ 240, 480 ] | |
383 | await updateConf(resolutions) | |
384 | liveVideoId = await createLiveWrapper(false) | |
385 | ||
386 | const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId) | |
387 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoId) | |
388 | await waitJobs(servers) | |
389 | ||
390 | await testVideoResolutions(liveVideoId, resolutions) | |
391 | ||
392 | await stopFfmpeg(command) | |
393 | }) | |
394 | ||
395 | it('Should enable transcoding with some resolutions and correctly save them', async function () { | |
396 | this.timeout(60000) | |
397 | ||
398 | const resolutions = [ 240, 360, 720 ] | |
399 | await updateConf(resolutions) | |
400 | liveVideoId = await createLiveWrapper(true) | |
401 | ||
402 | const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId) | |
403 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoId) | |
404 | await waitJobs(servers) | |
405 | ||
406 | await testVideoResolutions(liveVideoId, resolutions) | |
407 | ||
408 | await stopFfmpeg(command) | |
409 | ||
410 | await waitJobs(servers) | |
411 | ||
412 | for (const server of servers) { | |
413 | const resVideo = await getVideo(server.url, liveVideoId) | |
414 | const video: VideoDetails = resVideo.body | |
415 | ||
416 | expect(video.duration).to.be.greaterThan(1) | |
417 | expect(video.files).to.have.lengthOf(0) | |
418 | ||
419 | const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS) | |
420 | ||
421 | expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length) | |
422 | ||
423 | for (const resolution of resolutions) { | |
424 | const file = hlsPlaylist.files.find(f => f.resolution.id === resolution) | |
425 | ||
426 | expect(file).to.exist | |
427 | expect(file.fps).to.equal(25) | |
428 | expect(file.size).to.be.greaterThan(1) | |
429 | ||
430 | await makeRawRequest(file.torrentUrl, 200) | |
431 | await makeRawRequest(file.fileUrl, 200) | |
432 | } | |
433 | } | |
434 | }) | |
435 | ||
436 | it('Should correctly have cleaned up the live files', async function () { | |
437 | this.timeout(30000) | |
438 | ||
439 | await checkLiveCleanup(servers[0], liveVideoId, [ 240, 360, 720 ]) | |
440 | }) | |
441 | }) | |
442 | ||
443 | describe('Live views', function () { | |
444 | let liveVideoId: string | |
445 | let command: FfmpegCommand | |
446 | ||
447 | async function countViews (expected: number) { | |
448 | for (const server of servers) { | |
449 | const res = await getVideo(server.url, liveVideoId) | |
450 | const video: VideoDetails = res.body | |
451 | ||
452 | expect(video.views).to.equal(expected) | |
453 | } | |
454 | } | |
455 | ||
456 | before(async function () { | |
457 | this.timeout(30000) | |
458 | ||
459 | const liveAttributes = { | |
460 | name: 'live video', | |
461 | channelId: servers[0].videoChannel.id, | |
462 | privacy: VideoPrivacy.PUBLIC | |
463 | } | |
464 | ||
465 | const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) | |
466 | liveVideoId = res.body.video.uuid | |
467 | ||
468 | command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId) | |
469 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoId) | |
470 | await waitJobs(servers) | |
471 | }) | |
472 | ||
473 | it('Should display no views for a live', async function () { | |
474 | await countViews(0) | |
475 | }) | |
476 | ||
477 | it('Should view a live twice and display 1 view', async function () { | |
478 | this.timeout(30000) | |
479 | ||
480 | await viewVideo(servers[0].url, liveVideoId) | |
481 | await viewVideo(servers[0].url, liveVideoId) | |
482 | ||
483 | await wait(7000) | |
484 | ||
485 | await waitJobs(servers) | |
486 | ||
487 | await countViews(1) | |
488 | }) | |
489 | ||
490 | it('Should wait and display 0 views', async function () { | |
491 | this.timeout(30000) | |
492 | ||
493 | await wait(7000) | |
494 | await waitJobs(servers) | |
495 | ||
496 | await countViews(0) | |
497 | }) | |
498 | ||
499 | it('Should view a live on a remote and on local and display 2 views', async function () { | |
500 | this.timeout(30000) | |
501 | ||
502 | await viewVideo(servers[0].url, liveVideoId) | |
503 | await viewVideo(servers[1].url, liveVideoId) | |
504 | await viewVideo(servers[1].url, liveVideoId) | |
505 | ||
506 | await wait(7000) | |
507 | await waitJobs(servers) | |
508 | ||
509 | await countViews(2) | |
510 | }) | |
511 | ||
512 | after(async function () { | |
513 | await stopFfmpeg(command) | |
514 | }) | |
515 | }) | |
516 | ||
517 | describe('Live socket messages', function () { | |
518 | ||
519 | async function createLiveWrapper () { | |
520 | const liveAttributes = { | |
521 | name: 'live video', | |
522 | channelId: servers[0].videoChannel.id, | |
523 | privacy: VideoPrivacy.PUBLIC | |
524 | } | |
525 | ||
526 | const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) | |
527 | return res.body.video.uuid | |
528 | } | |
529 | ||
530 | it('Should correctly send a message when the live starts and ends', async function () { | |
531 | this.timeout(60000) | |
532 | ||
533 | const localStateChanges: VideoState[] = [] | |
534 | const remoteStateChanges: VideoState[] = [] | |
535 | ||
536 | const liveVideoUUID = await createLiveWrapper() | |
537 | await waitJobs(servers) | |
538 | ||
539 | { | |
540 | const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID) | |
541 | ||
542 | const localSocket = getLiveNotificationSocket(servers[0].url) | |
543 | localSocket.on('state-change', data => localStateChanges.push(data.state)) | |
544 | localSocket.emit('subscribe', { videoId }) | |
545 | } | |
546 | ||
547 | { | |
548 | const videoId = await getVideoIdFromUUID(servers[1].url, liveVideoUUID) | |
549 | ||
550 | const remoteSocket = getLiveNotificationSocket(servers[1].url) | |
551 | remoteSocket.on('state-change', data => remoteStateChanges.push(data.state)) | |
552 | remoteSocket.emit('subscribe', { videoId }) | |
553 | } | |
554 | ||
555 | const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID) | |
556 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoUUID) | |
557 | await waitJobs(servers) | |
558 | ||
559 | for (const stateChanges of [ localStateChanges, remoteStateChanges ]) { | |
560 | expect(stateChanges).to.have.lengthOf(1) | |
561 | expect(stateChanges[0]).to.equal(VideoState.PUBLISHED) | |
562 | } | |
563 | ||
564 | await stopFfmpeg(command) | |
565 | await waitJobs(servers) | |
566 | ||
567 | for (const stateChanges of [ localStateChanges, remoteStateChanges ]) { | |
568 | expect(stateChanges).to.have.lengthOf(2) | |
569 | expect(stateChanges[1]).to.equal(VideoState.LIVE_ENDED) | |
570 | } | |
571 | }) | |
572 | ||
573 | it('Should not receive a notification after unsubscribe', async function () { | |
574 | this.timeout(60000) | |
575 | ||
576 | const stateChanges: VideoState[] = [] | |
577 | ||
578 | const liveVideoUUID = await createLiveWrapper() | |
579 | await waitJobs(servers) | |
580 | ||
581 | const videoId = await getVideoIdFromUUID(servers[0].url, liveVideoUUID) | |
582 | ||
583 | const socket = getLiveNotificationSocket(servers[0].url) | |
584 | socket.on('state-change', data => stateChanges.push(data.state)) | |
585 | socket.emit('subscribe', { videoId }) | |
586 | ||
587 | const command = await sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoUUID) | |
588 | await waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoUUID) | |
589 | await waitJobs(servers) | |
590 | ||
591 | expect(stateChanges).to.have.lengthOf(1) | |
592 | socket.emit('unsubscribe', { videoId }) | |
593 | ||
594 | await stopFfmpeg(command) | |
595 | await waitJobs(servers) | |
596 | ||
597 | expect(stateChanges).to.have.lengthOf(1) | |
598 | }) | |
599 | }) | |
600 | ||
601 | describe('After a server restart', function () { | |
602 | let liveVideoId: string | |
603 | let liveVideoReplayId: string | |
604 | ||
605 | async function createLiveWrapper (saveReplay: boolean) { | |
606 | const liveAttributes = { | |
607 | name: 'live video', | |
608 | channelId: servers[0].videoChannel.id, | |
609 | privacy: VideoPrivacy.PUBLIC, | |
610 | saveReplay | |
611 | } | |
612 | ||
613 | const res = await createLive(servers[0].url, servers[0].accessToken, liveAttributes) | |
614 | return res.body.video.uuid | |
615 | } | |
616 | ||
617 | before(async function () { | |
618 | this.timeout(60000) | |
619 | ||
620 | liveVideoId = await createLiveWrapper(false) | |
621 | liveVideoReplayId = await createLiveWrapper(true) | |
622 | ||
623 | await Promise.all([ | |
624 | sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoId), | |
625 | sendRTMPStreamInVideo(servers[0].url, servers[0].accessToken, liveVideoReplayId) | |
626 | ]) | |
627 | ||
628 | await Promise.all([ | |
629 | waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoId), | |
630 | waitUntilLiveStarts(servers[0].url, servers[0].accessToken, liveVideoReplayId) | |
631 | ]) | |
632 | ||
633 | await killallServers([ servers[0] ]) | |
634 | await reRunServer(servers[0]) | |
635 | ||
636 | await wait(5000) | |
637 | }) | |
638 | ||
639 | it('Should cleanup lives', async function () { | |
640 | this.timeout(60000) | |
641 | ||
642 | const res = await getVideo(servers[0].url, liveVideoId) | |
643 | const video: VideoDetails = res.body | |
644 | ||
645 | expect(video.state.id).to.equal(VideoState.LIVE_ENDED) | |
646 | }) | |
647 | ||
648 | it('Should save a live replay', async function () { | |
649 | this.timeout(60000) | |
650 | ||
651 | await waitJobs(servers) | |
652 | ||
653 | const res = await getVideo(servers[0].url, liveVideoReplayId) | |
654 | const video: VideoDetails = res.body | |
655 | ||
656 | expect(video.state.id).to.equal(VideoState.PUBLISHED) | |
657 | }) | |
658 | }) | |
659 | ||
660 | after(async function () { | |
661 | await cleanupTests(servers) | |
662 | }) | |
663 | }) |