21 files changed, 177 insertions, 189 deletions

diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 3c752cc3e..7f825f79e 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -345,7 +345,7 @@ describe('Test config API validators', function () {
       })
     })
 
-    it('Should fail with a disabled webtorrent & hls transcoding', async function () {
+    it('Should fail with a disabled web videos & hls transcoding', async function () {
       const newUpdateParams = {
         ...updateParams,
 
diff --git a/server/tests/api/check-params/transcoding.ts b/server/tests/api/check-params/transcoding.ts
index 9846ac182..4bebcb528 100644
--- a/server/tests/api/check-params/transcoding.ts
+++ b/server/tests/api/check-params/transcoding.ts
@@ -49,21 +49,21 @@ describe('Test transcoding API validators', function () {
 
   it('Should not run transcoding of a unknown video', async function () {
     await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'hls', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-    await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'webtorrent', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'web-video', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
   })
 
   it('Should not run transcoding of a remote video', async function () {
     const expectedStatus = HttpStatusCode.BAD_REQUEST_400
 
     await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'hls', expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'web-video', expectedStatus })
   })
 
   it('Should not run transcoding by a non admin user', async function () {
     const expectedStatus = HttpStatusCode.FORBIDDEN_403
 
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls', token: userToken, expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', token: moderatorToken, expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', token: moderatorToken, expectedStatus })
   })
 
   it('Should not run transcoding without transcoding type', async function () {
@@ -82,7 +82,7 @@ describe('Test transcoding API validators', function () {
     await servers[0].config.disableTranscoding()
 
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls', expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', expectedStatus })
   })
 
   it('Should run transcoding', async function () {
@@ -93,15 +93,15 @@ describe('Test transcoding API validators', function () {
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls' })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video' })
     await waitJobs(servers)
   })
 
   it('Should not run transcoding on a video that is already being transcoded', async function () {
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video' })
 
     const expectedStatus = HttpStatusCode.CONFLICT_409
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', expectedStatus })
   })
 
   after(async function () {
diff --git a/server/tests/api/check-params/video-files.ts b/server/tests/api/check-params/video-files.ts
index 9dc59a1b5..4d43ab6f8 100644
--- a/server/tests/api/check-params/video-files.ts
+++ b/server/tests/api/check-params/video-files.ts
@@ -60,7 +60,7 @@ describe('Test videos files', function () {
   })
 
   describe('Deleting files', function () {
-    let webtorrentId: string
+    let webVideoId: string
     let hlsId: string
     let remoteId: string
 
@@ -68,10 +68,10 @@ describe('Test videos files', function () {
     let validId2: string
 
     let hlsFileId: number
-    let webtorrentFileId: number
+    let webVideoFileId: number
 
     let remoteHLSFileId: number
-    let remoteWebtorrentFileId: number
+    let remoteWebVideoFileId: number
 
     before(async function () {
       this.timeout(300_000)
@@ -83,7 +83,7 @@ describe('Test videos files', function () {
         const video = await servers[1].videos.get({ id: uuid })
         remoteId = video.uuid
         remoteHLSFileId = video.streamingPlaylists[0].files[0].id
-        remoteWebtorrentFileId = video.files[0].id
+        remoteWebVideoFileId = video.files[0].id
       }
 
       {
@@ -96,7 +96,7 @@ describe('Test videos files', function () {
           const video = await servers[0].videos.get({ id: uuid })
           validId1 = video.uuid
           hlsFileId = video.streamingPlaylists[0].files[0].id
-          webtorrentFileId = video.files[0].id
+          webVideoFileId = video.files[0].id
         }
 
         {
@@ -117,8 +117,8 @@ describe('Test videos files', function () {
 
       {
         await servers[0].config.enableTranscoding(false, true)
-        const { uuid } = await servers[0].videos.quickUpload({ name: 'webtorrent' })
-        webtorrentId = uuid
+        const { uuid } = await servers[0].videos.quickUpload({ name: 'web-video' })
+        webVideoId = uuid
       }
 
       await waitJobs(servers)
@@ -128,27 +128,27 @@ describe('Test videos files', function () {
       const expectedStatus = HttpStatusCode.NOT_FOUND_404
 
       await servers[0].videos.removeHLSPlaylist({ videoId: 404, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: 404, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: 404, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: 404, fileId: hlsFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: 404, fileId: webtorrentFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: 404, fileId: webVideoFileId, expectedStatus })
     })
 
     it('Should not delete unknown files', async function () {
       const expectedStatus = HttpStatusCode.NOT_FOUND_404
 
-      await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: webtorrentFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: hlsFileId, expectedStatus })
+      await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: webVideoFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: hlsFileId, expectedStatus })
     })
 
     it('Should not delete files of a remote video', async function () {
       const expectedStatus = HttpStatusCode.BAD_REQUEST_400
 
       await servers[0].videos.removeHLSPlaylist({ videoId: remoteId, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: remoteId, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: remoteId, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: remoteId, fileId: remoteHLSFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: remoteId, fileId: remoteWebtorrentFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: remoteId, fileId: remoteWebVideoFileId, expectedStatus })
     })
 
     it('Should not delete files by a non admin user', async function () {
@@ -157,35 +157,35 @@ describe('Test videos files', function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1, token: userToken, expectedStatus })
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1, token: moderatorToken, expectedStatus })
 
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1, token: userToken, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1, token: moderatorToken, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1, token: userToken, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1, token: moderatorToken, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId, token: userToken, expectedStatus })
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId, token: moderatorToken, expectedStatus })
 
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId, token: userToken, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId, token: moderatorToken, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId, token: userToken, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId, token: moderatorToken, expectedStatus })
     })
 
     it('Should not delete files if the files are not available', async function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: hlsId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: webtorrentId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: webVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
       await servers[0].videos.removeHLSFile({ videoId: hlsId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should not delete files if no both versions are available', async function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: hlsId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: webtorrentId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: webVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should delete files if both versions are available', async function () {
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId })
 
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId2 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId2 })
     })
   })
 
diff --git a/server/tests/api/object-storage/video-static-file-privacy.ts b/server/tests/api/object-storage/video-static-file-privacy.ts
index 2a7c3381d..18d30a2f5 100644
--- a/server/tests/api/object-storage/video-static-file-privacy.ts
+++ b/server/tests/api/object-storage/video-static-file-privacy.ts
@@ -120,7 +120,7 @@ describe('Object storage for video static file privacy', function () {
       const video = await server.videos.getWithToken({ id: videoId })
 
       return {
-        webTorrentFile: video.files[0].fileUrl,
+        webVideoFile: video.files[0].fileUrl,
         hlsFile: getHLS(video).files[0].fileUrl
       }
     }
@@ -175,10 +175,10 @@ describe('Object storage for video static file privacy', function () {
     it('Should not get files without appropriate OAuth token', async function () {
       this.timeout(60000)
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
 
-      await makeRawRequest({ url: webTorrentFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({ url: webTorrentFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
 
       await makeRawRequest({ url: hlsFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
       await makeRawRequest({ url: hlsFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
@@ -187,18 +187,18 @@ describe('Object storage for video static file privacy', function () {
     it('Should not get files without appropriate password or appropriate OAuth token', async function () {
       this.timeout(60000)
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
 
-      await makeRawRequest({ url: webTorrentFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
       await makeRawRequest({
-        url: webTorrentFile,
+        url: webVideoFile,
         token: null,
         headers: incorrectPasswordHeader,
         expectedStatus: HttpStatusCode.FORBIDDEN_403
       })
-      await makeRawRequest({ url: webTorrentFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
       await makeRawRequest({
-        url: webTorrentFile,
+        url: webVideoFile,
         token: null,
         headers: correctPasswordHeader,
         expectedStatus: HttpStatusCode.OK_200
@@ -239,9 +239,9 @@ describe('Object storage for video static file privacy', function () {
       const badVideoFileToken = await server.videoToken.getVideoFileToken({ token: userToken, videoId: userPrivateVideoUUID })
       const goodVideoFileToken = await server.videoToken.getVideoFileToken({ videoId: privateVideoUUID })
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
 
-      for (const url of [ webTorrentFile, hlsFile ]) {
+      for (const url of [ webVideoFile, hlsFile ]) {
         await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
@@ -261,9 +261,9 @@ describe('Object storage for video static file privacy', function () {
         videoPassword: correctPassword
       })
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
 
-      for (const url of [ hlsFile, webTorrentFile ]) {
+      for (const url of [ hlsFile, webVideoFile ]) {
         await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
@@ -534,11 +534,11 @@ describe('Object storage for video static file privacy', function () {
 
     it('Should not be able to access object storage proxy', async function () {
       const privateVideo = await server.videos.getWithToken({ id: videoUUID })
-      const webtorrentFilename = extractFilenameFromUrl(privateVideo.files[0].fileUrl)
+      const webVideoFilename = extractFilenameFromUrl(privateVideo.files[0].fileUrl)
       const hlsFilename = extractFilenameFromUrl(getHLS(privateVideo).files[0].fileUrl)
 
       await makeRawRequest({
-        url: server.url + '/object-storage-proxy/webseed/private/' + webtorrentFilename,
+        url: server.url + '/object-storage-proxy/webseed/private/' + webVideoFilename,
         token: server.accessToken,
         expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
diff --git a/server/tests/api/object-storage/videos.ts b/server/tests/api/object-storage/videos.ts
index f837d9966..c4f72bbe4 100644
--- a/server/tests/api/object-storage/videos.ts
+++ b/server/tests/api/object-storage/videos.ts
@@ -41,8 +41,8 @@ async function checkFiles (options: {
   playlistBucket: string
   playlistPrefix?: string
 
-  webtorrentBucket: string
-  webtorrentPrefix?: string
+  webVideoBucket: string
+  webVideoPrefix?: string
 }) {
   const {
     server,
@@ -50,20 +50,20 @@ async function checkFiles (options: {
     originSQLCommand,
     video,
     playlistBucket,
-    webtorrentBucket,
+    webVideoBucket,
     baseMockUrl,
     playlistPrefix,
-    webtorrentPrefix
+    webVideoPrefix
   } = options
 
   let allFiles = video.files
 
   for (const file of video.files) {
     const baseUrl = baseMockUrl
-      ? `${baseMockUrl}/${webtorrentBucket}/`
-      : `http://${webtorrentBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
+      ? `${baseMockUrl}/${webVideoBucket}/`
+      : `http://${webVideoBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
 
-    const prefix = webtorrentPrefix || ''
+    const prefix = webVideoPrefix || ''
     const start = baseUrl + prefix
 
     expectStartWith(file.fileUrl, start)
@@ -134,8 +134,8 @@ function runTestSuite (options: {
   playlistBucket: string
   playlistPrefix?: string
 
-  webtorrentBucket: string
-  webtorrentPrefix?: string
+  webVideoBucket: string
+  webVideoPrefix?: string
 
   useMockBaseUrl?: boolean
 }) {
@@ -161,7 +161,7 @@ function runTestSuite (options: {
       : undefined
 
     await objectStorage.createMockBucket(options.playlistBucket)
-    await objectStorage.createMockBucket(options.webtorrentBucket)
+    await objectStorage.createMockBucket(options.webVideoBucket)
 
     const config = {
       object_storage: {
@@ -182,10 +182,10 @@ function runTestSuite (options: {
         },
 
         videos: {
-          bucket_name: options.webtorrentBucket,
-          prefix: options.webtorrentPrefix,
+          bucket_name: options.webVideoBucket,
+          prefix: options.webVideoPrefix,
           base_url: baseMockUrl
-            ? `${baseMockUrl}/${options.webtorrentBucket}`
+            ? `${baseMockUrl}/${options.webVideoBucket}`
             : undefined
         }
       }
@@ -386,27 +386,27 @@ describe('Object storage for videos', function () {
   describe('Test simple object storage', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webtorrentBucket: objectStorage.getMockBucketName('videos')
+      webVideoBucket: objectStorage.getMockBucketName('videos')
     })
   })
 
   describe('Test object storage with prefix', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webtorrentBucket: objectStorage.getMockBucketName('mybucket'),
+      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
 
       playlistPrefix: 'streaming-playlists_',
-      webtorrentPrefix: 'webtorrent_'
+      webVideoPrefix: 'webvideo_'
     })
   })
 
   describe('Test object storage with prefix and base URL', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webtorrentBucket: objectStorage.getMockBucketName('mybucket'),
+      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
 
       playlistPrefix: 'streaming-playlists/',
-      webtorrentPrefix: 'webtorrent/',
+      webVideoPrefix: 'webvideo/',
 
       useMockBaseUrl: true
     })
@@ -431,7 +431,7 @@ describe('Object storage for videos', function () {
     runTestSuite({
       maxUploadPart,
       playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webtorrentBucket: objectStorage.getMockBucketName('videos'),
+      webVideoBucket: objectStorage.getMockBucketName('videos'),
       fixture
     })
   })
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
index 5262c503f..b35059c29 100644
--- a/server/tests/api/redundancy/redundancy.ts
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -43,7 +43,7 @@ async function checkMagnetWebseeds (file: VideoFile, baseWebseeds: string[], ser
   }
 }
 
-async function createServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
+async function createServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebVideo = true) {
   const strategies: any[] = []
 
   if (strategy !== null) {
@@ -61,7 +61,7 @@ async function createServers (strategy: VideoRedundancyStrategy | null, addition
   const config = {
     transcoding: {
       webtorrent: {
-        enabled: withWebtorrent
+        enabled: withWebVideo
       },
       hls: {
         enabled: true
@@ -100,7 +100,7 @@ async function createServers (strategy: VideoRedundancyStrategy | null, addition
 }
 
 async function ensureSameFilenames (videoUUID: string) {
-  let webtorrentFilenames: string[]
+  let webVideoFilenames: string[]
   let hlsFilenames: string[]
 
   for (const server of servers) {
@@ -108,17 +108,17 @@ async function ensureSameFilenames (videoUUID: string) {
 
     // Ensure we use the same filenames that the origin
 
-    const localWebtorrentFilenames = video.files.map(f => basename(f.fileUrl)).sort()
+    const localWebVideoFilenames = video.files.map(f => basename(f.fileUrl)).sort()
     const localHLSFilenames = video.streamingPlaylists[0].files.map(f => basename(f.fileUrl)).sort()
 
-    if (webtorrentFilenames) expect(webtorrentFilenames).to.deep.equal(localWebtorrentFilenames)
-    else webtorrentFilenames = localWebtorrentFilenames
+    if (webVideoFilenames) expect(webVideoFilenames).to.deep.equal(localWebVideoFilenames)
+    else webVideoFilenames = localWebVideoFilenames
 
     if (hlsFilenames) expect(hlsFilenames).to.deep.equal(localHLSFilenames)
     else hlsFilenames = localHLSFilenames
   }
 
-  return { webtorrentFilenames, hlsFilenames }
+  return { webVideoFilenames, hlsFilenames }
 }
 
 async function check1WebSeed (videoUUID?: string) {
@@ -156,7 +156,7 @@ async function check2Webseeds (videoUUID?: string) {
     }
   }
 
-  const { webtorrentFilenames } = await ensureSameFilenames(videoUUID)
+  const { webVideoFilenames } = await ensureSameFilenames(videoUUID)
 
   const directories = [
     servers[0].getDirectoryPath('redundancy'),
@@ -168,7 +168,7 @@ async function check2Webseeds (videoUUID?: string) {
     expect(files).to.have.length.at.least(4)
 
     // Ensure we files exist on disk
-    expect(files.find(f => webtorrentFilenames.includes(f))).to.exist
+    expect(files.find(f => webVideoFilenames.includes(f))).to.exist
   }
 }
 
diff --git a/server/tests/api/transcoding/audio-only.ts b/server/tests/api/transcoding/audio-only.ts
index 1e31418e7..aa1113fc1 100644
--- a/server/tests/api/transcoding/audio-only.ts
+++ b/server/tests/api/transcoding/audio-only.ts
@@ -14,7 +14,7 @@ import {
 describe('Test audio only video transcoding', function () {
   let servers: PeerTubeServer[] = []
   let videoUUID: string
-  let webtorrentAudioFileUrl: string
+  let webVideoAudioFileUrl: string
   let fragmentedAudioFileUrl: string
 
   before(async function () {
@@ -71,7 +71,7 @@ describe('Test audio only video transcoding', function () {
       }
 
       if (server.serverNumber === 1) {
-        webtorrentAudioFileUrl = video.files[2].fileUrl
+        webVideoAudioFileUrl = video.files[2].fileUrl
         fragmentedAudioFileUrl = video.streamingPlaylists[0].files[2].fileUrl
       }
     }
@@ -79,7 +79,7 @@ describe('Test audio only video transcoding', function () {
 
   it('0p transcoded video should not have video', async function () {
     const paths = [
-      servers[0].servers.buildWebTorrentFilePath(webtorrentAudioFileUrl),
+      servers[0].servers.buildWebVideoFilePath(webVideoAudioFileUrl),
       servers[0].servers.buildFragmentedFilePath(videoUUID, fragmentedAudioFileUrl)
     ]
 
diff --git a/server/tests/api/transcoding/create-transcoding.ts b/server/tests/api/transcoding/create-transcoding.ts
index d6f5b01dc..21a63f547 100644
--- a/server/tests/api/transcoding/create-transcoding.ts
+++ b/server/tests/api/transcoding/create-transcoding.ts
@@ -96,12 +96,12 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should generate WebTorrent', async function () {
+  it('Should generate Web Video', async function () {
     this.timeout(60000)
 
     await servers[0].videos.runTranscoding({
       videoId: videoUUID,
-      transcodingType: 'webtorrent'
+      transcodingType: 'web-video'
     })
 
     await waitJobs(servers)
@@ -117,13 +117,13 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should generate WebTorrent from HLS only video', async function () {
+  it('Should generate Web Video from HLS only video', async function () {
     this.timeout(60000)
 
-    await servers[0].videos.removeAllWebTorrentFiles({ videoId: videoUUID })
+    await servers[0].videos.removeAllWebVideoFiles({ videoId: videoUUID })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'web-video' })
     await waitJobs(servers)
 
     for (const server of servers) {
@@ -137,13 +137,13 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should only generate WebTorrent', async function () {
+  it('Should only generate Web Video', async function () {
     this.timeout(60000)
 
     await servers[0].videos.removeHLSPlaylist({ videoId: videoUUID })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'web-video' })
     await waitJobs(servers)
 
     for (const server of servers) {
diff --git a/server/tests/api/transcoding/hls.ts b/server/tests/api/transcoding/hls.ts
index c668d7e0b..ba889e718 100644
--- a/server/tests/api/transcoding/hls.ts
+++ b/server/tests/api/transcoding/hls.ts
@@ -111,7 +111,7 @@ describe('Test HLS videos', function () {
     await doubleFollow(servers[0], servers[1])
   })
 
-  describe('With WebTorrent & HLS enabled', function () {
+  describe('With Web Video & HLS enabled', function () {
     runTestSuite(false)
   })
 
diff --git a/server/tests/api/transcoding/transcoder.ts b/server/tests/api/transcoding/transcoder.ts
index 3cd247a24..36e1d90f4 100644
--- a/server/tests/api/transcoding/transcoder.ts
+++ b/server/tests/api/transcoding/transcoder.ts
@@ -251,7 +251,7 @@ describe('Test video transcoding', function () {
         expect(videoDetails.files).to.have.lengthOf(5)
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const probe = await getAudioStream(path)
 
         if (probe.audioStream) {
@@ -281,7 +281,7 @@ describe('Test video transcoding', function () {
         const videoDetails = await server.videos.get({ id: video.id })
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         expect(await hasAudioStream(path)).to.be.false
       }
@@ -310,7 +310,7 @@ describe('Test video transcoding', function () {
         const fixtureVideoProbe = await getAudioStream(fixturePath)
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         const videoProbe = await getAudioStream(path)
 
@@ -472,14 +472,14 @@ describe('Test video transcoding', function () {
 
         for (const resolution of [ 144, 240, 360, 480 ]) {
           const file = videoDetails.files.find(f => f.resolution.id === resolution)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
 
           expect(fps).to.be.below(31)
         }
 
         const file = videoDetails.files.find(f => f.resolution.id === 720)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const fps = await getVideoStreamFPS(path)
 
         expect(fps).to.be.above(58).and.below(62)
@@ -516,14 +516,14 @@ describe('Test video transcoding', function () {
 
         {
           const file = video.files.find(f => f.resolution.id === 240)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(25)
         }
 
         {
           const file = video.files.find(f => f.resolution.id === 720)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(59)
         }
@@ -556,7 +556,7 @@ describe('Test video transcoding', function () {
 
         for (const resolution of [ 240, 360, 480, 720, 1080 ]) {
           const file = video.files.find(f => f.resolution.id === resolution)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
           const bitrate = await getVideoStreamBitrate(path)
           const fps = await getVideoStreamFPS(path)
@@ -607,7 +607,7 @@ describe('Test video transcoding', function () {
       for (const r of resolutions) {
         const file = video.files.find(f => f.resolution.id === r)
 
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const bitrate = await getVideoStreamBitrate(path)
 
         const inputBitrate = 60_000
@@ -631,7 +631,7 @@ describe('Test video transcoding', function () {
       {
         const video = await servers[1].videos.get({ id: videoUUID })
         const file = video.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         const probe = await ffprobePromise(path)
         const metadata = new VideoFileMetadata(probe)
@@ -704,14 +704,14 @@ describe('Test video transcoding', function () {
       expect(transcodingJobs).to.have.lengthOf(16)
 
       const hlsJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-hls')
-      const webtorrentJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-webtorrent')
-      const optimizeJobs = transcodingJobs.filter(j => j.data.type === 'optimize-to-webtorrent')
+      const webVideoJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-web-video')
+      const optimizeJobs = transcodingJobs.filter(j => j.data.type === 'optimize-to-web-video')
 
       expect(hlsJobs).to.have.lengthOf(8)
-      expect(webtorrentJobs).to.have.lengthOf(7)
+      expect(webVideoJobs).to.have.lengthOf(7)
       expect(optimizeJobs).to.have.lengthOf(1)
 
-      for (const j of optimizeJobs.concat(hlsJobs.concat(webtorrentJobs))) {
+      for (const j of optimizeJobs.concat(hlsJobs.concat(webVideoJobs))) {
         expect(j.priority).to.be.greaterThan(100)
         expect(j.priority).to.be.lessThan(150)
       }
diff --git a/server/tests/api/transcoding/update-while-transcoding.ts b/server/tests/api/transcoding/update-while-transcoding.ts
index 61655f102..2e0edc770 100644
--- a/server/tests/api/transcoding/update-while-transcoding.ts
+++ b/server/tests/api/transcoding/update-while-transcoding.ts
@@ -96,7 +96,7 @@ describe('Test update video privacy while transcoding', function () {
     await doubleFollow(servers[0], servers[1])
   })
 
-  describe('With WebTorrent & HLS enabled', function () {
+  describe('With Web Video & HLS enabled', function () {
     runTestSuite(false)
   })
 
diff --git a/server/tests/api/transcoding/video-studio.ts b/server/tests/api/transcoding/video-studio.ts
index e97f2b689..2595d3cdb 100644
--- a/server/tests/api/transcoding/video-studio.ts
+++ b/server/tests/api/transcoding/video-studio.ts
@@ -273,7 +273,7 @@ describe('Test video studio', function () {
   describe('HLS only studio edition', function () {
 
     before(async function () {
-      // Disable webtorrent
+      // Disable Web Videos
       await servers[0].config.updateExistingSubConfig({
         newConfig: {
           transcoding: {
@@ -354,8 +354,8 @@ describe('Test video studio', function () {
           expect(oldFileUrls).to.not.include(f.fileUrl)
         }
 
-        for (const webtorrentFile of video.files) {
-          expectStartWith(webtorrentFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
+        for (const webVideoFile of video.files) {
+          expectStartWith(webVideoFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
         }
 
         for (const hlsFile of video.streamingPlaylists[0].files) {
diff --git a/server/tests/api/users/user-videos.ts b/server/tests/api/users/user-videos.ts
index 696949504..70f22e2eb 100644
--- a/server/tests/api/users/user-videos.ts
+++ b/server/tests/api/users/user-videos.ts
@@ -184,7 +184,7 @@ describe('Test user videos', function () {
       }
     })
 
-    it('Should disable webtorrent, enable HLS, and update my quota', async function () {
+    it('Should disable web videos, enable HLS, and update my quota', async function () {
       this.timeout(160000)
 
       {
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 1c00f9a93..67ade1d0d 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -229,25 +229,13 @@ describe('Test users', function () {
     })
 
     it('Should be able to change the p2p attribute', async function () {
-      {
-        await server.users.updateMe({
-          token: userToken,
-          webTorrentEnabled: false
-        })
-
-        const user = await server.users.getMyInfo({ token: userToken })
-        expect(user.p2pEnabled).to.be.false
-      }
-
-      {
-        await server.users.updateMe({
-          token: userToken,
-          p2pEnabled: true
-        })
+      await server.users.updateMe({
+        token: userToken,
+        p2pEnabled: true
+      })
 
-        const user = await server.users.getMyInfo({ token: userToken })
-        expect(user.p2pEnabled).to.be.true
-      }
+      const user = await server.users.getMyInfo({ token: userToken })
+      expect(user.p2pEnabled).to.be.true
     })
 
     it('Should be able to change the email attribute', async function () {
diff --git a/server/tests/api/videos/video-files.ts b/server/tests/api/videos/video-files.ts
index 8c913bf31..0a183c44d 100644
--- a/server/tests/api/videos/video-files.ts
+++ b/server/tests/api/videos/video-files.ts
@@ -48,10 +48,10 @@ describe('Test videos files', function () {
       await waitJobs(servers)
     })
 
-    it('Should delete webtorrent files', async function () {
+    it('Should delete web video files', async function () {
       this.timeout(30_000)
 
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1 })
 
       await waitJobs(servers)
 
@@ -80,15 +80,15 @@ describe('Test videos files', function () {
   })
 
   describe('When deleting a specific file', function () {
-    let webtorrentId: string
+    let webVideoId: string
     let hlsId: string
 
     before(async function () {
       this.timeout(120_000)
 
       {
-        const { uuid } = await servers[0].videos.quickUpload({ name: 'webtorrent' })
-        webtorrentId = uuid
+        const { uuid } = await servers[0].videos.quickUpload({ name: 'web-video' })
+        webVideoId = uuid
       }
 
       {
@@ -99,38 +99,38 @@ describe('Test videos files', function () {
       await waitJobs(servers)
     })
 
-    it('Shoulde delete a webtorrent file', async function () {
+    it('Shoulde delete a web video file', async function () {
       this.timeout(30_000)
 
-      const video = await servers[0].videos.get({ id: webtorrentId })
+      const video = await servers[0].videos.get({ id: webVideoId })
       const files = video.files
 
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: files[0].id })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: files[0].id })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const video = await server.videos.get({ id: webtorrentId })
+        const video = await server.videos.get({ id: webVideoId })
 
         expect(video.files).to.have.lengthOf(files.length - 1)
         expect(video.files.find(f => f.id === files[0].id)).to.not.exist
       }
     })
 
-    it('Should delete all webtorrent files', async function () {
+    it('Should delete all web video files', async function () {
       this.timeout(30_000)
 
-      const video = await servers[0].videos.get({ id: webtorrentId })
+      const video = await servers[0].videos.get({ id: webVideoId })
       const files = video.files
 
       for (const file of files) {
-        await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: file.id })
+        await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: file.id })
       }
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const video = await server.videos.get({ id: webtorrentId })
+        const video = await server.videos.get({ id: webVideoId })
 
         expect(video.files).to.have.lengthOf(0)
       }
@@ -182,16 +182,16 @@ describe('Test videos files', function () {
     it('Should not delete last file of a video', async function () {
       this.timeout(60_000)
 
-      const webtorrentOnly = await servers[0].videos.get({ id: hlsId })
-      const hlsOnly = await servers[0].videos.get({ id: webtorrentId })
+      const webVideoOnly = await servers[0].videos.get({ id: hlsId })
+      const hlsOnly = await servers[0].videos.get({ id: webVideoId })
 
       for (let i = 0; i < 4; i++) {
-        await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentOnly.id, fileId: webtorrentOnly.files[i].id })
+        await servers[0].videos.removeWebVideoFile({ videoId: webVideoOnly.id, fileId: webVideoOnly.files[i].id })
         await servers[0].videos.removeHLSFile({ videoId: hlsOnly.id, fileId: hlsOnly.streamingPlaylists[0].files[i].id })
       }
 
       const expectedStatus = HttpStatusCode.BAD_REQUEST_400
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentOnly.id, fileId: webtorrentOnly.files[4].id, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoOnly.id, fileId: webVideoOnly.files[4].id, expectedStatus })
       await servers[0].videos.removeHLSFile({ videoId: hlsOnly.id, fileId: hlsOnly.streamingPlaylists[0].files[4].id, expectedStatus })
     })
   })
diff --git a/server/tests/api/videos/videos-common-filters.ts b/server/tests/api/videos/videos-common-filters.ts
index 30251706b..73c066bfb 100644
--- a/server/tests/api/videos/videos-common-filters.ts
+++ b/server/tests/api/videos/videos-common-filters.ts
@@ -154,7 +154,7 @@ describe('Test videos filter', function () {
       server: PeerTubeServer
       path: string
       isLocal?: boolean
-      hasWebtorrentFiles?: boolean
+      hasWebVideoFiles?: boolean
       hasHLSFiles?: boolean
       include?: VideoInclude
       privacyOneOf?: VideoPrivacy[]
@@ -174,7 +174,7 @@ describe('Test videos filter', function () {
             'include',
             'category',
             'tagsAllOf',
-            'hasWebtorrentFiles',
+            'hasWebVideoFiles',
             'hasHLSFiles',
             'privacyOneOf',
             'excludeAlreadyWatched'
@@ -463,14 +463,14 @@ describe('Test videos filter', function () {
       }
     })
 
-    it('Should filter by HLS or WebTorrent files', async function () {
+    it('Should filter by HLS or Web Video files', async function () {
       this.timeout(360000)
 
       const finderFactory = (name: string) => (videos: Video[]) => videos.some(v => v.name === name)
 
       await servers[0].config.enableTranscoding(true, false)
-      await servers[0].videos.upload({ attributes: { name: 'webtorrent video' } })
-      const hasWebtorrent = finderFactory('webtorrent video')
+      await servers[0].videos.upload({ attributes: { name: 'web video video' } })
+      const hasWebVideo = finderFactory('web video video')
 
       await waitJobs(servers)
 
@@ -481,24 +481,24 @@ describe('Test videos filter', function () {
       await waitJobs(servers)
 
       await servers[0].config.enableTranscoding(true, true)
-      await servers[0].videos.upload({ attributes: { name: 'hls and webtorrent video' } })
-      const hasBoth = finderFactory('hls and webtorrent video')
+      await servers[0].videos.upload({ attributes: { name: 'hls and web video video' } })
+      const hasBoth = finderFactory('hls and web video video')
 
       await waitJobs(servers)
 
       for (const path of paths) {
         {
-          const videos = await listVideos({ server: servers[0], path, hasWebtorrentFiles: true })
+          const videos = await listVideos({ server: servers[0], path, hasWebVideoFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.true
+          expect(hasWebVideo(videos)).to.be.true
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.true
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasWebtorrentFiles: false })
+          const videos = await listVideos({ server: servers[0], path, hasWebVideoFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.true
           expect(hasBoth(videos)).to.be.false
         }
@@ -506,7 +506,7 @@ describe('Test videos filter', function () {
         {
           const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.true
           expect(hasBoth(videos)).to.be.true
         }
@@ -514,23 +514,23 @@ describe('Test videos filter', function () {
         {
           const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.true
+          expect(hasWebVideo(videos)).to.be.true
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.false
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false, hasWebtorrentFiles: false })
+          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false, hasWebVideoFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.false
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true, hasWebtorrentFiles: true })
+          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true, hasWebVideoFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.true
         }
diff --git a/server/tests/peertube-runner/studio-transcoding.ts b/server/tests/peertube-runner/studio-transcoding.ts
index 988201947..c265d7934 100644
--- a/server/tests/peertube-runner/studio-transcoding.ts
+++ b/server/tests/peertube-runner/studio-transcoding.ts
@@ -44,8 +44,8 @@ describe('Test studio transcoding in peertube-runner program', function () {
         }
 
         if (objectStorage) {
-          for (const webtorrentFile of video.files) {
-            expectStartWith(webtorrentFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
+          for (const webVideoFile of video.files) {
+            expectStartWith(webVideoFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
           }
 
           for (const hlsFile of video.streamingPlaylists[0].files) {
diff --git a/server/tests/peertube-runner/vod-transcoding.ts b/server/tests/peertube-runner/vod-transcoding.ts
index c3f41c097..eef6faf4e 100644
--- a/server/tests/peertube-runner/vod-transcoding.ts
+++ b/server/tests/peertube-runner/vod-transcoding.ts
@@ -24,13 +24,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
   let peertubeRunner: PeerTubeRunnerProcess
 
   function runSuite (options: {
-    webtorrentEnabled: boolean
+    webVideoEnabled: boolean
     hlsEnabled: boolean
     objectStorage?: ObjectStorageCommand
   }) {
-    const { webtorrentEnabled, hlsEnabled, objectStorage } = options
+    const { webVideoEnabled, hlsEnabled, objectStorage } = options
 
-    const objectStorageBaseUrlWebTorrent = objectStorage
+    const objectStorageBaseUrlWebVideo = objectStorage
       ? objectStorage.getMockWebVideosBaseUrl()
       : undefined
 
@@ -46,13 +46,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'video_short.mp4',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -66,7 +66,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -84,13 +84,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'video_short.webm',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -104,7 +104,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -123,13 +123,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'sample.ogg',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -142,7 +142,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -159,13 +159,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       await waitJobs(servers, { runnerJobs: true })
 
-      if (webtorrentEnabled) {
+      if (webVideoEnabled) {
         await completeWebVideoFilesCheck({
           server: servers[0],
           originServer: servers[0],
           fixture: 'video_short.mp4',
           videoUUID: uuid,
-          objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+          objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
           files: [
             { resolution: 0 },
             { resolution: 144 },
@@ -179,7 +179,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       if (hlsEnabled) {
         await completeCheckHlsPlaylist({
-          hlsOnly: !webtorrentEnabled,
+          hlsOnly: !webVideoEnabled,
           servers: [ servers[0] ],
           videoUUID: uuid,
           objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -203,7 +203,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       await servers[0].config.enableTranscoding(true, true, true)
 
-      await servers[0].videos.runTranscoding({ transcodingType: 'webtorrent', videoId: uuid })
+      await servers[0].videos.runTranscoding({ transcodingType: 'web-video', videoId: uuid })
       await waitJobs(servers, { runnerJobs: true })
 
       await completeWebVideoFilesCheck({
@@ -211,7 +211,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         originServer: servers[0],
         fixture: 'video_short.mp4',
         videoUUID: uuid,
-        objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+        objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
         files: [
           { resolution: 0 },
           { resolution: 144 },
@@ -262,7 +262,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, false, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: false })
+      runSuite({ webVideoEnabled: true, hlsEnabled: false })
     })
 
     describe('HLS videos only enabled', function () {
@@ -271,7 +271,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(false, true, true)
       })
 
-      runSuite({ webtorrentEnabled: false, hlsEnabled: true })
+      runSuite({ webVideoEnabled: false, hlsEnabled: true })
     })
 
     describe('Web video & HLS enabled', function () {
@@ -280,7 +280,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, true, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: true })
+      runSuite({ webVideoEnabled: true, hlsEnabled: true })
     })
   })
 
@@ -306,7 +306,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, false, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage })
+      runSuite({ webVideoEnabled: true, hlsEnabled: false, objectStorage })
     })
 
     describe('HLS videos only enabled', function () {
@@ -315,7 +315,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(false, true, true)
       })
 
-      runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage })
+      runSuite({ webVideoEnabled: false, hlsEnabled: true, objectStorage })
     })
 
     describe('Web video & HLS enabled', function () {
@@ -324,7 +324,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, true, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage })
+      runSuite({ webVideoEnabled: true, hlsEnabled: true, objectStorage })
     })
 
     after(async function () {
diff --git a/server/tests/plugins/plugin-helpers.ts b/server/tests/plugins/plugin-helpers.ts
index e951a1299..f5a0cbe85 100644
--- a/server/tests/plugins/plugin-helpers.ts
+++ b/server/tests/plugins/plugin-helpers.ts
@@ -302,11 +302,11 @@ describe('Test plugin helpers', function () {
 
       // Video files check
       {
-        expect(body.webtorrent.videoFiles).to.be.an('array')
+        expect(body.webVideo.videoFiles).to.be.an('array')
         expect(body.hls.videoFiles).to.be.an('array')
 
         for (const resolution of [ 144, 240, 360, 480, 720 ]) {
-          for (const files of [ body.webtorrent.videoFiles, body.hls.videoFiles ]) {
+          for (const files of [ body.webVideo.videoFiles, body.hls.videoFiles ]) {
             const file = files.find(f => f.resolution === resolution)
             expect(file).to.exist
 
@@ -318,7 +318,7 @@ describe('Test plugin helpers', function () {
           }
         }
 
-        videoPath = body.webtorrent.videoFiles[0].path
+        videoPath = body.webVideo.videoFiles[0].path
       }
 
       // Thumbnails check
diff --git a/server/tests/plugins/plugin-transcoding.ts b/server/tests/plugins/plugin-transcoding.ts
index 689eec5ac..f3d929426 100644
--- a/server/tests/plugins/plugin-transcoding.ts
+++ b/server/tests/plugins/plugin-transcoding.ts
@@ -247,7 +247,7 @@ describe('Test transcoding plugins', function () {
 
       const video = await server.videos.get({ id: videoUUID })
 
-      const path = server.servers.buildWebTorrentFilePath(video.files[0].fileUrl)
+      const path = server.servers.buildWebVideoFilePath(video.files[0].fileUrl)
       const audioProbe = await getAudioStream(path)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
diff --git a/server/tests/shared/videos.ts b/server/tests/shared/videos.ts
index 0bd161820..6cba5b14c 100644
--- a/server/tests/shared/videos.ts
+++ b/server/tests/shared/videos.ts
@@ -215,22 +215,22 @@ async function checkVideoFilesWereRemoved (options: {
 }) {
   const { video, server, captions = [], onlyVideoFiles = false } = options
 
-  const webtorrentFiles = video.files || []
+  const webVideoFiles = video.files || []
   const hlsFiles = video.streamingPlaylists[0]?.files || []
 
   const thumbnailName = basename(video.thumbnailPath)
   const previewName = basename(video.previewPath)
 
-  const torrentNames = webtorrentFiles.concat(hlsFiles).map(f => basename(f.torrentUrl))
+  const torrentNames = webVideoFiles.concat(hlsFiles).map(f => basename(f.torrentUrl))
 
   const captionNames = captions.map(c => basename(c.captionPath))
 
-  const webtorrentFilenames = webtorrentFiles.map(f => basename(f.fileUrl))
+  const webVideoFilenames = webVideoFiles.map(f => basename(f.fileUrl))
   const hlsFilenames = hlsFiles.map(f => basename(f.fileUrl))
 
   let directories: { [ directory: string ]: string[] } = {
-    videos: webtorrentFilenames,
-    redundancy: webtorrentFilenames,
+    videos: webVideoFilenames,
+    redundancy: webVideoFilenames,
     [join('playlists', 'hls')]: hlsFilenames,
     [join('redundancy', 'hls')]: hlsFilenames
   }