1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import * as chai from 'chai'
8 flushAndRunMultipleServers,
16 setAccessTokensToServers,
19 } from '../../../../shared/extra-utils'
20 import { areHttpImportTestsDisabled, testImage } from '../../../../shared/extra-utils/miscs/miscs'
21 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
25 getYoutubeHDRVideoUrl,
28 } from '../../../../shared/extra-utils/videos/video-imports'
29 import { VideoCaption, VideoDetails, VideoImport, VideoPrivacy, VideoResolution } from '../../../../shared/models/videos'
31 const expect = chai.expect
33 describe('Test video imports', function () {
34 let servers: ServerInfo[] = []
35 let channelIdServer1: number
36 let channelIdServer2: number
38 if (areHttpImportTestsDisabled()) return
40 async function checkVideosServer1 (url: string, idHttp: string, idMagnet: string, idTorrent: string) {
41 const resHttp = await getVideo(url, idHttp)
42 const videoHttp: VideoDetails = resHttp.body
44 expect(videoHttp.name).to.equal('small video - youtube')
45 // FIXME: youtube-dl seems broken
46 // expect(videoHttp.category.label).to.equal('News & Politics')
47 // expect(videoHttp.licence.label).to.equal('Attribution')
48 expect(videoHttp.language.label).to.equal('Unknown')
49 expect(videoHttp.nsfw).to.be.false
50 expect(videoHttp.description).to.equal('this is a super description')
51 expect(videoHttp.tags).to.deep.equal([ 'tag1', 'tag2' ])
52 expect(videoHttp.files).to.have.lengthOf(1)
54 const originallyPublishedAt = new Date(videoHttp.originallyPublishedAt)
55 expect(originallyPublishedAt.getDate()).to.equal(14)
56 expect(originallyPublishedAt.getMonth()).to.equal(0)
57 expect(originallyPublishedAt.getFullYear()).to.equal(2019)
59 const resMagnet = await getVideo(url, idMagnet)
60 const videoMagnet: VideoDetails = resMagnet.body
61 const resTorrent = await getVideo(url, idTorrent)
62 const videoTorrent: VideoDetails = resTorrent.body
64 for (const video of [ videoMagnet, videoTorrent ]) {
65 expect(video.category.label).to.equal('Misc')
66 expect(video.licence.label).to.equal('Unknown')
67 expect(video.language.label).to.equal('Unknown')
68 expect(video.nsfw).to.be.false
69 expect(video.description).to.equal('this is a super torrent description')
70 expect(video.tags).to.deep.equal([ 'tag_torrent1', 'tag_torrent2' ])
71 expect(video.files).to.have.lengthOf(1)
74 expect(videoTorrent.name).to.contain('你好 世界 720p.mp4')
75 expect(videoMagnet.name).to.contain('super peertube2 video')
77 const resCaptions = await listVideoCaptions(url, idHttp)
78 expect(resCaptions.body.total).to.equal(2)
81 async function checkVideoServer2 (url: string, id: number | string) {
82 const res = await getVideo(url, id)
83 const video: VideoDetails = res.body
85 expect(video.name).to.equal('my super name')
86 expect(video.category.label).to.equal('Entertainment')
87 expect(video.licence.label).to.equal('Public Domain Dedication')
88 expect(video.language.label).to.equal('English')
89 expect(video.nsfw).to.be.false
90 expect(video.description).to.equal('my super description')
91 expect(video.tags).to.deep.equal([ 'supertag1', 'supertag2' ])
93 expect(video.files).to.have.lengthOf(1)
95 const resCaptions = await listVideoCaptions(url, id)
96 expect(resCaptions.body.total).to.equal(2)
99 before(async function () {
103 servers = await flushAndRunMultipleServers(2)
105 await setAccessTokensToServers(servers)
108 const res = await getMyUserInformation(servers[0].url, servers[0].accessToken)
109 channelIdServer1 = res.body.videoChannels[0].id
113 const res = await getMyUserInformation(servers[1].url, servers[1].accessToken)
114 channelIdServer2 = res.body.videoChannels[0].id
117 await doubleFollow(servers[0], servers[1])
120 it('Should import videos on server 1', async function () {
123 const baseAttributes = {
124 channelId: channelIdServer1,
125 privacy: VideoPrivacy.PUBLIC
129 const attributes = immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() })
130 const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
131 expect(res.body.video.name).to.equal('small video - youtube')
133 expect(res.body.video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
134 expect(res.body.video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
136 await testImage(servers[0].url, 'video_import_thumbnail', res.body.video.thumbnailPath)
137 await testImage(servers[0].url, 'video_import_preview', res.body.video.previewPath)
139 const resCaptions = await listVideoCaptions(servers[0].url, res.body.video.id)
140 const videoCaptions: VideoCaption[] = resCaptions.body.data
141 expect(videoCaptions).to.have.lengthOf(2)
143 const enCaption = videoCaptions.find(caption => caption.language.id === 'en')
144 expect(enCaption).to.exist
145 expect(enCaption.language.label).to.equal('English')
146 expect(enCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-en.vtt$`))
147 await testCaptionFile(servers[0].url, enCaption.captionPath, `WEBVTT
151 00:00:01.600 --> 00:00:04.200
154 00:00:05.900 --> 00:00:07.999
155 This is a subtitle in American English
157 00:00:10.000 --> 00:00:14.000
158 Adding subtitles is very easy to do`)
160 const frCaption = videoCaptions.find(caption => caption.language.id === 'fr')
161 expect(frCaption).to.exist
162 expect(frCaption.language.label).to.equal('French')
163 expect(frCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-fr.vtt`))
164 await testCaptionFile(servers[0].url, frCaption.captionPath, `WEBVTT
168 00:00:01.600 --> 00:00:04.200
171 00:00:05.900 --> 00:00:07.999
172 C'est un sous-titre français
174 00:00:10.000 --> 00:00:14.000
175 Ajouter un sous-titre est vraiment facile`)
179 const attributes = immutableAssign(baseAttributes, {
180 magnetUri: getMagnetURI(),
181 description: 'this is a super torrent description',
182 tags: [ 'tag_torrent1', 'tag_torrent2' ]
184 const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
185 expect(res.body.video.name).to.equal('super peertube2 video')
189 const attributes = immutableAssign(baseAttributes, {
190 torrentfile: 'video-720p.torrent' as any,
191 description: 'this is a super torrent description',
192 tags: [ 'tag_torrent1', 'tag_torrent2' ]
194 const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
195 expect(res.body.video.name).to.equal('你好 世界 720p.mp4')
199 it('Should list the videos to import in my videos on server 1', async function () {
200 const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5, 'createdAt')
202 expect(res.body.total).to.equal(3)
204 const videos = res.body.data
205 expect(videos).to.have.lengthOf(3)
206 expect(videos[0].name).to.equal('small video - youtube')
207 expect(videos[1].name).to.equal('super peertube2 video')
208 expect(videos[2].name).to.equal('你好 世界 720p.mp4')
211 it('Should list the videos to import in my imports on server 1', async function () {
212 const res = await getMyVideoImports(servers[0].url, servers[0].accessToken, '-createdAt')
214 expect(res.body.total).to.equal(3)
215 const videoImports: VideoImport[] = res.body.data
216 expect(videoImports).to.have.lengthOf(3)
218 expect(videoImports[2].targetUrl).to.equal(getYoutubeVideoUrl())
219 expect(videoImports[2].magnetUri).to.be.null
220 expect(videoImports[2].torrentName).to.be.null
221 expect(videoImports[2].video.name).to.equal('small video - youtube')
223 expect(videoImports[1].targetUrl).to.be.null
224 expect(videoImports[1].magnetUri).to.equal(getMagnetURI())
225 expect(videoImports[1].torrentName).to.be.null
226 expect(videoImports[1].video.name).to.equal('super peertube2 video')
228 expect(videoImports[0].targetUrl).to.be.null
229 expect(videoImports[0].magnetUri).to.be.null
230 expect(videoImports[0].torrentName).to.equal('video-720p.torrent')
231 expect(videoImports[0].video.name).to.equal('你好 世界 720p.mp4')
234 it('Should have the video listed on the two instances', async function () {
235 this.timeout(120_000)
237 await waitJobs(servers)
239 for (const server of servers) {
240 const res = await getVideosList(server.url)
241 expect(res.body.total).to.equal(3)
242 expect(res.body.data).to.have.lengthOf(3)
244 const [ videoHttp, videoMagnet, videoTorrent ] = res.body.data
245 await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
249 it('Should import a video on server 2 with some fields', async function () {
253 targetUrl: getYoutubeVideoUrl(),
254 channelId: channelIdServer2,
255 privacy: VideoPrivacy.PUBLIC,
259 name: 'my super name',
260 description: 'my super description',
261 tags: [ 'supertag1', 'supertag2' ]
263 const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
264 expect(res.body.video.name).to.equal('my super name')
267 it('Should have the videos listed on the two instances', async function () {
268 this.timeout(120_000)
270 await waitJobs(servers)
272 for (const server of servers) {
273 const res = await getVideosList(server.url)
274 expect(res.body.total).to.equal(4)
275 expect(res.body.data).to.have.lengthOf(4)
277 await checkVideoServer2(server.url, res.body.data[0].uuid)
279 const [ , videoHttp, videoMagnet, videoTorrent ] = res.body.data
280 await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
284 it('Should import a video that will be transcoded', async function () {
285 this.timeout(120_000)
288 name: 'transcoded video',
289 magnetUri: getMagnetURI(),
290 channelId: channelIdServer2,
291 privacy: VideoPrivacy.PUBLIC
293 const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
294 const videoUUID = res.body.video.uuid
296 await waitJobs(servers)
298 for (const server of servers) {
299 const res = await getVideo(server.url, videoUUID)
300 const video: VideoDetails = res.body
302 expect(video.name).to.equal('transcoded video')
303 expect(video.files).to.have.lengthOf(4)
307 it('Should import no HDR version on a HDR video', async function () {
308 this.timeout(120_000)
318 '1080p': true, // the resulting resolution shouldn't be higher than this, and not vp9.2/av01
322 webtorrent: { enabled: true },
323 hls: { enabled: false }
336 await updateCustomSubConfig(servers[0].url, servers[0].accessToken, config)
340 targetUrl: getYoutubeHDRVideoUrl(),
341 channelId: channelIdServer1,
342 privacy: VideoPrivacy.PUBLIC
344 const res1 = await importVideo(servers[0].url, servers[0].accessToken, attributes)
345 const videoUUID = res1.body.video.uuid
347 await waitJobs(servers)
350 const res2 = await getVideo(servers[0].url, videoUUID)
351 const video: VideoDetails = res2.body
352 expect(video.name).to.equal('hdr video')
353 const maxResolution = Math.max.apply(Math, video.files.map(function (o) { return o.resolution.id }))
354 expect(maxResolution, 'expected max resolution not met').to.equals(VideoResolution.H_1080P)
357 after(async function () {
358 await cleanupTests(servers)