36 files changed, 2542 insertions, 51 deletions

diff --git a/server/tests/api/check-params/blocklist.ts b/server/tests/api/check-params/blocklist.ts
new file mode 100644
index 000000000..c745ac975
--- /dev/null
+++ b/server/tests/api/check-params/blocklist.ts
@@ -0,0 +1,494 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+
+import {
+  createUser,
+  doubleFollow,
+  flushAndRunMultipleServers,
+  flushTests,
+  killallServers,
+  makeDeleteRequest,
+  makeGetRequest,
+  makePostBodyRequest,
+  ServerInfo,
+  setAccessTokensToServers, userLogin
+} from '../../utils'
+import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '../../utils/requests/check-api-params'
+
+describe('Test blocklist API validators', function () {
+  let servers: ServerInfo[]
+  let server: ServerInfo
+  let userAccessToken: string
+
+  before(async function () {
+    this.timeout(60000)
+
+    await flushTests()
+
+    servers = await flushAndRunMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    server = servers[0]
+
+    const user = { username: 'user1', password: 'password' }
+    await createUser(server.url, server.accessToken, user.username, user.password)
+
+    userAccessToken = await userLogin(server, user)
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  // ---------------------------------------------------------------
+
+  describe('When managing user blocklist', function () {
+
+    describe('When managing user accounts blocklist', function () {
+      const path = '/api/v1/users/me/blocklist/accounts'
+
+      describe('When listing blocked accounts', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeGetRequest({
+            url: server.url,
+            path,
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a bad start pagination', async function () {
+          await checkBadStartPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with a bad count pagination', async function () {
+          await checkBadCountPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with an incorrect sort', async function () {
+          await checkBadSortPagination(server.url, path, server.accessToken)
+        })
+      })
+
+      describe('When blocking an account', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            path,
+            fields: { accountName: 'user1' },
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with an unknown account', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'user2' },
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should fail to block ourselves', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'root' },
+            statusCodeExpected: 409
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'user1' },
+            statusCodeExpected: 204
+          })
+        })
+      })
+
+      describe('When unblocking an account', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user1',
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with an unknown account block', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user2',
+            token: server.accessToken,
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user1',
+            token: server.accessToken,
+            statusCodeExpected: 204
+          })
+        })
+      })
+    })
+
+    describe('When managing user servers blocklist', function () {
+      const path = '/api/v1/users/me/blocklist/servers'
+
+      describe('When listing blocked servers', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeGetRequest({
+            url: server.url,
+            path,
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a bad start pagination', async function () {
+          await checkBadStartPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with a bad count pagination', async function () {
+          await checkBadCountPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with an incorrect sort', async function () {
+          await checkBadSortPagination(server.url, path, server.accessToken)
+        })
+      })
+
+      describe('When blocking a server', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            path,
+            fields: { host: 'localhost:9002' },
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with an unknown server', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9003' },
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should fail with our own server', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9001' },
+            statusCodeExpected: 409
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9002' },
+            statusCodeExpected: 204
+          })
+        })
+      })
+
+      describe('When unblocking a server', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9002',
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with an unknown server block', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9003',
+            token: server.accessToken,
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9002',
+            token: server.accessToken,
+            statusCodeExpected: 204
+          })
+        })
+      })
+    })
+  })
+
+  describe('When managing server blocklist', function () {
+
+    describe('When managing server accounts blocklist', function () {
+      const path = '/api/v1/server/blocklist/accounts'
+
+      describe('When listing blocked accounts', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeGetRequest({
+            url: server.url,
+            path,
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makeGetRequest({
+            url: server.url,
+            token: userAccessToken,
+            path,
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with a bad start pagination', async function () {
+          await checkBadStartPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with a bad count pagination', async function () {
+          await checkBadCountPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with an incorrect sort', async function () {
+          await checkBadSortPagination(server.url, path, server.accessToken)
+        })
+      })
+
+      describe('When blocking an account', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            path,
+            fields: { accountName: 'user1' },
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: userAccessToken,
+            path,
+            fields: { accountName: 'user1' },
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with an unknown account', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'user2' },
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should fail to block ourselves', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'root' },
+            statusCodeExpected: 409
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { accountName: 'user1' },
+            statusCodeExpected: 204
+          })
+        })
+      })
+
+      describe('When unblocking an account', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user1',
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user1',
+            token: userAccessToken,
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with an unknown account block', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user2',
+            token: server.accessToken,
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/user1',
+            token: server.accessToken,
+            statusCodeExpected: 204
+          })
+        })
+      })
+    })
+
+    describe('When managing server servers blocklist', function () {
+      const path = '/api/v1/server/blocklist/servers'
+
+      describe('When listing blocked servers', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeGetRequest({
+            url: server.url,
+            path,
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makeGetRequest({
+            url: server.url,
+            token: userAccessToken,
+            path,
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with a bad start pagination', async function () {
+          await checkBadStartPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with a bad count pagination', async function () {
+          await checkBadCountPagination(server.url, path, server.accessToken)
+        })
+
+        it('Should fail with an incorrect sort', async function () {
+          await checkBadSortPagination(server.url, path, server.accessToken)
+        })
+      })
+
+      describe('When blocking a server', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            path,
+            fields: { host: 'localhost:9002' },
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: userAccessToken,
+            path,
+            fields: { host: 'localhost:9002' },
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with an unknown server', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9003' },
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should fail with our own server', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9001' },
+            statusCodeExpected: 409
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makePostBodyRequest({
+            url: server.url,
+            token: server.accessToken,
+            path,
+            fields: { host: 'localhost:9002' },
+            statusCodeExpected: 204
+          })
+        })
+      })
+
+      describe('When unblocking a server', function () {
+        it('Should fail with an unauthenticated user', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9002',
+            statusCodeExpected: 401
+          })
+        })
+
+        it('Should fail with a user without the appropriate rights', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9002',
+            token: userAccessToken,
+            statusCodeExpected: 403
+          })
+        })
+
+        it('Should fail with an unknown server block', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9003',
+            token: server.accessToken,
+            statusCodeExpected: 404
+          })
+        })
+
+        it('Should succeed with the correct params', async function () {
+          await makeDeleteRequest({
+            url: server.url,
+            path: path + '/localhost:9002',
+            token: server.accessToken,
+            statusCodeExpected: 204
+          })
+        })
+      })
+    })
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index 44460a167..877ceb0a7 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -1,5 +1,6 @@
 // Order of the tests we want to execute
 import './accounts'
+import './blocklist'
 import './config'
 import './follows'
 import './jobs'
@@ -15,3 +16,5 @@ import './video-channels'
 import './video-comments'
 import './video-imports'
 import './videos'
+import './videos-filter'
+import './videos-history'
diff --git a/server/tests/api/check-params/users.ts b/server/tests/api/check-params/users.ts
index cbfa0c137..ec46609a4 100644
--- a/server/tests/api/check-params/users.ts
+++ b/server/tests/api/check-params/users.ts
@@ -315,7 +315,7 @@ describe('Test users API validators', function () {
 
     it('Should fail with a too long description', async function () {
       const fields = {
-        description: 'super'.repeat(60)
+        description: 'super'.repeat(201)
       }
 
       await makePutBodyRequest({ url: server.url, path: path + 'me', token: userAccessToken, fields })
diff --git a/server/tests/api/check-params/video-channels.ts b/server/tests/api/check-params/video-channels.ts
index 3a7942945..e5696224d 100644
--- a/server/tests/api/check-params/video-channels.ts
+++ b/server/tests/api/check-params/video-channels.ts
@@ -118,12 +118,12 @@ describe('Test video channels API validator', function () {
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(201) })
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
       await makePostBodyRequest({ url: server.url, path: videoChannelPath, token: server.accessToken, fields })
     })
 
@@ -185,12 +185,12 @@ describe('Test video channels API validator', function () {
     })
 
     it('Should fail with a long description', async function () {
-      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { description: 'super'.repeat(201) })
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
       await makePutBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
diff --git a/server/tests/api/check-params/video-imports.ts b/server/tests/api/check-params/video-imports.ts
index 44645b0e2..b51f3d2cd 100644
--- a/server/tests/api/check-params/video-imports.ts
+++ b/server/tests/api/check-params/video-imports.ts
@@ -140,7 +140,7 @@ describe('Test video imports API validator', function () {
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
diff --git a/server/tests/api/check-params/videos-filter.ts b/server/tests/api/check-params/videos-filter.ts
new file mode 100644
index 000000000..784cd8ba1
--- /dev/null
+++ b/server/tests/api/check-params/videos-filter.ts
@@ -0,0 +1,127 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  createUser,
+  flushTests,
+  killallServers,
+  makeGetRequest,
+  runServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  userLogin
+} from '../../utils'
+import { UserRole } from '../../../../shared/models/users'
+
+const expect = chai.expect
+
+async function testEndpoints (server: ServerInfo, token: string, filter: string, statusCodeExpected: number) {
+  const paths = [
+    '/api/v1/video-channels/root_channel/videos',
+    '/api/v1/accounts/root/videos',
+    '/api/v1/videos',
+    '/api/v1/search/videos'
+  ]
+
+  for (const path of paths) {
+    await makeGetRequest({
+      url: server.url,
+      path,
+      token,
+      query: {
+        filter
+      },
+      statusCodeExpected
+    })
+  }
+}
+
+describe('Test videos filters', function () {
+  let server: ServerInfo
+  let userAccessToken: string
+  let moderatorAccessToken: string
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(30000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const user = { username: 'user1', password: 'my super password' }
+    await createUser(server.url, server.accessToken, user.username, user.password)
+    userAccessToken = await userLogin(server, user)
+
+    const moderator = { username: 'moderator', password: 'my super password' }
+    await createUser(
+      server.url,
+      server.accessToken,
+      moderator.username,
+      moderator.password,
+      undefined,
+      undefined,
+      UserRole.MODERATOR
+    )
+    moderatorAccessToken = await userLogin(server, moderator)
+  })
+
+  describe('When setting a video filter', function () {
+
+    it('Should fail with a bad filter', async function () {
+      await testEndpoints(server, server.accessToken, 'bad-filter', 400)
+    })
+
+    it('Should succeed with a good filter', async function () {
+      await testEndpoints(server, server.accessToken,'local', 200)
+    })
+
+    it('Should fail to list all-local with a simple user', async function () {
+      await testEndpoints(server, userAccessToken, 'all-local', 401)
+    })
+
+    it('Should succeed to list all-local with a moderator', async function () {
+      await testEndpoints(server, moderatorAccessToken, 'all-local', 200)
+    })
+
+    it('Should succeed to list all-local with an admin', async function () {
+      await testEndpoints(server, server.accessToken, 'all-local', 200)
+    })
+
+    // Because we cannot authenticate the user on the RSS endpoint
+    it('Should fail on the feeds endpoint with the all-local filter', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path: '/feeds/videos.json',
+        statusCodeExpected: 401,
+        query: {
+          filter: 'all-local'
+        }
+      })
+    })
+
+    it('Should succed on the feeds endpoint with the local filter', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path: '/feeds/videos.json',
+        statusCodeExpected: 200,
+        query: {
+          filter: 'local'
+        }
+      })
+    })
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/check-params/videos-history.ts b/server/tests/api/check-params/videos-history.ts
new file mode 100644
index 000000000..808c3b616
--- /dev/null
+++ b/server/tests/api/check-params/videos-history.ts
@@ -0,0 +1,79 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushTests,
+  killallServers,
+  makePostBodyRequest,
+  makePutBodyRequest,
+  runServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo
+} from '../../utils'
+
+const expect = chai.expect
+
+describe('Test videos history API validator', function () {
+  let path: string
+  let server: ServerInfo
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(30000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const res = await uploadVideo(server.url, server.accessToken, {})
+    const videoUUID = res.body.video.uuid
+
+    path = '/api/v1/videos/' + videoUUID + '/watching'
+  })
+
+  describe('When notifying a user is watching a video', function () {
+
+    it('Should fail with an unauthenticated user', async function () {
+      const fields = { currentTime: 5 }
+      await makePutBodyRequest({ url: server.url, path, fields, statusCodeExpected: 401 })
+    })
+
+    it('Should fail with an incorrect video id', async function () {
+      const fields = { currentTime: 5 }
+      const path = '/api/v1/videos/blabla/watching'
+      await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+    })
+
+    it('Should fail with an unknown video', async function () {
+      const fields = { currentTime: 5 }
+      const path = '/api/v1/videos/d91fff41-c24d-4508-8e13-3bd5902c3b02/watching'
+
+      await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 404 })
+    })
+
+    it('Should fail with a bad current time', async function () {
+      const fields = { currentTime: 'hello' }
+      await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      const fields = { currentTime: 5 }
+
+      await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 204 })
+    })
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/check-params/videos.ts b/server/tests/api/check-params/videos.ts
index 904d22870..699f135c7 100644
--- a/server/tests/api/check-params/videos.ts
+++ b/server/tests/api/check-params/videos.ts
@@ -233,7 +233,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
       const attaches = baseCorrectAttaches
 
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@@ -482,7 +482,7 @@ describe('Test videos API validator', function () {
     })
 
     it('Should fail with a long support text', async function () {
-      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(150) })
+      const fields = immutableAssign(baseCorrectParams, { support: 'super'.repeat(201) })
 
       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
     })
diff --git a/server/tests/api/index-4.ts b/server/tests/api/index-4.ts
new file mode 100644
index 000000000..8e69b95a6
--- /dev/null
+++ b/server/tests/api/index-4.ts
@@ -0,0 +1 @@
+import './redundancy'
diff --git a/server/tests/api/index.ts b/server/tests/api/index.ts
index 2d996dbf9..bc140f860 100644
--- a/server/tests/api/index.ts
+++ b/server/tests/api/index.ts
@@ -2,3 +2,4 @@
 import './index-1'
 import './index-2'
 import './index-3'
+import './index-4'
diff --git a/server/tests/api/redundancy/index.ts b/server/tests/api/redundancy/index.ts
new file mode 100644
index 000000000..8e69b95a6
--- /dev/null
+++ b/server/tests/api/redundancy/index.ts
@@ -0,0 +1 @@
+import './redundancy'
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
new file mode 100644
index 000000000..1960854b6
--- /dev/null
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -0,0 +1,483 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { VideoDetails } from '../../../../shared/models/videos'
+import {
+  doubleFollow,
+  flushAndRunMultipleServers,
+  getFollowingListPaginationAndSort,
+  getVideo,
+  immutableAssign,
+  killallServers, makeGetRequest,
+  root,
+  ServerInfo,
+  setAccessTokensToServers, unfollow,
+  uploadVideo,
+  viewVideo,
+  wait,
+  waitUntilLog,
+  checkVideoFilesWereRemoved, removeVideo
+} from '../../utils'
+import { waitJobs } from '../../utils/server/jobs'
+import * as magnetUtil from 'magnet-uri'
+import { updateRedundancy } from '../../utils/server/redundancy'
+import { ActorFollow } from '../../../../shared/models/actors'
+import { readdir } from 'fs-extra'
+import { join } from 'path'
+import { VideoRedundancyStrategy } from '../../../../shared/models/redundancy'
+import { getStats } from '../../utils/server/stats'
+import { ServerStats } from '../../../../shared/models/server/server-stats.model'
+
+const expect = chai.expect
+
+let servers: ServerInfo[] = []
+let video1Server2UUID: string
+
+function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: number } }, baseWebseeds: string[], server: ServerInfo) {
+  const parsed = magnetUtil.decode(file.magnetUri)
+
+  for (const ws of baseWebseeds) {
+    const found = parsed.urlList.find(url => url === `${ws}-${file.resolution.id}.mp4`)
+    expect(found, `Webseed ${ws} not found in ${file.magnetUri} on server ${server.url}`).to.not.be.undefined
+  }
+
+  expect(parsed.urlList).to.have.lengthOf(baseWebseeds.length)
+}
+
+async function runServers (strategy: VideoRedundancyStrategy, additionalParams: any = {}) {
+  const config = {
+    redundancy: {
+      videos: {
+        check_interval: '5 seconds',
+        strategies: [
+          immutableAssign({
+            min_lifetime: '1 hour',
+            strategy: strategy,
+            size: '100KB'
+          }, additionalParams)
+        ]
+      }
+    }
+  }
+  servers = await flushAndRunMultipleServers(3, config)
+
+  // Get the access tokens
+  await setAccessTokensToServers(servers)
+
+  {
+    const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, { name: 'video 1 server 2' })
+    video1Server2UUID = res.body.video.uuid
+
+    await viewVideo(servers[ 1 ].url, video1Server2UUID)
+  }
+
+  await waitJobs(servers)
+
+  // 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 ])
+
+  await waitJobs(servers)
+}
+
+async function check1WebSeed (strategy: VideoRedundancyStrategy, videoUUID?: string) {
+  if (!videoUUID) videoUUID = video1Server2UUID
+
+  const webseeds = [
+    'http://localhost:9002/static/webseed/' + videoUUID
+  ]
+
+  for (const server of servers) {
+    {
+      const res = await getVideo(server.url, videoUUID)
+
+      const video: VideoDetails = res.body
+      for (const f of video.files) {
+        checkMagnetWebseeds(f, webseeds, server)
+      }
+    }
+  }
+}
+
+async function checkStatsWith2Webseed (strategy: VideoRedundancyStrategy) {
+  const res = await getStats(servers[0].url)
+  const data: ServerStats = res.body
+
+  expect(data.videosRedundancy).to.have.lengthOf(1)
+  const stat = data.videosRedundancy[0]
+
+  expect(stat.strategy).to.equal(strategy)
+  expect(stat.totalSize).to.equal(102400)
+  expect(stat.totalUsed).to.be.at.least(1).and.below(102401)
+  expect(stat.totalVideoFiles).to.equal(4)
+  expect(stat.totalVideos).to.equal(1)
+}
+
+async function checkStatsWith1Webseed (strategy: VideoRedundancyStrategy) {
+  const res = await getStats(servers[0].url)
+  const data: ServerStats = res.body
+
+  expect(data.videosRedundancy).to.have.lengthOf(1)
+
+  const stat = data.videosRedundancy[0]
+  expect(stat.strategy).to.equal(strategy)
+  expect(stat.totalSize).to.equal(102400)
+  expect(stat.totalUsed).to.equal(0)
+  expect(stat.totalVideoFiles).to.equal(0)
+  expect(stat.totalVideos).to.equal(0)
+}
+
+async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: string) {
+  if (!videoUUID) videoUUID = video1Server2UUID
+
+  const webseeds = [
+    'http://localhost:9001/static/webseed/' + videoUUID,
+    'http://localhost:9002/static/webseed/' + videoUUID
+  ]
+
+  for (const server of servers) {
+    const res = await getVideo(server.url, videoUUID)
+
+    const video: VideoDetails = res.body
+
+    for (const file of video.files) {
+      checkMagnetWebseeds(file, webseeds, server)
+
+      // Only servers 1 and 2 have the video
+      if (server.serverNumber !== 3) {
+        await makeGetRequest({
+          url: server.url,
+          statusCodeExpected: 200,
+          path: '/static/webseed/' + `${videoUUID}-${file.resolution.id}.mp4`,
+          contentType: null
+        })
+      }
+    }
+  }
+
+  for (const directory of [ 'test1', 'test2' ]) {
+    const files = await readdir(join(root(), directory, 'videos'))
+    expect(files).to.have.length.at.least(4)
+
+    for (const resolution of [ 240, 360, 480, 720 ]) {
+      expect(files.find(f => f === `${videoUUID}-${resolution}.mp4`)).to.not.be.undefined
+    }
+  }
+}
+
+async function enableRedundancyOnServer1 () {
+  await updateRedundancy(servers[ 0 ].url, servers[ 0 ].accessToken, servers[ 1 ].host, true)
+
+  const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 5, '-createdAt')
+  const follows: ActorFollow[] = res.body.data
+  const server2 = follows.find(f => f.following.host === 'localhost:9002')
+  const server3 = follows.find(f => f.following.host === 'localhost:9003')
+
+  expect(server3).to.not.be.undefined
+  expect(server3.following.hostRedundancyAllowed).to.be.false
+
+  expect(server2).to.not.be.undefined
+  expect(server2.following.hostRedundancyAllowed).to.be.true
+}
+
+async function disableRedundancyOnServer1 () {
+  await updateRedundancy(servers[ 0 ].url, servers[ 0 ].accessToken, servers[ 1 ].host, false)
+
+  const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 5, '-createdAt')
+  const follows: ActorFollow[] = res.body.data
+  const server2 = follows.find(f => f.following.host === 'localhost:9002')
+  const server3 = follows.find(f => f.following.host === 'localhost:9003')
+
+  expect(server3).to.not.be.undefined
+  expect(server3.following.hostRedundancyAllowed).to.be.false
+
+  expect(server2).to.not.be.undefined
+  expect(server2.following.hostRedundancyAllowed).to.be.false
+}
+
+async function cleanServers () {
+  killallServers(servers)
+}
+
+describe('Test videos redundancy', function () {
+
+  describe('With most-views strategy', function () {
+    const strategy = 'most-views'
+
+    before(function () {
+      this.timeout(120000)
+
+      return runServers(strategy)
+    })
+
+    it('Should have 1 webseed on the first video', async function () {
+      await check1WebSeed(strategy)
+      await checkStatsWith1Webseed(strategy)
+    })
+
+    it('Should enable redundancy on server 1', function () {
+      return enableRedundancyOnServer1()
+    })
+
+    it('Should have 2 webseed on the first video', async function () {
+      this.timeout(40000)
+
+      await waitJobs(servers)
+      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitJobs(servers)
+
+      await check2Webseeds(strategy)
+      await checkStatsWith2Webseed(strategy)
+    })
+
+    it('Should undo redundancy on server 1 and remove duplicated videos', async function () {
+      this.timeout(40000)
+
+      await disableRedundancyOnServer1()
+
+      await waitJobs(servers)
+      await wait(5000)
+
+      await check1WebSeed(strategy)
+
+      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ])
+    })
+
+    after(function () {
+      return cleanServers()
+    })
+  })
+
+  describe('With trending strategy', function () {
+    const strategy = 'trending'
+
+    before(function () {
+      this.timeout(120000)
+
+      return runServers(strategy)
+    })
+
+    it('Should have 1 webseed on the first video', async function () {
+      await check1WebSeed(strategy)
+      await checkStatsWith1Webseed(strategy)
+    })
+
+    it('Should enable redundancy on server 1', function () {
+      return enableRedundancyOnServer1()
+    })
+
+    it('Should have 2 webseed on the first video', async function () {
+      this.timeout(40000)
+
+      await waitJobs(servers)
+      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitJobs(servers)
+
+      await check2Webseeds(strategy)
+      await checkStatsWith2Webseed(strategy)
+    })
+
+    it('Should unfollow on server 1 and remove duplicated videos', async function () {
+      this.timeout(40000)
+
+      await unfollow(servers[0].url, servers[0].accessToken, servers[1])
+
+      await waitJobs(servers)
+      await wait(5000)
+
+      await check1WebSeed(strategy)
+
+      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ])
+    })
+
+    after(function () {
+      return cleanServers()
+    })
+  })
+
+  describe('With recently added strategy', function () {
+    const strategy = 'recently-added'
+
+    before(function () {
+      this.timeout(120000)
+
+      return runServers(strategy, { min_views: 3 })
+    })
+
+    it('Should have 1 webseed on the first video', async function () {
+      await check1WebSeed(strategy)
+      await checkStatsWith1Webseed(strategy)
+    })
+
+    it('Should enable redundancy on server 1', function () {
+      return enableRedundancyOnServer1()
+    })
+
+    it('Should still have 1 webseed on the first video', async function () {
+      this.timeout(40000)
+
+      await waitJobs(servers)
+      await wait(15000)
+      await waitJobs(servers)
+
+      await check1WebSeed(strategy)
+      await checkStatsWith1Webseed(strategy)
+    })
+
+    it('Should view 2 times the first video to have > min_views config', async function () {
+      this.timeout(40000)
+
+      await viewVideo(servers[ 0 ].url, video1Server2UUID)
+      await viewVideo(servers[ 2 ].url, video1Server2UUID)
+
+      await wait(10000)
+      await waitJobs(servers)
+    })
+
+    it('Should have 2 webseed on the first video', async function () {
+      this.timeout(40000)
+
+      await waitJobs(servers)
+      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitJobs(servers)
+
+      await check2Webseeds(strategy)
+      await checkStatsWith2Webseed(strategy)
+    })
+
+    it('Should remove the video and the redundancy files', async function () {
+      this.timeout(20000)
+
+      await removeVideo(servers[1].url, servers[1].accessToken, video1Server2UUID)
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        await checkVideoFilesWereRemoved(video1Server2UUID, server.serverNumber)
+      }
+    })
+
+    after(function () {
+      return cleanServers()
+    })
+  })
+
+  describe('Test expiration', function () {
+    const strategy = 'recently-added'
+
+    async function checkContains (servers: ServerInfo[], str: string) {
+      for (const server of servers) {
+        const res = await getVideo(server.url, video1Server2UUID)
+        const video: VideoDetails = res.body
+
+        for (const f of video.files) {
+          expect(f.magnetUri).to.contain(str)
+        }
+      }
+    }
+
+    async function checkNotContains (servers: ServerInfo[], str: string) {
+      for (const server of servers) {
+        const res = await getVideo(server.url, video1Server2UUID)
+        const video: VideoDetails = res.body
+
+        for (const f of video.files) {
+          expect(f.magnetUri).to.not.contain(str)
+        }
+      }
+    }
+
+    before(async function () {
+      this.timeout(120000)
+
+      await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+
+      await enableRedundancyOnServer1()
+    })
+
+    it('Should still have 2 webseeds after 10 seconds', async function () {
+      this.timeout(40000)
+
+      await wait(10000)
+
+      try {
+        await checkContains(servers, 'http%3A%2F%2Flocalhost%3A9001')
+      } catch {
+        // Maybe a server deleted a redundancy in the scheduler
+        await wait(2000)
+
+        await checkContains(servers, 'http%3A%2F%2Flocalhost%3A9001')
+      }
+    })
+
+    it('Should stop server 1 and expire video redundancy', async function () {
+      this.timeout(40000)
+
+      killallServers([ servers[0] ])
+
+      await wait(10000)
+
+      await checkNotContains([ servers[1], servers[2] ], 'http%3A%2F%2Flocalhost%3A9001')
+    })
+
+    after(function () {
+      return killallServers([ servers[1], servers[2] ])
+    })
+  })
+
+  describe('Test file replacement', function () {
+    let video2Server2UUID: string
+    const strategy = 'recently-added'
+
+    before(async function () {
+      this.timeout(120000)
+
+      await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+
+      await enableRedundancyOnServer1()
+
+      await waitJobs(servers)
+      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitJobs(servers)
+
+      await check2Webseeds(strategy)
+      await checkStatsWith2Webseed(strategy)
+
+      const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, { name: 'video 2 server 2' })
+      video2Server2UUID = res.body.video.uuid
+    })
+
+    it('Should cache video 2 webseed on the first video', async function () {
+      this.timeout(50000)
+
+      await waitJobs(servers)
+
+      await wait(7000)
+
+      try {
+        await check1WebSeed(strategy, video1Server2UUID)
+        await check2Webseeds(strategy, video2Server2UUID)
+      } catch {
+        await wait(3000)
+
+        try {
+          await check1WebSeed(strategy, video1Server2UUID)
+          await check2Webseeds(strategy, video2Server2UUID)
+        } catch {
+          await wait(5000)
+
+          await check1WebSeed(strategy, video1Server2UUID)
+          await check2Webseeds(strategy, video2Server2UUID)
+        }
+      }
+    })
+
+    after(function () {
+      return cleanServers()
+    })
+  })
+})
diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index 310c291bf..e80e93e7f 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -93,7 +93,26 @@ describe('Test follows', function () {
     expect(server3Follow.state).to.equal('accepted')
   })
 
-  it('Should have 0 followings on server 1 and 2', async function () {
+  it('Should search followings on server 1', async function () {
+    {
+      const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 1, 'createdAt', ':9002')
+      const follows = res.body.data
+
+      expect(res.body.total).to.equal(1)
+      expect(follows.length).to.equal(1)
+      expect(follows[ 0 ].following.host).to.equal('localhost:9002')
+    }
+
+    {
+      const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 1, 'createdAt', 'bla')
+      const follows = res.body.data
+
+      expect(res.body.total).to.equal(0)
+      expect(follows.length).to.equal(0)
+    }
+  })
+
+  it('Should have 0 followings on server 2 and 3', async function () {
     for (const server of [ servers[1], servers[2] ]) {
       const res = await getFollowingListPaginationAndSort(server.url, 0, 5, 'createdAt')
       const follows = res.body.data
@@ -116,6 +135,25 @@ describe('Test follows', function () {
     }
   })
 
+  it('Should search followers on server 2', async function () {
+    {
+      const res = await getFollowersListPaginationAndSort(servers[ 2 ].url, 0, 5, 'createdAt', '9001')
+      const follows = res.body.data
+
+      expect(res.body.total).to.equal(1)
+      expect(follows.length).to.equal(1)
+      expect(follows[ 0 ].following.host).to.equal('localhost:9003')
+    }
+
+    {
+      const res = await getFollowersListPaginationAndSort(servers[ 2 ].url, 0, 5, 'createdAt', 'bla')
+      const follows = res.body.data
+
+      expect(res.body.total).to.equal(0)
+      expect(follows.length).to.equal(0)
+    }
+  })
+
   it('Should have 0 followers on server 1', async function () {
     const res = await getFollowersListPaginationAndSort(servers[0].url, 0, 5, 'createdAt')
     const follows = res.body.data
diff --git a/server/tests/api/server/index.ts b/server/tests/api/server/index.ts
index c74c68a33..eeb8b7a28 100644
--- a/server/tests/api/server/index.ts
+++ b/server/tests/api/server/index.ts
@@ -3,7 +3,6 @@ import './email'
 import './follows'
 import './handle-down'
 import './jobs'
-import './redundancy'
 import './reverse-proxy'
 import './stats'
 import './tracker'
diff --git a/server/tests/api/server/redundancy.ts b/server/tests/api/server/redundancy.ts
index 1960854b6..f50d6e3cf 100644
--- a/server/tests/api/server/redundancy.ts
+++ b/server/tests/api/server/redundancy.ts
@@ -419,7 +419,7 @@ describe('Test videos redundancy', function () {
 
       killallServers([ servers[0] ])
 
-      await wait(10000)
+      await wait(15000)
 
       await checkNotContains([ servers[1], servers[2] ], 'http%3A%2F%2Flocalhost%3A9001')
     })
@@ -452,26 +452,22 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should cache video 2 webseed on the first video', async function () {
-      this.timeout(50000)
+      this.timeout(120000)
 
       await waitJobs(servers)
 
-      await wait(7000)
+      let checked = false
 
-      try {
-        await check1WebSeed(strategy, video1Server2UUID)
-        await check2Webseeds(strategy, video2Server2UUID)
-      } catch {
-        await wait(3000)
+      while (checked === false) {
+        await wait(1000)
 
         try {
           await check1WebSeed(strategy, video1Server2UUID)
           await check2Webseeds(strategy, video2Server2UUID)
-        } catch {
-          await wait(5000)
 
-          await check1WebSeed(strategy, video1Server2UUID)
-          await check2Webseeds(strategy, video2Server2UUID)
+          checked = true
+        } catch {
+          checked = false
         }
       }
     })
diff --git a/server/tests/api/users/blocklist.ts b/server/tests/api/users/blocklist.ts
new file mode 100644
index 000000000..eed4b9f3e
--- /dev/null
+++ b/server/tests/api/users/blocklist.ts
@@ -0,0 +1,511 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import { AccountBlock, ServerBlock, Video } from '../../../../shared/index'
+import {
+  createUser,
+  doubleFollow,
+  flushAndRunMultipleServers,
+  flushTests,
+  killallServers,
+  ServerInfo,
+  uploadVideo,
+  userLogin
+} from '../../utils/index'
+import { setAccessTokensToServers } from '../../utils/users/login'
+import { getVideosListWithToken, getVideosList } from '../../utils/videos/videos'
+import {
+  addVideoCommentReply,
+  addVideoCommentThread,
+  getVideoCommentThreads,
+  getVideoThreadComments
+} from '../../utils/videos/video-comments'
+import { waitJobs } from '../../utils/server/jobs'
+import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
+import {
+  addAccountToAccountBlocklist,
+  addAccountToServerBlocklist,
+  addServerToAccountBlocklist,
+  addServerToServerBlocklist,
+  getAccountBlocklistByAccount,
+  getAccountBlocklistByServer,
+  getServerBlocklistByAccount,
+  getServerBlocklistByServer,
+  removeAccountFromAccountBlocklist,
+  removeAccountFromServerBlocklist,
+  removeServerFromAccountBlocklist,
+  removeServerFromServerBlocklist
+} from '../../utils/users/blocklist'
+
+const expect = chai.expect
+
+async function checkAllVideos (url: string, token: string) {
+  {
+    const res = await getVideosListWithToken(url, token)
+
+    expect(res.body.data).to.have.lengthOf(4)
+  }
+
+  {
+    const res = await getVideosList(url)
+
+    expect(res.body.data).to.have.lengthOf(4)
+  }
+}
+
+async function checkAllComments (url: string, token: string, videoUUID: string) {
+  const resThreads = await getVideoCommentThreads(url, videoUUID, 0, 5, '-createdAt', token)
+
+  const threads: VideoComment[] = resThreads.body.data
+  expect(threads).to.have.lengthOf(2)
+
+  for (const thread of threads) {
+    const res = await getVideoThreadComments(url, videoUUID, thread.id, token)
+
+    const tree: VideoCommentThreadTree = res.body
+    expect(tree.children).to.have.lengthOf(1)
+  }
+}
+
+describe('Test blocklist', function () {
+  let servers: ServerInfo[]
+  let videoUUID1: string
+  let videoUUID2: string
+  let userToken1: string
+  let userModeratorToken: string
+  let userToken2: string
+
+  before(async function () {
+    this.timeout(60000)
+
+    await flushTests()
+
+    servers = await flushAndRunMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    {
+      const user = { username: 'user1', password: 'password' }
+      await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+
+      userToken1 = await userLogin(servers[0], user)
+      await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
+    }
+
+    {
+      const user = { username: 'moderator', password: 'password' }
+      await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+
+      userModeratorToken = await userLogin(servers[0], user)
+    }
+
+    {
+      const user = { username: 'user2', password: 'password' }
+      await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
+
+      userToken2 = await userLogin(servers[1], user)
+      await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
+    }
+
+    {
+      const res = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video server 1' })
+      videoUUID1 = res.body.video.uuid
+    }
+
+    {
+      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video server 2' })
+      videoUUID2 = res.body.video.uuid
+    }
+
+    await doubleFollow(servers[0], servers[1])
+
+    {
+      const resComment = await addVideoCommentThread(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1, 'comment root 1')
+      const resReply = await addVideoCommentReply(servers[ 0 ].url, userToken1, videoUUID1, resComment.body.comment.id, 'comment user 1')
+      await addVideoCommentReply(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1, resReply.body.comment.id, 'comment root 1')
+    }
+
+    {
+      const resComment = await addVideoCommentThread(servers[ 0 ].url, userToken1, videoUUID1, 'comment user 1')
+      await addVideoCommentReply(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1, resComment.body.comment.id, 'comment root 1')
+    }
+
+    await waitJobs(servers)
+  })
+
+  describe('User blocklist', function () {
+
+    describe('When managing account blocklist', function () {
+      it('Should list all videos', function () {
+        return checkAllVideos(servers[ 0 ].url, servers[ 0 ].accessToken)
+      })
+
+      it('Should list the comments', function () {
+        return checkAllComments(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1)
+      })
+
+      it('Should block a remote account', async function () {
+        await addAccountToAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user2@localhost:9002')
+      })
+
+      it('Should hide its videos', async function () {
+        const res = await getVideosListWithToken(servers[ 0 ].url, servers[ 0 ].accessToken)
+
+        const videos: Video[] = res.body.data
+        expect(videos).to.have.lengthOf(3)
+
+        const v = videos.find(v => v.name === 'video user 2')
+        expect(v).to.be.undefined
+      })
+
+      it('Should block a local account', async function () {
+        await addAccountToAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user1')
+      })
+
+      it('Should hide its videos', async function () {
+        const res = await getVideosListWithToken(servers[ 0 ].url, servers[ 0 ].accessToken)
+
+        const videos: Video[] = res.body.data
+        expect(videos).to.have.lengthOf(2)
+
+        const v = videos.find(v => v.name === 'video user 1')
+        expect(v).to.be.undefined
+      })
+
+      it('Should hide its comments', async function () {
+        const resThreads = await getVideoCommentThreads(servers[ 0 ].url, videoUUID1, 0, 5, '-createdAt', servers[ 0 ].accessToken)
+
+        const threads: VideoComment[] = resThreads.body.data
+        expect(threads).to.have.lengthOf(1)
+        expect(threads[ 0 ].totalReplies).to.equal(0)
+
+        const t = threads.find(t => t.text === 'comment user 1')
+        expect(t).to.be.undefined
+
+        for (const thread of threads) {
+          const res = await getVideoThreadComments(servers[ 0 ].url, videoUUID1, thread.id, servers[ 0 ].accessToken)
+
+          const tree: VideoCommentThreadTree = res.body
+          expect(tree.children).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should list all the videos with another user', async function () {
+        return checkAllVideos(servers[ 0 ].url, userToken1)
+      })
+
+      it('Should list all the comments with another user', async function () {
+        return checkAllComments(servers[ 0 ].url, userToken1, videoUUID1)
+      })
+
+      it('Should list blocked accounts', async function () {
+        {
+          const res = await getAccountBlocklistByAccount(servers[ 0 ].url, servers[ 0 ].accessToken, 0, 1, 'createdAt')
+          const blocks: AccountBlock[] = res.body.data
+
+          expect(res.body.total).to.equal(2)
+
+          const block = blocks[ 0 ]
+          expect(block.byAccount.displayName).to.equal('root')
+          expect(block.byAccount.name).to.equal('root')
+          expect(block.blockedAccount.displayName).to.equal('user2')
+          expect(block.blockedAccount.name).to.equal('user2')
+          expect(block.blockedAccount.host).to.equal('localhost:9002')
+        }
+
+        {
+          const res = await getAccountBlocklistByAccount(servers[ 0 ].url, servers[ 0 ].accessToken, 1, 2, 'createdAt')
+          const blocks: AccountBlock[] = res.body.data
+
+          expect(res.body.total).to.equal(2)
+
+          const block = blocks[ 0 ]
+          expect(block.byAccount.displayName).to.equal('root')
+          expect(block.byAccount.name).to.equal('root')
+          expect(block.blockedAccount.displayName).to.equal('user1')
+          expect(block.blockedAccount.name).to.equal('user1')
+          expect(block.blockedAccount.host).to.equal('localhost:9001')
+        }
+      })
+
+      it('Should unblock the remote account', async function () {
+        await removeAccountFromAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user2@localhost:9002')
+      })
+
+      it('Should display its videos', async function () {
+        const res = await getVideosListWithToken(servers[ 0 ].url, servers[ 0 ].accessToken)
+
+        const videos: Video[] = res.body.data
+        expect(videos).to.have.lengthOf(3)
+
+        const v = videos.find(v => v.name === 'video user 2')
+        expect(v).not.to.be.undefined
+      })
+
+      it('Should unblock the local account', async function () {
+        await removeAccountFromAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user1')
+      })
+
+      it('Should display its comments', function () {
+        return checkAllComments(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1)
+      })
+    })
+
+    describe('When managing server blocklist', function () {
+      it('Should list all videos', function () {
+        return checkAllVideos(servers[ 0 ].url, servers[ 0 ].accessToken)
+      })
+
+      it('Should list the comments', function () {
+        return checkAllComments(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1)
+      })
+
+      it('Should block a remote server', async function () {
+        await addServerToAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'localhost:9002')
+      })
+
+      it('Should hide its videos', async function () {
+        const res = await getVideosListWithToken(servers[ 0 ].url, servers[ 0 ].accessToken)
+
+        const videos: Video[] = res.body.data
+        expect(videos).to.have.lengthOf(2)
+
+        const v1 = videos.find(v => v.name === 'video user 2')
+        const v2 = videos.find(v => v.name === 'video server 2')
+
+        expect(v1).to.be.undefined
+        expect(v2).to.be.undefined
+      })
+
+      it('Should list all the videos with another user', async function () {
+        return checkAllVideos(servers[ 0 ].url, userToken1)
+      })
+
+      it('Should hide its comments')
+
+      it('Should list blocked servers', async function () {
+        const res = await getServerBlocklistByAccount(servers[ 0 ].url, servers[ 0 ].accessToken, 0, 1, 'createdAt')
+        const blocks: ServerBlock[] = res.body.data
+
+        expect(res.body.total).to.equal(1)
+
+        const block = blocks[ 0 ]
+        expect(block.byAccount.displayName).to.equal('root')
+        expect(block.byAccount.name).to.equal('root')
+        expect(block.blockedServer.host).to.equal('localhost:9002')
+      })
+
+      it('Should unblock the remote server', async function () {
+        await removeServerFromAccountBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'localhost:9002')
+      })
+
+      it('Should display its videos', function () {
+        return checkAllVideos(servers[ 0 ].url, servers[ 0 ].accessToken)
+      })
+
+      it('Should display its comments', function () {
+        return checkAllComments(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID1)
+      })
+    })
+  })
+
+  describe('Server blocklist', function () {
+
+    describe('When managing account blocklist', function () {
+      it('Should list all videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllVideos(servers[ 0 ].url, token)
+        }
+      })
+
+      it('Should list the comments', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllComments(servers[ 0 ].url, token, videoUUID1)
+        }
+      })
+
+      it('Should block a remote account', async function () {
+        await addAccountToServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user2@localhost:9002')
+      })
+
+      it('Should hide its videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          const res = await getVideosListWithToken(servers[ 0 ].url, token)
+
+          const videos: Video[] = res.body.data
+          expect(videos).to.have.lengthOf(3)
+
+          const v = videos.find(v => v.name === 'video user 2')
+          expect(v).to.be.undefined
+        }
+      })
+
+      it('Should block a local account', async function () {
+        await addAccountToServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user1')
+      })
+
+      it('Should hide its videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          const res = await getVideosListWithToken(servers[ 0 ].url, token)
+
+          const videos: Video[] = res.body.data
+          expect(videos).to.have.lengthOf(2)
+
+          const v = videos.find(v => v.name === 'video user 1')
+          expect(v).to.be.undefined
+        }
+      })
+
+      it('Should hide its comments', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          const resThreads = await getVideoCommentThreads(servers[ 0 ].url, videoUUID1, 0, 5, '-createdAt', token)
+
+          const threads: VideoComment[] = resThreads.body.data
+          expect(threads).to.have.lengthOf(1)
+          expect(threads[ 0 ].totalReplies).to.equal(0)
+
+          const t = threads.find(t => t.text === 'comment user 1')
+          expect(t).to.be.undefined
+
+          for (const thread of threads) {
+            const res = await getVideoThreadComments(servers[ 0 ].url, videoUUID1, thread.id, token)
+
+            const tree: VideoCommentThreadTree = res.body
+            expect(tree.children).to.have.lengthOf(0)
+          }
+        }
+      })
+
+      it('Should list blocked accounts', async function () {
+        {
+          const res = await getAccountBlocklistByServer(servers[ 0 ].url, servers[ 0 ].accessToken, 0, 1, 'createdAt')
+          const blocks: AccountBlock[] = res.body.data
+
+          expect(res.body.total).to.equal(2)
+
+          const block = blocks[ 0 ]
+          expect(block.byAccount.displayName).to.equal('peertube')
+          expect(block.byAccount.name).to.equal('peertube')
+          expect(block.blockedAccount.displayName).to.equal('user2')
+          expect(block.blockedAccount.name).to.equal('user2')
+          expect(block.blockedAccount.host).to.equal('localhost:9002')
+        }
+
+        {
+          const res = await getAccountBlocklistByServer(servers[ 0 ].url, servers[ 0 ].accessToken, 1, 2, 'createdAt')
+          const blocks: AccountBlock[] = res.body.data
+
+          expect(res.body.total).to.equal(2)
+
+          const block = blocks[ 0 ]
+          expect(block.byAccount.displayName).to.equal('peertube')
+          expect(block.byAccount.name).to.equal('peertube')
+          expect(block.blockedAccount.displayName).to.equal('user1')
+          expect(block.blockedAccount.name).to.equal('user1')
+          expect(block.blockedAccount.host).to.equal('localhost:9001')
+        }
+      })
+
+      it('Should unblock the remote account', async function () {
+        await removeAccountFromServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user2@localhost:9002')
+      })
+
+      it('Should display its videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          const res = await getVideosListWithToken(servers[ 0 ].url, token)
+
+          const videos: Video[] = res.body.data
+          expect(videos).to.have.lengthOf(3)
+
+          const v = videos.find(v => v.name === 'video user 2')
+          expect(v).not.to.be.undefined
+        }
+      })
+
+      it('Should unblock the local account', async function () {
+        await removeAccountFromServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'user1')
+      })
+
+      it('Should display its comments', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllComments(servers[ 0 ].url, token, videoUUID1)
+        }
+      })
+    })
+
+    describe('When managing server blocklist', function () {
+      it('Should list all videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllVideos(servers[ 0 ].url, token)
+        }
+      })
+
+      it('Should list the comments', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllComments(servers[ 0 ].url, token, videoUUID1)
+        }
+      })
+
+      it('Should block a remote server', async function () {
+        await addServerToServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'localhost:9002')
+      })
+
+      it('Should hide its videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          const res1 = await getVideosList(servers[ 0 ].url)
+          const res2 = await getVideosListWithToken(servers[ 0 ].url, token)
+
+          for (const res of [ res1, res2 ]) {
+            const videos: Video[] = res.body.data
+            expect(videos).to.have.lengthOf(2)
+
+            const v1 = videos.find(v => v.name === 'video user 2')
+            const v2 = videos.find(v => v.name === 'video server 2')
+
+            expect(v1).to.be.undefined
+            expect(v2).to.be.undefined
+          }
+        }
+      })
+
+      it('Should hide its comments')
+
+      it('Should list blocked servers', async function () {
+        const res = await getServerBlocklistByServer(servers[ 0 ].url, servers[ 0 ].accessToken, 0, 1, 'createdAt')
+        const blocks: ServerBlock[] = res.body.data
+
+        expect(res.body.total).to.equal(1)
+
+        const block = blocks[ 0 ]
+        expect(block.byAccount.displayName).to.equal('peertube')
+        expect(block.byAccount.name).to.equal('peertube')
+        expect(block.blockedServer.host).to.equal('localhost:9002')
+      })
+
+      it('Should unblock the remote server', async function () {
+        await removeServerFromServerBlocklist(servers[ 0 ].url, servers[ 0 ].accessToken, 'localhost:9002')
+      })
+
+      it('Should list all videos', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllVideos(servers[ 0 ].url, token)
+        }
+      })
+
+      it('Should list the comments', async function () {
+        for (const token of [ userModeratorToken, servers[ 0 ].accessToken ]) {
+          await checkAllComments(servers[ 0 ].url, token, videoUUID1)
+        }
+      })
+    })
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this[ 'ok' ]) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/users/index.ts b/server/tests/api/users/index.ts
index 21d75da3e..0a1b8b0b2 100644
--- a/server/tests/api/users/index.ts
+++ b/server/tests/api/users/index.ts
@@ -1,3 +1,4 @@
+import './blocklist'
 import './user-subscriptions'
 import './users'
 import './users-verification'
diff --git a/server/tests/api/users/users-multiple-servers.ts b/server/tests/api/users/users-multiple-servers.ts
index b67072851..d8699db17 100644
--- a/server/tests/api/users/users-multiple-servers.ts
+++ b/server/tests/api/users/users-multiple-servers.ts
@@ -148,6 +148,12 @@ describe('Test users with multiple servers', function () {
       expect(rootServer1Get.displayName).to.equal('my super display name')
       expect(rootServer1Get.description).to.equal('my super description updated')
 
+      if (server.serverNumber === 1) {
+        expect(rootServer1Get.userId).to.be.a('number')
+      } else {
+        expect(rootServer1Get.userId).to.be.undefined
+      }
+
       await testImage(server.url, 'avatar2-resized', rootServer1Get.avatar.path, '.png')
     }
   })
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 8b9c6b455..513bca8a0 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -180,7 +180,7 @@ describe('Test users', function () {
   it('Should be able to upload a video again')
 
   it('Should be able to create a new user', async function () {
-    await createUser(server.url, accessToken, user.username,user.password, 2 * 1024 * 1024)
+    await createUser(server.url, accessToken, user.username, user.password, 2 * 1024 * 1024)
   })
 
   it('Should be able to login with this user', async function () {
@@ -322,6 +322,40 @@ describe('Test users', function () {
     expect(users[ 1 ].nsfwPolicy).to.equal('display')
   })
 
+  it('Should search user by username', async function () {
+    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'oot')
+    const users = res.body.data as User[]
+
+    expect(res.body.total).to.equal(1)
+    expect(users.length).to.equal(1)
+
+    expect(users[ 0 ].username).to.equal('root')
+  })
+
+  it('Should search user by email', async function () {
+    {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'r_1@exam')
+      const users = res.body.data as User[]
+
+      expect(res.body.total).to.equal(1)
+      expect(users.length).to.equal(1)
+
+      expect(users[ 0 ].username).to.equal('user_1')
+      expect(users[ 0 ].email).to.equal('user_1@example.com')
+    }
+
+    {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'example')
+      const users = res.body.data as User[]
+
+      expect(res.body.total).to.equal(2)
+      expect(users.length).to.equal(2)
+
+      expect(users[ 0 ].username).to.equal('root')
+      expect(users[ 1 ].username).to.equal('user_1')
+    }
+  })
+
   it('Should update my password', async function () {
     await updateMyUser({
       url: server.url,
diff --git a/server/tests/api/videos/index.ts b/server/tests/api/videos/index.ts
index bf58f9c79..9bdb78491 100644
--- a/server/tests/api/videos/index.ts
+++ b/server/tests/api/videos/index.ts
@@ -14,4 +14,6 @@ import './video-nsfw'
 import './video-privacy'
 import './video-schedule-update'
 import './video-transcoder'
+import './videos-filter'
+import './videos-history'
 import './videos-overview'
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index 4553ee855..b9ace2885 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -987,19 +987,19 @@ describe('Test multiple servers', function () {
           files: [
             {
               resolution: 720,
-              size: 36000
+              size: 72000
             },
             {
               resolution: 480,
-              size: 21000
+              size: 45000
             },
             {
               resolution: 360,
-              size: 17000
+              size: 34600
             },
             {
               resolution: 240,
-              size: 13000
+              size: 24770
             }
           ]
         }
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index e3d62b7a0..089c3df25 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -118,7 +118,7 @@ describe('Test a single server', function () {
     const categories = res.body
     expect(Object.keys(categories)).to.have.length.above(10)
 
-    expect(categories[11]).to.equal('News')
+    expect(categories[11]).to.equal('News & Politics')
   })
 
   it('Should list video licences', async function () {
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index b7866d529..aaee79a4a 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -30,7 +30,7 @@ describe('Test video imports', function () {
     const videoHttp: VideoDetails = resHttp.body
 
     expect(videoHttp.name).to.equal('small video - youtube')
-    expect(videoHttp.category.label).to.equal('News')
+    expect(videoHttp.category.label).to.equal('News & Politics')
     expect(videoHttp.licence.label).to.equal('Attribution')
     expect(videoHttp.language.label).to.equal('Unknown')
     expect(videoHttp.nsfw).to.be.false
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index 0f83d4d57..85795d2ed 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -4,8 +4,8 @@ import * as chai from 'chai'
 import 'mocha'
 import { omit } from 'lodash'
 import * as ffmpeg from 'fluent-ffmpeg'
-import { VideoDetails, VideoState } from '../../../../shared/models/videos'
-import { getVideoFileFPS, audio } from '../../../helpers/ffmpeg-utils'
+import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
+import { audio, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
 import {
   buildAbsoluteFixturePath,
   doubleFollow,
@@ -18,10 +18,13 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo,
-  webtorrentAdd
+  webtorrentAdd,
+  generateHighBitrateVideo
 } from '../../utils'
 import { join } from 'path'
 import { waitJobs } from '../../utils/server/jobs'
+import { pathExists } from 'fs-extra'
+import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
 
 const expect = chai.expect
 
@@ -121,7 +124,7 @@ describe('Test video transcoding', function () {
       expect(videoDetails.files).to.have.lengthOf(4)
 
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const probe = await audio.get(ffmpeg, path)
+      const probe = await audio.get(path)
 
       if (probe.audioStream) {
         expect(probe.audioStream[ 'codec_name' ]).to.be.equal('aac')
@@ -152,7 +155,7 @@ describe('Test video transcoding', function () {
 
       expect(videoDetails.files).to.have.lengthOf(4)
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const probe = await audio.get(ffmpeg, path)
+      const probe = await audio.get(path)
       expect(probe).to.not.have.property('audioStream')
     }
   })
@@ -177,9 +180,9 @@ describe('Test video transcoding', function () {
 
       expect(videoDetails.files).to.have.lengthOf(4)
       const fixturePath = buildAbsoluteFixturePath(videoAttributes.fixture)
-      const fixtureVideoProbe = await audio.get(ffmpeg, fixturePath)
+      const fixtureVideoProbe = await audio.get(fixturePath)
       const path = join(root(), 'test2', 'videos', video.uuid + '-240.mp4')
-      const videoProbe = await audio.get(ffmpeg, path)
+      const videoProbe = await audio.get(path)
       if (videoProbe.audioStream && fixtureVideoProbe.audioStream) {
         const toOmit = [ 'max_bit_rate', 'duration', 'duration_ts', 'nb_frames', 'start_time', 'start_pts' ]
         expect(omit(videoProbe.audioStream, toOmit)).to.be.deep.equal(omit(fixtureVideoProbe.audioStream, toOmit))
@@ -228,7 +231,7 @@ describe('Test video transcoding', function () {
     }
   })
 
-  it('Should wait transcoding before publishing the video', async function () {
+  it('Should wait for transcoding before publishing the video', async function () {
     this.timeout(80000)
 
     {
@@ -281,6 +284,45 @@ describe('Test video transcoding', function () {
     }
   })
 
+  it('Should respect maximum bitrate values', async function () {
+    this.timeout(160000)
+
+    let tempFixturePath: string
+
+    {
+      tempFixturePath = await generateHighBitrateVideo()
+
+      const bitrate = await getVideoFileBitrate(tempFixturePath)
+      expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 60, VIDEO_TRANSCODING_FPS))
+    }
+
+    const videoAttributes = {
+      name: 'high bitrate video',
+      description: 'high bitrate video',
+      fixture: tempFixturePath
+    }
+
+    await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+
+      const video = res.body.data.find(v => v.name === videoAttributes.name)
+
+      for (const resolution of ['240', '360', '480', '720', '1080']) {
+        const path = join(root(), 'test2', 'videos', video.uuid + '-' + resolution + '.mp4')
+        const bitrate = await getVideoFileBitrate(path)
+        const fps = await getVideoFileFPS(path)
+        const resolution2 = await getVideoFileResolution(path)
+
+        expect(resolution2.videoFileResolution.toString()).to.equal(resolution)
+        expect(bitrate).to.be.below(getMaxBitrate(resolution2.videoFileResolution, fps, VIDEO_TRANSCODING_FPS))
+      }
+    }
+  })
+
   after(async function () {
     killallServers(servers)
   })
diff --git a/server/tests/api/videos/videos-filter.ts b/server/tests/api/videos/videos-filter.ts
new file mode 100644
index 000000000..a7588129f
--- /dev/null
+++ b/server/tests/api/videos/videos-filter.ts
@@ -0,0 +1,130 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  createUser,
+  doubleFollow,
+  flushAndRunMultipleServers,
+  flushTests,
+  killallServers,
+  makeGetRequest,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  userLogin
+} from '../../utils'
+import { Video, VideoPrivacy } from '../../../../shared/models/videos'
+import { UserRole } from '../../../../shared/models/users'
+
+const expect = chai.expect
+
+async function getVideosNames (server: ServerInfo, token: string, filter: string, statusCodeExpected = 200) {
+  const paths = [
+    '/api/v1/video-channels/root_channel/videos',
+    '/api/v1/accounts/root/videos',
+    '/api/v1/videos',
+    '/api/v1/search/videos'
+  ]
+
+  const videosResults: Video[][] = []
+
+  for (const path of paths) {
+    const res = await makeGetRequest({
+      url: server.url,
+      path,
+      token,
+      query: {
+        sort: 'createdAt',
+        filter
+      },
+      statusCodeExpected
+    })
+
+    videosResults.push(res.body.data.map(v => v.name))
+  }
+
+  return videosResults
+}
+
+describe('Test videos filter validator', function () {
+  let servers: ServerInfo[]
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(120000)
+
+    await flushTests()
+
+    servers = await flushAndRunMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+
+    for (const server of servers) {
+      const moderator = { username: 'moderator', password: 'my super password' }
+      await createUser(
+        server.url,
+        server.accessToken,
+        moderator.username,
+        moderator.password,
+        undefined,
+        undefined,
+        UserRole.MODERATOR
+      )
+      server['moderatorAccessToken'] = await userLogin(server, moderator)
+
+      await uploadVideo(server.url, server.accessToken, { name: 'public ' + server.serverNumber })
+
+      {
+        const attributes = { name: 'unlisted ' + server.serverNumber, privacy: VideoPrivacy.UNLISTED }
+        await uploadVideo(server.url, server.accessToken, attributes)
+      }
+
+      {
+        const attributes = { name: 'private ' + server.serverNumber, privacy: VideoPrivacy.PRIVATE }
+        await uploadVideo(server.url, server.accessToken, attributes)
+      }
+    }
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('Check videos filter', function () {
+
+    it('Should display local videos', async function () {
+      for (const server of servers) {
+        const namesResults = await getVideosNames(server, server.accessToken, 'local')
+        for (const names of namesResults) {
+          expect(names).to.have.lengthOf(1)
+          expect(names[ 0 ]).to.equal('public ' + server.serverNumber)
+        }
+      }
+    })
+
+    it('Should display all local videos by the admin or the moderator', async function () {
+      for (const server of servers) {
+        for (const token of [ server.accessToken, server['moderatorAccessToken'] ]) {
+
+          const namesResults = await getVideosNames(server, token, 'all-local')
+          for (const names of namesResults) {
+            expect(names).to.have.lengthOf(3)
+
+            expect(names[ 0 ]).to.equal('public ' + server.serverNumber)
+            expect(names[ 1 ]).to.equal('unlisted ' + server.serverNumber)
+            expect(names[ 2 ]).to.equal('private ' + server.serverNumber)
+          }
+        }
+      }
+    })
+  })
+
+  after(async function () {
+    killallServers(servers)
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/api/videos/videos-history.ts b/server/tests/api/videos/videos-history.ts
new file mode 100644
index 000000000..6d289b288
--- /dev/null
+++ b/server/tests/api/videos/videos-history.ts
@@ -0,0 +1,128 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushTests,
+  getVideosListWithToken,
+  getVideoWithToken,
+  killallServers, makePutBodyRequest,
+  runServer, searchVideoWithToken,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo
+} from '../../utils'
+import { Video, VideoDetails } from '../../../../shared/models/videos'
+import { userWatchVideo } from '../../utils/videos/video-history'
+
+const expect = chai.expect
+
+describe('Test videos history', function () {
+  let server: ServerInfo = null
+  let video1UUID: string
+  let video2UUID: string
+  let video3UUID: string
+
+  before(async function () {
+    this.timeout(30000)
+
+    await flushTests()
+
+    server = await runServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    {
+      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
+      video1UUID = res.body.video.uuid
+    }
+
+    {
+      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+      video2UUID = res.body.video.uuid
+    }
+
+    {
+      const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
+      video3UUID = res.body.video.uuid
+    }
+  })
+
+  it('Should get videos, without watching history', async function () {
+    const res = await getVideosListWithToken(server.url, server.accessToken)
+    const videos: Video[] = res.body.data
+
+    for (const video of videos) {
+      const resDetail = await getVideoWithToken(server.url, server.accessToken, video.id)
+      const videoDetails: VideoDetails = resDetail.body
+
+      expect(video.userHistory).to.be.undefined
+      expect(videoDetails.userHistory).to.be.undefined
+    }
+  })
+
+  it('Should watch the first and second video', async function () {
+    await userWatchVideo(server.url, server.accessToken, video1UUID, 3)
+    await userWatchVideo(server.url, server.accessToken, video2UUID, 8)
+  })
+
+  it('Should return the correct history when listing, searching and getting videos', async function () {
+    const videosOfVideos: Video[][] = []
+
+    {
+      const res = await getVideosListWithToken(server.url, server.accessToken)
+      videosOfVideos.push(res.body.data)
+    }
+
+    {
+      const res = await searchVideoWithToken(server.url, 'video', server.accessToken)
+      videosOfVideos.push(res.body.data)
+    }
+
+    for (const videos of videosOfVideos) {
+      const video1 = videos.find(v => v.uuid === video1UUID)
+      const video2 = videos.find(v => v.uuid === video2UUID)
+      const video3 = videos.find(v => v.uuid === video3UUID)
+
+      expect(video1.userHistory).to.not.be.undefined
+      expect(video1.userHistory.currentTime).to.equal(3)
+
+      expect(video2.userHistory).to.not.be.undefined
+      expect(video2.userHistory.currentTime).to.equal(8)
+
+      expect(video3.userHistory).to.be.undefined
+    }
+
+    {
+      const resDetail = await getVideoWithToken(server.url, server.accessToken, video1UUID)
+      const videoDetails: VideoDetails = resDetail.body
+
+      expect(videoDetails.userHistory).to.not.be.undefined
+      expect(videoDetails.userHistory.currentTime).to.equal(3)
+    }
+
+    {
+      const resDetail = await getVideoWithToken(server.url, server.accessToken, video2UUID)
+      const videoDetails: VideoDetails = resDetail.body
+
+      expect(videoDetails.userHistory).to.not.be.undefined
+      expect(videoDetails.userHistory.currentTime).to.equal(8)
+    }
+
+    {
+      const resDetail = await getVideoWithToken(server.url, server.accessToken, video3UUID)
+      const videoDetails: VideoDetails = resDetail.body
+
+      expect(videoDetails.userHistory).to.be.undefined
+    }
+  })
+
+  after(async function () {
+    killallServers([ server ])
+
+    // Keep the logs if the test failed
+    if (this['ok']) {
+      await flushTests()
+    }
+  })
+})
diff --git a/server/tests/cli/optimize-old-videos.ts b/server/tests/cli/optimize-old-videos.ts
new file mode 100644
index 000000000..66dd39cce
--- /dev/null
+++ b/server/tests/cli/optimize-old-videos.ts
@@ -0,0 +1,120 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import * as chai from 'chai'
+import { getMaxBitrate, Video, VideoDetails, VideoResolution } from '../../../shared/models/videos'
+import {
+  doubleFollow,
+  execCLI,
+  flushAndRunMultipleServers,
+  flushTests, generateHighBitrateVideo,
+  getEnvCli,
+  getVideo,
+  getVideosList,
+  killallServers, root,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo, viewVideo, wait
+} from '../utils'
+import { waitJobs } from '../utils/server/jobs'
+import { getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../helpers/ffmpeg-utils'
+import { VIDEO_TRANSCODING_FPS } from '../../initializers'
+import { join } from 'path'
+
+const expect = chai.expect
+
+describe('Test optimize old videos', function () {
+  let servers: ServerInfo[] = []
+  let video1UUID: string
+  let video2UUID: string
+
+  before(async function () {
+    this.timeout(200000)
+
+    await flushTests()
+
+    // Run server 2 to have transcoding enabled
+    servers = await flushAndRunMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    let tempFixturePath: string
+
+    {
+      tempFixturePath = await generateHighBitrateVideo()
+
+      const bitrate = await getVideoFileBitrate(tempFixturePath)
+      expect(bitrate).to.be.above(getMaxBitrate(VideoResolution.H_1080P, 60, VIDEO_TRANSCODING_FPS))
+    }
+
+    // Upload two videos for our needs
+    const res1 = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video1', fixture: tempFixturePath })
+    video1UUID = res1.body.video.uuid
+    const res2 = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video2', fixture: tempFixturePath })
+    video2UUID = res2.body.video.uuid
+
+    await waitJobs(servers)
+  })
+
+  it('Should have two video files on each server', async function () {
+    this.timeout(30000)
+
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+      const videos = res.body.data
+      expect(videos).to.have.lengthOf(2)
+
+      for (const video of videos) {
+        const res2 = await getVideo(server.url, video.uuid)
+        const videoDetail: VideoDetails = res2.body
+        expect(videoDetail.files).to.have.lengthOf(1)
+      }
+    }
+  })
+
+  it('Should run optimize script', async function () {
+    this.timeout(120000)
+
+    const env = getEnvCli(servers[0])
+    await execCLI(`${env} npm run optimize-old-videos`)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideosList(server.url)
+      const videos: Video[] = res.body.data
+
+      expect(videos).to.have.lengthOf(2)
+
+      for (const video of videos) {
+        await viewVideo(server.url, video.uuid)
+
+        // Refresh video
+        await waitJobs(servers)
+        await wait(5000)
+        await waitJobs(servers)
+
+        const res2 = await getVideo(server.url, video.uuid)
+        const videosDetails: VideoDetails = res2.body
+
+        expect(videosDetails.files).to.have.lengthOf(1)
+        const file = videosDetails.files[0]
+
+        expect(file.size).to.be.below(5000000)
+
+        const path = join(root(), 'test1', 'videos', video.uuid + '-' + file.resolution.id + '.mp4')
+        const bitrate = await getVideoFileBitrate(path)
+        const fps = await getVideoFileFPS(path)
+        const resolution = await getVideoFileResolution(path)
+
+        expect(resolution.videoFileResolution).to.equal(file.resolution.id)
+        expect(bitrate).to.be.below(getMaxBitrate(resolution.videoFileResolution, fps, VIDEO_TRANSCODING_FPS))
+      }
+    }
+  })
+
+  after(async function () {
+    killallServers(servers)
+  })
+})
diff --git a/server/tests/helpers/core-utils.ts b/server/tests/helpers/core-utils.ts
new file mode 100644
index 000000000..a6d829a9f
--- /dev/null
+++ b/server/tests/helpers/core-utils.ts
@@ -0,0 +1,48 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  parseBytes
+} from '../../helpers/core-utils'
+
+const expect = chai.expect
+
+describe('Parse Bytes', function () {
+  it('Should pass when given valid value', async function () {
+    // just return it
+    expect(parseBytes(1024)).to.be.eq(1024)
+    expect(parseBytes(1048576)).to.be.eq(1048576)
+    expect(parseBytes('1024')).to.be.eq(1024)
+    expect(parseBytes('1048576')).to.be.eq(1048576)
+
+    // sizes
+    expect(parseBytes('1B')).to.be.eq(1024)
+    expect(parseBytes('1MB')).to.be.eq(1048576)
+    expect(parseBytes('1GB')).to.be.eq(1073741824)
+    expect(parseBytes('1TB')).to.be.eq(1099511627776)
+
+    expect(parseBytes('5GB')).to.be.eq(5368709120)
+    expect(parseBytes('5TB')).to.be.eq(5497558138880)
+
+    expect(parseBytes('1024B')).to.be.eq(1048576)
+    expect(parseBytes('1024MB')).to.be.eq(1073741824)
+    expect(parseBytes('1024GB')).to.be.eq(1099511627776)
+    expect(parseBytes('1024TB')).to.be.eq(1125899906842624)
+
+    // with whitespace
+    expect(parseBytes('1 GB')).to.be.eq(1073741824)
+    expect(parseBytes('1\tGB')).to.be.eq(1073741824)
+
+    // sum value
+    expect(parseBytes('1TB 1024MB')).to.be.eq(1100585369600)
+    expect(parseBytes('4GB 1024MB')).to.be.eq(5368709120)
+    expect(parseBytes('4TB 1024GB')).to.be.eq(5497558138880)
+    expect(parseBytes('4TB 1024GB 0MB')).to.be.eq(5497558138880)
+    expect(parseBytes('1024TB 1024GB 1024MB')).to.be.eq(1127000492212224)
+  })
+
+  it('Should be invalid when given invalid value', async function () {
+    expect(parseBytes('6GB 1GB')).to.be.eq(6)
+  })
+})
diff --git a/server/tests/helpers/index.ts b/server/tests/helpers/index.ts
new file mode 100644
index 000000000..40c7dc70e
--- /dev/null
+++ b/server/tests/helpers/index.ts
@@ -0,0 +1 @@
+import './core-utils'
diff --git a/server/tests/utils/miscs/miscs.ts b/server/tests/utils/miscs/miscs.ts
index b2f80e9b1..589daa420 100644
--- a/server/tests/utils/miscs/miscs.ts
+++ b/server/tests/utils/miscs/miscs.ts
@@ -4,7 +4,8 @@ import * as chai from 'chai'
 import { isAbsolute, join } from 'path'
 import * as request from 'supertest'
 import * as WebTorrent from 'webtorrent'
-import { readFile } from 'fs-extra'
+import { pathExists, readFile } from 'fs-extra'
+import * as ffmpeg from 'fluent-ffmpeg'
 
 const expect = chai.expect
 let webtorrent = new WebTorrent()
@@ -51,14 +52,41 @@ async function testImage (url: string, imageName: string, imagePath: string, ext
   expect(data.length).to.be.below(maxLength)
 }
 
-function buildAbsoluteFixturePath (path: string) {
+function buildAbsoluteFixturePath (path: string, customTravisPath = false) {
   if (isAbsolute(path)) {
     return path
   }
 
+  if (customTravisPath && process.env.TRAVIS) return join(process.env.HOME, 'fixtures', path)
+
   return join(__dirname, '..', '..', 'fixtures', path)
 }
 
+async function generateHighBitrateVideo () {
+  const tempFixturePath = buildAbsoluteFixturePath('video_high_bitrate_1080p.mp4', true)
+
+  const exists = await pathExists(tempFixturePath)
+  if (!exists) {
+
+    // Generate a random, high bitrate video on the fly, so we don't have to include
+    // a large file in the repo. The video needs to have a certain minimum length so
+    // that FFmpeg properly applies bitrate limits.
+    // https://stackoverflow.com/a/15795112
+    return new Promise<string>(async (res, rej) => {
+      ffmpeg()
+        .outputOptions([ '-f rawvideo', '-video_size 1920x1080', '-i /dev/urandom' ])
+        .outputOptions([ '-ac 2', '-f s16le', '-i /dev/urandom', '-t 10' ])
+        .outputOptions([ '-maxrate 10M', '-bufsize 10M' ])
+        .output(tempFixturePath)
+        .on('error', rej)
+        .on('end', () => res(tempFixturePath))
+        .run()
+    })
+  }
+
+  return tempFixturePath
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -68,5 +96,6 @@ export {
   immutableAssign,
   testImage,
   buildAbsoluteFixturePath,
-  root
+  root,
+  generateHighBitrateVideo
 }
diff --git a/server/tests/utils/requests/requests.ts b/server/tests/utils/requests/requests.ts
index 27a529eda..5796540f7 100644
--- a/server/tests/utils/requests/requests.ts
+++ b/server/tests/utils/requests/requests.ts
@@ -37,9 +37,7 @@ function makeDeleteRequest (options: {
 
   if (options.token) req.set('Authorization', 'Bearer ' + options.token)
 
-  return req
-    .expect('Content-Type', /json/)
-    .expect(options.statusCodeExpected)
+  return req.expect(options.statusCodeExpected)
 }
 
 function makeUploadRequest (options: {
diff --git a/server/tests/utils/server/follows.ts b/server/tests/utils/server/follows.ts
index 8a65a958b..7741757a6 100644
--- a/server/tests/utils/server/follows.ts
+++ b/server/tests/utils/server/follows.ts
@@ -2,7 +2,7 @@ import * as request from 'supertest'
 import { ServerInfo } from './servers'
 import { waitJobs } from './jobs'
 
-function getFollowersListPaginationAndSort (url: string, start: number, count: number, sort: string) {
+function getFollowersListPaginationAndSort (url: string, start: number, count: number, sort: string, search?: string) {
   const path = '/api/v1/server/followers'
 
   return request(url)
@@ -10,12 +10,13 @@ function getFollowersListPaginationAndSort (url: string, start: number, count: n
     .query({ start })
     .query({ count })
     .query({ sort })
+    .query({ search })
     .set('Accept', 'application/json')
     .expect(200)
     .expect('Content-Type', /json/)
 }
 
-function getFollowingListPaginationAndSort (url: string, start: number, count: number, sort: string) {
+function getFollowingListPaginationAndSort (url: string, start: number, count: number, sort: string, search?: string) {
   const path = '/api/v1/server/following'
 
   return request(url)
@@ -23,6 +24,7 @@ function getFollowingListPaginationAndSort (url: string, start: number, count: n
     .query({ start })
     .query({ count })
     .query({ sort })
+    .query({ search })
     .set('Accept', 'application/json')
     .expect(200)
     .expect('Content-Type', /json/)
diff --git a/server/tests/utils/users/blocklist.ts b/server/tests/utils/users/blocklist.ts
new file mode 100644
index 000000000..35b537571
--- /dev/null
+++ b/server/tests/utils/users/blocklist.ts
@@ -0,0 +1,198 @@
+/* tslint:disable:no-unused-expression */
+
+import { makeDeleteRequest, makePostBodyRequest } from '../index'
+import { makeGetRequest } from '../requests/requests'
+
+function getAccountBlocklistByAccount (
+  url: string,
+  token: string,
+  start: number,
+  count: number,
+  sort = '-createdAt',
+  statusCodeExpected = 200
+) {
+  const path = '/api/v1/users/me/blocklist/accounts'
+
+  return makeGetRequest({
+    url,
+    token,
+    query: { start, count, sort },
+    path,
+    statusCodeExpected
+  })
+}
+
+function addAccountToAccountBlocklist (url: string, token: string, accountToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/users/me/blocklist/accounts'
+
+  return makePostBodyRequest({
+    url,
+    path,
+    token,
+    fields: {
+      accountName: accountToBlock
+    },
+    statusCodeExpected
+  })
+}
+
+function removeAccountFromAccountBlocklist (url: string, token: string, accountToUnblock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/users/me/blocklist/accounts/' + accountToUnblock
+
+  return makeDeleteRequest({
+    url,
+    path,
+    token,
+    statusCodeExpected
+  })
+}
+
+function getServerBlocklistByAccount (
+  url: string,
+  token: string,
+  start: number,
+  count: number,
+  sort = '-createdAt',
+  statusCodeExpected = 200
+) {
+  const path = '/api/v1/users/me/blocklist/servers'
+
+  return makeGetRequest({
+    url,
+    token,
+    query: { start, count, sort },
+    path,
+    statusCodeExpected
+  })
+}
+
+function addServerToAccountBlocklist (url: string, token: string, serverToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/users/me/blocklist/servers'
+
+  return makePostBodyRequest({
+    url,
+    path,
+    token,
+    fields: {
+      host: serverToBlock
+    },
+    statusCodeExpected
+  })
+}
+
+function removeServerFromAccountBlocklist (url: string, token: string, serverToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/users/me/blocklist/servers/' + serverToBlock
+
+  return makeDeleteRequest({
+    url,
+    path,
+    token,
+    statusCodeExpected
+  })
+}
+
+function getAccountBlocklistByServer (
+  url: string,
+  token: string,
+  start: number,
+  count: number,
+  sort = '-createdAt',
+  statusCodeExpected = 200
+) {
+  const path = '/api/v1/server/blocklist/accounts'
+
+  return makeGetRequest({
+    url,
+    token,
+    query: { start, count, sort },
+    path,
+    statusCodeExpected
+  })
+}
+
+function addAccountToServerBlocklist (url: string, token: string, accountToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/server/blocklist/accounts'
+
+  return makePostBodyRequest({
+    url,
+    path,
+    token,
+    fields: {
+      accountName: accountToBlock
+    },
+    statusCodeExpected
+  })
+}
+
+function removeAccountFromServerBlocklist (url: string, token: string, accountToUnblock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/server/blocklist/accounts/' + accountToUnblock
+
+  return makeDeleteRequest({
+    url,
+    path,
+    token,
+    statusCodeExpected
+  })
+}
+
+function getServerBlocklistByServer (
+  url: string,
+  token: string,
+  start: number,
+  count: number,
+  sort = '-createdAt',
+  statusCodeExpected = 200
+) {
+  const path = '/api/v1/server/blocklist/servers'
+
+  return makeGetRequest({
+    url,
+    token,
+    query: { start, count, sort },
+    path,
+    statusCodeExpected
+  })
+}
+
+function addServerToServerBlocklist (url: string, token: string, serverToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/server/blocklist/servers'
+
+  return makePostBodyRequest({
+    url,
+    path,
+    token,
+    fields: {
+      host: serverToBlock
+    },
+    statusCodeExpected
+  })
+}
+
+function removeServerFromServerBlocklist (url: string, token: string, serverToBlock: string, statusCodeExpected = 204) {
+  const path = '/api/v1/server/blocklist/servers/' + serverToBlock
+
+  return makeDeleteRequest({
+    url,
+    path,
+    token,
+    statusCodeExpected
+  })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  getAccountBlocklistByAccount,
+  addAccountToAccountBlocklist,
+  removeAccountFromAccountBlocklist,
+  getServerBlocklistByAccount,
+  addServerToAccountBlocklist,
+  removeServerFromAccountBlocklist,
+
+  getAccountBlocklistByServer,
+  addAccountToServerBlocklist,
+  removeAccountFromServerBlocklist,
+  getServerBlocklistByServer,
+  addServerToServerBlocklist,
+  removeServerFromServerBlocklist
+}
diff --git a/server/tests/utils/users/users.ts b/server/tests/utils/users/users.ts
index 41d8ce265..d77233d62 100644
--- a/server/tests/utils/users/users.ts
+++ b/server/tests/utils/users/users.ts
@@ -112,7 +112,7 @@ function getUsersList (url: string, accessToken: string) {
           .expect('Content-Type', /json/)
 }
 
-function getUsersListPaginationAndSort (url: string, accessToken: string, start: number, count: number, sort: string) {
+function getUsersListPaginationAndSort (url: string, accessToken: string, start: number, count: number, sort: string, search?: string) {
   const path = '/api/v1/users'
 
   return request(url)
@@ -120,6 +120,7 @@ function getUsersListPaginationAndSort (url: string, accessToken: string, start:
           .query({ start })
           .query({ count })
           .query({ sort })
+          .query({ search })
           .set('Accept', 'application/json')
           .set('Authorization', 'Bearer ' + accessToken)
           .expect(200)
diff --git a/server/tests/utils/videos/video-comments.ts b/server/tests/utils/videos/video-comments.ts
index 1b9ee452e..7d4cae364 100644
--- a/server/tests/utils/videos/video-comments.ts
+++ b/server/tests/utils/videos/video-comments.ts
@@ -1,7 +1,7 @@
 import * as request from 'supertest'
 import { makeDeleteRequest } from '../'
 
-function getVideoCommentThreads (url: string, videoId: number | string, start: number, count: number, sort?: string) {
+function getVideoCommentThreads (url: string, videoId: number | string, start: number, count: number, sort?: string, token?: string) {
   const path = '/api/v1/videos/' + videoId + '/comment-threads'
 
   const req = request(url)
@@ -10,20 +10,24 @@ function getVideoCommentThreads (url: string, videoId: number | string, start: n
     .query({ count: count })
 
   if (sort) req.query({ sort })
+  if (token) req.set('Authorization', 'Bearer ' + token)
 
   return req.set('Accept', 'application/json')
     .expect(200)
     .expect('Content-Type', /json/)
 }
 
-function getVideoThreadComments (url: string, videoId: number | string, threadId: number) {
+function getVideoThreadComments (url: string, videoId: number | string, threadId: number, token?: string) {
   const path = '/api/v1/videos/' + videoId + '/comment-threads/' + threadId
 
-  return request(url)
+  const req = request(url)
     .get(path)
     .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
+
+  if (token) req.set('Authorization', 'Bearer ' + token)
+
+  return req.expect(200)
+            .expect('Content-Type', /json/)
 }
 
 function addVideoCommentThread (url: string, token: string, videoId: number | string, text: string, expectedStatus = 200) {
diff --git a/server/tests/utils/videos/video-history.ts b/server/tests/utils/videos/video-history.ts
new file mode 100644
index 000000000..7635478f7
--- /dev/null
+++ b/server/tests/utils/videos/video-history.ts
@@ -0,0 +1,14 @@
+import { makePutBodyRequest } from '../requests/requests'
+
+function userWatchVideo (url: string, token: string, videoId: number | string, currentTime: number) {
+  const path = '/api/v1/videos/' + videoId + '/watching'
+  const fields = { currentTime }
+
+  return makePutBodyRequest({ url, path, token, fields, statusCodeExpected: 204 })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  userWatchVideo
+}