1 files changed, 190 insertions, 210 deletions

diff --git a/server/tests/plugins/filter-hooks.ts b/server/tests/plugins/filter-hooks.ts
index 644b41dea..c00ac8f91 100644
--- a/server/tests/plugins/filter-hooks.ts
+++ b/server/tests/plugins/filter-hooks.ts
@@ -2,192 +2,152 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { advancedVideoChannelSearch } from '@shared/extra-utils/search/video-channels'
-import { ServerConfig } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import {
-  addVideoCommentReply,
-  addVideoCommentThread,
-  advancedVideoPlaylistSearch,
-  advancedVideosSearch,
-  createLive,
-  createVideoPlaylist,
+  cleanupTests,
+  createMultipleServers,
   doubleFollow,
-  getAccountVideos,
-  getConfig,
-  getMyVideos,
-  getPluginTestPath,
-  getVideo,
-  getVideoChannelVideos,
-  getVideoCommentThreads,
-  getVideoPlaylist,
-  getVideosList,
-  getVideosListPagination,
-  getVideoThreadComments,
-  getVideoWithToken,
-  installPlugin,
+  FIXTURE_URLS,
   makeRawRequest,
-  registerUser,
+  PeerTubeServer,
+  PluginsCommand,
   setAccessTokensToServers,
   setDefaultVideoChannel,
-  updateCustomSubConfig,
-  updateVideo,
-  uploadVideo,
-  uploadVideoAndGetId,
   waitJobs
-} from '../../../shared/extra-utils'
-import { cleanupTests, flushAndRunMultipleServers, ServerInfo, waitUntilLog } from '../../../shared/extra-utils/server/servers'
-import { getGoodVideoUrl, getMyVideoImports, importVideo } from '../../../shared/extra-utils/videos/video-imports'
-import {
-  VideoCommentThreadTree,
-  VideoDetails,
-  VideoImport,
-  VideoImportState,
-  VideoPlaylist,
-  VideoPlaylistPrivacy,
-  VideoPrivacy
-} from '../../../shared/models/videos'
+} from '@shared/extra-utils'
+import { HttpStatusCode, VideoDetails, VideoImportState, VideoPlaylist, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test plugin filter hooks', function () {
-  let servers: ServerInfo[]
+  let servers: PeerTubeServer[]
   let videoUUID: string
   let threadId: number
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await createMultipleServers(2)
     await setAccessTokensToServers(servers)
     await setDefaultVideoChannel(servers)
     await doubleFollow(servers[0], servers[1])
 
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath()
-    })
-
-    await installPlugin({
-      url: servers[0].url,
-      accessToken: servers[0].accessToken,
-      path: getPluginTestPath('-filter-translations')
-    })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath() })
+    await servers[0].plugins.install({ path: PluginsCommand.getPluginTestPath('-filter-translations') })
 
     for (let i = 0; i < 10; i++) {
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'default video ' + i })
+      await servers[0].videos.upload({ attributes: { name: 'default video ' + i } })
     }
 
-    const res = await getVideosList(servers[0].url)
-    videoUUID = res.body.data[0].uuid
-
-    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-      live: { enabled: true },
-      signup: { enabled: true },
-      import: {
-        videos: {
-          http: { enabled: true },
-          torrent: { enabled: true }
+    const { data } = await servers[0].videos.list()
+    videoUUID = data[0].uuid
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: { enabled: true },
+        signup: { enabled: true },
+        import: {
+          videos: {
+            http: { enabled: true },
+            torrent: { enabled: true }
+          }
         }
       }
     })
   })
 
   it('Should run filter:api.videos.list.params', async function () {
-    const res = await getVideosListPagination(servers[0].url, 0, 2)
+    const { data } = await servers[0].videos.list({ start: 0, count: 2 })
 
     // 2 plugins do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(4)
+    expect(data).to.have.lengthOf(4)
   })
 
   it('Should run filter:api.videos.list.result', async function () {
-    const res = await getVideosListPagination(servers[0].url, 0, 0)
+    const { total } = await servers[0].videos.list({ start: 0, count: 0 })
 
     // Plugin do +1 to the total result
-    expect(res.body.total).to.equal(11)
+    expect(total).to.equal(11)
   })
 
   it('Should run filter:api.accounts.videos.list.params', async function () {
-    const res = await getAccountVideos(servers[0].url, servers[0].accessToken, 'root', 0, 2)
+    const { data } = await servers[0].videos.listByAccount({ handle: 'root', start: 0, count: 2 })
 
     // 1 plugin do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(3)
+    expect(data).to.have.lengthOf(3)
   })
 
   it('Should run filter:api.accounts.videos.list.result', async function () {
-    const res = await getAccountVideos(servers[0].url, servers[0].accessToken, 'root', 0, 2)
+    const { total } = await servers[0].videos.listByAccount({ handle: 'root', start: 0, count: 2 })
 
     // Plugin do +2 to the total result
-    expect(res.body.total).to.equal(12)
+    expect(total).to.equal(12)
   })
 
   it('Should run filter:api.video-channels.videos.list.params', async function () {
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, 'root_channel', 0, 2)
+    const { data } = await servers[0].videos.listByChannel({ handle: 'root_channel', start: 0, count: 2 })
 
     // 1 plugin do +3 to the count parameter
-    expect(res.body.data).to.have.lengthOf(5)
+    expect(data).to.have.lengthOf(5)
   })
 
   it('Should run filter:api.video-channels.videos.list.result', async function () {
-    const res = await getVideoChannelVideos(servers[0].url, servers[0].accessToken, 'root_channel', 0, 2)
+    const { total } = await servers[0].videos.listByChannel({ handle: 'root_channel', start: 0, count: 2 })
 
     // Plugin do +3 to the total result
-    expect(res.body.total).to.equal(13)
+    expect(total).to.equal(13)
   })
 
   it('Should run filter:api.user.me.videos.list.params', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 2)
+    const { data } = await servers[0].videos.listMyVideos({ start: 0, count: 2 })
 
     // 1 plugin do +4 to the count parameter
-    expect(res.body.data).to.have.lengthOf(6)
+    expect(data).to.have.lengthOf(6)
   })
 
   it('Should run filter:api.user.me.videos.list.result', async function () {
-    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 2)
+    const { total } = await servers[0].videos.listMyVideos({ start: 0, count: 2 })
 
     // Plugin do +4 to the total result
-    expect(res.body.total).to.equal(14)
+    expect(total).to.equal(14)
   })
 
   it('Should run filter:api.video.get.result', async function () {
-    const res = await getVideo(servers[0].url, videoUUID)
-
-    expect(res.body.name).to.contain('<3')
+    const video = await servers[0].videos.get({ id: videoUUID })
+    expect(video.name).to.contain('<3')
   })
 
   it('Should run filter:api.video.upload.accept.result', async function () {
-    await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video with bad word' }, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].videos.upload({ attributes: { name: 'video with bad word' }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.live-video.create.accept.result', async function () {
     const attributes = {
       name: 'video with bad word',
       privacy: VideoPrivacy.PUBLIC,
-      channelId: servers[0].videoChannel.id
+      channelId: servers[0].store.channel.id
     }
 
-    await createLive(servers[0].url, servers[0].accessToken, attributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].live.create({ fields: attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   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'
+      channelId: servers[0].store.channel.id,
+      targetUrl: FIXTURE_URLS.goodVideo + 'bad'
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].imports.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,
+      channelId: servers[0].store.channel.id,
       torrentfile: 'video-720p.torrent' as any
     }
-    await importVideo(servers[0].url, servers[0].accessToken, baseAttributes, HttpStatusCode.FORBIDDEN_403)
+    await servers[0].imports.importVideo({ attributes, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should run filter:api.video.post-import-url.accept.result', async function () {
@@ -196,21 +156,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()
+        channelId: servers[0].store.channel.id,
+        targetUrl: FIXTURE_URLS.goodVideo
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, baseAttributes)
-      videoImportId = res.body.id
+      const body = await servers[0].imports.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].imports.getMyVideoImports()
+      const videoImports = body.data
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -225,21 +185,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,
+        channelId: servers[0].store.channel.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].imports.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].imports.getMyVideoImports()
 
       const videoImport = videoImports.find(i => i.id === videoImportId)
 
@@ -249,60 +208,63 @@ describe('Test plugin filter hooks', function () {
   })
 
   it('Should run filter:api.video-thread.create.accept.result', async function () {
-    await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'comment with bad word', HttpStatusCode.FORBIDDEN_403)
+    await servers[0].comments.createThread({
+      videoId: videoUUID,
+      text: 'comment with bad word',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
   })
 
   it('Should run filter:api.video-comment-reply.create.accept.result', async function () {
-    const res = await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'thread')
-    threadId = res.body.comment.id
-
-    await addVideoCommentReply(
-      servers[0].url,
-      servers[0].accessToken,
-      videoUUID,
-      threadId,
-      'comment with bad word',
-      HttpStatusCode.FORBIDDEN_403
-    )
-    await addVideoCommentReply(servers[0].url, servers[0].accessToken, videoUUID, threadId, 'comment with good word', HttpStatusCode.OK_200)
+    const created = await servers[0].comments.createThread({ videoId: videoUUID, text: 'thread' })
+    threadId = created.id
+
+    await servers[0].comments.addReply({
+      videoId: videoUUID,
+      toCommentId: threadId,
+      text: 'comment with bad word',
+      expectedStatus: HttpStatusCode.FORBIDDEN_403
+    })
+    await servers[0].comments.addReply({
+      videoId: videoUUID,
+      toCommentId: threadId,
+      text: 'comment with good word',
+      expectedStatus: HttpStatusCode.OK_200
+    })
   })
 
   it('Should run filter:api.video-threads.list.params', async function () {
-    const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 0)
+    const { data } = await servers[0].comments.listThreads({ videoId: videoUUID, start: 0, count: 0 })
 
     // our plugin do +1 to the count parameter
-    expect(res.body.data).to.have.lengthOf(1)
+    expect(data).to.have.lengthOf(1)
   })
 
   it('Should run filter:api.video-threads.list.result', async function () {
-    const res = await getVideoCommentThreads(servers[0].url, videoUUID, 0, 0)
+    const { total } = await servers[0].comments.listThreads({ videoId: videoUUID, start: 0, count: 0 })
 
     // Plugin do +1 to the total result
-    expect(res.body.total).to.equal(2)
+    expect(total).to.equal(2)
   })
 
   it('Should run filter:api.video-thread-comments.list.params')
 
   it('Should run filter:api.video-thread-comments.list.result', async function () {
-    const res = await getVideoThreadComments(servers[0].url, videoUUID, threadId)
+    const thread = await servers[0].comments.getThread({ videoId: videoUUID, threadId })
 
-    const thread = res.body as VideoCommentThreadTree
     expect(thread.comment.text.endsWith(' <3')).to.be.true
   })
 
   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)
-      const video: VideoDetails = res.body
+    async function checkIsBlacklisted (id: number | string, value: boolean) {
+      const video = await servers[0].videos.getWithToken({ id })
       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)
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video please blacklist me' } })
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on import', async function () {
@@ -310,60 +272,62 @@ describe('Test plugin filter hooks', function () {
 
       const attributes = {
         name: 'video please blacklist me',
-        targetUrl: getGoodVideoUrl(),
-        channelId: servers[0].videoChannel.id
+        targetUrl: FIXTURE_URLS.goodVideo,
+        channelId: servers[0].store.channel.id
       }
-      const res = await importVideo(servers[0].url, servers[0].accessToken, attributes)
-      await checkIsBlacklisted(res, true)
+      const body = await servers[0].imports.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)
+      const { uuid } = await servers[0].videos.upload({ attributes: { name: 'video' } })
+      await checkIsBlacklisted(uuid, false)
 
-      await updateVideo(servers[0].url, servers[0].accessToken, videoId, { name: 'please blacklist me' })
-      await checkIsBlacklisted(res, true)
+      await servers[0].videos.update({ id: uuid, attributes: { name: 'please blacklist me' } })
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on remote upload', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'remote please blacklist me' })
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'remote please blacklist me' } })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(uuid, true)
     })
 
     it('Should blacklist on remote update', async function () {
       this.timeout(120000)
 
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video' })
+      const { uuid } = await servers[1].videos.upload({ attributes: { name: 'video' } })
       await waitJobs(servers)
 
-      const videoId = res.body.video.uuid
-      await checkIsBlacklisted(res, false)
+      await checkIsBlacklisted(uuid, false)
 
-      await updateVideo(servers[1].url, servers[1].accessToken, videoId, { name: 'please blacklist me' })
+      await servers[1].videos.update({ id: uuid, attributes: { name: 'please blacklist me' } })
       await waitJobs(servers)
 
-      await checkIsBlacklisted(res, true)
+      await checkIsBlacklisted(uuid, true)
     })
   })
 
   describe('Should run filter:api.user.signup.allowed.result', function () {
 
     it('Should run on config endpoint', async function () {
-      const res = await getConfig(servers[0].url)
-      expect((res.body as ServerConfig).signup.allowed).to.be.true
+      const body = await servers[0].config.getConfig()
+      expect(body.signup.allowed).to.be.true
     })
 
     it('Should allow a signup', async function () {
-      await registerUser(servers[0].url, 'john', 'password')
+      await servers[0].users.register({ username: 'john', password: 'password' })
     })
 
     it('Should not allow a signup', async function () {
-      const res = await registerUser(servers[0].url, 'jma', 'password', HttpStatusCode.FORBIDDEN_403)
+      const res = await servers[0].users.register({
+        username: 'jma',
+        password: 'password',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
 
       expect(res.body.error).to.equal('No jma')
     })
@@ -375,13 +339,15 @@ describe('Test plugin filter hooks', function () {
     before(async function () {
       this.timeout(120000)
 
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          webtorrent: {
-            enabled: true
-          },
-          hls: {
-            enabled: true
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            webtorrent: {
+              enabled: true
+            },
+            hls: {
+              enabled: true
+            }
           }
         }
       })
@@ -389,15 +355,14 @@ describe('Test plugin filter hooks', function () {
       const uuids: string[] = []
 
       for (const name of [ 'bad torrent', 'bad file', 'bad playlist file' ]) {
-        const uuid = (await uploadVideoAndGetId({ server: servers[0], videoName: name })).uuid
+        const uuid = (await servers[0].videos.quickUpload({ name: name })).uuid
         uuids.push(uuid)
       }
 
       await waitJobs(servers)
 
       for (const uuid of uuids) {
-        const res = await getVideo(servers[0].url, uuid)
-        downloadVideos.push(res.body)
+        downloadVideos.push(await servers[0].videos.get({ id: uuid }))
       }
     })
 
@@ -437,25 +402,26 @@ describe('Test plugin filter hooks', function () {
     before(async function () {
       this.timeout(60000)
 
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        transcoding: {
-          enabled: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          transcoding: {
+            enabled: false
+          }
         }
       })
 
       for (const name of [ 'bad embed', 'good embed' ]) {
         {
-          const uuid = (await uploadVideoAndGetId({ server: servers[0], videoName: name })).uuid
-          const res = await getVideo(servers[0].url, uuid)
-          embedVideos.push(res.body)
+          const uuid = (await servers[0].videos.quickUpload({ name: name })).uuid
+          embedVideos.push(await servers[0].videos.get({ id: uuid }))
         }
 
         {
-          const playlistAttrs = { displayName: name, videoChannelId: servers[0].videoChannel.id, privacy: VideoPlaylistPrivacy.PUBLIC }
-          const res = await createVideoPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistAttrs })
+          const attributes = { displayName: name, videoChannelId: servers[0].store.channel.id, privacy: VideoPlaylistPrivacy.PUBLIC }
+          const { id } = await servers[0].playlists.create({ attributes })
 
-          const resPlaylist = await getVideoPlaylist(servers[0].url, res.body.videoPlaylist.id)
-          embedPlaylists.push(resPlaylist.body)
+          const playlist = await servers[0].playlists.get({ playlistId: id })
+          embedPlaylists.push(playlist)
         }
       }
     })
@@ -474,78 +440,92 @@ describe('Test plugin filter hooks', function () {
   describe('Search filters', function () {
 
     before(async function () {
-      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
-        search: {
-          searchIndex: {
-            enabled: true,
-            isDefaultSearch: false,
-            disableLocalSearch: false
+      await servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          search: {
+            searchIndex: {
+              enabled: true,
+              isDefaultSearch: false,
+              disableLocalSearch: false
+            }
           }
         }
       })
     })
 
     it('Should run filter:api.search.videos.local.list.{params,result}', async function () {
-      await advancedVideosSearch(servers[0].url, {
-        search: 'Sun Quan'
+      await servers[0].search.advancedVideoSearch({
+        search: {
+          search: 'Sun Quan'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.result', 1)
     })
 
     it('Should run filter:api.search.videos.index.list.{params,result}', async function () {
-      await advancedVideosSearch(servers[0].url, {
-        search: 'Sun Quan',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedVideoSearch({
+        search: {
+          search: 'Sun Quan',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.videos.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.videos.index.list.result', 1)
     })
 
     it('Should run filter:api.search.video-channels.local.list.{params,result}', async function () {
-      await advancedVideoChannelSearch(servers[0].url, {
-        search: 'Sun Ce'
+      await servers[0].search.advancedChannelSearch({
+        search: {
+          search: 'Sun Ce'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.result', 1)
     })
 
     it('Should run filter:api.search.video-channels.index.list.{params,result}', async function () {
-      await advancedVideoChannelSearch(servers[0].url, {
-        search: 'Sun Ce',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedChannelSearch({
+        search: {
+          search: 'Sun Ce',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-channels.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-channels.index.list.result', 1)
     })
 
     it('Should run filter:api.search.video-playlists.local.list.{params,result}', async function () {
-      await advancedVideoPlaylistSearch(servers[0].url, {
-        search: 'Sun Jian'
+      await servers[0].search.advancedPlaylistSearch({
+        search: {
+          search: 'Sun Jian'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.result', 1)
     })
 
     it('Should run filter:api.search.video-playlists.index.list.{params,result}', async function () {
-      await advancedVideoPlaylistSearch(servers[0].url, {
-        search: 'Sun Jian',
-        searchTarget: 'search-index'
+      await servers[0].search.advancedPlaylistSearch({
+        search: {
+          search: 'Sun Jian',
+          searchTarget: 'search-index'
+        }
       })
 
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.local.list.result', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.index.list.params', 1)
-      await waitUntilLog(servers[0], 'Run hook filter:api.search.video-playlists.index.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.local.list.result', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.index.list.params', 1)
+      await servers[0].servers.waitUntilLog('Run hook filter:api.search.video-playlists.index.list.result', 1)
     })
   })