/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import * as chai from 'chai'
import 'mocha'
-import { VideoDetails, VideoImport, VideoPrivacy, VideoCaption } from '../../../../shared/models/videos'
+import * as chai from 'chai'
import {
cleanupTests,
doubleFollow,
getMyVideos,
getVideo,
getVideosList,
- listVideoCaptions,
- testCaptionFile,
immutableAssign,
ServerInfo,
- setAccessTokensToServers
+ setAccessTokensToServers,
+ testCaptionFile
} from '../../../../shared/extra-utils'
+import { areHttpImportTestsDisabled, testImage } from '../../../../shared/extra-utils/miscs/miscs'
import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
-import { getMagnetURI, getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
-import { testImage } from '../../../../shared/extra-utils/miscs/miscs'
+import {
+ getMagnetURI,
+ getMyVideoImports,
+ getYoutubeHDRVideoUrl,
+ getYoutubeVideoUrl,
+ importVideo
+} from '../../../../shared/extra-utils/videos/video-imports'
+import { VideoDetails, VideoImport, VideoPrivacy, VideoResolution } from '../../../../shared/models/videos'
const expect = chai.expect
let channelIdServer1: number
let channelIdServer2: number
- async function checkVideosServer1 (url: string, idHttp: string, idMagnet: string, idTorrent: string) {
- const resHttp = await getVideo(url, idHttp)
+ if (areHttpImportTestsDisabled()) return
+
+ async function checkVideosServer1 (server: ServerInfo, idHttp: string, idMagnet: string, idTorrent: string) {
+ const resHttp = await getVideo(server.url, idHttp)
const videoHttp: VideoDetails = resHttp.body
expect(videoHttp.name).to.equal('small video - youtube')
expect(originallyPublishedAt.getMonth()).to.equal(0)
expect(originallyPublishedAt.getFullYear()).to.equal(2019)
- const resMagnet = await getVideo(url, idMagnet)
+ const resMagnet = await getVideo(server.url, idMagnet)
const videoMagnet: VideoDetails = resMagnet.body
- const resTorrent = await getVideo(url, idTorrent)
+ const resTorrent = await getVideo(server.url, idTorrent)
const videoTorrent: VideoDetails = resTorrent.body
for (const video of [ videoMagnet, videoTorrent ]) {
expect(videoTorrent.name).to.contain('你好 世界 720p.mp4')
expect(videoMagnet.name).to.contain('super peertube2 video')
- const resCaptions = await listVideoCaptions(url, idHttp)
- expect(resCaptions.body.total).to.equal(2)
+ const bodyCaptions = await server.captionsCommand.listVideoCaptions({ videoId: idHttp })
+ expect(bodyCaptions.total).to.equal(2)
}
- async function checkVideoServer2 (url: string, id: number | string) {
- const res = await getVideo(url, id)
+ async function checkVideoServer2 (server: ServerInfo, id: number | string) {
+ const res = await getVideo(server.url, id)
const video: VideoDetails = res.body
expect(video.name).to.equal('my super name')
expect(video.files).to.have.lengthOf(1)
- const resCaptions = await listVideoCaptions(url, id)
- expect(resCaptions.body.total).to.equal(2)
+ const bodyCaptions = await server.captionsCommand.listVideoCaptions({ videoId: id })
+ expect(bodyCaptions.total).to.equal(2)
}
before(async function () {
- this.timeout(30000)
+ this.timeout(30_000)
// Run servers
servers = await flushAndRunMultipleServers(2)
})
it('Should import videos on server 1', async function () {
- this.timeout(60000)
+ this.timeout(60_000)
const baseAttributes = {
channelId: channelIdServer1,
const attributes = immutableAssign(baseAttributes, { targetUrl: getYoutubeVideoUrl() })
const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
expect(res.body.video.name).to.equal('small video - youtube')
- expect(res.body.video.thumbnailPath).to.equal(`/static/thumbnails/${res.body.video.uuid}.jpg`)
- expect(res.body.video.previewPath).to.equal(`/static/previews/${res.body.video.uuid}.jpg`)
+
+ expect(res.body.video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
+ expect(res.body.video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
+
await testImage(servers[0].url, 'video_import_thumbnail', res.body.video.thumbnailPath)
await testImage(servers[0].url, 'video_import_preview', res.body.video.previewPath)
- const resCaptions = await listVideoCaptions(servers[0].url, res.body.video.id)
- const videoCaptions: VideoCaption[] = resCaptions.body.data
+ const bodyCaptions = await servers[0].captionsCommand.listVideoCaptions({ videoId: res.body.video.id })
+ const videoCaptions = bodyCaptions.data
expect(videoCaptions).to.have.lengthOf(2)
const enCaption = videoCaptions.find(caption => caption.language.id === 'en')
expect(enCaption).to.exist
expect(enCaption.language.label).to.equal('English')
- expect(enCaption.captionPath).to.equal(`/static/video-captions/${res.body.video.uuid}-en.vtt`)
+ expect(enCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-en.vtt$`))
await testCaptionFile(servers[0].url, enCaption.captionPath, `WEBVTT
Kind: captions
Language: en
const frCaption = videoCaptions.find(caption => caption.language.id === 'fr')
expect(frCaption).to.exist
expect(frCaption.language.label).to.equal('French')
- expect(frCaption.captionPath).to.equal(`/static/video-captions/${res.body.video.uuid}-fr.vtt`)
+ expect(frCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-fr.vtt`))
await testCaptionFile(servers[0].url, frCaption.captionPath, `WEBVTT
Kind: captions
Language: fr
})
it('Should have the video listed on the two instances', async function () {
- this.timeout(120000)
+ this.timeout(120_000)
await waitJobs(servers)
expect(res.body.data).to.have.lengthOf(3)
const [ videoHttp, videoMagnet, videoTorrent ] = res.body.data
- await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+ await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
}
})
it('Should import a video on server 2 with some fields', async function () {
- this.timeout(60000)
+ this.timeout(60_000)
const attributes = {
targetUrl: getYoutubeVideoUrl(),
})
it('Should have the videos listed on the two instances', async function () {
- this.timeout(120000)
+ this.timeout(120_000)
await waitJobs(servers)
expect(res.body.total).to.equal(4)
expect(res.body.data).to.have.lengthOf(4)
- await checkVideoServer2(server.url, res.body.data[0].uuid)
+ await checkVideoServer2(server, res.body.data[0].uuid)
const [ , videoHttp, videoMagnet, videoTorrent ] = res.body.data
- await checkVideosServer1(server.url, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
+ await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
}
})
it('Should import a video that will be transcoded', async function () {
- this.timeout(120000)
+ this.timeout(120_000)
const attributes = {
name: 'transcoded video',
}
})
+ it('Should import no HDR version on a HDR video', async function () {
+ this.timeout(120_000)
+
+ const config = {
+ transcoding: {
+ enabled: true,
+ resolutions: {
+ '240p': false,
+ '360p': false,
+ '480p': false,
+ '720p': false,
+ '1080p': true, // the resulting resolution shouldn't be higher than this, and not vp9.2/av01
+ '1440p': false,
+ '2160p': false
+ },
+ webtorrent: { enabled: true },
+ hls: { enabled: false }
+ },
+ import: {
+ videos: {
+ http: {
+ enabled: true
+ },
+ torrent: {
+ enabled: true
+ }
+ }
+ }
+ }
+ await servers[0].configCommand.updateCustomSubConfig({ newConfig: config })
+
+ const attributes = {
+ name: 'hdr video',
+ targetUrl: getYoutubeHDRVideoUrl(),
+ channelId: channelIdServer1,
+ privacy: VideoPrivacy.PUBLIC
+ }
+ const res1 = await importVideo(servers[0].url, servers[0].accessToken, attributes)
+ const videoUUID = res1.body.video.uuid
+
+ await waitJobs(servers)
+
+ // test resolution
+ const res2 = await getVideo(servers[0].url, videoUUID)
+ const video: VideoDetails = res2.body
+ expect(video.name).to.equal('hdr video')
+ const maxResolution = Math.max.apply(Math, video.files.map(function (o) { return o.resolution.id }))
+ expect(maxResolution, 'expected max resolution not met').to.equals(VideoResolution.H_1080P)
+ })
+
after(async function () {
await cleanupTests(servers)
})