server/tests/api/videos/video-imports.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import {
   6   areHttpImportTestsDisabled,
   7   cleanupTests,
   8   doubleFollow,
   9   flushAndRunMultipleServers,
  10   getMyVideos,
  11   getVideo,
  12   getVideosList,
  13   ImportsCommand,
  14   ServerInfo,
  15   setAccessTokensToServers,
  16   testCaptionFile,
  17   testImage,
  18   waitJobs
  19 } from '@shared/extra-utils'
  20 import { VideoDetails, VideoPrivacy, VideoResolution } from '@shared/models'
  21
  22 const expect = chai.expect
  23
  24 describe('Test video imports', function () {
  25   let servers: ServerInfo[] = []
  26   let channelIdServer1: number
  27   let channelIdServer2: number
  28
  29   if (areHttpImportTestsDisabled()) return
  30
  31   async function checkVideosServer1 (server: ServerInfo, idHttp: string, idMagnet: string, idTorrent: string) {
  32     const resHttp = await getVideo(server.url, idHttp)
  33     const videoHttp: VideoDetails = resHttp.body
  34
  35     expect(videoHttp.name).to.equal('small video - youtube')
  36     // FIXME: youtube-dl seems broken
  37     // expect(videoHttp.category.label).to.equal('News & Politics')
  38     // expect(videoHttp.licence.label).to.equal('Attribution')
  39     expect(videoHttp.language.label).to.equal('Unknown')
  40     expect(videoHttp.nsfw).to.be.false
  41     expect(videoHttp.description).to.equal('this is a super description')
  42     expect(videoHttp.tags).to.deep.equal([ 'tag1', 'tag2' ])
  43     expect(videoHttp.files).to.have.lengthOf(1)
  44
  45     const originallyPublishedAt = new Date(videoHttp.originallyPublishedAt)
  46     expect(originallyPublishedAt.getDate()).to.equal(14)
  47     expect(originallyPublishedAt.getMonth()).to.equal(0)
  48     expect(originallyPublishedAt.getFullYear()).to.equal(2019)
  49
  50     const resMagnet = await getVideo(server.url, idMagnet)
  51     const videoMagnet: VideoDetails = resMagnet.body
  52     const resTorrent = await getVideo(server.url, idTorrent)
  53     const videoTorrent: VideoDetails = resTorrent.body
  54
  55     for (const video of [ videoMagnet, videoTorrent ]) {
  56       expect(video.category.label).to.equal('Misc')
  57       expect(video.licence.label).to.equal('Unknown')
  58       expect(video.language.label).to.equal('Unknown')
  59       expect(video.nsfw).to.be.false
  60       expect(video.description).to.equal('this is a super torrent description')
  61       expect(video.tags).to.deep.equal([ 'tag_torrent1', 'tag_torrent2' ])
  62       expect(video.files).to.have.lengthOf(1)
  63     }
  64
  65     expect(videoTorrent.name).to.contain('你好 世界 720p.mp4')
  66     expect(videoMagnet.name).to.contain('super peertube2 video')
  67
  68     const bodyCaptions = await server.captionsCommand.listVideoCaptions({ videoId: idHttp })
  69     expect(bodyCaptions.total).to.equal(2)
  70   }
  71
  72   async function checkVideoServer2 (server: ServerInfo, id: number | string) {
  73     const res = await getVideo(server.url, id)
  74     const video: VideoDetails = res.body
  75
  76     expect(video.name).to.equal('my super name')
  77     expect(video.category.label).to.equal('Entertainment')
  78     expect(video.licence.label).to.equal('Public Domain Dedication')
  79     expect(video.language.label).to.equal('English')
  80     expect(video.nsfw).to.be.false
  81     expect(video.description).to.equal('my super description')
  82     expect(video.tags).to.deep.equal([ 'supertag1', 'supertag2' ])
  83
  84     expect(video.files).to.have.lengthOf(1)
  85
  86     const bodyCaptions = await server.captionsCommand.listVideoCaptions({ videoId: id })
  87     expect(bodyCaptions.total).to.equal(2)
  88   }
  89
  90   before(async function () {
  91     this.timeout(30_000)
  92
  93     // Run servers
  94     servers = await flushAndRunMultipleServers(2)
  95
  96     await setAccessTokensToServers(servers)
  97
  98     {
  99       const { videoChannels } = await servers[0].usersCommand.getMyInfo()
 100       channelIdServer1 = videoChannels[0].id
 101     }
 102
 103     {
 104       const { videoChannels } = await servers[1].usersCommand.getMyInfo()
 105       channelIdServer2 = videoChannels[0].id
 106     }
 107
 108     await doubleFollow(servers[0], servers[1])
 109   })
 110
 111   it('Should import videos on server 1', async function () {
 112     this.timeout(60_000)
 113
 114     const baseAttributes = {
 115       channelId: channelIdServer1,
 116       privacy: VideoPrivacy.PUBLIC
 117     }
 118
 119     {
 120       const attributes = { ...baseAttributes, targetUrl: ImportsCommand.getYoutubeVideoUrl() }
 121       const { video } = await servers[0].importsCommand.importVideo({ attributes })
 122       expect(video.name).to.equal('small video - youtube')
 123
 124       expect(video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
 125       expect(video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
 126
 127       await testImage(servers[0].url, 'video_import_thumbnail', video.thumbnailPath)
 128       await testImage(servers[0].url, 'video_import_preview', video.previewPath)
 129
 130       const bodyCaptions = await servers[0].captionsCommand.listVideoCaptions({ videoId: video.id })
 131       const videoCaptions = bodyCaptions.data
 132       expect(videoCaptions).to.have.lengthOf(2)
 133
 134       const enCaption = videoCaptions.find(caption => caption.language.id === 'en')
 135       expect(enCaption).to.exist
 136       expect(enCaption.language.label).to.equal('English')
 137       expect(enCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-en.vtt$`))
 138       await testCaptionFile(servers[0].url, enCaption.captionPath, `WEBVTT
 139 Kind: captions
 140 Language: en
 141
 142 00:00:01.600 --> 00:00:04.200
 143 English (US)
 144
 145 00:00:05.900 --> 00:00:07.999
 146 This is a subtitle in American English
 147
 148 00:00:10.000 --> 00:00:14.000
 149 Adding subtitles is very easy to do`)
 150
 151       const frCaption = videoCaptions.find(caption => caption.language.id === 'fr')
 152       expect(frCaption).to.exist
 153       expect(frCaption.language.label).to.equal('French')
 154       expect(frCaption.captionPath).to.match(new RegExp(`^/lazy-static/video-captions/.+-fr.vtt`))
 155       await testCaptionFile(servers[0].url, frCaption.captionPath, `WEBVTT
 156 Kind: captions
 157 Language: fr
 158
 159 00:00:01.600 --> 00:00:04.200
 160 Français (FR)
 161
 162 00:00:05.900 --> 00:00:07.999
 163 C'est un sous-titre français
 164
 165 00:00:10.000 --> 00:00:14.000
 166 Ajouter un sous-titre est vraiment facile`)
 167     }
 168
 169     {
 170       const attributes = {
 171         ...baseAttributes,
 172         magnetUri: ImportsCommand.getMagnetURI(),
 173         description: 'this is a super torrent description',
 174         tags: [ 'tag_torrent1', 'tag_torrent2' ]
 175       }
 176       const { video } = await servers[0].importsCommand.importVideo({ attributes })
 177       expect(video.name).to.equal('super peertube2 video')
 178     }
 179
 180     {
 181       const attributes = {
 182         ...baseAttributes,
 183         torrentfile: 'video-720p.torrent' as any,
 184         description: 'this is a super torrent description',
 185         tags: [ 'tag_torrent1', 'tag_torrent2' ]
 186       }
 187       const { video } = await servers[0].importsCommand.importVideo({ attributes })
 188       expect(video.name).to.equal('你好 世界 720p.mp4')
 189     }
 190   })
 191
 192   it('Should list the videos to import in my videos on server 1', async function () {
 193     const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 5, 'createdAt')
 194
 195     expect(res.body.total).to.equal(3)
 196
 197     const videos = res.body.data
 198     expect(videos).to.have.lengthOf(3)
 199     expect(videos[0].name).to.equal('small video - youtube')
 200     expect(videos[1].name).to.equal('super peertube2 video')
 201     expect(videos[2].name).to.equal('你好 世界 720p.mp4')
 202   })
 203
 204   it('Should list the videos to import in my imports on server 1', async function () {
 205     const { total, data: videoImports } = await servers[0].importsCommand.getMyVideoImports({ sort: '-createdAt' })
 206     expect(total).to.equal(3)
 207
 208     expect(videoImports).to.have.lengthOf(3)
 209
 210     expect(videoImports[2].targetUrl).to.equal(ImportsCommand.getYoutubeVideoUrl())
 211     expect(videoImports[2].magnetUri).to.be.null
 212     expect(videoImports[2].torrentName).to.be.null
 213     expect(videoImports[2].video.name).to.equal('small video - youtube')
 214
 215     expect(videoImports[1].targetUrl).to.be.null
 216     expect(videoImports[1].magnetUri).to.equal(ImportsCommand.getMagnetURI())
 217     expect(videoImports[1].torrentName).to.be.null
 218     expect(videoImports[1].video.name).to.equal('super peertube2 video')
 219
 220     expect(videoImports[0].targetUrl).to.be.null
 221     expect(videoImports[0].magnetUri).to.be.null
 222     expect(videoImports[0].torrentName).to.equal('video-720p.torrent')
 223     expect(videoImports[0].video.name).to.equal('你好 世界 720p.mp4')
 224   })
 225
 226   it('Should have the video listed on the two instances', async function () {
 227     this.timeout(120_000)
 228
 229     await waitJobs(servers)
 230
 231     for (const server of servers) {
 232       const res = await getVideosList(server.url)
 233       expect(res.body.total).to.equal(3)
 234       expect(res.body.data).to.have.lengthOf(3)
 235
 236       const [ videoHttp, videoMagnet, videoTorrent ] = res.body.data
 237       await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
 238     }
 239   })
 240
 241   it('Should import a video on server 2 with some fields', async function () {
 242     this.timeout(60_000)
 243
 244     const attributes = {
 245       targetUrl: ImportsCommand.getYoutubeVideoUrl(),
 246       channelId: channelIdServer2,
 247       privacy: VideoPrivacy.PUBLIC,
 248       category: 10,
 249       licence: 7,
 250       language: 'en',
 251       name: 'my super name',
 252       description: 'my super description',
 253       tags: [ 'supertag1', 'supertag2' ]
 254     }
 255     const { video } = await servers[1].importsCommand.importVideo({ attributes })
 256     expect(video.name).to.equal('my super name')
 257   })
 258
 259   it('Should have the videos listed on the two instances', async function () {
 260     this.timeout(120_000)
 261
 262     await waitJobs(servers)
 263
 264     for (const server of servers) {
 265       const res = await getVideosList(server.url)
 266       expect(res.body.total).to.equal(4)
 267       expect(res.body.data).to.have.lengthOf(4)
 268
 269       await checkVideoServer2(server, res.body.data[0].uuid)
 270
 271       const [ , videoHttp, videoMagnet, videoTorrent ] = res.body.data
 272       await checkVideosServer1(server, videoHttp.uuid, videoMagnet.uuid, videoTorrent.uuid)
 273     }
 274   })
 275
 276   it('Should import a video that will be transcoded', async function () {
 277     this.timeout(120_000)
 278
 279     const attributes = {
 280       name: 'transcoded video',
 281       magnetUri: ImportsCommand.getMagnetURI(),
 282       channelId: channelIdServer2,
 283       privacy: VideoPrivacy.PUBLIC
 284     }
 285     const { video } = await servers[1].importsCommand.importVideo({ attributes })
 286     const videoUUID = video.uuid
 287
 288     await waitJobs(servers)
 289
 290     for (const server of servers) {
 291       const res = await getVideo(server.url, videoUUID)
 292       const video: VideoDetails = res.body
 293
 294       expect(video.name).to.equal('transcoded video')
 295       expect(video.files).to.have.lengthOf(4)
 296     }
 297   })
 298
 299   it('Should import no HDR version on a HDR video', async function () {
 300     this.timeout(120_000)
 301
 302     const config = {
 303       transcoding: {
 304         enabled: true,
 305         resolutions: {
 306           '240p': false,
 307           '360p': false,
 308           '480p': false,
 309           '720p': false,
 310           '1080p': true, // the resulting resolution shouldn't be higher than this, and not vp9.2/av01
 311           '1440p': false,
 312           '2160p': false
 313         },
 314         webtorrent: { enabled: true },
 315         hls: { enabled: false }
 316       },
 317       import: {
 318         videos: {
 319           http: {
 320             enabled: true
 321           },
 322           torrent: {
 323             enabled: true
 324           }
 325         }
 326       }
 327     }
 328     await servers[0].configCommand.updateCustomSubConfig({ newConfig: config })
 329
 330     const attributes = {
 331       name: 'hdr video',
 332       targetUrl: ImportsCommand.getYoutubeHDRVideoUrl(),
 333       channelId: channelIdServer1,
 334       privacy: VideoPrivacy.PUBLIC
 335     }
 336     const { video: videoImported } = await servers[0].importsCommand.importVideo({ attributes })
 337     const videoUUID = videoImported.uuid
 338
 339     await waitJobs(servers)
 340
 341     // test resolution
 342     const res2 = await getVideo(servers[0].url, videoUUID)
 343     const video: VideoDetails = res2.body
 344     expect(video.name).to.equal('hdr video')
 345     const maxResolution = Math.max.apply(Math, video.files.map(function (o) { return o.resolution.id }))
 346     expect(maxResolution, 'expected max resolution not met').to.equals(VideoResolution.H_1080P)
 347   })
 348
 349   after(async function () {
 350     await cleanupTests(servers)
 351   })
 352 })