Tests directories refractor

11 files changed, 2712 insertions, 0 deletions

diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
new file mode 100644
index 000000000..84f730a8e
--- /dev/null
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -0,0 +1,861 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { join } from 'path'
+import * as request from 'supertest'
+import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
+
+import {
+  addVideoChannel, dateIsValid, doubleFollow, flushAndRunMultipleServers, flushTests, getUserAccessToken, getVideo,
+  getVideoChannelsList, getVideosList, killallServers, rateVideo, removeVideo, ServerInfo, setAccessTokensToServers, testVideoImage,
+  updateVideo, uploadVideo, wait, webtorrentAdd
+} from '../../utils/index'
+import { createUser } from '../../utils/users/users'
+import {
+  addVideoCommentReply, addVideoCommentThread, getVideoCommentThreads,
+  getVideoThreadComments
+} from '../../utils/videos/video-comments'
+import { viewVideo } from '../../utils/videos/videos'
+
+const expect = chai.expect
+
+describe('Test multiple servers', function () {
+  let servers: ServerInfo[] = []
+  const toRemove = []
+  let videoUUID = ''
+  let videoChannelId: number
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await flushAndRunMultipleServers(3)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    const videoChannel = {
+      name: 'my channel',
+      description: 'super channel'
+    }
+    await addVideoChannel(servers[0].url, servers[0].accessToken, videoChannel)
+    const channelRes = await getVideoChannelsList(servers[0].url, 0, 1)
+    videoChannelId = channelRes.body.data[0].id
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+    // Server 1 and server 3 follow each other
+    await doubleFollow(servers[0], servers[2])
+    // Server 2 and server 3 follow each other
+    await doubleFollow(servers[1], servers[2])
+  })
+
+  it('Should not have videos for all servers', async function () {
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(0)
+    }
+  })
+
+  describe('Should upload the video and propagate on each server', function () {
+    it('Should upload the video on server 1 and propagate on each server', async function () {
+      this.timeout(25000)
+
+      const videoAttributes = {
+        name: 'my super name for server 1',
+        category: 5,
+        licence: 4,
+        language: 9,
+        nsfw: true,
+        description: 'my super description for server 1',
+        tags: [ 'tag1p1', 'tag2p1' ],
+        channelId: videoChannelId,
+        fixture: 'video_short1.webm'
+      }
+      await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+
+      await wait(10000)
+
+      // All servers should have this video
+      for (const server of servers) {
+        let baseMagnet = null
+
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        expect(videos).to.be.an('array')
+        expect(videos.length).to.equal(1)
+        const video = videos[0]
+        expect(video.name).to.equal('my super name for server 1')
+        expect(video.category).to.equal(5)
+        expect(video.categoryLabel).to.equal('Sports')
+        expect(video.licence).to.equal(4)
+        expect(video.licenceLabel).to.equal('Attribution - Non Commercial')
+        expect(video.language).to.equal(9)
+        expect(video.languageLabel).to.equal('Japanese')
+        expect(video.nsfw).to.be.ok
+        expect(video.description).to.equal('my super description for server 1')
+        expect(video.serverHost).to.equal('localhost:9001')
+        expect(video.duration).to.equal(10)
+        expect(dateIsValid(video.createdAt)).to.be.true
+        expect(dateIsValid(video.updatedAt)).to.be.true
+        expect(video.accountName).to.equal('root')
+
+        const res2 = await getVideo(server.url, video.uuid)
+        const videoDetails = res2.body
+
+        expect(videoDetails.channel.name).to.equal('my channel')
+        expect(videoDetails.channel.description).to.equal('super channel')
+        expect(videoDetails.account.name).to.equal('root')
+        expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
+        expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
+        expect(videoDetails.files).to.have.lengthOf(1)
+        expect(videoDetails.tags).to.deep.equal([ 'tag1p1', 'tag2p1' ])
+
+        const file = videoDetails.files[0]
+        const magnetUri = file.magnetUri
+        expect(file.magnetUri).to.have.lengthOf.above(2)
+        expect(file.torrentUrl).to
+          .equal(`http://${videoDetails.serverHost}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
+        expect(file.fileUrl).to.equal(`http://${videoDetails.serverHost}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
+        expect(file.resolution).to.equal(720)
+        expect(file.resolutionLabel).to.equal('720p')
+        expect(file.size).to.equal(572456)
+
+        if (server.url !== 'http://localhost:9001') {
+          expect(video.isLocal).to.be.false
+          expect(videoDetails.channel.isLocal).to.be.false
+        } else {
+          expect(video.isLocal).to.be.true
+          expect(videoDetails.channel.isLocal).to.be.true
+        }
+
+        // All servers should have the same magnet Uri
+        if (baseMagnet === null) {
+          baseMagnet = magnetUri
+        } else {
+          expect(baseMagnet).to.equal(magnetUri)
+        }
+
+        const test = await testVideoImage(server.url, 'video_short1.webm', video.thumbnailPath)
+        expect(test).to.equal(true)
+      }
+    })
+
+    it('Should upload the video on server 2 and propagate on each server', async function () {
+      this.timeout(50000)
+
+      const user = {
+        username: 'user1',
+        password: 'super_password'
+      }
+      await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
+      const userAccessToken = await getUserAccessToken(servers[1], user)
+
+      const videoAttributes = {
+        name: 'my super name for server 2',
+        category: 4,
+        licence: 3,
+        language: 11,
+        nsfw: true,
+        description: 'my super description for server 2',
+        tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
+        fixture: 'video_short2.webm'
+      }
+      await uploadVideo(servers[1].url, userAccessToken, videoAttributes)
+
+      // Transcoding
+      await wait(30000)
+
+      // All servers should have this video
+      for (const server of servers) {
+        let baseMagnet = {}
+
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        expect(videos).to.be.an('array')
+        expect(videos.length).to.equal(2)
+        const video = videos[1]
+        expect(video.name).to.equal('my super name for server 2')
+        expect(video.category).to.equal(4)
+        expect(video.categoryLabel).to.equal('Art')
+        expect(video.licence).to.equal(3)
+        expect(video.licenceLabel).to.equal('Attribution - No Derivatives')
+        expect(video.language).to.equal(11)
+        expect(video.languageLabel).to.equal('German')
+        expect(video.nsfw).to.be.true
+        expect(video.description).to.equal('my super description for server 2')
+        expect(video.serverHost).to.equal('localhost:9002')
+        expect(video.duration).to.equal(5)
+        expect(dateIsValid(video.createdAt)).to.be.true
+        expect(dateIsValid(video.updatedAt)).to.be.true
+        expect(video.accountName).to.equal('user1')
+
+        if (server.url !== 'http://localhost:9002') {
+          expect(video.isLocal).to.be.false
+        } else {
+          expect(video.isLocal).to.be.true
+        }
+
+        const res2 = await getVideo(server.url, video.uuid)
+        const videoDetails = res2.body
+
+        expect(videoDetails.channel.name).to.equal('Default user1 channel')
+        expect(dateIsValid(videoDetails.channel.createdAt)).to.be.true
+        expect(dateIsValid(videoDetails.channel.updatedAt)).to.be.true
+        expect(videoDetails.tags).to.deep.equal([ 'tag1p2', 'tag2p2', 'tag3p2' ])
+
+        expect(videoDetails.files).to.have.lengthOf(4)
+
+        // Check common attributes
+        for (const file of videoDetails.files) {
+          expect(file.magnetUri).to.have.lengthOf.above(2)
+
+          // All servers should have the same magnet Uri
+          if (baseMagnet[file.resolution] === undefined) {
+            baseMagnet[file.resolution] = file.magnet
+          } else {
+            expect(baseMagnet[file.resolution]).to.equal(file.magnet)
+          }
+        }
+
+        const file240p = videoDetails.files.find(f => f.resolution === 240)
+        expect(file240p).not.to.be.undefined
+        expect(file240p.resolutionLabel).to.equal('240p')
+        expect(file240p.size).to.be.above(180000).and.below(200000)
+
+        const file360p = videoDetails.files.find(f => f.resolution === 360)
+        expect(file360p).not.to.be.undefined
+        expect(file360p.resolutionLabel).to.equal('360p')
+        expect(file360p.size).to.be.above(270000).and.below(290000)
+
+        const file480p = videoDetails.files.find(f => f.resolution === 480)
+        expect(file480p).not.to.be.undefined
+        expect(file480p.resolutionLabel).to.equal('480p')
+        expect(file480p.size).to.be.above(380000).and.below(400000)
+
+        const file720p = videoDetails.files.find(f => f.resolution === 720)
+        expect(file720p).not.to.be.undefined
+        expect(file720p.resolutionLabel).to.equal('720p')
+        expect(file720p.size).to.be.above(700000).and.below(7200000)
+
+        const test = await testVideoImage(server.url, 'video_short2.webm', videoDetails.thumbnailPath)
+        expect(test).to.equal(true)
+      }
+    })
+
+    it('Should upload two videos on server 3 and propagate on each server', async function () {
+      this.timeout(45000)
+
+      const videoAttributes1 = {
+        name: 'my super name for server 3',
+        category: 6,
+        licence: 5,
+        language: 11,
+        nsfw: true,
+        description: 'my super description for server 3',
+        tags: [ 'tag1p3' ],
+        fixture: 'video_short3.webm'
+      }
+      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes1)
+
+      const videoAttributes2 = {
+        name: 'my super name for server 3-2',
+        category: 7,
+        licence: 6,
+        language: 12,
+        nsfw: false,
+        description: 'my super description for server 3-2',
+        tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
+        fixture: 'video_short.webm'
+      }
+      await uploadVideo(servers[2].url, servers[2].accessToken, videoAttributes2)
+
+      await wait(10000)
+
+      let baseMagnet = null
+      // All servers should have this video
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        expect(videos).to.be.an('array')
+        expect(videos.length).to.equal(4)
+
+        // We not sure about the order of the two last uploads
+        let video1 = null
+        let video2 = null
+        if (videos[2].name === 'my super name for server 3') {
+          video1 = videos[2]
+          video2 = videos[3]
+        } else {
+          video1 = videos[3]
+          video2 = videos[2]
+        }
+
+        expect(video1.name).to.equal('my super name for server 3')
+        expect(video1.category).to.equal(6)
+        expect(video1.categoryLabel).to.equal('Travels')
+        expect(video1.licence).to.equal(5)
+        expect(video1.licenceLabel).to.equal('Attribution - Non Commercial - Share Alike')
+        expect(video1.language).to.equal(11)
+        expect(video1.languageLabel).to.equal('German')
+        expect(video1.nsfw).to.be.ok
+        expect(video1.description).to.equal('my super description for server 3')
+        expect(video1.serverHost).to.equal('localhost:9003')
+        expect(video1.duration).to.equal(5)
+        expect(video1.accountName).to.equal('root')
+        expect(dateIsValid(video1.createdAt)).to.be.true
+        expect(dateIsValid(video1.updatedAt)).to.be.true
+
+        const res2 = await getVideo(server.url, video1.id)
+        const video1Details = res2.body
+        expect(video1Details.files).to.have.lengthOf(1)
+        expect(video1Details.tags).to.deep.equal([ 'tag1p3' ])
+
+        const file1 = video1Details.files[0]
+        expect(file1.magnetUri).to.have.lengthOf.above(2)
+        expect(file1.resolution).to.equal(720)
+        expect(file1.resolutionLabel).to.equal('720p')
+        expect(file1.size).to.equal(292677)
+
+        expect(video2.name).to.equal('my super name for server 3-2')
+        expect(video2.category).to.equal(7)
+        expect(video2.categoryLabel).to.equal('Gaming')
+        expect(video2.licence).to.equal(6)
+        expect(video2.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+        expect(video2.language).to.equal(12)
+        expect(video2.languageLabel).to.equal('Korean')
+        expect(video2.nsfw).to.be.false
+        expect(video2.description).to.equal('my super description for server 3-2')
+        expect(video2.serverHost).to.equal('localhost:9003')
+        expect(video2.duration).to.equal(5)
+        expect(video2.accountName).to.equal('root')
+        expect(dateIsValid(video2.createdAt)).to.be.true
+        expect(dateIsValid(video2.updatedAt)).to.be.true
+
+        const res3 = await getVideo(server.url, video2.id)
+        const video2Details = res3.body
+        expect(video2Details.tags).to.deep.equal([ 'tag2p3', 'tag3p3', 'tag4p3' ])
+
+        expect(video2Details.files).to.have.lengthOf(1)
+
+        const file2 = video2Details.files[0]
+        const magnetUri2 = file2.magnetUri
+        expect(file2.magnetUri).to.have.lengthOf.above(2)
+        expect(file2.resolution).to.equal(720)
+        expect(file2.resolutionLabel).to.equal('720p')
+        expect(file2.size).to.equal(218910)
+
+        if (server.url !== 'http://localhost:9003') {
+          expect(video1.isLocal).to.be.false
+          expect(video2.isLocal).to.be.false
+        } else {
+          expect(video1.isLocal).to.be.true
+          expect(video2.isLocal).to.be.true
+        }
+
+        // All servers should have the same magnet Uri
+        if (baseMagnet === null) {
+          baseMagnet = magnetUri2
+        } else {
+          expect(baseMagnet).to.equal(magnetUri2)
+        }
+
+        const test1 = await testVideoImage(server.url, 'video_short3.webm', video1.thumbnailPath)
+        expect(test1).to.equal(true)
+
+        const test2 = await testVideoImage(server.url, 'video_short.webm', video2.thumbnailPath)
+        expect(test2).to.equal(true)
+      }
+    })
+  })
+
+  describe('Should seed the uploaded video', function () {
+    it('Should add the file 1 by asking server 3', async function () {
+      this.timeout(10000)
+
+      const res = await getVideosList(servers[2].url)
+
+      const video = res.body.data[0]
+      toRemove.push(res.body.data[2])
+      toRemove.push(res.body.data[3])
+
+      const res2 = await getVideo(servers[2].url, video.id)
+      const videoDetails = res2.body
+
+      const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    })
+
+    it('Should add the file 2 by asking server 1', async function () {
+      this.timeout(10000)
+
+      const res = await getVideosList(servers[0].url)
+
+      const video = res.body.data[1]
+      const res2 = await getVideo(servers[0].url, video.id)
+      const videoDetails = res2.body
+
+      const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    })
+
+    it('Should add the file 3 by asking server 2', async function () {
+      this.timeout(10000)
+
+      const res = await getVideosList(servers[1].url)
+
+      const video = res.body.data[2]
+      const res2 = await getVideo(servers[1].url, video.id)
+      const videoDetails = res2.body
+
+      const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    })
+
+    it('Should add the file 3-2 by asking server 1', async function () {
+      this.timeout(10000)
+
+      const res = await getVideosList(servers[0].url)
+
+      const video = res.body.data[3]
+      const res2 = await getVideo(servers[0].url, video.id)
+      const videoDetails = res2.body
+
+      const torrent = await webtorrentAdd(videoDetails.files[0].magnetUri)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    })
+
+    it('Should add the file 2 in 360p by asking server 1', async function () {
+      this.timeout(10000)
+
+      const res = await getVideosList(servers[0].url)
+
+      const video = res.body.data.find(v => v.name === 'my super name for server 2')
+      const res2 = await getVideo(servers[0].url, video.id)
+      const videoDetails = res2.body
+
+      const file = videoDetails.files.find(f => f.resolution === 360)
+      expect(file).not.to.be.undefined
+
+      const torrent = await webtorrentAdd(file.magnetUri)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    })
+  })
+
+  describe('Should update video views, likes and dislikes', function () {
+    let localVideosServer3 = []
+    let remoteVideosServer1 = []
+    let remoteVideosServer2 = []
+    let remoteVideosServer3 = []
+
+    before(async function () {
+      const res1 = await getVideosList(servers[0].url)
+      remoteVideosServer1 = res1.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+
+      const res2 = await getVideosList(servers[1].url)
+      remoteVideosServer2 = res2.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+
+      const res3 = await getVideosList(servers[2].url)
+      localVideosServer3 = res3.body.data.filter(video => video.isLocal === true).map(video => video.uuid)
+      remoteVideosServer3 = res3.body.data.filter(video => video.isLocal === false).map(video => video.uuid)
+    })
+
+    it('Should view multiple videos on owned servers', async function () {
+      this.timeout(10000)
+
+      const tasks: Promise<any>[] = []
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[0]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[0]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[0]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+
+      await Promise.all(tasks)
+
+      await wait(5000)
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        const video0 = videos.find(v => v.uuid === localVideosServer3[0])
+        const video1 = videos.find(v => v.uuid === localVideosServer3[1])
+
+        expect(video0.views).to.equal(3)
+        expect(video1.views).to.equal(1)
+      }
+    })
+
+    it('Should view multiple videos on each servers', async function () {
+      this.timeout(15000)
+
+      const tasks: Promise<any>[] = []
+      tasks.push(viewVideo(servers[0].url, remoteVideosServer1[0]))
+      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
+      tasks.push(viewVideo(servers[1].url, remoteVideosServer2[0]))
+      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[0]))
+      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
+      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
+      tasks.push(viewVideo(servers[2].url, remoteVideosServer3[1]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+      tasks.push(viewVideo(servers[2].url, localVideosServer3[1]))
+
+      await Promise.all(tasks)
+
+      await wait(10000)
+
+      let baseVideos = null
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+
+        // Initialize base videos for future comparisons
+        if (baseVideos === null) {
+          baseVideos = videos
+          continue
+        }
+
+        for (const baseVideo of baseVideos) {
+          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          expect(baseVideo.views).to.equal(sameVideo.views)
+        }
+      }
+    })
+
+    it('Should like and dislikes videos on different services', async function () {
+      this.timeout(20000)
+
+      const tasks: Promise<any>[] = []
+      tasks.push(rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like'))
+      tasks.push(rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'dislike'))
+      tasks.push(rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like'))
+      tasks.push(rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'like'))
+      tasks.push(rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'dislike'))
+      tasks.push(rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[1], 'dislike'))
+      tasks.push(rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[0], 'like'))
+
+      await Promise.all(tasks)
+
+      await wait(10000)
+
+      let baseVideos = null
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+
+        // Initialize base videos for future comparisons
+        if (baseVideos === null) {
+          baseVideos = videos
+          continue
+        }
+
+        for (const baseVideo of baseVideos) {
+          const sameVideo = videos.find(video => video.name === baseVideo.name)
+          expect(baseVideo.likes).to.equal(sameVideo.likes)
+          expect(baseVideo.dislikes).to.equal(sameVideo.dislikes)
+        }
+      }
+    })
+  })
+
+  describe('Should manipulate these videos', function () {
+    it('Should update the video 3 by asking server 3', async function () {
+      this.timeout(10000)
+
+      const attributes = {
+        name: 'my super video updated',
+        category: 10,
+        licence: 7,
+        language: 13,
+        nsfw: true,
+        description: 'my super description updated',
+        tags: [ 'tag_up_1', 'tag_up_2' ]
+      }
+
+      await updateVideo(servers[2].url, servers[2].accessToken, toRemove[0].id, attributes)
+
+      await wait(5000)
+    })
+
+    it('Should have the video 3 updated on each server', async function () {
+      this.timeout(10000)
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        const videoUpdated = videos.find(video => video.name === 'my super video updated')
+
+        expect(!!videoUpdated).to.be.true
+        expect(videoUpdated.category).to.equal(10)
+        expect(videoUpdated.categoryLabel).to.equal('Entertainment')
+        expect(videoUpdated.licence).to.equal(7)
+        expect(videoUpdated.licenceLabel).to.equal('Public Domain Dedication')
+        expect(videoUpdated.language).to.equal(13)
+        expect(videoUpdated.languageLabel).to.equal('French')
+        expect(videoUpdated.nsfw).to.be.ok
+        expect(videoUpdated.description).to.equal('my super description updated')
+        expect(dateIsValid(videoUpdated.updatedAt, 20000)).to.be.true
+
+        const res2 = await getVideo(server.url, videoUpdated.uuid)
+        const videoUpdatedDetails = res2.body
+        expect(videoUpdatedDetails.tags).to.deep.equal([ 'tag_up_1', 'tag_up_2' ])
+
+        const file = videoUpdatedDetails.files[0]
+        expect(file.magnetUri).to.have.lengthOf.above(2)
+        expect(file.resolution).to.equal(720)
+        expect(file.resolutionLabel).to.equal('720p')
+        expect(file.size).to.equal(292677)
+
+        const test = await testVideoImage(server.url, 'video_short3.webm', videoUpdated.thumbnailPath)
+        expect(test).to.equal(true)
+
+        // Avoid "duplicate torrent" errors
+        const refreshWebTorrent = true
+        const torrent = await webtorrentAdd(videoUpdatedDetails .files[0].magnetUri, refreshWebTorrent)
+        expect(torrent.files).to.be.an('array')
+        expect(torrent.files.length).to.equal(1)
+        expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+      }
+    })
+
+    it('Should remove the videos 3 and 3-2 by asking server 3', async function () {
+      this.timeout(10000)
+
+      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[0].id)
+      await removeVideo(servers[2].url, servers[2].accessToken, toRemove[1].id)
+
+      await wait(5000)
+    })
+
+    it('Should have videos 1 and 3 on each server', async function () {
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+
+        const videos = res.body.data
+        expect(videos).to.be.an('array')
+        expect(videos.length).to.equal(2)
+        expect(videos[0].name).not.to.equal(videos[1].name)
+        expect(videos[0].name).not.to.equal(toRemove[0].name)
+        expect(videos[1].name).not.to.equal(toRemove[0].name)
+        expect(videos[0].name).not.to.equal(toRemove[1].name)
+        expect(videos[1].name).not.to.equal(toRemove[1].name)
+
+        videoUUID = videos.find(video => video.name === 'my super name for server 1').uuid
+      }
+    })
+
+    it('Should get the same video by UUID on each server', async function () {
+      let baseVideo = null
+      for (const server of servers) {
+        const res = await getVideo(server.url, videoUUID)
+
+        const video = res.body
+
+        if (baseVideo === null) {
+          baseVideo = video
+          continue
+        }
+
+        expect(baseVideo.name).to.equal(video.name)
+        expect(baseVideo.uuid).to.equal(video.uuid)
+        expect(baseVideo.category).to.equal(video.category)
+        expect(baseVideo.language).to.equal(video.language)
+        expect(baseVideo.licence).to.equal(video.licence)
+        expect(baseVideo.category).to.equal(video.category)
+        expect(baseVideo.nsfw).to.equal(video.nsfw)
+        expect(baseVideo.accountName).to.equal(video.accountName)
+        expect(baseVideo.tags).to.deep.equal(video.tags)
+      }
+    })
+
+    it('Should get the preview from each server', async function () {
+      for (const server of servers) {
+        const res = await getVideo(server.url, videoUUID)
+        const video = res.body
+
+        const test = await testVideoImage(server.url, 'video_short1-preview.webm', video.previewPath)
+        expect(test).to.equal(true)
+      }
+    })
+  })
+
+  describe('Should comment these videos', function () {
+    it('Should add comment (threads and replies)', async function () {
+      this.timeout(25000)
+
+      {
+        const text = 'my super first comment'
+        await addVideoCommentThread(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID, text)
+      }
+
+      {
+        const text = 'my super second comment'
+        await addVideoCommentThread(servers[ 2 ].url, servers[ 2 ].accessToken, videoUUID, text)
+      }
+
+      await wait(5000)
+
+      {
+        const res = await getVideoCommentThreads(servers[1].url, videoUUID, 0, 5)
+        const threadId = res.body.data.find(c => c.text === 'my super first comment').id
+
+        const text = 'my super answer to thread 1'
+        await addVideoCommentReply(servers[ 1 ].url, servers[ 1 ].accessToken, videoUUID, threadId, text)
+      }
+
+      await wait(5000)
+
+      {
+        const res1 = await getVideoCommentThreads(servers[2].url, videoUUID, 0, 5)
+        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
+
+        const res2 = await getVideoThreadComments(servers[2].url, videoUUID, threadId)
+        const childCommentId = res2.body.children[0].comment.id
+
+        const text3 = 'my second answer to thread 1'
+        await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, videoUUID, threadId, text3)
+
+        const text2 = 'my super answer to answer of thread 1'
+        await addVideoCommentReply(servers[ 2 ].url, servers[ 2 ].accessToken, videoUUID, childCommentId, text2)
+      }
+
+      await wait(5000)
+    })
+
+    it('Should have these threads', async function () {
+      for (const server of servers) {
+        const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+
+        expect(res.body.total).to.equal(2)
+        expect(res.body.data).to.be.an('array')
+        expect(res.body.data).to.have.lengthOf(2)
+
+        {
+          const comment: VideoComment = res.body.data.find(c => c.text === 'my super first comment')
+          expect(comment).to.not.be.undefined
+          expect(comment.inReplyToCommentId).to.be.null
+          expect(comment.account.name).to.equal('root')
+          expect(comment.account.host).to.equal('localhost:9001')
+          expect(comment.totalReplies).to.equal(3)
+          expect(dateIsValid(comment.createdAt as string)).to.be.true
+          expect(dateIsValid(comment.updatedAt as string)).to.be.true
+        }
+
+        {
+          const comment: VideoComment = res.body.data.find(c => c.text === 'my super second comment')
+          expect(comment).to.not.be.undefined
+          expect(comment.inReplyToCommentId).to.be.null
+          expect(comment.account.name).to.equal('root')
+          expect(comment.account.host).to.equal('localhost:9003')
+          expect(comment.totalReplies).to.equal(0)
+          expect(dateIsValid(comment.createdAt as string)).to.be.true
+          expect(dateIsValid(comment.updatedAt as string)).to.be.true
+        }
+      }
+    })
+
+    it('Should have these comments', async function () {
+      for (const server of servers) {
+        const res1 = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+        const threadId = res1.body.data.find(c => c.text === 'my super first comment').id
+
+        const res2 = await getVideoThreadComments(server.url, videoUUID, threadId)
+
+        const tree: VideoCommentThreadTree = res2.body
+        expect(tree.comment.text).equal('my super first comment')
+        expect(tree.comment.account.name).equal('root')
+        expect(tree.comment.account.host).equal('localhost:9001')
+        expect(tree.children).to.have.lengthOf(2)
+
+        const firstChild = tree.children[0]
+        expect(firstChild.comment.text).to.equal('my super answer to thread 1')
+        expect(firstChild.comment.account.name).equal('root')
+        expect(firstChild.comment.account.host).equal('localhost:9002')
+        expect(firstChild.children).to.have.lengthOf(1)
+
+        const childOfFirstChild = firstChild.children[0]
+        expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
+        expect(childOfFirstChild.comment.account.name).equal('root')
+        expect(childOfFirstChild.comment.account.host).equal('localhost:9003')
+        expect(childOfFirstChild.children).to.have.lengthOf(0)
+
+        const secondChild = tree.children[1]
+        expect(secondChild.comment.text).to.equal('my second answer to thread 1')
+        expect(secondChild.comment.account.name).equal('root')
+        expect(secondChild.comment.account.host).equal('localhost:9003')
+        expect(secondChild.children).to.have.lengthOf(0)
+      }
+    })
+  })
+
+  describe('With minimum parameters', function () {
+    it('Should upload and propagate the video', async function () {
+      this.timeout(50000)
+
+      const path = '/api/v1/videos/upload'
+
+      const req = request(servers[1].url)
+        .post(path)
+        .set('Accept', 'application/json')
+        .set('Authorization', 'Bearer ' + servers[1].accessToken)
+        .field('name', 'minimum parameters')
+        .field('privacy', '1')
+        .field('nsfw', 'false')
+        .field('channelId', '1')
+
+      const filePath = join(__dirname, '..', 'api', 'fixtures', 'video_short.webm')
+
+      await req.attach('videofile', filePath)
+        .expect(200)
+
+      await wait(25000)
+
+      for (const server of servers) {
+        const res = await getVideosList(server.url)
+        const video = res.body.data.find(v => v.name === 'minimum parameters')
+
+        expect(video.name).to.equal('minimum parameters')
+        expect(video.category).to.equal(null)
+        expect(video.categoryLabel).to.equal('Misc')
+        expect(video.licence).to.equal(null)
+        expect(video.licenceLabel).to.equal('Unknown')
+        expect(video.language).to.equal(null)
+        expect(video.languageLabel).to.equal('Unknown')
+        expect(video.nsfw).to.not.be.ok
+        expect(video.description).to.equal(null)
+        expect(video.serverHost).to.equal('localhost:9002')
+        expect(video.accountName).to.equal('root')
+        expect(dateIsValid(video.createdAt)).to.be.true
+        expect(dateIsValid(video.updatedAt)).to.be.true
+      }
+    })
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/services.ts b/server/tests/api/videos/services.ts
new file mode 100644
index 000000000..1cda464d9
--- /dev/null
+++ b/server/tests/api/videos/services.ts
@@ -0,0 +1,85 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import * as chai from 'chai'
+const expect = chai.expect
+
+import {
+  ServerInfo,
+  flushTests,
+  uploadVideo,
+  getVideosList,
+  setAccessTokensToServers,
+  killallServers,
+  getOEmbed
+} from '../../utils/index'
+import { runServer } from '../../utils/server/servers'
+
+describe('Test services', function () {
+  let server: ServerInfo = null
+
+  before(async function () {
+    this.timeout(10000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const videoAttributes = {
+      name: 'my super name'
+    }
+    await uploadVideo(server.url, server.accessToken, videoAttributes)
+
+    const res = await getVideosList(server.url)
+    server.video = res.body.data[0]
+  })
+
+  it('Should have a valid oEmbed response', async function () {
+    const oembedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+
+    const res = await getOEmbed(server.url, oembedUrl)
+    const expectedHtml = `<iframe width="560" height="315" src="http://localhost:9001/videos/embed/${server.video.uuid}" ` +
+                         'frameborder="0" allowfullscreen></iframe>'
+    const expectedThumbnailUrl = 'http://localhost:9001/static/previews/' + server.video.uuid + '.jpg'
+
+    expect(res.body.html).to.equal(expectedHtml)
+    expect(res.body.title).to.equal(server.video.name)
+    expect(res.body.author_name).to.equal(server.video.accountName)
+    expect(res.body.width).to.equal(560)
+    expect(res.body.height).to.equal(315)
+    expect(res.body.thumbnail_url).to.equal(expectedThumbnailUrl)
+    expect(res.body.thumbnail_width).to.equal(560)
+    expect(res.body.thumbnail_height).to.equal(315)
+  })
+
+  it('Should have a valid oEmbed response with small max height query', async function () {
+    const oembedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+    const format = 'json'
+    const maxHeight = 50
+    const maxWidth = 50
+
+    const res = await getOEmbed(server.url, oembedUrl, format, maxHeight, maxWidth)
+    const expectedHtml = `<iframe width="50" height="50" src="http://localhost:9001/videos/embed/${server.video.uuid}" ` +
+                         'frameborder="0" allowfullscreen></iframe>'
+
+    expect(res.body.html).to.equal(expectedHtml)
+    expect(res.body.title).to.equal(server.video.name)
+    expect(res.body.author_name).to.equal(server.video.accountName)
+    expect(res.body.height).to.equal(50)
+    expect(res.body.width).to.equal(50)
+    expect(res.body).to.not.have.property('thumbnail_url')
+    expect(res.body).to.not.have.property('thumbnail_width')
+    expect(res.body).to.not.have.property('thumbnail_height')
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
new file mode 100644
index 000000000..02723654d
--- /dev/null
+++ b/server/tests/api/videos/single-server.ts
@@ -0,0 +1,701 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import { keyBy } from 'lodash'
+import 'mocha'
+import { join } from 'path'
+import {
+  dateIsValid,
+  flushTests,
+  getVideo,
+  getVideoCategories,
+  getVideoLanguages,
+  getVideoLicences,
+  getVideoPrivacies,
+  getVideosList,
+  getVideosListPagination,
+  getVideosListSort,
+  killallServers,
+  rateVideo,
+  readdirPromise,
+  removeVideo,
+  runServer,
+  searchVideo,
+  searchVideoWithPagination,
+  searchVideoWithSort,
+  ServerInfo,
+  setAccessTokensToServers,
+  testVideoImage,
+  updateVideo,
+  uploadVideo,
+  wait,
+  webtorrentAdd
+} from '../../utils/index'
+import { viewVideo } from '../../utils/videos/videos'
+
+const expect = chai.expect
+
+describe('Test a single server', function () {
+  let server: ServerInfo = null
+  let videoId = -1
+  let videoUUID = ''
+  let videosListBase: any[] = null
+
+  before(async function () {
+    this.timeout(10000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should list video categories', async function () {
+    const res = await getVideoCategories(server.url)
+
+    const categories = res.body
+    expect(Object.keys(categories)).to.have.length.above(10)
+
+    expect(categories[11]).to.equal('News')
+  })
+
+  it('Should list video licences', async function () {
+    const res = await getVideoLicences(server.url)
+
+    const licences = res.body
+    expect(Object.keys(licences)).to.have.length.above(5)
+
+    expect(licences[3]).to.equal('Attribution - No Derivatives')
+  })
+
+  it('Should list video languages', async function () {
+    const res = await getVideoLanguages(server.url)
+
+    const languages = res.body
+    expect(Object.keys(languages)).to.have.length.above(5)
+
+    expect(languages[3]).to.equal('Mandarin')
+  })
+
+  it('Should list video privacies', async function () {
+    const res = await getVideoPrivacies(server.url)
+
+    const privacies = res.body
+    expect(Object.keys(privacies)).to.have.length.at.least(3)
+
+    expect(privacies[3]).to.equal('Private')
+  })
+
+  it('Should not have videos', async function () {
+    const res = await getVideosList(server.url)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(0)
+  })
+
+  it('Should upload the video', async function () {
+    const videoAttributes = {
+      name: 'my super name',
+      category: 2,
+      nsfw: true,
+      licence: 6,
+      tags: [ 'tag1', 'tag2', 'tag3' ]
+    }
+    const res = await uploadVideo(server.url, server.accessToken, videoAttributes)
+    expect(res.body.video).to.not.be.undefined
+    expect(res.body.video.id).to.equal(1)
+    expect(res.body.video.uuid).to.have.length.above(5)
+  })
+
+  it('Should seed the uploaded video', async function () {
+    // Yes, this could be long
+    this.timeout(60000)
+
+    const res = await getVideosList(server.url)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(1)
+
+    const video = res.body.data[0]
+    expect(video.name).to.equal('my super name')
+    expect(video.category).to.equal(2)
+    expect(video.categoryLabel).to.equal('Films')
+    expect(video.licence).to.equal(6)
+    expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+    expect(video.language).to.equal(3)
+    expect(video.languageLabel).to.equal('Mandarin')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('my super description')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+
+    const res2 = await getVideo(server.url, res.body.data[0].id)
+    const videoDetails = res2.body
+
+    expect(videoDetails.files).to.have.lengthOf(1)
+
+    const file = videoDetails.files[0]
+    const magnetUri = file.magnetUri
+    expect(file.magnetUri).to.have.lengthOf.above(2)
+    expect(file.torrentUrl).to.equal(`${server.url}/static/torrents/${videoDetails.uuid}-${file.resolution}.torrent`)
+    expect(file.fileUrl).to.equal(`${server.url}/static/webseed/${videoDetails.uuid}-${file.resolution}.webm`)
+    expect(file.resolution).to.equal(720)
+    expect(file.resolutionLabel).to.equal('720p')
+    expect(file.size).to.equal(218910)
+
+    const test = await testVideoImage(server.url, 'video_short.webm', videoDetails.thumbnailPath)
+    expect(test).to.equal(true)
+
+    videoId = videoDetails.id
+    videoUUID = videoDetails.uuid
+
+    const torrent = await webtorrentAdd(magnetUri)
+    expect(torrent.files).to.be.an('array')
+    expect(torrent.files.length).to.equal(1)
+    expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+  })
+
+  it('Should get the video', async function () {
+    // Yes, this could be long
+    this.timeout(60000)
+
+    const res = await getVideo(server.url, videoId)
+
+    const video = res.body
+    expect(video.name).to.equal('my super name')
+    expect(video.category).to.equal(2)
+    expect(video.categoryLabel).to.equal('Films')
+    expect(video.licence).to.equal(6)
+    expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+    expect(video.language).to.equal(3)
+    expect(video.languageLabel).to.equal('Mandarin')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('my super description')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+    expect(video.channel.name).to.equal('Default root channel')
+    expect(video.channel.isLocal).to.be.true
+    expect(dateIsValid(video.channel.createdAt)).to.be.true
+    expect(dateIsValid(video.channel.updatedAt)).to.be.true
+
+    expect(video.files).to.have.lengthOf(1)
+
+    const file = video.files[0]
+    expect(file.magnetUri).to.have.lengthOf.above(2)
+    expect(file.resolution).to.equal(720)
+    expect(file.resolutionLabel).to.equal('720p')
+    expect(file.size).to.equal(218910)
+
+    const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
+    expect(test).to.equal(true)
+
+    // Wait the async views increment
+    await wait(500)
+  })
+
+  it('Should get the video by UUID', async function () {
+    // Yes, this could be long
+    this.timeout(60000)
+
+    const res = await getVideo(server.url, videoUUID)
+
+    const video = res.body
+    expect(video.name).to.equal('my super name')
+
+    // Wait the async views increment
+    await wait(500)
+  })
+
+  it('Should have the views updated', async function () {
+    await viewVideo(server.url, videoId)
+    await viewVideo(server.url, videoId)
+    await viewVideo(server.url, videoId)
+
+    const res = await getVideo(server.url, videoId)
+
+    const video = res.body
+    expect(video.views).to.equal(3)
+  })
+
+  it('Should search the video by name', async function () {
+    const res = await searchVideo(server.url, 'my')
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(1)
+
+    const video = res.body.data[0]
+    expect(video.name).to.equal('my super name')
+    expect(video.category).to.equal(2)
+    expect(video.categoryLabel).to.equal('Films')
+    expect(video.licence).to.equal(6)
+    expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+    expect(video.language).to.equal(3)
+    expect(video.languageLabel).to.equal('Mandarin')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('my super description')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+
+    const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
+    expect(test).to.equal(true)
+  })
+
+  // Not implemented yet
+  // it('Should search the video by serverHost', async function () {
+  //     const res = await   videosUtils.searchVideo(server.url, '9001', 'host')
+
+  //     expect(res.body.total).to.equal(1)
+  //     expect(res.body.data).to.be.an('array')
+  //     expect(res.body.data.length).to.equal(1)
+
+  //     const video = res.body.data[0]
+  //     expect(video.name).to.equal('my super name')
+  //     expect(video.description).to.equal('my super description')
+  //     expect(video.serverHost).to.equal('localhost:9001')
+  //     expect(video.author).to.equal('root')
+  //     expect(video.isLocal).to.be.true
+  //     expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
+  //     expect(dateIsValid(video.createdAt)).to.be.true
+  //     expect(dateIsValid(video.updatedAt)).to.be.true
+
+  //     const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
+  //       expect(test).to.equal(true)
+
+  //       done()
+  //     })
+  //   })
+  // })
+
+  // Not implemented yet
+  // it('Should search the video by tag', async function () {
+  //   const res = await searchVideo(server.url, 'tag1')
+  //
+  //   expect(res.body.total).to.equal(1)
+  //   expect(res.body.data).to.be.an('array')
+  //   expect(res.body.data.length).to.equal(1)
+  //
+  //   const video = res.body.data[0]
+  //   expect(video.name).to.equal('my super name')
+  //   expect(video.category).to.equal(2)
+  //   expect(video.categoryLabel).to.equal('Films')
+  //   expect(video.licence).to.equal(6)
+  //   expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+  //   expect(video.language).to.equal(3)
+  //   expect(video.languageLabel).to.equal('Mandarin')
+  //   expect(video.nsfw).to.be.ok
+  //   expect(video.description).to.equal('my super description')
+  //   expect(video.serverHost).to.equal('localhost:9001')
+  //   expect(video.accountName).to.equal('root')
+  //   expect(video.isLocal).to.be.true
+  //   expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
+  //   expect(dateIsValid(video.createdAt)).to.be.true
+  //   expect(dateIsValid(video.updatedAt)).to.be.true
+  //
+  //   const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
+  //   expect(test).to.equal(true)
+  // })
+
+  it('Should not find a search by name', async function () {
+    const res = await searchVideo(server.url, 'hello')
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(0)
+  })
+
+  // Not implemented yet
+  // it('Should not find a search by author', async function () {
+  //   const res = await searchVideo(server.url, 'hello')
+  //
+  //   expect(res.body.total).to.equal(0)
+  //   expect(res.body.data).to.be.an('array')
+  //   expect(res.body.data.length).to.equal(0)
+  // })
+  //
+  // Not implemented yet
+  // it('Should not find a search by tag', async function () {
+  //   const res = await searchVideo(server.url, 'hello')
+  //
+  //   expect(res.body.total).to.equal(0)
+  //   expect(res.body.data).to.be.an('array')
+  //   expect(res.body.data.length).to.equal(0)
+  // })
+
+  it('Should remove the video', async function () {
+    await removeVideo(server.url, server.accessToken, videoId)
+
+    const files1 = await readdirPromise(join(__dirname, '..', '..', '..', 'test1/videos/'))
+    expect(files1).to.have.lengthOf(0)
+
+    const files2 = await readdirPromise(join(__dirname, '..', '..', '..', 'test1/thumbnails/'))
+    expect(files2).to.have.lengthOf(0)
+  })
+
+  it('Should not have videos', async function () {
+    const res = await getVideosList(server.url)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(0)
+  })
+
+  it('Should upload 6 videos', async function () {
+    this.timeout(25000)
+
+    const videos = [
+      'video_short.mp4', 'video_short.ogv', 'video_short.webm',
+      'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
+    ]
+
+    const tasks: Promise<any>[] = []
+    for (const video of videos) {
+      const videoAttributes = {
+        name: video + ' name',
+        description: video + ' description',
+        category: 2,
+        licence: 1,
+        language: 1,
+        nsfw: true,
+        tags: [ 'tag1', 'tag2', 'tag3' ],
+        fixture: video
+      }
+
+      const p = uploadVideo(server.url, server.accessToken, videoAttributes)
+      tasks.push(p)
+    }
+
+    await Promise.all(tasks)
+  })
+
+  it('Should have the correct durations', async function () {
+    const res = await getVideosList(server.url)
+
+    expect(res.body.total).to.equal(6)
+    const videos = res.body.data
+    expect(videos).to.be.an('array')
+    expect(videos).to.have.lengthOf(6)
+
+    const videosByName = keyBy<{ duration: number }>(videos, 'name')
+    expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
+    expect(videosByName['video_short.ogv name'].duration).to.equal(5)
+    expect(videosByName['video_short.webm name'].duration).to.equal(5)
+    expect(videosByName['video_short1.webm name'].duration).to.equal(10)
+    expect(videosByName['video_short2.webm name'].duration).to.equal(5)
+    expect(videosByName['video_short3.webm name'].duration).to.equal(5)
+  })
+
+  it('Should have the correct thumbnails', async function () {
+    const res = await getVideosList(server.url)
+
+    const videos = res.body.data
+    // For the next test
+    videosListBase = videos
+
+    for (const video of videos) {
+      const videoName = video.name.replace(' name', '')
+      const test = await testVideoImage(server.url, videoName, video.thumbnailPath)
+
+      expect(test).to.equal(true)
+    }
+  })
+
+  it('Should list only the two first videos', async function () {
+    const res = await getVideosListPagination(server.url, 0, 2, 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(6)
+    expect(videos.length).to.equal(2)
+    expect(videos[0].name).to.equal(videosListBase[0].name)
+    expect(videos[1].name).to.equal(videosListBase[1].name)
+  })
+
+  it('Should list only the next three videos', async function () {
+    const res = await getVideosListPagination(server.url, 2, 3, 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(6)
+    expect(videos.length).to.equal(3)
+    expect(videos[0].name).to.equal(videosListBase[2].name)
+    expect(videos[1].name).to.equal(videosListBase[3].name)
+    expect(videos[2].name).to.equal(videosListBase[4].name)
+  })
+
+  it('Should list the last video', async function () {
+    const res = await getVideosListPagination(server.url, 5, 6, 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(6)
+    expect(videos.length).to.equal(1)
+    expect(videos[0].name).to.equal(videosListBase[5].name)
+  })
+
+  it('Should search the first video', async function () {
+    const res = await searchVideoWithPagination(server.url, 'webm', 0, 1, 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(4)
+    expect(videos.length).to.equal(1)
+    expect(videos[0].name).to.equal('video_short1.webm name')
+  })
+
+  it('Should search the last two videos', async function () {
+    const res = await searchVideoWithPagination(server.url, 'webm', 2, 2, 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(4)
+    expect(videos.length).to.equal(2)
+    expect(videos[0].name).to.equal('video_short3.webm name')
+    expect(videos[1].name).to.equal('video_short.webm name')
+  })
+
+  it('Should search all the webm videos', async function () {
+    const res = await searchVideoWithPagination(server.url, 'webm', 0, 15)
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(4)
+    expect(videos.length).to.equal(4)
+  })
+
+  // Not implemented yet
+  // it('Should search all the root author videos', async function () {
+  //   const res = await searchVideoWithPagination(server.url, 'root', 0, 15)
+  //
+  //   const videos = res.body.data
+  //   expect(res.body.total).to.equal(6)
+  //   expect(videos.length).to.equal(6)
+  // })
+
+  // Not implemented yet
+  // it('Should search all the 9001 port videos', async function () {
+  // const res = await   videosUtils.searchVideoWithPagination(server.url, '9001', 'host', 0, 15)
+
+  //     const videos = res.body.data
+  //     expect(res.body.total).to.equal(6)
+  //     expect(videos.length).to.equal(6)
+
+  //     done()
+  //   })
+  // })
+
+  // it('Should search all the localhost videos', async function () {
+  // const res = await   videosUtils.searchVideoWithPagination(server.url, 'localhost', 'host', 0, 15)
+
+  //     const videos = res.body.data
+  //     expect(res.body.total).to.equal(6)
+  //     expect(videos.length).to.equal(6)
+
+  //     done()
+  //   })
+  // })
+
+  it('Should list and sort by name in descending order', async function () {
+    const res = await getVideosListSort(server.url, '-name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(6)
+    expect(videos.length).to.equal(6)
+    expect(videos[0].name).to.equal('video_short.webm name')
+    expect(videos[1].name).to.equal('video_short.ogv name')
+    expect(videos[2].name).to.equal('video_short.mp4 name')
+    expect(videos[3].name).to.equal('video_short3.webm name')
+    expect(videos[4].name).to.equal('video_short2.webm name')
+    expect(videos[5].name).to.equal('video_short1.webm name')
+  })
+
+  it('Should search and sort by name in ascending order', async function () {
+    const res = await searchVideoWithSort(server.url, 'webm', 'name')
+
+    const videos = res.body.data
+    expect(res.body.total).to.equal(4)
+    expect(videos.length).to.equal(4)
+
+    expect(videos[0].name).to.equal('video_short1.webm name')
+    expect(videos[1].name).to.equal('video_short2.webm name')
+    expect(videos[2].name).to.equal('video_short3.webm name')
+    expect(videos[3].name).to.equal('video_short.webm name')
+
+    videoId = videos[2].id
+  })
+
+  it('Should update a video', async function () {
+    const attributes = {
+      name: 'my super video updated',
+      category: 4,
+      licence: 2,
+      language: 5,
+      nsfw: false,
+      description: 'my super description updated',
+      tags: [ 'tagup1', 'tagup2' ]
+    }
+    await updateVideo(server.url, server.accessToken, videoId, attributes)
+  })
+
+  it('Should have the video updated', async function () {
+    this.timeout(60000)
+
+    const res = await getVideo(server.url, videoId)
+
+    const video = res.body
+
+    expect(video.name).to.equal('my super video updated')
+    expect(video.category).to.equal(4)
+    expect(video.categoryLabel).to.equal('Art')
+    expect(video.licence).to.equal(2)
+    expect(video.licenceLabel).to.equal('Attribution - Share Alike')
+    expect(video.language).to.equal(5)
+    expect(video.languageLabel).to.equal('Arabic')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('my super description updated')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.account.name).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(video.tags).to.deep.equal([ 'tagup1', 'tagup2' ])
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+
+    expect(video.channel.name).to.equal('Default root channel')
+    expect(video.channel.isLocal).to.be.true
+    expect(dateIsValid(video.channel.createdAt)).to.be.true
+    expect(dateIsValid(video.channel.updatedAt)).to.be.true
+
+    expect(video.files).to.have.lengthOf(1)
+
+    const file = video.files[0]
+    const magnetUri = file.magnetUri
+    expect(file.magnetUri).to.have.lengthOf.above(2)
+    expect(file.resolution).to.equal(720)
+    expect(file.resolutionLabel).to.equal('720p')
+    expect(file.size).to.equal(292677)
+
+    const test = await testVideoImage(server.url, 'video_short3.webm', video.thumbnailPath)
+    expect(test).to.equal(true)
+
+    const torrent = await webtorrentAdd(magnetUri)
+    expect(torrent.files).to.be.an('array')
+    expect(torrent.files.length).to.equal(1)
+    expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+  })
+
+  it('Should update only the tags of a video', async function () {
+    const attributes = {
+      tags: [ 'tag1', 'tag2', 'supertag' ]
+    }
+
+    await updateVideo(server.url, server.accessToken, videoId, attributes)
+
+    const res = await getVideo(server.url, videoId)
+    const video = res.body
+
+    expect(video.name).to.equal('my super video updated')
+    expect(video.category).to.equal(4)
+    expect(video.categoryLabel).to.equal('Art')
+    expect(video.licence).to.equal(2)
+    expect(video.licenceLabel).to.equal('Attribution - Share Alike')
+    expect(video.language).to.equal(5)
+    expect(video.languageLabel).to.equal('Arabic')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('my super description updated')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(video.tags).to.deep.equal([ 'supertag', 'tag1', 'tag2' ])
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+
+    expect(video.channel.name).to.equal('Default root channel')
+    expect(video.channel.isLocal).to.be.true
+    expect(dateIsValid(video.channel.createdAt)).to.be.true
+    expect(dateIsValid(video.channel.updatedAt)).to.be.true
+
+    expect(video.files).to.have.lengthOf(1)
+
+    const file = video.files[0]
+    expect(file.magnetUri).to.have.lengthOf.above(2)
+    expect(file.resolution).to.equal(720)
+    expect(file.resolutionLabel).to.equal('720p')
+    expect(file.size).to.equal(292677)
+  })
+
+  it('Should update only the description of a video', async function () {
+    const attributes = {
+      description: 'hello everybody'
+    }
+
+    await updateVideo(server.url, server.accessToken, videoId, attributes)
+
+    const res = await getVideo(server.url, videoId)
+    const video = res.body
+
+    expect(video.name).to.equal('my super video updated')
+    expect(video.category).to.equal(4)
+    expect(video.categoryLabel).to.equal('Art')
+    expect(video.licence).to.equal(2)
+    expect(video.licenceLabel).to.equal('Attribution - Share Alike')
+    expect(video.language).to.equal(5)
+    expect(video.languageLabel).to.equal('Arabic')
+    expect(video.nsfw).to.be.ok
+    expect(video.description).to.equal('hello everybody')
+    expect(video.serverHost).to.equal('localhost:9001')
+    expect(video.accountName).to.equal('root')
+    expect(video.isLocal).to.be.true
+    expect(video.tags).to.deep.equal([ 'supertag', 'tag1', 'tag2' ])
+    expect(dateIsValid(video.createdAt)).to.be.true
+    expect(dateIsValid(video.updatedAt)).to.be.true
+
+    expect(video.channel.name).to.equal('Default root channel')
+    expect(video.channel.isLocal).to.be.true
+    expect(dateIsValid(video.channel.createdAt)).to.be.true
+    expect(dateIsValid(video.channel.updatedAt)).to.be.true
+
+    expect(video.files).to.have.lengthOf(1)
+
+    const file = video.files[0]
+    expect(file.magnetUri).to.have.lengthOf.above(2)
+    expect(file.resolution).to.equal(720)
+    expect(file.resolutionLabel).to.equal('720p')
+    expect(file.size).to.equal(292677)
+  })
+
+  it('Should like a video', async function () {
+    await rateVideo(server.url, server.accessToken, videoId, 'like')
+
+    const res = await getVideo(server.url, videoId)
+    const video = res.body
+
+    expect(video.likes).to.equal(1)
+    expect(video.dislikes).to.equal(0)
+  })
+
+  it('Should dislike the same video', async function () {
+    await rateVideo(server.url, server.accessToken, videoId, 'dislike')
+
+    const res = await getVideo(server.url, videoId)
+    const video = res.body
+
+    expect(video.likes).to.equal(0)
+    expect(video.dislikes).to.equal(1)
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-abuse.ts b/server/tests/api/videos/video-abuse.ts
new file mode 100644
index 000000000..3fcf5d8c7
--- /dev/null
+++ b/server/tests/api/videos/video-abuse.ts
@@ -0,0 +1,145 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushAndRunMultipleServers,
+  flushTests,
+  getVideoAbusesList,
+  getVideosList,
+  killallServers,
+  reportVideoAbuse,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  wait
+} from '../../utils/index'
+import { doubleFollow } from '../../utils/server/follows'
+
+const expect = chai.expect
+
+describe('Test video abuses', function () {
+  let servers: ServerInfo[] = []
+
+  before(async function () {
+    this.timeout(50000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    // Upload some videos on each servers
+    const video1Attributes = {
+      name: 'my super name for server 1',
+      description: 'my super description for server 1'
+    }
+    await uploadVideo(servers[0].url, servers[0].accessToken, video1Attributes)
+
+    const video2Attributes = {
+      name: 'my super name for server 2',
+      description: 'my super description for server 2'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, video2Attributes)
+
+    // Wait videos propagation, server 2 has transcoding enabled
+    await wait(15000)
+
+    const res = await getVideosList(servers[0].url)
+    const videos = res.body.data
+
+    expect(videos.length).to.equal(2)
+
+    servers[0].video = videos.find(video => video.name === 'my super name for server 1')
+    servers[1].video = videos.find(video => video.name === 'my super name for server 2')
+  })
+
+  it('Should not have video abuses', async function () {
+    const res = await getVideoAbusesList(servers[0].url, servers[0].accessToken)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(0)
+  })
+
+  it('Should report abuse on a local video', async function () {
+    this.timeout(10000)
+
+    const reason = 'my super bad reason'
+    await reportVideoAbuse(servers[0].url, servers[0].accessToken, servers[0].video.id, reason)
+
+    // We wait requests propagation, even if the server 1 is not supposed to make a request to server 2
+    await wait(5000)
+  })
+
+  it('Should have 1 video abuses on server 1 and 0 on server 2', async function () {
+    const res1 = await getVideoAbusesList(servers[0].url, servers[0].accessToken)
+
+    expect(res1.body.total).to.equal(1)
+    expect(res1.body.data).to.be.an('array')
+    expect(res1.body.data.length).to.equal(1)
+
+    const abuse = res1.body.data[0]
+    expect(abuse.reason).to.equal('my super bad reason')
+    expect(abuse.reporterUsername).to.equal('root')
+    expect(abuse.reporterServerHost).to.equal('localhost:9001')
+    expect(abuse.videoId).to.equal(servers[0].video.id)
+
+    const res2 = await getVideoAbusesList(servers[1].url, servers[1].accessToken)
+    expect(res2.body.total).to.equal(0)
+    expect(res2.body.data).to.be.an('array')
+    expect(res2.body.data.length).to.equal(0)
+  })
+
+  it('Should report abuse on a remote video', async function () {
+    this.timeout(10000)
+
+    const reason = 'my super bad reason 2'
+    await reportVideoAbuse(servers[0].url, servers[0].accessToken, servers[1].video.id, reason)
+
+    // We wait requests propagation
+    await wait(5000)
+  })
+
+  it('Should have 2 video abuse on server 1 and 1 on server 2', async function () {
+    const res1 = await getVideoAbusesList(servers[0].url, servers[0].accessToken)
+    expect(res1.body.total).to.equal(2)
+    expect(res1.body.data).to.be.an('array')
+    expect(res1.body.data.length).to.equal(2)
+
+    const abuse1 = res1.body.data[0]
+    expect(abuse1.reason).to.equal('my super bad reason')
+    expect(abuse1.reporterUsername).to.equal('root')
+    expect(abuse1.reporterServerHost).to.equal('localhost:9001')
+    expect(abuse1.videoId).to.equal(servers[0].video.id)
+
+    const abuse2 = res1.body.data[1]
+    expect(abuse2.reason).to.equal('my super bad reason 2')
+    expect(abuse2.reporterUsername).to.equal('root')
+    expect(abuse2.reporterServerHost).to.equal('localhost:9001')
+    expect(abuse2.videoId).to.equal(servers[1].video.id)
+
+    const res2 = await getVideoAbusesList(servers[1].url, servers[1].accessToken)
+    expect(res2.body.total).to.equal(1)
+    expect(res2.body.data).to.be.an('array')
+    expect(res2.body.data.length).to.equal(1)
+
+    const abuse3 = res2.body.data[0]
+    expect(abuse3.reason).to.equal('my super bad reason 2')
+    expect(abuse3.reporterUsername).to.equal('root')
+    expect(abuse3.reporterServerHost).to.equal('localhost:9001')
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-blacklist-management.ts b/server/tests/api/videos/video-blacklist-management.ts
new file mode 100644
index 000000000..db79784c2
--- /dev/null
+++ b/server/tests/api/videos/video-blacklist-management.ts
@@ -0,0 +1,162 @@
+/* tslint:disable:no-unused-expressions */
+
+import * as chai from 'chai'
+import * as lodash from 'lodash'
+import 'mocha'
+import {
+  addVideoToBlacklist,
+  flushAndRunMultipleServers,
+  flushTests,
+  getBlacklistedVideosList,
+  getSortedBlacklistedVideosList,
+  getVideosList,
+  killallServers,
+  removeVideoFromBlacklist,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  wait
+} from '../../utils/index'
+import { doubleFollow } from '../../utils/server/follows'
+
+const expect = chai.expect
+const orderBy = lodash.orderBy
+
+describe('Test video blacklist management', function () {
+  let servers: ServerInfo[] = []
+
+  async function blacklistVideosOnServer (server: ServerInfo) {
+    const res = await getVideosList(server.url)
+
+    const videos = res.body.data
+    for (let video of videos) {
+      await addVideoToBlacklist(server.url, server.accessToken, video.id)
+    }
+  }
+
+  before(async function () {
+    this.timeout(50000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    // Upload 2 videos on server 2
+    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 1st video', description: 'A video on server 2' })
+    await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'My 2nd video', description: 'A video on server 2' })
+
+    // Wait videos propagation, server 2 has transcoding enabled
+    await wait(15000)
+
+    // Blacklist the two videos on server 1
+    await blacklistVideosOnServer(servers[0])
+  })
+
+  describe('When listing blacklisted videos', function () {
+    it('Should display all the blacklisted videos', async function () {
+      const res = await getBlacklistedVideosList(servers[0].url, servers[0].accessToken)
+
+      expect(res.body.total).to.equal(2)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(2)
+    })
+
+    it('Should get the correct sort when sorting by descending id', async function () {
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-id')
+      expect(res.body.total).to.equal(2)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(2)
+
+      const result = orderBy(res.body.data, [ 'id' ], [ 'desc' ])
+
+      expect(videos).to.deep.equal(result)
+    })
+
+    it('Should get the correct sort when sorting by descending video name', async function () {
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      expect(res.body.total).to.equal(2)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(2)
+
+      const result = orderBy(res.body.data, [ 'name' ], [ 'desc' ])
+
+      expect(videos).to.deep.equal(result)
+    })
+
+    it('Should get the correct sort when sorting by ascending creation date', async function () {
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, 'createdAt')
+      expect(res.body.total).to.equal(2)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(2)
+
+      const result = orderBy(res.body.data, [ 'createdAt' ])
+
+      expect(videos).to.deep.equal(result)
+    })
+  })
+
+  describe('When removing a blacklisted video', function () {
+    let videoToRemove
+    let blacklist = []
+
+    it('Should not have any video in videos list on server 1', async function () {
+      const res = await getVideosList(servers[0].url)
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.be.an('array')
+      expect(res.body.data.length).to.equal(0)
+    })
+
+    it('Should remove a video from the blacklist on server 1', async function () {
+      // Get one video in the blacklist
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      videoToRemove = res.body.data[0]
+      blacklist = res.body.data.slice(1)
+
+      // Remove it
+      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoToRemove.videoId)
+    })
+
+    it('Should have the ex-blacklisted video in videos list on server 1', async function () {
+      const res = await getVideosList(servers[0].url)
+      expect(res.body.total).to.equal(1)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(1)
+
+      expect(videos[0].name).to.equal(videoToRemove.name)
+      expect(videos[0].id).to.equal(videoToRemove.videoId)
+    })
+
+    it('Should not have the ex-blacklisted video in videos blacklist list on server 1', async function () {
+      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      expect(res.body.total).to.equal(1)
+
+      const videos = res.body.data
+      expect(videos).to.be.an('array')
+      expect(videos.length).to.equal(1)
+      expect(videos).to.deep.equal(blacklist)
+    })
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-blacklist.ts b/server/tests/api/videos/video-blacklist.ts
new file mode 100644
index 000000000..d1cefa5d7
--- /dev/null
+++ b/server/tests/api/videos/video-blacklist.ts
@@ -0,0 +1,98 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  addVideoToBlacklist,
+  flushAndRunMultipleServers,
+  flushTests,
+  getVideosList,
+  killallServers,
+  searchVideo,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  wait
+} from '../../utils/index'
+import { doubleFollow } from '../../utils/server/follows'
+
+const expect = chai.expect
+
+describe('Test video blacklists', function () {
+  let servers: ServerInfo[] = []
+
+  before(async function () {
+    this.timeout(50000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    // Upload a video on server 2
+    const videoAttributes = {
+      name: 'my super name for server 2',
+      description: 'my super description for server 2'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    // Wait videos propagation, server 2 has transcoding enabled
+    await wait(10000)
+
+    const res = await getVideosList(servers[0].url)
+    const videos = res.body.data
+
+    expect(videos.length).to.equal(1)
+
+    servers[0].remoteVideo = videos.find(video => video.name === 'my super name for server 2')
+  })
+
+  it('Should blacklist a remote video on server 1', async function () {
+    await addVideoToBlacklist(servers[0].url, servers[0].accessToken, servers[0].remoteVideo.id)
+  })
+
+  it('Should not have the video blacklisted in videos list on server 1', async function () {
+    const res = await getVideosList(servers[0].url)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(0)
+  })
+
+  it('Should not have the video blacklisted in videos search on server 1', async function () {
+    const res = await searchVideo(servers[0].url, 'name')
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(0)
+  })
+
+  it('Should have the blacklisted video in videos list on server 2', async function () {
+    const res = await getVideosList(servers[1].url)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(1)
+  })
+
+  it('Should have the video blacklisted in videos search on server 2', async function () {
+    const res = await searchVideo(servers[1].url, 'name')
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data.length).to.equal(1)
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
new file mode 100644
index 000000000..454a96da6
--- /dev/null
+++ b/server/tests/api/videos/video-channels.ts
@@ -0,0 +1,139 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import * as chai from 'chai'
+const expect = chai.expect
+
+import {
+  ServerInfo,
+  flushTests,
+  runServer,
+  setAccessTokensToServers,
+  killallServers,
+  getMyUserInformation,
+  getVideoChannelsList,
+  addVideoChannel,
+  getAccountVideoChannelsList,
+  updateVideoChannel,
+  deleteVideoChannel,
+  getVideoChannel
+} from '../../utils/index'
+import { User } from '../../../../shared/index'
+
+describe('Test a video channels', function () {
+  let server: ServerInfo
+  let userInfo: User
+  let videoChannelId: number
+
+  before(async function () {
+    this.timeout(10000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should have one video channel (created with root)', async () => {
+    const res = await getVideoChannelsList(server.url, 0, 2)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(1)
+  })
+
+  it('Should create another video channel', async () => {
+    const videoChannel = {
+      name: 'second video channel',
+      description: 'super video channel description'
+    }
+    await addVideoChannel(server.url, server.accessToken, videoChannel)
+  })
+
+  it('Should have two video channels when getting my information', async () => {
+    const res = await getMyUserInformation(server.url, server.accessToken)
+    userInfo = res.body
+
+    expect(userInfo.videoChannels).to.be.an('array')
+    expect(userInfo.videoChannels).to.have.lengthOf(2)
+
+    const videoChannels = userInfo.videoChannels
+    expect(videoChannels[0].name).to.equal('Default root channel')
+    expect(videoChannels[1].name).to.equal('second video channel')
+    expect(videoChannels[1].description).to.equal('super video channel description')
+  })
+
+  it('Should have two video channels when getting account channels', async () => {
+    const res = await getAccountVideoChannelsList(server.url, userInfo.account.uuid)
+
+    expect(res.body.total).to.equal(2)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(2)
+
+    const videoChannels = res.body.data
+    expect(videoChannels[0].name).to.equal('Default root channel')
+    expect(videoChannels[1].name).to.equal('second video channel')
+    expect(videoChannels[1].description).to.equal('super video channel description')
+
+    videoChannelId = videoChannels[1].id
+  })
+
+  it('Should list video channels', async () => {
+    const res = await getVideoChannelsList(server.url, 1, 1, '-name')
+
+    expect(res.body.total).to.equal(2)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(1)
+    expect(res.body.data[0].name).to.equal('Default root channel')
+  })
+
+  it('Should update video channel', async () => {
+    const videoChannelAttributes = {
+      name: 'video channel updated',
+      description: 'video channel description updated'
+    }
+
+    await updateVideoChannel(server.url, server.accessToken, videoChannelId, videoChannelAttributes)
+  })
+
+  it('Should have video channel updated', async () => {
+    const res = await getVideoChannelsList(server.url, 0, 1, '-name')
+
+    expect(res.body.total).to.equal(2)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(1)
+    expect(res.body.data[0].name).to.equal('video channel updated')
+    expect(res.body.data[0].description).to.equal('video channel description updated')
+  })
+
+  it('Should get video channel', async () => {
+    const res = await getVideoChannel(server.url, videoChannelId)
+
+    const videoChannel = res.body
+    expect(videoChannel.name).to.equal('video channel updated')
+    expect(videoChannel.description).to.equal('video channel description updated')
+  })
+
+  it('Should delete video channel', async () => {
+    await deleteVideoChannel(server.url, server.accessToken, videoChannelId)
+  })
+
+  it('Should have video channel deleted', async () => {
+    const res = await getVideoChannelsList(server.url, 0, 10)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(1)
+    expect(res.body.data[0].name).to.equal('Default root channel')
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-comments.ts b/server/tests/api/videos/video-comments.ts
new file mode 100644
index 000000000..3b6578f04
--- /dev/null
+++ b/server/tests/api/videos/video-comments.ts
@@ -0,0 +1,154 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
+import { dateIsValid, flushTests, killallServers, runServer, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../utils/index'
+import {
+  addVideoCommentReply, addVideoCommentThread, getVideoCommentThreads,
+  getVideoThreadComments
+} from '../../utils/videos/video-comments'
+
+const expect = chai.expect
+
+describe('Test video comments', function () {
+  let server: ServerInfo
+  let videoId
+  let videoUUID
+  let threadId
+
+  before(async function () {
+    this.timeout(10000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const res = await uploadVideo(server.url, server.accessToken, {})
+    videoUUID = res.body.video.uuid
+    videoId = res.body.video.id
+  })
+
+  it('Should not have threads on this video', async function () {
+    const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(0)
+  })
+
+  it('Should create a thread in this video', async function () {
+    const text = 'my super first comment'
+
+    const res = await addVideoCommentThread(server.url, server.accessToken, videoUUID, text)
+    const comment = res.body.comment
+
+    expect(comment.inReplyToCommentId).to.be.null
+    expect(comment.text).equal('my super first comment')
+    expect(comment.videoId).to.equal(videoId)
+    expect(comment.id).to.equal(comment.threadId)
+    expect(comment.account.name).to.equal('root')
+    expect(comment.account.host).to.equal('localhost:9001')
+    expect(comment.totalReplies).to.equal(0)
+    expect(dateIsValid(comment.createdAt as string)).to.be.true
+    expect(dateIsValid(comment.updatedAt as string)).to.be.true
+  })
+
+  it('Should list threads of this video', async function () {
+    const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(1)
+
+    const comment: VideoComment = res.body.data[0]
+    expect(comment.inReplyToCommentId).to.be.null
+    expect(comment.text).equal('my super first comment')
+    expect(comment.videoId).to.equal(videoId)
+    expect(comment.id).to.equal(comment.threadId)
+    expect(comment.account.name).to.equal('root')
+    expect(comment.account.host).to.equal('localhost:9001')
+    expect(comment.totalReplies).to.equal(0)
+    expect(dateIsValid(comment.createdAt as string)).to.be.true
+    expect(dateIsValid(comment.updatedAt as string)).to.be.true
+
+    threadId = comment.threadId
+  })
+
+  it('Should get all the thread created', async function () {
+    const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+
+    const rootComment = res.body.comment
+    expect(rootComment.inReplyToCommentId).to.be.null
+    expect(rootComment.text).equal('my super first comment')
+    expect(rootComment.videoId).to.equal(videoId)
+    expect(dateIsValid(rootComment.createdAt as string)).to.be.true
+    expect(dateIsValid(rootComment.updatedAt as string)).to.be.true
+  })
+
+  it('Should create multiple replies in this thread', async function () {
+    const text1 = 'my super answer to thread 1'
+    const childCommentRes = await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text1)
+    const childCommentId = childCommentRes.body.comment.id
+
+    const text2 = 'my super answer to answer of thread 1'
+    await addVideoCommentReply(server.url, server.accessToken, videoId, childCommentId, text2)
+
+    const text3 = 'my second answer to thread 1'
+    await addVideoCommentReply(server.url, server.accessToken, videoId, threadId, text3)
+  })
+
+  it('Should get correctly the replies', async function () {
+    const res = await getVideoThreadComments(server.url, videoUUID, threadId)
+
+    const tree: VideoCommentThreadTree = res.body
+    expect(tree.comment.text).equal('my super first comment')
+    expect(tree.children).to.have.lengthOf(2)
+
+    const firstChild = tree.children[0]
+    expect(firstChild.comment.text).to.equal('my super answer to thread 1')
+    expect(firstChild.children).to.have.lengthOf(1)
+
+    const childOfFirstChild = firstChild.children[0]
+    expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
+    expect(childOfFirstChild.children).to.have.lengthOf(0)
+
+    const secondChild = tree.children[1]
+    expect(secondChild.comment.text).to.equal('my second answer to thread 1')
+    expect(secondChild.children).to.have.lengthOf(0)
+  })
+
+  it('Should create other threads', async function () {
+    const text1 = 'super thread 2'
+    await addVideoCommentThread(server.url, server.accessToken, videoUUID, text1)
+
+    const text2 = 'super thread 3'
+    await addVideoCommentThread(server.url, server.accessToken, videoUUID, text2)
+  })
+
+  it('Should list the threads', async function () {
+    const res = await getVideoCommentThreads(server.url, videoUUID, 0, 5, 'createdAt')
+
+    expect(res.body.total).to.equal(3)
+    expect(res.body.data).to.be.an('array')
+    expect(res.body.data).to.have.lengthOf(3)
+
+    expect(res.body.data[0].text).to.equal('my super first comment')
+    expect(res.body.data[0].totalReplies).to.equal(3)
+    expect(res.body.data[1].text).to.equal('super thread 2')
+    expect(res.body.data[1].totalReplies).to.equal(0)
+    expect(res.body.data[2].text).to.equal('super thread 3')
+    expect(res.body.data[2].totalReplies).to.equal(0)
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-description.ts b/server/tests/api/videos/video-description.ts
new file mode 100644
index 000000000..c2985194c
--- /dev/null
+++ b/server/tests/api/videos/video-description.ts
@@ -0,0 +1,111 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushAndRunMultipleServers,
+  flushTests,
+  getVideo,
+  getVideoDescription,
+  getVideosList,
+  killallServers,
+  ServerInfo,
+  setAccessTokensToServers,
+  updateVideo,
+  uploadVideo,
+  wait
+} from '../../utils/index'
+import { doubleFollow } from '../../utils/server/follows'
+
+const expect = chai.expect
+
+describe('Test video description', function () {
+  let servers: ServerInfo[] = []
+  let videoUUID = ''
+  let videoId: number
+  let longDescription = 'my super description for server 1'.repeat(50)
+
+  before(async function () {
+    this.timeout(40000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should upload video with long description', async function () {
+    this.timeout(10000)
+
+    const attributes = {
+      description: longDescription
+    }
+    await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+
+    await wait(5000)
+
+    const res = await getVideosList(servers[0].url)
+
+    videoId = res.body.data[0].id
+    videoUUID = res.body.data[0].uuid
+  })
+
+  it('Should have a truncated description on each server', async function () {
+    for (const server of servers) {
+      const res = await getVideo(server.url, videoUUID)
+      const video = res.body
+
+      // 30 characters * 6 -> 240 characters
+      const truncatedDescription = 'my super description for server 1'.repeat(7) +
+                                   'my super descrip...'
+
+      expect(video.description).to.equal(truncatedDescription)
+    }
+  })
+
+  it('Should fetch long description on each server', async function () {
+    for (const server of servers) {
+      const res = await getVideo(server.url, videoUUID)
+      const video = res.body
+
+      const res2 = await getVideoDescription(server.url, video.descriptionPath)
+      expect(res2.body.description).to.equal(longDescription)
+    }
+  })
+
+  it('Should update with a short description', async function () {
+    this.timeout(10000)
+
+    const attributes = {
+      description: 'short description'
+    }
+    await updateVideo(servers[0].url, servers[0].accessToken, videoId, attributes)
+
+    await wait(5000)
+  })
+
+  it('Should have a small description on each server', async function () {
+    for (const server of servers) {
+      const res = await getVideo(server.url, videoUUID)
+      const video = res.body
+
+      expect(video.description).to.equal('short description')
+
+      const res2 = await getVideoDescription(server.url, video.descriptionPath)
+      expect(res2.body.description).to.equal('short description')
+    }
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-privacy.ts b/server/tests/api/videos/video-privacy.ts
new file mode 100644
index 000000000..de709f8f1
--- /dev/null
+++ b/server/tests/api/videos/video-privacy.ts
@@ -0,0 +1,159 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
+import {
+  flushAndRunMultipleServers,
+  flushTests,
+  getVideosList,
+  killallServers,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  wait
+} from '../../utils/index'
+import { doubleFollow } from '../../utils/server/follows'
+import { getUserAccessToken } from '../../utils/users/login'
+import { createUser } from '../../utils/users/users'
+import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../utils/videos/videos'
+
+const expect = chai.expect
+
+describe('Test video privacy', function () {
+  let servers: ServerInfo[] = []
+  let privateVideoId
+  let privateVideoUUID
+  let unlistedVideoUUID
+
+  before(async function () {
+    this.timeout(50000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should upload a private video on server 1', async function () {
+    this.timeout(10000)
+
+    const attributes = {
+      privacy: VideoPrivacy.PRIVATE
+    }
+    await uploadVideo(servers[0].url, servers[0].accessToken, attributes)
+
+    await wait(5000)
+  })
+
+  it('Should not have this private video on server 2', async function () {
+    const res = await getVideosList(servers[1].url)
+
+    expect(res.body.total).to.equal(0)
+    expect(res.body.data).to.have.lengthOf(0)
+  })
+
+  it('Should list my (private) videos', async function () {
+    const res = await getMyVideos(servers[0].url, servers[0].accessToken, 0, 1)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.have.lengthOf(1)
+
+    privateVideoId = res.body.data[0].id
+    privateVideoUUID = res.body.data[0].uuid
+  })
+
+  it('Should not be able to watch this video with non authenticated user', async function () {
+    await getVideo(servers[0].url, privateVideoUUID, 401)
+  })
+
+  it('Should not be able to watch this private video with another user', async function () {
+    const user = {
+      username: 'hello',
+      password: 'super password'
+    }
+    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+
+    const token = await getUserAccessToken(servers[0], user)
+    await getVideoWithToken(servers[0].url, token, privateVideoUUID, 403)
+  })
+
+  it('Should be able to watch this video with the correct user', async function () {
+    await getVideoWithToken(servers[0].url, servers[0].accessToken, privateVideoUUID)
+  })
+
+  it('Should upload an unlisted video on server 2', async function () {
+    this.timeout(30000)
+
+    const attributes = {
+      name: 'unlisted video',
+      privacy: VideoPrivacy.UNLISTED
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, attributes)
+
+    // Server 2 has transcoding enabled
+    await wait(10000)
+  })
+
+  it('Should not have this unlisted video listed on server 1 and 2', async function () {
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should list my (unlisted) videos', async function () {
+    const res = await getMyVideos(servers[1].url, servers[1].accessToken, 0, 1)
+
+    expect(res.body.total).to.equal(1)
+    expect(res.body.data).to.have.lengthOf(1)
+
+    unlistedVideoUUID = res.body.data[0].uuid
+  })
+
+  it('Should be able to get this unlisted video', async function () {
+    for (const server of servers) {
+      const res = await getVideo(server.url, unlistedVideoUUID)
+
+      expect(res.body.name).to.equal('unlisted video')
+    }
+  })
+
+  it('Should update the private video to public on server 1', async function () {
+    this.timeout(10000)
+
+    const attribute = {
+      name: 'super video public',
+      privacy: VideoPrivacy.PUBLIC
+    }
+
+    await updateVideo(servers[0].url, servers[0].accessToken, privateVideoId, attribute)
+
+    await wait(5000)
+  })
+
+  it('Should have this new public video listed on server 1 and 2', async function () {
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+      expect(res.body.data[0].name).to.equal('super video public')
+    }
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
new file mode 100644
index 000000000..27927a594
--- /dev/null
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -0,0 +1,97 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import * as chai from 'chai'
+const expect = chai.expect
+
+import {
+  ServerInfo,
+  flushTests,
+  uploadVideo,
+  getVideosList,
+  wait,
+  setAccessTokensToServers,
+  flushAndRunMultipleServers,
+  killallServers,
+  webtorrentAdd,
+  getVideo
+} from '../../utils/index'
+
+describe('Test video transcoding', function () {
+  let servers: ServerInfo[] = []
+
+  before(async function () {
+    this.timeout(10000)
+
+    // Run servers
+    servers = await flushAndRunMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+  })
+
+  it('Should not transcode video on server 1', async function () {
+    this.timeout(60000)
+
+    const videoAttributes = {
+      name: 'my super name for server 1',
+      description: 'my super description for server 1',
+      fixture: 'video_short.webm'
+    }
+    await uploadVideo(servers[0].url, servers[0].accessToken, videoAttributes)
+
+    await wait(10000)
+
+    const res = await getVideosList(servers[0].url)
+    const video = res.body.data[0]
+
+    const res2 = await getVideo(servers[0].url, video.id)
+    const videoDetails = res2.body
+    expect(videoDetails.files).to.have.lengthOf(1)
+
+    const magnetUri = videoDetails.files[0].magnetUri
+    expect(magnetUri).to.match(/\.webm/)
+
+    const torrent = await webtorrentAdd(magnetUri)
+    expect(torrent.files).to.be.an('array')
+    expect(torrent.files.length).to.equal(1)
+    expect(torrent.files[0].path).match(/\.webm$/)
+  })
+
+  it('Should transcode video on server 2', async function () {
+    this.timeout(60000)
+
+    const videoAttributes = {
+      name: 'my super name for server 2',
+      description: 'my super description for server 2',
+      fixture: 'video_short.webm'
+    }
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    await wait(20000)
+
+    const res = await getVideosList(servers[1].url)
+
+    const video = res.body.data[0]
+    const res2 = await getVideo(servers[1].url, video.id)
+    const videoDetails = res2.body
+
+    expect(videoDetails.files).to.have.lengthOf(4)
+
+    const magnetUri = videoDetails.files[0].magnetUri
+    expect(magnetUri).to.match(/\.mp4/)
+
+    const torrent = await webtorrentAdd(magnetUri)
+    expect(torrent.files).to.be.an('array')
+    expect(torrent.files.length).to.equal(1)
+    expect(torrent.files[0].path).match(/\.mp4$/)
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})