]>
Commit | Line | Data |
---|---|---|
d102de1b C |
1 | /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ |
2 | import { expect } from 'chai' | |
5e47f6ab C |
3 | import { |
4 | checkPeerTubeRunnerCacheIsEmpty, | |
5 | completeCheckHlsPlaylist, | |
6 | completeWebVideoFilesCheck, | |
7 | PeerTubeRunnerProcess | |
8 | } from '@server/tests/shared' | |
d102de1b C |
9 | import { areMockObjectStorageTestsDisabled, getAllFiles, wait } from '@shared/core-utils' |
10 | import { VideoPrivacy } from '@shared/models' | |
11 | import { | |
12 | cleanupTests, | |
13 | createMultipleServers, | |
14 | doubleFollow, | |
15 | ObjectStorageCommand, | |
16 | PeerTubeServer, | |
17 | setAccessTokensToServers, | |
18 | setDefaultVideoChannel, | |
19 | waitJobs | |
20 | } from '@shared/server-commands' | |
21 | ||
22 | describe('Test VOD transcoding in peertube-runner program', function () { | |
23 | let servers: PeerTubeServer[] = [] | |
24 | let peertubeRunner: PeerTubeRunnerProcess | |
25 | ||
26 | function runSuite (options: { | |
27 | webtorrentEnabled: boolean | |
28 | hlsEnabled: boolean | |
29 | objectStorage: boolean | |
30 | }) { | |
31 | const { webtorrentEnabled, hlsEnabled, objectStorage } = options | |
32 | ||
33 | const objectStorageBaseUrlWebTorrent = objectStorage | |
34 | ? ObjectStorageCommand.getMockWebTorrentBaseUrl() | |
35 | : undefined | |
36 | ||
37 | const objectStorageBaseUrlHLS = objectStorage | |
38 | ? ObjectStorageCommand.getMockPlaylistBaseUrl() | |
39 | : undefined | |
40 | ||
41 | it('Should upload a classic video mp4 and transcode it', async function () { | |
42 | this.timeout(120000) | |
43 | ||
44 | const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.mp4' }) | |
45 | ||
46 | await waitJobs(servers, { runnerJobs: true }) | |
47 | ||
48 | for (const server of servers) { | |
49 | if (webtorrentEnabled) { | |
50 | await completeWebVideoFilesCheck({ | |
51 | server, | |
52 | originServer: servers[0], | |
53 | fixture: 'video_short.mp4', | |
54 | videoUUID: uuid, | |
55 | objectStorageBaseUrl: objectStorageBaseUrlWebTorrent, | |
56 | files: [ | |
57 | { resolution: 0 }, | |
58 | { resolution: 144 }, | |
59 | { resolution: 240 }, | |
60 | { resolution: 360 }, | |
61 | { resolution: 480 }, | |
62 | { resolution: 720 } | |
63 | ] | |
64 | }) | |
65 | } | |
66 | ||
67 | if (hlsEnabled) { | |
68 | await completeCheckHlsPlaylist({ | |
69 | hlsOnly: !webtorrentEnabled, | |
70 | servers, | |
71 | videoUUID: uuid, | |
72 | objectStorageBaseUrl: objectStorageBaseUrlHLS, | |
73 | resolutions: [ 720, 480, 360, 240, 144, 0 ] | |
74 | }) | |
75 | } | |
76 | } | |
77 | }) | |
78 | ||
79 | it('Should upload a webm video and transcode it', async function () { | |
80 | this.timeout(120000) | |
81 | ||
82 | const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.webm' }) | |
83 | ||
84 | await waitJobs(servers, { runnerJobs: true }) | |
85 | ||
86 | for (const server of servers) { | |
87 | if (webtorrentEnabled) { | |
88 | await completeWebVideoFilesCheck({ | |
89 | server, | |
90 | originServer: servers[0], | |
91 | fixture: 'video_short.webm', | |
92 | videoUUID: uuid, | |
93 | objectStorageBaseUrl: objectStorageBaseUrlWebTorrent, | |
94 | files: [ | |
95 | { resolution: 0 }, | |
96 | { resolution: 144 }, | |
97 | { resolution: 240 }, | |
98 | { resolution: 360 }, | |
99 | { resolution: 480 }, | |
100 | { resolution: 720 } | |
101 | ] | |
102 | }) | |
103 | } | |
104 | ||
105 | if (hlsEnabled) { | |
106 | await completeCheckHlsPlaylist({ | |
107 | hlsOnly: !webtorrentEnabled, | |
108 | servers, | |
109 | videoUUID: uuid, | |
110 | objectStorageBaseUrl: objectStorageBaseUrlHLS, | |
111 | resolutions: [ 720, 480, 360, 240, 144, 0 ] | |
112 | }) | |
113 | } | |
114 | } | |
115 | }) | |
116 | ||
117 | it('Should upload an audio only video and transcode it', async function () { | |
118 | this.timeout(120000) | |
119 | ||
120 | const attributes = { name: 'audio_without_preview', fixture: 'sample.ogg' } | |
121 | const { uuid } = await servers[0].videos.upload({ attributes, mode: 'resumable' }) | |
122 | ||
123 | await waitJobs(servers, { runnerJobs: true }) | |
124 | ||
125 | for (const server of servers) { | |
126 | if (webtorrentEnabled) { | |
127 | await completeWebVideoFilesCheck({ | |
128 | server, | |
129 | originServer: servers[0], | |
130 | fixture: 'sample.ogg', | |
131 | videoUUID: uuid, | |
132 | objectStorageBaseUrl: objectStorageBaseUrlWebTorrent, | |
133 | files: [ | |
134 | { resolution: 0 }, | |
135 | { resolution: 144 }, | |
136 | { resolution: 240 }, | |
137 | { resolution: 360 }, | |
138 | { resolution: 480 } | |
139 | ] | |
140 | }) | |
141 | } | |
142 | ||
143 | if (hlsEnabled) { | |
144 | await completeCheckHlsPlaylist({ | |
145 | hlsOnly: !webtorrentEnabled, | |
146 | servers, | |
147 | videoUUID: uuid, | |
148 | objectStorageBaseUrl: objectStorageBaseUrlHLS, | |
149 | resolutions: [ 480, 360, 240, 144, 0 ] | |
150 | }) | |
151 | } | |
152 | } | |
153 | }) | |
154 | ||
155 | it('Should upload a private video and transcode it', async function () { | |
156 | this.timeout(120000) | |
157 | ||
158 | const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.mp4', privacy: VideoPrivacy.PRIVATE }) | |
159 | ||
160 | await waitJobs(servers, { runnerJobs: true }) | |
161 | ||
162 | if (webtorrentEnabled) { | |
163 | await completeWebVideoFilesCheck({ | |
164 | server: servers[0], | |
165 | originServer: servers[0], | |
166 | fixture: 'video_short.mp4', | |
167 | videoUUID: uuid, | |
168 | objectStorageBaseUrl: objectStorageBaseUrlWebTorrent, | |
169 | files: [ | |
170 | { resolution: 0 }, | |
171 | { resolution: 144 }, | |
172 | { resolution: 240 }, | |
173 | { resolution: 360 }, | |
174 | { resolution: 480 }, | |
175 | { resolution: 720 } | |
176 | ] | |
177 | }) | |
178 | } | |
179 | ||
180 | if (hlsEnabled) { | |
181 | await completeCheckHlsPlaylist({ | |
182 | hlsOnly: !webtorrentEnabled, | |
183 | servers: [ servers[0] ], | |
184 | videoUUID: uuid, | |
185 | objectStorageBaseUrl: objectStorageBaseUrlHLS, | |
186 | resolutions: [ 720, 480, 360, 240, 144, 0 ] | |
187 | }) | |
188 | } | |
189 | }) | |
190 | ||
191 | it('Should transcode videos on manual run', async function () { | |
192 | this.timeout(120000) | |
193 | ||
194 | await servers[0].config.disableTranscoding() | |
195 | ||
196 | const { uuid } = await servers[0].videos.quickUpload({ name: 'manual transcoding', fixture: 'video_short.mp4' }) | |
197 | await waitJobs(servers, { runnerJobs: true }) | |
198 | ||
199 | { | |
200 | const video = await servers[0].videos.get({ id: uuid }) | |
201 | expect(getAllFiles(video)).to.have.lengthOf(1) | |
202 | } | |
203 | ||
204 | await servers[0].config.enableTranscoding(true, true, true) | |
205 | ||
206 | await servers[0].videos.runTranscoding({ transcodingType: 'webtorrent', videoId: uuid }) | |
207 | await waitJobs(servers, { runnerJobs: true }) | |
208 | ||
209 | await completeWebVideoFilesCheck({ | |
210 | server: servers[0], | |
211 | originServer: servers[0], | |
212 | fixture: 'video_short.mp4', | |
213 | videoUUID: uuid, | |
214 | objectStorageBaseUrl: objectStorageBaseUrlWebTorrent, | |
215 | files: [ | |
216 | { resolution: 0 }, | |
217 | { resolution: 144 }, | |
218 | { resolution: 240 }, | |
219 | { resolution: 360 }, | |
220 | { resolution: 480 }, | |
221 | { resolution: 720 } | |
222 | ] | |
223 | }) | |
224 | ||
225 | await servers[0].videos.runTranscoding({ transcodingType: 'hls', videoId: uuid }) | |
226 | await waitJobs(servers, { runnerJobs: true }) | |
227 | ||
228 | await completeCheckHlsPlaylist({ | |
229 | hlsOnly: false, | |
230 | servers: [ servers[0] ], | |
231 | videoUUID: uuid, | |
232 | objectStorageBaseUrl: objectStorageBaseUrlHLS, | |
233 | resolutions: [ 720, 480, 360, 240, 144, 0 ] | |
234 | }) | |
235 | }) | |
236 | } | |
237 | ||
238 | before(async function () { | |
239 | this.timeout(120_000) | |
240 | ||
241 | servers = await createMultipleServers(2) | |
242 | ||
243 | await setAccessTokensToServers(servers) | |
244 | await setDefaultVideoChannel(servers) | |
245 | ||
246 | await doubleFollow(servers[0], servers[1]) | |
247 | ||
248 | await servers[0].config.enableRemoteTranscoding() | |
249 | ||
250 | const registrationToken = await servers[0].runnerRegistrationTokens.getFirstRegistrationToken() | |
251 | ||
252 | peertubeRunner = new PeerTubeRunnerProcess() | |
253 | await peertubeRunner.runServer() | |
254 | await peertubeRunner.registerPeerTubeInstance({ server: servers[0], registrationToken, runnerName: 'runner' }) | |
255 | }) | |
256 | ||
257 | describe('With videos on local filesystem storage', function () { | |
258 | ||
259 | describe('Web video only enabled', function () { | |
260 | ||
261 | before(async function () { | |
262 | await servers[0].config.enableTranscoding(true, false, true) | |
263 | }) | |
264 | ||
265 | runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage: false }) | |
266 | }) | |
267 | ||
268 | describe('HLS videos only enabled', function () { | |
269 | ||
270 | before(async function () { | |
271 | await servers[0].config.enableTranscoding(false, true, true) | |
272 | }) | |
273 | ||
274 | runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage: false }) | |
275 | }) | |
276 | ||
277 | describe('Web video & HLS enabled', function () { | |
278 | ||
279 | before(async function () { | |
280 | await servers[0].config.enableTranscoding(true, true, true) | |
281 | }) | |
282 | ||
283 | runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage: false }) | |
284 | }) | |
285 | }) | |
286 | ||
287 | describe('With videos on object storage', function () { | |
288 | if (areMockObjectStorageTestsDisabled()) return | |
289 | ||
290 | before(async function () { | |
291 | await ObjectStorageCommand.prepareDefaultMockBuckets() | |
292 | ||
293 | await servers[0].kill() | |
294 | ||
295 | await servers[0].run(ObjectStorageCommand.getDefaultMockConfig()) | |
296 | ||
297 | // Wait for peertube runner socket reconnection | |
298 | await wait(1500) | |
299 | }) | |
300 | ||
301 | describe('Web video only enabled', function () { | |
302 | ||
303 | before(async function () { | |
304 | await servers[0].config.enableTranscoding(true, false, true) | |
305 | }) | |
306 | ||
307 | runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage: true }) | |
308 | }) | |
309 | ||
310 | describe('HLS videos only enabled', function () { | |
311 | ||
312 | before(async function () { | |
313 | await servers[0].config.enableTranscoding(false, true, true) | |
314 | }) | |
315 | ||
316 | runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage: true }) | |
317 | }) | |
318 | ||
319 | describe('Web video & HLS enabled', function () { | |
320 | ||
321 | before(async function () { | |
322 | await servers[0].config.enableTranscoding(true, true, true) | |
323 | }) | |
324 | ||
325 | runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage: true }) | |
326 | }) | |
327 | }) | |
328 | ||
5e47f6ab C |
329 | describe('Check cleanup', function () { |
330 | ||
331 | it('Should have an empty cache directory', async function () { | |
332 | await checkPeerTubeRunnerCacheIsEmpty() | |
333 | }) | |
334 | }) | |
335 | ||
d102de1b C |
336 | after(async function () { |
337 | await peertubeRunner.unregisterPeerTubeInstance({ server: servers[0] }) | |
338 | peertubeRunner.kill() | |
339 | ||
340 | await cleanupTests(servers) | |
341 | }) | |
342 | }) |