Introduce import command

7 files changed, 93 insertions, 115 deletions

diff --git a/server/tests/api/check-params/upload-quota.ts b/server/tests/api/check-params/upload-quota.ts
index d0fbec415..c444663b8 100644
--- a/server/tests/api/check-params/upload-quota.ts
+++ b/server/tests/api/check-params/upload-quota.ts
@@ -3,13 +3,12 @@
 import 'mocha'
 import { expect } from 'chai'
 import { HttpStatusCode, randomInt } from '@shared/core-utils'
-import { getGoodVideoUrl, getMagnetURI, getMyVideoImports, importVideo } from '@shared/extra-utils/videos/video-imports'
-import { MyUser, VideoImport, VideoImportState, VideoPrivacy } from '@shared/models'
+import { MyUser, VideoImportState, VideoPrivacy } from '@shared/models'
 import {
   cleanupTests,
   flushAndRunServer,
   getMyUserInformation,
-  immutableAssign,
+  ImportsCommand,
   registerUser,
   ServerInfo,
   setAccessTokensToServers,
@@ -83,16 +82,15 @@ describe('Test upload quota', function () {
         channelId: server.videoChannel.id,
         privacy: VideoPrivacy.PUBLIC
       }
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { targetUrl: getGoodVideoUrl() }))
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { magnetUri: getMagnetURI() }))
-      await importVideo(server.url, server.accessToken, immutableAssign(baseAttributes, { torrentfile: 'video-720p.torrent' as any }))
+      await server.importsCommand.importVideo({ attributes: { ...baseAttributes, targetUrl: ImportsCommand.getGoodVideoUrl() } })
+      await server.importsCommand.importVideo({ attributes: { ...baseAttributes, magnetUri: ImportsCommand.getMagnetURI() } })
+      await server.importsCommand.importVideo({ attributes: { ...baseAttributes, torrentfile: 'video-720p.torrent' as any } })
 
       await waitJobs([ server ])
 
-      const res = await getMyVideoImports(server.url, server.accessToken)
+      const { total, data: videoImports } = await server.importsCommand.getMyVideoImports()
+      expect(total).to.equal(3)
 
-      expect(res.body.total).to.equal(3)
-      const videoImports: VideoImport[] = res.body.data
       expect(videoImports).to.have.lengthOf(3)
 
       for (const videoImport of videoImports) {
diff --git a/server/tests/api/check-params/video-imports.ts b/server/tests/api/check-params/video-imports.ts
index dae3860ef..ea473191e 100644
--- a/server/tests/api/check-params/video-imports.ts
+++ b/server/tests/api/check-params/video-imports.ts
@@ -13,6 +13,7 @@ import {
   flushAndRunServer,
   getMyUserInformation,
   immutableAssign,
+  ImportsCommand,
   makeGetRequest,
   makePostBodyRequest,
   makeUploadRequest,
@@ -20,7 +21,6 @@ import {
   setAccessTokensToServers,
   userLogin
 } from '@shared/extra-utils'
-import { getGoodVideoUrl, getMagnetURI } from '@shared/extra-utils/videos/video-imports'
 import { VideoPrivacy } from '@shared/models'
 
 describe('Test video imports API validator', function () {
@@ -74,7 +74,7 @@ describe('Test video imports API validator', function () {
 
     before(function () {
       baseCorrectParams = {
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: ImportsCommand.getGoodVideoUrl(),
         name: 'my super name',
         category: 5,
         licence: 1,
@@ -301,7 +301,7 @@ describe('Test video imports API validator', function () {
       })
 
       let fields = omit(baseCorrectParams, 'targetUrl')
-      fields = immutableAssign(fields, { magnetUri: getMagnetURI() })
+      fields = immutableAssign(fields, { magnetUri: ImportsCommand.getMagnetURI() })
 
       await makePostBodyRequest({
         url: server.url,
diff --git a/server/tests/api/moderation/video-blacklist.ts b/server/tests/api/moderation/video-blacklist.ts
index 17a68e4a6..c72ebc16b 100644
--- a/server/tests/api/moderation/video-blacklist.ts
+++ b/server/tests/api/moderation/video-blacklist.ts
@@ -12,6 +12,7 @@ import {
   getMyUserInformation,
   getMyVideos,
   getVideosList,
+  ImportsCommand,
   killallServers,
   reRunServer,
   ServerInfo,
@@ -21,7 +22,6 @@ import {
   userLogin,
   waitJobs
 } from '@shared/extra-utils'
-import { getGoodVideoUrl, getMagnetURI, importVideo } from '@shared/extra-utils/videos/video-imports'
 import { User, UserAdminFlag, UserRole, VideoBlacklist, VideoBlacklistType } from '@shared/models'
 
 const expect = chai.expect
@@ -402,11 +402,11 @@ describe('Test video blacklist', function () {
       this.timeout(15000)
 
       const attributes = {
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: ImportsCommand.getGoodVideoUrl(),
         name: 'URL import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
+      await servers[0].importsCommand.importVideo({ token: userWithoutFlag, attributes })
 
       const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(2)
@@ -415,11 +415,11 @@ describe('Test video blacklist', function () {
 
     it('Should auto blacklist a video on torrent import', async function () {
       const attributes = {
-        magnetUri: getMagnetURI(),
+        magnetUri: ImportsCommand.getMagnetURI(),
         name: 'Torrent import',
         channelId: channelOfUserWithoutFlag
       }
-      await importVideo(servers[0].url, userWithoutFlag, attributes)
+      await servers[0].importsCommand.importVideo({ token: userWithoutFlag, attributes })
 
       const body = await command.list({ sort: 'createdAt', type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED })
       expect(body.total).to.equal(3)
diff --git a/server/tests/api/notifications/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index 15be983f2..a9315c818 100644
--- a/server/tests/api/notifications/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -11,6 +11,7 @@ import {
   checkVideoIsPublished,
   cleanupTests,
   getLastNotification,
+  ImportsCommand,
   MockSmtpServer,
   prepareNotificationsTest,
   ServerInfo,
@@ -21,7 +22,6 @@ import {
   wait,
   waitJobs
 } from '@shared/extra-utils'
-import { getBadVideoUrl, getGoodVideoUrl, importVideo } from '@shared/extra-utils/videos/video-imports'
 import { UserNotification, UserNotificationType, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
@@ -209,14 +209,13 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PUBLIC,
-        targetUrl: getGoodVideoUrl()
+        targetUrl: ImportsCommand.getGoodVideoUrl()
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
 
       await waitJobs(servers)
 
-      await checkNewVideoFromSubscription(baseParams, name, uuid, 'presence')
+      await checkNewVideoFromSubscription(baseParams, name, video.uuid, 'presence')
     })
   })
 
@@ -280,14 +279,13 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PUBLIC,
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: ImportsCommand.getGoodVideoUrl(),
         waitTranscoding: true
       }
-      const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[1].importsCommand.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkVideoIsPublished(baseParams, name, uuid, 'presence')
+      await checkVideoIsPublished(baseParams, name, video.uuid, 'presence')
     })
 
     it('Should send a notification when the scheduled update has been proceeded', async function () {
@@ -349,13 +347,12 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PRIVATE,
-        targetUrl: getBadVideoUrl()
+        targetUrl: ImportsCommand.getBadVideoUrl()
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkMyVideoImportIsFinished(baseParams, name, uuid, getBadVideoUrl(), false, 'presence')
+      await checkMyVideoImportIsFinished(baseParams, name, video.uuid, ImportsCommand.getBadVideoUrl(), false, 'presence')
     })
 
     it('Should send a notification when the video import succeeded', async function () {
@@ -367,13 +364,12 @@ describe('Test user notifications', function () {
         name,
         channelId,
         privacy: VideoPrivacy.PRIVATE,
-        targetUrl: getGoodVideoUrl()
+        targetUrl: ImportsCommand.getGoodVideoUrl()
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      const uuid = res.body.video.uuid
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
 
       await waitJobs(servers)
-      await checkMyVideoImportIsFinished(baseParams, name, uuid, getGoodVideoUrl(), true, 'presence')
+      await checkMyVideoImportIsFinished(baseParams, name, video.uuid, ImportsCommand.getGoodVideoUrl(), true, 'presence')
     })
   })
 
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index 14aed604f..4f9ecbe8e 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
+  areHttpImportTestsDisabled,
   cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -11,20 +12,14 @@ import {
   getVideo,
   getVideosList,
   immutableAssign,
+  ImportsCommand,
   ServerInfo,
   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,
-  getYoutubeHDRVideoUrl,
-  getYoutubeVideoUrl,
-  importVideo
-} from '../../../../shared/extra-utils/videos/video-imports'
-import { VideoDetails, VideoImport, VideoPrivacy, VideoResolution } from '../../../../shared/models/videos'
+  testCaptionFile,
+  testImage,
+  waitJobs
+} from '@shared/extra-utils'
+import { VideoDetails, VideoPrivacy, VideoResolution } from '@shared/models'
 
 const expect = chai.expect
 
@@ -124,17 +119,17 @@ describe('Test video imports', function () {
     }
 
     {
-      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')
+      const attributes = immutableAssign(baseAttributes, { targetUrl: ImportsCommand.getYoutubeVideoUrl() })
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
+      expect(video.name).to.equal('small video - youtube')
 
-      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$`))
+      expect(video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
+      expect(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)
+      await testImage(servers[0].url, 'video_import_thumbnail', video.thumbnailPath)
+      await testImage(servers[0].url, 'video_import_preview', video.previewPath)
 
-      const bodyCaptions = await servers[0].captionsCommand.listVideoCaptions({ videoId: res.body.video.id })
+      const bodyCaptions = await servers[0].captionsCommand.listVideoCaptions({ videoId: video.id })
       const videoCaptions = bodyCaptions.data
       expect(videoCaptions).to.have.lengthOf(2)
 
@@ -175,12 +170,12 @@ Ajouter un sous-titre est vraiment facile`)
 
     {
       const attributes = immutableAssign(baseAttributes, {
-        magnetUri: getMagnetURI(),
+        magnetUri: ImportsCommand.getMagnetURI(),
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
       })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('super peertube2 video')
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
+      expect(video.name).to.equal('super peertube2 video')
     }
 
     {
@@ -189,8 +184,8 @@ Ajouter un sous-titre est vraiment facile`)
         description: 'this is a super torrent description',
         tags: [ 'tag_torrent1', 'tag_torrent2' ]
       })
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      expect(res.body.video.name).to.equal('你好 世界 720p.mp4')
+      const { video } = await servers[0].importsCommand.importVideo({ attributes })
+      expect(video.name).to.equal('你好 世界 720p.mp4')
     }
   })
 
@@ -207,19 +202,18 @@ Ajouter un sous-titre est vraiment facile`)
   })
 
   it('Should list the videos to import in my imports on server 1', async function () {
-    const res = await getMyVideoImports(servers[0].url, servers[0].accessToken, '-createdAt')
+    const { total, data: videoImports } = await servers[0].importsCommand.getMyVideoImports({ sort: '-createdAt' })
+    expect(total).to.equal(3)
 
-    expect(res.body.total).to.equal(3)
-    const videoImports: VideoImport[] = res.body.data
     expect(videoImports).to.have.lengthOf(3)
 
-    expect(videoImports[2].targetUrl).to.equal(getYoutubeVideoUrl())
+    expect(videoImports[2].targetUrl).to.equal(ImportsCommand.getYoutubeVideoUrl())
     expect(videoImports[2].magnetUri).to.be.null
     expect(videoImports[2].torrentName).to.be.null
     expect(videoImports[2].video.name).to.equal('small video - youtube')
 
     expect(videoImports[1].targetUrl).to.be.null
-    expect(videoImports[1].magnetUri).to.equal(getMagnetURI())
+    expect(videoImports[1].magnetUri).to.equal(ImportsCommand.getMagnetURI())
     expect(videoImports[1].torrentName).to.be.null
     expect(videoImports[1].video.name).to.equal('super peertube2 video')
 
@@ -248,7 +242,7 @@ Ajouter un sous-titre est vraiment facile`)
     this.timeout(60_000)
 
     const attributes = {
-      targetUrl: getYoutubeVideoUrl(),
+      targetUrl: ImportsCommand.getYoutubeVideoUrl(),
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC,
       category: 10,
@@ -258,8 +252,8 @@ Ajouter un sous-titre est vraiment facile`)
       description: 'my super description',
       tags: [ 'supertag1', 'supertag2' ]
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    expect(res.body.video.name).to.equal('my super name')
+    const { video } = await servers[1].importsCommand.importVideo({ attributes })
+    expect(video.name).to.equal('my super name')
   })
 
   it('Should have the videos listed on the two instances', async function () {
@@ -284,12 +278,12 @@ Ajouter un sous-titre est vraiment facile`)
 
     const attributes = {
       name: 'transcoded video',
-      magnetUri: getMagnetURI(),
+      magnetUri: ImportsCommand.getMagnetURI(),
       channelId: channelIdServer2,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res = await importVideo(servers[1].url, servers[1].accessToken, attributes)
-    const videoUUID = res.body.video.uuid
+    const { video } = await servers[1].importsCommand.importVideo({ attributes })
+    const videoUUID = video.uuid
 
     await waitJobs(servers)
 
@@ -335,12 +329,12 @@ Ajouter un sous-titre est vraiment facile`)
 
     const attributes = {
       name: 'hdr video',
-      targetUrl: getYoutubeHDRVideoUrl(),
+      targetUrl: ImportsCommand.getYoutubeHDRVideoUrl(),
       channelId: channelIdServer1,
       privacy: VideoPrivacy.PUBLIC
     }
-    const res1 = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-    const videoUUID = res1.body.video.uuid
+    const { video: videoImported } = await servers[0].importsCommand.importVideo({ attributes })
+    const videoUUID = videoImported.uuid
 
     await waitJobs(servers)
 
diff --git a/server/tests/cli/peertube.ts b/server/tests/cli/peertube.ts
index 0a4f54ffa..64a93ebb5 100644
--- a/server/tests/cli/peertube.ts
+++ b/server/tests/cli/peertube.ts
@@ -15,6 +15,7 @@ import {
   getLocalIdByUUID,
   getVideo,
   getVideosList,
+  ImportsCommand,
   removeVideo,
   ServerInfo,
   setAccessTokensToServers,
@@ -23,7 +24,6 @@ import {
   userLogin,
   waitJobs
 } from '../../../shared/extra-utils'
-import { getYoutubeVideoUrl } from '../../../shared/extra-utils/videos/video-imports'
 
 describe('Test CLI wrapper', function () {
   let server: ServerInfo
@@ -122,7 +122,7 @@ describe('Test CLI wrapper', function () {
 
       this.timeout(60000)
 
-      const params = `--target-url ${getYoutubeVideoUrl()} --channel-name user_channel`
+      const params = `--target-url ${ImportsCommand.getYoutubeVideoUrl()} --channel-name user_channel`
       await cliCommand.execWithEnv(`${cmd} import ${params}`)
     })
 
@@ -155,7 +155,8 @@ describe('Test CLI wrapper', function () {
 
       this.timeout(60000)
 
-      const params = `--target-url ${getYoutubeVideoUrl()} --channel-name user_channel --video-name toto --nsfw --support support`
+      const params = `--target-url ${ImportsCommand.getYoutubeVideoUrl()} ` +
+                     `--channel-name user_channel --video-name toto --nsfw --support support`
       await cliCommand.execWithEnv(`${cmd} import ${params}`)
 
       await waitJobs([ server ])
diff --git a/server/tests/plugins/filter-hooks.ts b/server/tests/plugins/filter-hooks.ts
index 203642d8d..a3c3c0551 100644
--- a/server/tests/plugins/filter-hooks.ts
+++ b/server/tests/plugins/filter-hooks.ts
@@ -18,6 +18,7 @@ import {
   getVideosListPagination,
   getVideoThreadComments,
   getVideoWithToken,
+  ImportsCommand,
   makeRawRequest,
   PluginsCommand,
   registerUser,
@@ -30,16 +31,7 @@ import {
   waitJobs,
   waitUntilLog
 } from '@shared/extra-utils'
-import { getGoodVideoUrl, getMyVideoImports, importVideo } from '@shared/extra-utils/videos/video-imports'
-import {
-  VideoCommentThreadTree,
-  VideoDetails,
-  VideoImport,
-  VideoImportState,
-  VideoPlaylist,
-  VideoPlaylistPrivacy,
-  VideoPrivacy
-} from '@shared/models'
+import { VideoCommentThreadTree, VideoDetails, VideoImportState, VideoPlaylist, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -157,23 +149,23 @@ describe('Test plugin filter hooks', function () {
   })
 
   it('Should run filter:api.video.pre-import-url.accept.result', async function () {
-    const baseAttributes = {
+    const attributes = {
       name: 'normal title',
       privacy: VideoPrivacy.PUBLIC,
       channelId: servers[0].videoChannel.id,
-      targetUrl: getGoodVideoUrl() + 'bad'
+      targetUrl: ImportsCommand.getGoodVideoUrl() + 'bad'
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].importsCommand.importVideo({ attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.pre-import-torrent.accept.result', async function () {
-    const baseAttributes = {
+    const attributes = {
       name: 'bad torrent',
       privacy: VideoPrivacy.PUBLIC,
       channelId: servers[0].videoChannel.id,
       torrentfile: 'video-720p.torrent' as any
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].importsCommand.importVideo({ attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.post-import-url.accept.result', async function () {
@@ -182,21 +174,21 @@ describe('Test plugin filter hooks', function () {
     let videoImportId: number
 
     {
-      const baseAttributes = {
+      const attributes = {
         name: 'title with bad word',
         privacy: VideoPrivacy.PUBLIC,
         channelId: servers[0].videoChannel.id,
-        targetUrl: getGoodVideoUrl()
+        targetUrl: ImportsCommand.getGoodVideoUrl()
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, baseAttributes)
-      videoImportId = res.body.id
+      const body = await servers[0].importsCommand.importVideo({ attributes })
+      videoImportId = body.id
     }
 
     await waitJobs(servers)
 
     {
-      const res = await getMyVideoImports(servers[0].url, servers[0].accessToken)
-      const videoImports = res.body.data as VideoImport[]
+      const body = await servers[0].importsCommand.getMyVideoImports()
+      const videoImports = body.data
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -211,21 +203,20 @@ describe('Test plugin filter hooks', function () {
     let videoImportId: number
 
     {
-      const baseAttributes = {
+      const attributes = {
         name: 'title with bad word',
         privacy: VideoPrivacy.PUBLIC,
         channelId: servers[0].videoChannel.id,
         torrentfile: 'video-720p.torrent' as any
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, baseAttributes)
-      videoImportId = res.body.id
+      const body = await servers[0].importsCommand.importVideo({ attributes })
+      videoImportId = body.id
     }
 
     await waitJobs(servers)
 
     {
-      const res = await getMyVideoImports(servers[0].url, servers[0].accessToken)
-      const videoImports = res.body.data as VideoImport[]
+      const { data: videoImports } = await servers[0].importsCommand.getMyVideoImports()
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -278,17 +269,15 @@ describe('Test plugin filter hooks', function () {
 
   describe('Should run filter:video.auto-blacklist.result', function () {
 
-    async function checkIsBlacklisted (oldRes: any, value: boolean) {
-      const videoId = oldRes.body.video.uuid
-
-      const res = await getVideoWithToken(servers[0].url, servers[0].accessToken, videoId)
+    async function checkIsBlacklisted (id: number | string, value: boolean) {
+      const res = await getVideoWithToken(servers[0].url, servers[0].accessToken, id)
       const video: VideoDetails = res.body
       expect(video.blacklisted).to.equal(value)
     }
 
     it('Should blacklist on upload', async function () {
       const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video please blacklist me' })
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(res.body.video.uuid, true)
     })
 
     it('Should blacklist on import', async function () {
@@ -296,20 +285,20 @@ describe('Test plugin filter hooks', function () {
 
       const attributes = {
         name: 'video please blacklist me',
-        targetUrl: getGoodVideoUrl(),
+        targetUrl: ImportsCommand.getGoodVideoUrl(),
         channelId: servers[0].videoChannel.id
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      await checkIsBlacklisted(res, true)
+      const body = await servers[0].importsCommand.importVideo({ attributes })
+      await checkIsBlacklisted(body.video.uuid, true)
     })
 
     it('Should blacklist on update', async function () {
       const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
       const videoId = res.body.video.uuid
-      await checkIsBlacklisted(res, false)
+      await checkIsBlacklisted(videoId, false)
 
       await updateVideo(servers[0].url, servers[0].accessToken, videoId, { name: 'please blacklist me' })
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(videoId, true)
     })
 
     it('Should blacklist on remote upload', async function () {
@@ -318,7 +307,7 @@ describe('Test plugin filter hooks', function () {
       const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'remote please blacklist me' })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(res.body.video.uuid, true)
     })
 
     it('Should blacklist on remote update', async function () {
@@ -328,12 +317,12 @@ describe('Test plugin filter hooks', function () {
       await waitJobs(servers)
 
       const videoId = res.body.video.uuid
-      await checkIsBlacklisted(res, false)
+      await checkIsBlacklisted(videoId, false)
 
       await updateVideo(servers[1].url, servers[1].accessToken, videoId, { name: 'please blacklist me' })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(videoId, true)
     })
   })