Merge branch 'master' into webseed-merged

10 files changed, 1201 insertions, 1013 deletions

diff --git a/server/tests/api/check-params.js b/server/tests/api/check-params.js
new file mode 100644
index 000000000..57b5ca024
--- /dev/null
+++ b/server/tests/api/check-params.js
@@ -0,0 +1,746 @@
+'use strict'
+
+const chai = require('chai')
+const expect = chai.expect
+const pathUtils = require('path')
+const request = require('supertest')
+const series = require('async/series')
+
+const loginUtils = require('../utils/login')
+const requestsUtils = require('../utils/requests')
+const serversUtils = require('../utils/servers')
+const usersUtils = require('../utils/users')
+
+describe('Test parameters validator', function () {
+  let server = null
+  let userAccessToken = null
+
+  // ---------------------------------------------------------------
+
+  before(function (done) {
+    this.timeout(20000)
+
+    series([
+      function (next) {
+        serversUtils.flushTests(next)
+      },
+      function (next) {
+        serversUtils.runServer(1, function (server1) {
+          server = server1
+
+          next()
+        })
+      },
+      function (next) {
+        loginUtils.loginAndGetAccessToken(server, function (err, token) {
+          if (err) throw err
+          server.accessToken = token
+
+          next()
+        })
+      }
+    ], done)
+  })
+
+  describe('Of the pods API', function () {
+    const path = '/api/v1/pods/'
+
+    describe('When making friends', function () {
+      let userAccessToken = null
+
+      before(function (done) {
+        usersUtils.createUser(server.url, server.accessToken, 'user1', 'password', function () {
+          server.user = {
+            username: 'user1',
+            password: 'password'
+          }
+
+          loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
+            if (err) throw err
+
+            userAccessToken = accessToken
+
+            done()
+          })
+        })
+      })
+
+      describe('When making friends', function () {
+        const body = {
+          urls: [ 'http://localhost:9002' ]
+        }
+
+        it('Should fail without urls', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .set('Authorization', 'Bearer ' + server.accessToken)
+            .set('Accept', 'application/json')
+            .expect(400, done)
+        })
+
+        it('Should fail with urls is not an array', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .send({ urls: 'http://localhost:9002' })
+            .set('Authorization', 'Bearer ' + server.accessToken)
+            .set('Accept', 'application/json')
+            .expect(400, done)
+        })
+
+        it('Should fail if the array is not composed by urls', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .send({ urls: [ 'http://localhost:9002', 'localhost:coucou' ] })
+            .set('Authorization', 'Bearer ' + server.accessToken)
+            .set('Accept', 'application/json')
+            .expect(400, done)
+        })
+
+        it('Should fail if urls are not unique', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .send({ urls: [ 'http://localhost:9002', 'http://localhost:9002' ] })
+            .set('Authorization', 'Bearer ' + server.accessToken)
+            .set('Accept', 'application/json')
+            .expect(400, done)
+        })
+
+        it('Should fail with a invalid token', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .send(body)
+            .set('Authorization', 'Bearer faketoken')
+            .set('Accept', 'application/json')
+            .expect(401, done)
+        })
+
+        it('Should fail if the user is not an administrator', function (done) {
+          request(server.url)
+            .post(path + '/makefriends')
+            .send(body)
+            .set('Authorization', 'Bearer ' + userAccessToken)
+            .set('Accept', 'application/json')
+            .expect(403, done)
+        })
+      })
+
+      describe('When quitting friends', function () {
+        it('Should fail with a invalid token', function (done) {
+          request(server.url)
+            .get(path + '/quitfriends')
+            .query({ start: 'hello' })
+            .set('Authorization', 'Bearer faketoken')
+            .set('Accept', 'application/json')
+            .expect(401, done)
+        })
+
+        it('Should fail if the user is not an administrator', function (done) {
+          request(server.url)
+            .get(path + '/quitfriends')
+            .query({ start: 'hello' })
+            .set('Authorization', 'Bearer ' + userAccessToken)
+            .set('Accept', 'application/json')
+            .expect(403, done)
+        })
+      })
+    })
+
+    describe('When adding a pod', function () {
+      it('Should fail with nothing', function (done) {
+        const data = {}
+        requestsUtils.makePostBodyRequest(server.url, path, null, data, done)
+      })
+
+      it('Should fail without public key', function (done) {
+        const data = {
+          url: 'http://coucou.com'
+        }
+        requestsUtils.makePostBodyRequest(server.url, path, null, data, done)
+      })
+
+      it('Should fail without an url', function (done) {
+        const data = {
+          publicKey: 'mysuperpublickey'
+        }
+        requestsUtils.makePostBodyRequest(server.url, path, null, data, done)
+      })
+
+      it('Should fail with an incorrect url', function (done) {
+        const data = {
+          url: 'coucou.com',
+          publicKey: 'mysuperpublickey'
+        }
+        requestsUtils.makePostBodyRequest(server.url, path, null, data, function () {
+          data.url = 'http://coucou'
+          requestsUtils.makePostBodyRequest(server.url, path, null, data, function () {
+            data.url = 'coucou'
+            requestsUtils.makePostBodyRequest(server.url, path, null, data, done)
+          })
+        })
+      })
+
+      it('Should succeed with the correct parameters', function (done) {
+        const data = {
+          url: 'http://coucou.com',
+          publicKey: 'mysuperpublickey'
+        }
+        requestsUtils.makePostBodyRequest(server.url, path, null, data, done, 200)
+      })
+    })
+  })
+
+  describe('Of the videos API', function () {
+    const path = '/api/v1/videos/'
+
+    describe('When listing a video', function () {
+      it('Should fail with a bad start pagination', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ start: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with a bad count pagination', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ count: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with an incorrect sort', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ sort: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+    })
+
+    describe('When searching a video', function () {
+      it('Should fail with nothing', function (done) {
+        request(server.url)
+          .get(pathUtils.join(path, 'search'))
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with a bad start pagination', function (done) {
+        request(server.url)
+          .get(pathUtils.join(path, 'search', 'test'))
+          .query({ start: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with a bad count pagination', function (done) {
+        request(server.url)
+          .get(pathUtils.join(path, 'search', 'test'))
+          .query({ count: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with an incorrect sort', function (done) {
+        request(server.url)
+          .get(pathUtils.join(path, 'search', 'test'))
+          .query({ sort: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+    })
+
+    describe('When adding a video', function () {
+      it('Should fail with nothing', function (done) {
+        const data = {}
+        const attach = {}
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail without name', function (done) {
+        const data = {
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with a long name', function (done) {
+        const data = {
+          name: 'My very very very very very very very very very very very very very very very very long name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail without description', function (done) {
+        const data = {
+          name: 'my super name',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with a long description', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description which is very very very very very very very very very very very very very very' +
+                       'very very very very very very very very very very very very very very very very very very very very very' +
+                       'very very very very very very very very very very very very very very very long',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail without tags', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description'
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with too many tags', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2', 'tag3', 'tag4' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with not enough tags', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with a tag length too low', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 't' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with a tag length too big', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'mysupertagtoolong', 'tag1' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with malformed tags', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'my tag' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail without an input file', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {}
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail without an incorrect input file', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short_fake.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should fail with a too big duration', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_too_long.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done)
+      })
+
+      it('Should succeed with the correct parameters', function (done) {
+        const data = {
+          name: 'my super name',
+          description: 'my super description',
+          tags: [ 'tag1', 'tag2' ]
+        }
+        const attach = {
+          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
+        }
+        requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, function () {
+          attach.videofile = pathUtils.join(__dirname, 'fixtures', 'video_short.mp4')
+          requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, function () {
+            attach.videofile = pathUtils.join(__dirname, 'fixtures', 'video_short.ogv')
+            requestsUtils.makePostUploadRequest(server.url, path, server.accessToken, data, attach, done, 204)
+          }, false)
+        }, false)
+      })
+    })
+
+    describe('When getting a video', function () {
+      it('Should return the list of the videos with nothing', function (done) {
+        request(server.url)
+          .get(path)
+          .set('Accept', 'application/json')
+          .expect(200)
+          .expect('Content-Type', /json/)
+          .end(function (err, res) {
+            if (err) throw err
+
+            expect(res.body.data).to.be.an('array')
+            expect(res.body.data.length).to.equal(3)
+
+            done()
+          })
+      })
+
+      it('Should fail without a mongodb id', function (done) {
+        request(server.url)
+          .get(path + 'coucou')
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should return 404 with an incorrect video', function (done) {
+        request(server.url)
+          .get(path + '123456789012345678901234')
+          .set('Accept', 'application/json')
+          .expect(404, done)
+      })
+
+      it('Should succeed with the correct parameters')
+    })
+
+    describe('When removing a video', function () {
+      it('Should have 404 with nothing', function (done) {
+        request(server.url)
+          .delete(path)
+          .set('Authorization', 'Bearer ' + server.accessToken)
+          .expect(400, done)
+      })
+
+      it('Should fail without a mongodb id', function (done) {
+        request(server.url)
+          .delete(path + 'hello')
+          .set('Authorization', 'Bearer ' + server.accessToken)
+          .expect(400, done)
+      })
+
+      it('Should fail with a video which does not exist', function (done) {
+        request(server.url)
+          .delete(path + '123456789012345678901234')
+          .set('Authorization', 'Bearer ' + server.accessToken)
+          .expect(404, done)
+      })
+
+      it('Should fail with a video of another user')
+
+      it('Should fail with a video of another pod')
+
+      it('Should succeed with the correct parameters')
+    })
+  })
+
+  describe('Of the users API', function () {
+    const path = '/api/v1/users/'
+    let userId = null
+
+    describe('When listing users', function () {
+      it('Should fail with a bad start pagination', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ start: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with a bad count pagination', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ count: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+
+      it('Should fail with an incorrect sort', function (done) {
+        request(server.url)
+          .get(path)
+          .query({ sort: 'hello' })
+          .set('Accept', 'application/json')
+          .expect(400, done)
+      })
+    })
+
+    describe('When adding a new user', function () {
+      it('Should fail with a too small username', function (done) {
+        const data = {
+          username: 'ji',
+          password: 'mysuperpassword'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done)
+      })
+
+      it('Should fail with a too long username', function (done) {
+        const data = {
+          username: 'mysuperusernamewhichisverylong',
+          password: 'mysuperpassword'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done)
+      })
+
+      it('Should fail with an incorrect username', function (done) {
+        const data = {
+          username: 'my username',
+          password: 'mysuperpassword'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done)
+      })
+
+      it('Should fail with a too small password', function (done) {
+        const data = {
+          username: 'myusername',
+          password: 'bla'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done)
+      })
+
+      it('Should fail with a too long password', function (done) {
+        const data = {
+          username: 'myusername',
+          password: 'my super long password which is very very very very very very very very very very very very very very' +
+                    'very very very very very very very very very very very very very very very veryv very very very very' +
+                    'very very very very very very very very very very very very very very very very very very very very long'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done)
+      })
+
+      it('Should fail with an non authenticated user', function (done) {
+        const data = {
+          username: 'myusername',
+          password: 'my super password'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, 'super token', data, done, 401)
+      })
+
+      it('Should fail if we add a user with the same username', function (done) {
+        const data = {
+          username: 'user1',
+          password: 'my super password'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done, 409)
+      })
+
+      it('Should succeed with the correct params', function (done) {
+        const data = {
+          username: 'user2',
+          password: 'my super password'
+        }
+
+        requestsUtils.makePostBodyRequest(server.url, path, server.accessToken, data, done, 204)
+      })
+
+      it('Should fail with a non admin user', function (done) {
+        server.user = {
+          username: 'user1',
+          password: 'password'
+        }
+
+        loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
+          if (err) throw err
+
+          userAccessToken = accessToken
+
+          const data = {
+            username: 'user3',
+            password: 'my super password'
+          }
+
+          requestsUtils.makePostBodyRequest(server.url, path, userAccessToken, data, done, 403)
+        })
+      })
+    })
+
+    describe('When updating a user', function () {
+      before(function (done) {
+        usersUtils.getUsersList(server.url, function (err, res) {
+          if (err) throw err
+
+          userId = res.body.data[1].id
+          done()
+        })
+      })
+
+      it('Should fail with a too small password', function (done) {
+        const data = {
+          password: 'bla'
+        }
+
+        requestsUtils.makePutBodyRequest(server.url, path + userId, userAccessToken, data, done)
+      })
+
+      it('Should fail with a too long password', function (done) {
+        const data = {
+          password: 'my super long password which is very very very very very very very very very very very very very very' +
+                    'very very very very very very very very very very very very very very very veryv very very very very' +
+                    'very very very very very very very very very very very very very very very very very very very very long'
+        }
+
+        requestsUtils.makePutBodyRequest(server.url, path + userId, userAccessToken, data, done)
+      })
+
+      it('Should fail with an non authenticated user', function (done) {
+        const data = {
+          password: 'my super password'
+        }
+
+        requestsUtils.makePutBodyRequest(server.url, path + userId, 'super token', data, done, 401)
+      })
+
+      it('Should succeed with the correct params', function (done) {
+        const data = {
+          password: 'my super password'
+        }
+
+        requestsUtils.makePutBodyRequest(server.url, path + userId, userAccessToken, data, done, 204)
+      })
+    })
+
+    describe('When getting my information', function () {
+      it('Should fail with a non authenticated user', function (done) {
+        request(server.url)
+          .get(path + 'me')
+          .set('Authorization', 'Bearer faketoken')
+          .set('Accept', 'application/json')
+          .expect(401, done)
+      })
+
+      it('Should success with the correct parameters', function (done) {
+        request(server.url)
+          .get(path + 'me')
+          .set('Authorization', 'Bearer ' + userAccessToken)
+          .set('Accept', 'application/json')
+          .expect(200, done)
+      })
+    })
+
+    describe('When removing an user', function () {
+      it('Should fail with an incorrect id', function (done) {
+        request(server.url)
+          .delete(path + 'bla-bla')
+          .set('Authorization', 'Bearer ' + server.accessToken)
+          .expect(400, done)
+      })
+
+      it('Should return 404 with a non existing id', function (done) {
+        request(server.url)
+          .delete(path + '579f982228c99c221d8092b8')
+          .set('Authorization', 'Bearer ' + server.accessToken)
+          .expect(404, done)
+      })
+    })
+  })
+
+  describe('Of the remote videos API', function () {
+    describe('When making a secure request', function () {
+      it('Should check a secure request')
+    })
+
+    describe('When adding a video', function () {
+      it('Should check when adding a video')
+    })
+
+    describe('When removing a video', function () {
+      it('Should check when removing a video')
+    })
+  })
+
+  describe('Of the requests API', function () {
+    const path = '/api/v1/requests/stats'
+
+    it('Should fail with an non authenticated user', function (done) {
+      request(server.url)
+        .get(path)
+        .set('Accept', 'application/json')
+        .expect(401, done)
+    })
+
+    it('Should fail with a non admin user', function (done) {
+      request(server.url)
+        .get(path)
+        .set('Authorization', 'Bearer ' + userAccessToken)
+        .set('Accept', 'application/json')
+        .expect(403, done)
+    })
+  })
+
+  after(function (done) {
+    process.kill(-server.app.pid)
+
+    // Keep the logs if the test failed
+    if (this.ok) {
+      serversUtils.flushTests(done)
+    } else {
+      done()
+    }
+  })
+})
diff --git a/server/tests/api/checkParams.js b/server/tests/api/checkParams.js
deleted file mode 100644
index c1ba9c2c0..000000000
--- a/server/tests/api/checkParams.js
+++ /dev/null
@@ -1,456 +0,0 @@
-'use strict'
-
-const chai = require('chai')
-const expect = chai.expect
-const pathUtils = require('path')
-const request = require('supertest')
-const series = require('async/series')
-
-const utils = require('./utils')
-
-describe('Test parameters validator', function () {
-  let server = null
-
-  function makePostRequest (path, token, fields, attaches, done, fail) {
-    let statusCode = 400
-    if (fail !== undefined && fail === false) statusCode = 204
-
-    const req = request(server.url)
-      .post(path)
-      .set('Accept', 'application/json')
-
-    if (token) req.set('Authorization', 'Bearer ' + token)
-
-    Object.keys(fields).forEach(function (field) {
-      const value = fields[field]
-
-      if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-          req.field(field + '[' + i + ']', value[i])
-        }
-      } else {
-        req.field(field, value)
-      }
-    })
-
-    Object.keys(attaches).forEach(function (attach) {
-      const value = attaches[attach]
-      req.attach(attach, value)
-    })
-
-    req.expect(statusCode, done)
-  }
-
-  function makePostBodyRequest (path, fields, done, fail) {
-    let statusCode = 400
-    if (fail !== undefined && fail === false) statusCode = 200
-
-    request(server.url)
-      .post(path)
-      .set('Accept', 'application/json')
-      .send(fields)
-      .expect(statusCode, done)
-  }
-
-  // ---------------------------------------------------------------
-
-  before(function (done) {
-    this.timeout(20000)
-
-    series([
-      function (next) {
-        utils.flushTests(next)
-      },
-      function (next) {
-        utils.runServer(1, function (server1) {
-          server = server1
-
-          next()
-        })
-      },
-      function (next) {
-        utils.loginAndGetAccessToken(server, function (err, token) {
-          if (err) throw err
-          server.accessToken = token
-
-          next()
-        })
-      }
-    ], done)
-  })
-
-  describe('Of the pods API', function () {
-    const path = '/api/v1/pods/'
-
-    describe('When adding a pod', function () {
-      it('Should fail with nothing', function (done) {
-        const data = {}
-        makePostBodyRequest(path, data, done)
-      })
-
-      it('Should fail without public key', function (done) {
-        const data = {
-          url: 'http://coucou.com'
-        }
-        makePostBodyRequest(path, data, done)
-      })
-
-      it('Should fail without an url', function (done) {
-        const data = {
-          publicKey: 'mysuperpublickey'
-        }
-        makePostBodyRequest(path, data, done)
-      })
-
-      it('Should fail with an incorrect url', function (done) {
-        const data = {
-          url: 'coucou.com',
-          publicKey: 'mysuperpublickey'
-        }
-        makePostBodyRequest(path, data, function () {
-          data.url = 'http://coucou'
-          makePostBodyRequest(path, data, function () {
-            data.url = 'coucou'
-            makePostBodyRequest(path, data, done)
-          })
-        })
-      })
-
-      it('Should succeed with the correct parameters', function (done) {
-        const data = {
-          url: 'http://coucou.com',
-          publicKey: 'mysuperpublickey'
-        }
-        makePostBodyRequest(path, data, done, false)
-      })
-    })
-  })
-
-  describe('Of the videos API', function () {
-    const path = '/api/v1/videos/'
-
-    describe('When listing a video', function () {
-      it('Should fail with a bad start pagination', function (done) {
-        request(server.url)
-          .get(path)
-          .query({ start: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should fail with a bad count pagination', function (done) {
-        request(server.url)
-          .get(path)
-          .query({ count: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should fail with an incorrect sort', function (done) {
-        request(server.url)
-          .get(path)
-          .query({ sort: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-    })
-
-    describe('When searching a video', function () {
-      it('Should fail with nothing', function (done) {
-        request(server.url)
-          .get(pathUtils.join(path, 'search'))
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should fail with a bad start pagination', function (done) {
-        request(server.url)
-          .get(pathUtils.join(path, 'search', 'test'))
-          .query({ start: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should fail with a bad count pagination', function (done) {
-        request(server.url)
-          .get(pathUtils.join(path, 'search', 'test'))
-          .query({ count: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should fail with an incorrect sort', function (done) {
-        request(server.url)
-          .get(pathUtils.join(path, 'search', 'test'))
-          .query({ sort: 'hello' })
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-    })
-
-    describe('When adding a video', function () {
-      it('Should fail with nothing', function (done) {
-        const data = {}
-        const attach = {}
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail without name', function (done) {
-        const data = {
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with a long name', function (done) {
-        const data = {
-          name: 'My very very very very very very very very very very very very very very very very long name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail without description', function (done) {
-        const data = {
-          name: 'my super name',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with a long description', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description which is very very very very very very very very very very very very very very' +
-                       'very very very very very very very very very very very very very very very very very very very very very' +
-                       'very very very very very very very very very very very very very very very long',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail without tags', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description'
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with too many tags', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2', 'tag3', 'tag4' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with not enough tags', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with a tag length too low', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 't' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with a tag length too big', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'mysupertagtoolong', 'tag1' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with malformed tags', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'my tag' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail without an input file', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {}
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail without an incorrect input file', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short_fake.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should fail with a too big duration', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_too_long.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, done)
-      })
-
-      it('Should succeed with the correct parameters', function (done) {
-        const data = {
-          name: 'my super name',
-          description: 'my super description',
-          tags: [ 'tag1', 'tag2' ]
-        }
-        const attach = {
-          'videofile': pathUtils.join(__dirname, 'fixtures', 'video_short.webm')
-        }
-        makePostRequest(path, server.accessToken, data, attach, function () {
-          attach.videofile = pathUtils.join(__dirname, 'fixtures', 'video_short.mp4')
-          makePostRequest(path, server.accessToken, data, attach, function () {
-            attach.videofile = pathUtils.join(__dirname, 'fixtures', 'video_short.ogv')
-            makePostRequest(path, server.accessToken, data, attach, done, false)
-          }, false)
-        }, false)
-      })
-    })
-
-    describe('When getting a video', function () {
-      it('Should return the list of the videos with nothing', function (done) {
-        request(server.url)
-          .get(path)
-          .set('Accept', 'application/json')
-          .expect(200)
-          .expect('Content-Type', /json/)
-          .end(function (err, res) {
-            if (err) throw err
-
-            expect(res.body.data).to.be.an('array')
-            expect(res.body.data.length).to.equal(3)
-
-            done()
-          })
-      })
-
-      it('Should fail without a mongodb id', function (done) {
-        request(server.url)
-          .get(path + 'coucou')
-          .set('Accept', 'application/json')
-          .expect(400, done)
-      })
-
-      it('Should return 404 with an incorrect video', function (done) {
-        request(server.url)
-          .get(path + '123456789012345678901234')
-          .set('Accept', 'application/json')
-          .expect(404, done)
-      })
-
-      it('Should succeed with the correct parameters')
-    })
-
-    describe('When removing a video', function () {
-      it('Should have 404 with nothing', function (done) {
-        request(server.url)
-          .delete(path)
-          .set('Authorization', 'Bearer ' + server.accessToken)
-          .expect(400, done)
-      })
-
-      it('Should fail without a mongodb id', function (done) {
-        request(server.url)
-          .delete(path + 'hello')
-          .set('Authorization', 'Bearer ' + server.accessToken)
-          .expect(400, done)
-      })
-
-      it('Should fail with a video which does not exist', function (done) {
-        request(server.url)
-          .delete(path + '123456789012345678901234')
-          .set('Authorization', 'Bearer ' + server.accessToken)
-          .expect(404, done)
-      })
-
-      it('Should fail with a video of another pod')
-
-      it('Should succeed with the correct parameters')
-    })
-  })
-
-  describe('Of the remote videos API', function () {
-    describe('When making a secure request', function () {
-      it('Should check a secure request')
-    })
-
-    describe('When adding a video', function () {
-      it('Should check when adding a video')
-    })
-
-    describe('When removing a video', function () {
-      it('Should check when removing a video')
-    })
-  })
-
-  after(function (done) {
-    process.kill(-server.app.pid)
-
-    // Keep the logs if the test failed
-    if (this.ok) {
-      utils.flushTests(done)
-    } else {
-      done()
-    }
-  })
-})
diff --git a/server/tests/api/friendsAdvanced.js b/server/tests/api/friends-advanced.js
index 603fbc16b..0d24481ef 100644
--- a/server/tests/api/friendsAdvanced.js
+++ b/server/tests/api/friends-advanced.js
@@ -5,24 +5,27 @@ const each = require('async/each')
 const expect = chai.expect
 const series = require('async/series')
 
-const utils = require('./utils')
+const loginUtils = require('../utils/login')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
+const videosUtils = require('../utils/videos')
 
 describe('Test advanced friends', function () {
   let servers = []
 
   function makeFriends (podNumber, callback) {
     const server = servers[podNumber - 1]
-    return utils.makeFriends(server.url, server.accessToken, callback)
+    return podsUtils.makeFriends(server.url, server.accessToken, callback)
   }
 
   function quitFriends (podNumber, callback) {
     const server = servers[podNumber - 1]
-    return utils.quitFriends(server.url, server.accessToken, callback)
+    return podsUtils.quitFriends(server.url, server.accessToken, callback)
   }
 
   function getFriendsList (podNumber, end) {
     const server = servers[podNumber - 1]
-    return utils.getFriendsList(server.url, end)
+    return podsUtils.getFriendsList(server.url, end)
   }
 
   function uploadVideo (podNumber, callback) {
@@ -32,22 +35,22 @@ describe('Test advanced friends', function () {
     const fixture = 'video_short.webm'
     const server = servers[podNumber - 1]
 
-    return utils.uploadVideo(server.url, server.accessToken, name, description, tags, fixture, callback)
+    return videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, fixture, callback)
   }
 
   function getVideos (podNumber, callback) {
-    return utils.getVideosList(servers[podNumber - 1].url, callback)
+    return videosUtils.getVideosList(servers[podNumber - 1].url, callback)
   }
 
   // ---------------------------------------------------------------
 
   before(function (done) {
     this.timeout(30000)
-    utils.flushAndRunMultipleServers(6, function (serversRun, urlsRun) {
+    serversUtils.flushAndRunMultipleServers(6, function (serversRun, urlsRun) {
       servers = serversRun
 
       each(servers, function (server, callbackEach) {
-        utils.loginAndGetAccessToken(server, function (err, accessToken) {
+        loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
           if (err) return callbackEach(err)
 
           server.accessToken = accessToken
@@ -169,7 +172,7 @@ describe('Test advanced friends', function () {
       },
       // Rerun server 4
       function (next) {
-        utils.runServer(4, function (server) {
+        serversUtils.runServer(4, function (server) {
           servers[3].app = server.app
           next()
         })
@@ -273,7 +276,7 @@ describe('Test advanced friends', function () {
     })
 
     if (this.ok) {
-      utils.flushTests(done)
+      serversUtils.flushTests(done)
     } else {
       done()
     }
diff --git a/server/tests/api/friendsBasic.js b/server/tests/api/friends-basic.js
index c74a7f224..f1393b5ec 100644
--- a/server/tests/api/friendsBasic.js
+++ b/server/tests/api/friends-basic.js
@@ -5,14 +5,17 @@ const each = require('async/each')
 const expect = chai.expect
 const series = require('async/series')
 
-const utils = require('./utils')
+const loginUtils = require('../utils/login')
+const miscsUtils = require('../utils/miscs')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
 
 describe('Test basic friends', function () {
   let servers = []
 
   function makeFriends (podNumber, callback) {
     const server = servers[podNumber - 1]
-    return utils.makeFriends(server.url, server.accessToken, callback)
+    return podsUtils.makeFriends(server.url, server.accessToken, callback)
   }
 
   function testMadeFriends (servers, serverToTest, callback) {
@@ -22,7 +25,7 @@ describe('Test basic friends', function () {
       friends.push(servers[i].url)
     }
 
-    utils.getFriendsList(serverToTest.url, function (err, res) {
+    podsUtils.getFriendsList(serverToTest.url, function (err, res) {
       if (err) throw err
 
       const result = res.body
@@ -43,11 +46,11 @@ describe('Test basic friends', function () {
 
   before(function (done) {
     this.timeout(20000)
-    utils.flushAndRunMultipleServers(3, function (serversRun, urlsRun) {
+    serversUtils.flushAndRunMultipleServers(3, function (serversRun, urlsRun) {
       servers = serversRun
 
       each(servers, function (server, callbackEach) {
-        utils.loginAndGetAccessToken(server, function (err, accessToken) {
+        loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
           if (err) return callbackEach(err)
 
           server.accessToken = accessToken
@@ -59,7 +62,7 @@ describe('Test basic friends', function () {
 
   it('Should not have friends', function (done) {
     each(servers, function (server, callback) {
-      utils.getFriendsList(server.url, function (err, res) {
+      podsUtils.getFriendsList(server.url, function (err, res) {
         if (err) throw err
 
         const result = res.body
@@ -71,7 +74,7 @@ describe('Test basic friends', function () {
   })
 
   it('Should make friends', function (done) {
-    this.timeout(10000)
+    this.timeout(40000)
 
     series([
       // The second pod make friend with the third
@@ -80,30 +83,38 @@ describe('Test basic friends', function () {
       },
       // Wait for the request between pods
       function (next) {
-        setTimeout(next, 1000)
+        setTimeout(next, 11000)
       },
       // The second pod should have the third as a friend
       function (next) {
-        utils.getFriendsList(servers[1].url, function (err, res) {
+        podsUtils.getFriendsList(servers[1].url, function (err, res) {
           if (err) throw err
 
           const result = res.body
           expect(result).to.be.an('array')
           expect(result.length).to.equal(1)
-          expect(result[0].url).to.be.equal(servers[2].url)
+
+          const pod = result[0]
+          expect(pod.url).to.equal(servers[2].url)
+          expect(pod.score).to.equal(20)
+          expect(miscsUtils.dateIsValid(pod.createdDate)).to.be.true
 
           next()
         })
       },
       // Same here, the third pod should have the second pod as a friend
       function (next) {
-        utils.getFriendsList(servers[2].url, function (err, res) {
+        podsUtils.getFriendsList(servers[2].url, function (err, res) {
           if (err) throw err
 
           const result = res.body
           expect(result).to.be.an('array')
           expect(result.length).to.equal(1)
-          expect(result[0].url).to.be.equal(servers[1].url)
+
+          const pod = result[0]
+          expect(pod.url).to.equal(servers[1].url)
+          expect(pod.score).to.equal(20)
+          expect(miscsUtils.dateIsValid(pod.createdDate)).to.be.true
 
           next()
         })
@@ -114,7 +125,7 @@ describe('Test basic friends', function () {
       },
       // Wait for the request between pods
       function (next) {
-        setTimeout(next, 1000)
+        setTimeout(next, 11000)
       }
     ],
     // Now each pod should be friend with the other ones
@@ -128,7 +139,7 @@ describe('Test basic friends', function () {
 
   it('Should not be allowed to make friend again', function (done) {
     const server = servers[1]
-    utils.makeFriends(server.url, server.accessToken, 409, done)
+    podsUtils.makeFriends(server.url, server.accessToken, 409, done)
   })
 
   it('Should quit friends of pod 2', function (done) {
@@ -136,11 +147,11 @@ describe('Test basic friends', function () {
       // Pod 1 quit friends
       function (next) {
         const server = servers[1]
-        utils.quitFriends(server.url, server.accessToken, next)
+        podsUtils.quitFriends(server.url, server.accessToken, next)
       },
       // Pod 1 should not have friends anymore
       function (next) {
-        utils.getFriendsList(servers[1].url, function (err, res) {
+        podsUtils.getFriendsList(servers[1].url, function (err, res) {
           if (err) throw err
 
           const result = res.body
@@ -153,7 +164,7 @@ describe('Test basic friends', function () {
       // Other pods shouldn't have pod 1 too
       function (next) {
         each([ servers[0].url, servers[2].url ], function (url, callback) {
-          utils.getFriendsList(url, function (err, res) {
+          podsUtils.getFriendsList(url, function (err, res) {
             if (err) throw err
 
             const result = res.body
@@ -168,11 +179,15 @@ describe('Test basic friends', function () {
   })
 
   it('Should allow pod 2 to make friend again', function (done) {
+    this.timeout(20000)
+
     const server = servers[1]
-    utils.makeFriends(server.url, server.accessToken, function () {
-      each(servers, function (server, callback) {
-        testMadeFriends(servers, server, callback)
-      }, done)
+    podsUtils.makeFriends(server.url, server.accessToken, function () {
+      setTimeout(function () {
+        each(servers, function (server, callback) {
+          testMadeFriends(servers, server, callback)
+        }, done)
+      }, 11000)
     })
   })
 
@@ -182,7 +197,7 @@ describe('Test basic friends', function () {
     })
 
     if (this.ok) {
-      utils.flushTests(done)
+      serversUtils.flushTests(done)
     } else {
       done()
     }
diff --git a/server/tests/api/index.js b/server/tests/api/index.js
index 61c9a7aca..11f49e1e2 100644
--- a/server/tests/api/index.js
+++ b/server/tests/api/index.js
@@ -1,9 +1,9 @@
 'use strict'
 
 // Order of the tests we want to execute
-require('./checkParams')
-require('./friendsBasic')
+require('./check-params')
+require('./friends-basic')
 require('./users')
-require('./singlePod')
-require('./multiplePods')
-require('./friendsAdvanced')
+require('./single-pod')
+require('./multiple-pods')
+require('./friends-advanced')
diff --git a/server/tests/api/multiplePods.js b/server/tests/api/multiple-pods.js
index ac140f6bb..b86f88c22 100644
--- a/server/tests/api/multiplePods.js
+++ b/server/tests/api/multiple-pods.js
@@ -6,7 +6,11 @@ const expect = chai.expect
 const pathUtils = require('path')
 const series = require('async/series')
 
-const utils = require('./utils')
+const loginUtils = require('../utils/login')
+const miscsUtils = require('../utils/miscs')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
+const videosUtils = require('../utils/videos')
 const webtorrent = require(pathUtils.join(__dirname, '../../lib/webtorrent'))
 webtorrent.silent = true
 
@@ -20,7 +24,7 @@ describe('Test multiple pods', function () {
     series([
       // Run servers
       function (next) {
-        utils.flushAndRunMultipleServers(3, function (serversRun) {
+        serversUtils.flushAndRunMultipleServers(3, function (serversRun) {
           servers = serversRun
           next()
         })
@@ -28,7 +32,7 @@ describe('Test multiple pods', function () {
       // Get the access tokens
       function (next) {
         each(servers, function (server, callbackEach) {
-          utils.loginAndGetAccessToken(server, function (err, accessToken) {
+          loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
             if (err) return callbackEach(err)
 
             server.accessToken = accessToken
@@ -39,7 +43,7 @@ describe('Test multiple pods', function () {
       // The second pod make friend with the third
       function (next) {
         const server = servers[1]
-        utils.makeFriends(server.url, server.accessToken, next)
+        podsUtils.makeFriends(server.url, server.accessToken, next)
       },
       // Wait for the request between pods
       function (next) {
@@ -48,7 +52,7 @@ describe('Test multiple pods', function () {
       // Pod 1 make friends too
       function (next) {
         const server = servers[0]
-        utils.makeFriends(server.url, server.accessToken, next)
+        podsUtils.makeFriends(server.url, server.accessToken, next)
       },
       function (next) {
         webtorrent.create({ host: 'client', port: '1' }, next)
@@ -58,7 +62,7 @@ describe('Test multiple pods', function () {
 
   it('Should not have videos for all pods', function (done) {
     each(servers, function (server, callback) {
-      utils.getVideosList(server.url, function (err, res) {
+      videosUtils.getVideosList(server.url, function (err, res) {
         if (err) throw err
 
         const videos = res.body.data
@@ -80,7 +84,7 @@ describe('Test multiple pods', function () {
           const description = 'my super description for pod 1'
           const tags = [ 'tag1p1', 'tag2p1' ]
           const file = 'video_short1.webm'
-          utils.uploadVideo(servers[0].url, servers[0].accessToken, name, description, tags, file, next)
+          videosUtils.uploadVideo(servers[0].url, servers[0].accessToken, name, description, tags, file, next)
         },
         function (next) {
           setTimeout(next, 11000)
@@ -92,7 +96,7 @@ describe('Test multiple pods', function () {
           each(servers, function (server, callback) {
             let baseMagnet = null
 
-            utils.getVideosList(server.url, function (err, res) {
+            videosUtils.getVideosList(server.url, function (err, res) {
               if (err) throw err
 
               const videos = res.body.data
@@ -105,7 +109,7 @@ describe('Test multiple pods', function () {
               expect(video.magnetUri).to.exist
               expect(video.duration).to.equal(10)
               expect(video.tags).to.deep.equal([ 'tag1p1', 'tag2p1' ])
-              expect(utils.dateIsValid(video.createdDate)).to.be.true
+              expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
               expect(video.author).to.equal('root')
 
               if (server.url !== 'http://localhost:9001') {
@@ -121,7 +125,7 @@ describe('Test multiple pods', function () {
                 expect(video.magnetUri).to.equal.magnetUri
               }
 
-              utils.testImage(server.url, 'video_short1.webm', video.thumbnailPath, function (err, test) {
+              videosUtils.testVideoImage(server.url, 'video_short1.webm', video.thumbnailPath, function (err, test) {
                 if (err) throw err
                 expect(test).to.equal(true)
 
@@ -142,7 +146,7 @@ describe('Test multiple pods', function () {
           const description = 'my super description for pod 2'
           const tags = [ 'tag1p2', 'tag2p2', 'tag3p2' ]
           const file = 'video_short2.webm'
-          utils.uploadVideo(servers[1].url, servers[1].accessToken, name, description, tags, file, next)
+          videosUtils.uploadVideo(servers[1].url, servers[1].accessToken, name, description, tags, file, next)
         },
         function (next) {
           setTimeout(next, 11000)
@@ -154,7 +158,7 @@ describe('Test multiple pods', function () {
           each(servers, function (server, callback) {
             let baseMagnet = null
 
-            utils.getVideosList(server.url, function (err, res) {
+            videosUtils.getVideosList(server.url, function (err, res) {
               if (err) throw err
 
               const videos = res.body.data
@@ -167,7 +171,7 @@ describe('Test multiple pods', function () {
               expect(video.magnetUri).to.exist
               expect(video.duration).to.equal(5)
               expect(video.tags).to.deep.equal([ 'tag1p2', 'tag2p2', 'tag3p2' ])
-              expect(utils.dateIsValid(video.createdDate)).to.be.true
+              expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
               expect(video.author).to.equal('root')
 
               if (server.url !== 'http://localhost:9002') {
@@ -183,7 +187,7 @@ describe('Test multiple pods', function () {
                 expect(video.magnetUri).to.equal.magnetUri
               }
 
-              utils.testImage(server.url, 'video_short2.webm', video.thumbnailPath, function (err, test) {
+              videosUtils.testVideoImage(server.url, 'video_short2.webm', video.thumbnailPath, function (err, test) {
                 if (err) throw err
                 expect(test).to.equal(true)
 
@@ -204,14 +208,14 @@ describe('Test multiple pods', function () {
           const description = 'my super description for pod 3'
           const tags = [ 'tag1p3' ]
           const file = 'video_short3.webm'
-          utils.uploadVideo(servers[2].url, servers[2].accessToken, name, description, tags, file, next)
+          videosUtils.uploadVideo(servers[2].url, servers[2].accessToken, name, description, tags, file, next)
         },
         function (next) {
           const name = 'my super name for pod 3-2'
           const description = 'my super description for pod 3-2'
           const tags = [ 'tag2p3', 'tag3p3', 'tag4p3' ]
           const file = 'video_short.webm'
-          utils.uploadVideo(servers[2].url, servers[2].accessToken, name, description, tags, file, next)
+          videosUtils.uploadVideo(servers[2].url, servers[2].accessToken, name, description, tags, file, next)
         },
         function (next) {
           setTimeout(next, 22000)
@@ -222,7 +226,7 @@ describe('Test multiple pods', function () {
           let baseMagnet = null
           // All pods should have this video
           each(servers, function (server, callback) {
-            utils.getVideosList(server.url, function (err, res) {
+            videosUtils.getVideosList(server.url, function (err, res) {
               if (err) throw err
 
               const videos = res.body.data
@@ -247,7 +251,7 @@ describe('Test multiple pods', function () {
               expect(video1.duration).to.equal(5)
               expect(video1.tags).to.deep.equal([ 'tag1p3' ])
               expect(video1.author).to.equal('root')
-              expect(utils.dateIsValid(video1.createdDate)).to.be.true
+              expect(miscsUtils.dateIsValid(video1.createdDate)).to.be.true
 
               expect(video2.name).to.equal('my super name for pod 3-2')
               expect(video2.description).to.equal('my super description for pod 3-2')
@@ -256,7 +260,7 @@ describe('Test multiple pods', function () {
               expect(video2.duration).to.equal(5)
               expect(video2.tags).to.deep.equal([ 'tag2p3', 'tag3p3', 'tag4p3' ])
               expect(video2.author).to.equal('root')
-              expect(utils.dateIsValid(video2.createdDate)).to.be.true
+              expect(miscsUtils.dateIsValid(video2.createdDate)).to.be.true
 
               if (server.url !== 'http://localhost:9003') {
                 expect(video1.isLocal).to.be.false
@@ -273,11 +277,11 @@ describe('Test multiple pods', function () {
                 expect(video2.magnetUri).to.equal.magnetUri
               }
 
-              utils.testImage(server.url, 'video_short3.webm', video1.thumbnailPath, function (err, test) {
+              videosUtils.testVideoImage(server.url, 'video_short3.webm', video1.thumbnailPath, function (err, test) {
                 if (err) throw err
                 expect(test).to.equal(true)
 
-                utils.testImage(server.url, 'video_short.webm', video2.thumbnailPath, function (err, test) {
+                videosUtils.testVideoImage(server.url, 'video_short.webm', video2.thumbnailPath, function (err, test) {
                   if (err) throw err
                   expect(test).to.equal(true)
 
@@ -296,7 +300,7 @@ describe('Test multiple pods', function () {
       // Yes, this could be long
       this.timeout(200000)
 
-      utils.getVideosList(servers[2].url, function (err, res) {
+      videosUtils.getVideosList(servers[2].url, function (err, res) {
         if (err) throw err
 
         const video = res.body.data[0]
@@ -317,7 +321,7 @@ describe('Test multiple pods', function () {
       // Yes, this could be long
       this.timeout(200000)
 
-      utils.getVideosList(servers[0].url, function (err, res) {
+      videosUtils.getVideosList(servers[0].url, function (err, res) {
         if (err) throw err
 
         const video = res.body.data[1]
@@ -336,7 +340,7 @@ describe('Test multiple pods', function () {
       // Yes, this could be long
       this.timeout(200000)
 
-      utils.getVideosList(servers[1].url, function (err, res) {
+      videosUtils.getVideosList(servers[1].url, function (err, res) {
         if (err) throw err
 
         const video = res.body.data[2]
@@ -355,7 +359,7 @@ describe('Test multiple pods', function () {
       // Yes, this could be long
       this.timeout(200000)
 
-      utils.getVideosList(servers[0].url, function (err, res) {
+      videosUtils.getVideosList(servers[0].url, function (err, res) {
         if (err) throw err
 
         const video = res.body.data[3]
@@ -375,10 +379,10 @@ describe('Test multiple pods', function () {
 
       series([
         function (next) {
-          utils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[0], next)
+          videosUtils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[0], next)
         },
         function (next) {
-          utils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[1], next)
+          videosUtils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[1], next)
         }],
         function (err) {
           if (err) throw err
@@ -389,7 +393,7 @@ describe('Test multiple pods', function () {
 
     it('Should have videos 1 and 3 on each pod', function (done) {
       each(servers, function (server, callback) {
-        utils.getVideosList(server.url, function (err, res) {
+        videosUtils.getVideosList(server.url, function (err, res) {
           if (err) throw err
 
           const videos = res.body.data
@@ -415,7 +419,7 @@ describe('Test multiple pods', function () {
 
     // Keep the logs if the test failed
     if (this.ok) {
-      utils.flushTests(done)
+      serversUtils.flushTests(done)
     } else {
       done()
     }
diff --git a/server/tests/api/requests.js b/server/tests/api/requests.js
new file mode 100644
index 000000000..af36f6e34
--- /dev/null
+++ b/server/tests/api/requests.js
@@ -0,0 +1,128 @@
+'use strict'
+
+const chai = require('chai')
+const each = require('async/each')
+const expect = chai.expect
+const request = require('supertest')
+
+const loginUtils = require('../utils/login')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
+const videosUtils = require('../utils/videos')
+
+describe('Test requests stats', function () {
+  const path = '/api/v1/requests/stats'
+  let servers = []
+
+  function uploadVideo (server, callback) {
+    const name = 'my super video'
+    const description = 'my super description'
+    const tags = [ 'tag1', 'tag2' ]
+    const fixture = 'video_short.webm'
+
+    videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, fixture, callback)
+  }
+
+  function getRequestsStats (server, callback) {
+    request(server.url)
+      .get(path)
+      .set('Accept', 'application/json')
+      .set('Authorization', 'Bearer ' + server.accessToken)
+      .expect(200)
+      .end(callback)
+  }
+
+  // ---------------------------------------------------------------
+
+  before(function (done) {
+    this.timeout(20000)
+    serversUtils.flushAndRunMultipleServers(2, function (serversRun, urlsRun) {
+      servers = serversRun
+
+      each(servers, function (server, callbackEach) {
+        loginUtils.loginAndGetAccessToken(server, function (err, accessToken) {
+          if (err) return callbackEach(err)
+
+          server.accessToken = accessToken
+          callbackEach()
+        })
+      }, function (err) {
+        if (err) throw err
+
+        const server1 = servers[0]
+        podsUtils.makeFriends(server1.url, server1.accessToken, done)
+      })
+    })
+  })
+
+  it('Should have a correct timer', function (done) {
+    const server = servers[0]
+
+    getRequestsStats(server, function (err, res) {
+      if (err) throw err
+
+      const body = res.body
+      expect(body.remainingMilliSeconds).to.be.at.least(0)
+      expect(body.remainingMilliSeconds).to.be.at.most(10000)
+
+      done()
+    })
+  })
+
+  it('Should have the correct request', function (done) {
+    this.timeout(15000)
+
+    const server = servers[0]
+    // Ensure the requests of pod 1 won't be made
+    servers[1].app.kill()
+
+    uploadVideo(server, function (err) {
+      if (err) throw err
+
+      getRequestsStats(server, function (err, res) {
+        if (err) throw err
+
+        const body = res.body
+        expect(body.requests).to.have.lengthOf(1)
+
+        const request = body.requests[0]
+        expect(request.to).to.have.lengthOf(1)
+        expect(request.request.type).to.equal('add')
+
+        // Wait one cycle
+        setTimeout(done, 10000)
+      })
+    })
+  })
+
+  it('Should have the correct requests', function (done) {
+    const server = servers[0]
+
+    uploadVideo(server, function (err) {
+      if (err) throw err
+
+      getRequestsStats(server, function (err, res) {
+        if (err) throw err
+
+        const body = res.body
+        expect(body.requests).to.have.lengthOf(2)
+
+        const request = body.requests[1]
+        expect(request.to).to.have.lengthOf(1)
+        expect(request.request.type).to.equal('add')
+
+        done()
+      })
+    })
+  })
+
+  after(function (done) {
+    process.kill(-servers[0].app.pid)
+
+    if (this.ok) {
+      serversUtils.flushTests(done)
+    } else {
+      done()
+    }
+  })
+})
diff --git a/server/tests/api/singlePod.js b/server/tests/api/single-pod.js
index 6ed719f87..bdaaee46c 100644
--- a/server/tests/api/singlePod.js
+++ b/server/tests/api/single-pod.js
@@ -8,11 +8,13 @@ const keyBy = require('lodash/keyBy')
 const pathUtils = require('path')
 const series = require('async/series')
 
+const loginUtils = require('../utils/login')
+const miscsUtils = require('../utils/miscs')
+const serversUtils = require('../utils/servers')
+const videosUtils = require('../utils/videos')
 const webtorrent = require(pathUtils.join(__dirname, '../../lib/webtorrent'))
 webtorrent.silent = true
 
-const utils = require('./utils')
-
 describe('Test a single pod', function () {
   let server = null
   let videoId = -1
@@ -23,16 +25,16 @@ describe('Test a single pod', function () {
 
     series([
       function (next) {
-        utils.flushTests(next)
+        serversUtils.flushTests(next)
       },
       function (next) {
-        utils.runServer(1, function (server1) {
+        serversUtils.runServer(1, function (server1) {
           server = server1
           next()
         })
       },
       function (next) {
-        utils.loginAndGetAccessToken(server, function (err, token) {
+        loginUtils.loginAndGetAccessToken(server, function (err, token) {
           if (err) throw err
           server.accessToken = token
           next()
@@ -45,7 +47,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should not have videos', function (done) {
-    utils.getVideosList(server.url, function (err, res) {
+    videosUtils.getVideosList(server.url, function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(0)
@@ -62,14 +64,14 @@ describe('Test a single pod', function () {
     const description = 'my super description'
     const tags = [ 'tag1', 'tag2', 'tag3' ]
     const file = 'video_short.webm'
-    utils.uploadVideo(server.url, server.accessToken, name, description, tags, file, done)
+    videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, file, done)
   })
 
   it('Should seed the uploaded video', function (done) {
     // Yes, this could be long
     this.timeout(60000)
 
-    utils.getVideosList(server.url, function (err, res) {
+    videosUtils.getVideosList(server.url, function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(1)
@@ -84,9 +86,9 @@ describe('Test a single pod', function () {
       expect(video.author).to.equal('root')
       expect(video.isLocal).to.be.true
       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-      expect(utils.dateIsValid(video.createdDate)).to.be.true
+      expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 
-      utils.testImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
+      videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
         expect(test).to.equal(true)
 
@@ -97,8 +99,7 @@ describe('Test a single pod', function () {
           expect(torrent.files.length).to.equal(1)
           expect(torrent.files[0].path).to.exist.and.to.not.equal('')
 
-          // We remove it because we'll add it again
-          webtorrent.remove(video.magnetUri, done)
+          done()
         })
       })
     })
@@ -108,7 +109,7 @@ describe('Test a single pod', function () {
     // Yes, this could be long
     this.timeout(60000)
 
-    utils.getVideo(server.url, videoId, function (err, res) {
+    videosUtils.getVideo(server.url, videoId, function (err, res) {
       if (err) throw err
 
       const video = res.body
@@ -119,25 +120,19 @@ describe('Test a single pod', function () {
       expect(video.author).to.equal('root')
       expect(video.isLocal).to.be.true
       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-      expect(utils.dateIsValid(video.createdDate)).to.be.true
+      expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 
-      utils.testImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
+      videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
         expect(test).to.equal(true)
 
-        webtorrent.add(video.magnetUri, function (torrent) {
-          expect(torrent.files).to.exist
-          expect(torrent.files.length).to.equal(1)
-          expect(torrent.files[0].path).to.exist.and.to.not.equal('')
-
-          done()
-        })
+        done()
       })
     })
   })
 
   it('Should search the video by name by default', function (done) {
-    utils.searchVideo(server.url, 'my', function (err, res) {
+    videosUtils.searchVideo(server.url, 'my', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(1)
@@ -151,9 +146,9 @@ describe('Test a single pod', function () {
       expect(video.author).to.equal('root')
       expect(video.isLocal).to.be.true
       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-      expect(utils.dateIsValid(video.createdDate)).to.be.true
+      expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 
-      utils.testImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
+      videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
         expect(test).to.equal(true)
 
@@ -163,7 +158,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search the video by podUrl', function (done) {
-    utils.searchVideo(server.url, '9001', 'podUrl', function (err, res) {
+    videosUtils.searchVideo(server.url, '9001', 'podUrl', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(1)
@@ -177,9 +172,9 @@ describe('Test a single pod', function () {
       expect(video.author).to.equal('root')
       expect(video.isLocal).to.be.true
       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-      expect(utils.dateIsValid(video.createdDate)).to.be.true
+      expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 
-      utils.testImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
+      videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
         expect(test).to.equal(true)
 
@@ -189,7 +184,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search the video by tag', function (done) {
-    utils.searchVideo(server.url, 'tag1', 'tags', function (err, res) {
+    videosUtils.searchVideo(server.url, 'tag1', 'tags', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(1)
@@ -203,9 +198,9 @@ describe('Test a single pod', function () {
       expect(video.author).to.equal('root')
       expect(video.isLocal).to.be.true
       expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
-      expect(utils.dateIsValid(video.createdDate)).to.be.true
+      expect(miscsUtils.dateIsValid(video.createdDate)).to.be.true
 
-      utils.testImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
+      videosUtils.testVideoImage(server.url, 'video_short.webm', video.thumbnailPath, function (err, test) {
         if (err) throw err
         expect(test).to.equal(true)
 
@@ -215,7 +210,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should not find a search by name by default', function (done) {
-    utils.searchVideo(server.url, 'hello', function (err, res) {
+    videosUtils.searchVideo(server.url, 'hello', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(0)
@@ -227,7 +222,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should not find a search by author', function (done) {
-    utils.searchVideo(server.url, 'hello', 'author', function (err, res) {
+    videosUtils.searchVideo(server.url, 'hello', 'author', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(0)
@@ -239,7 +234,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should not find a search by tag', function (done) {
-    utils.searchVideo(server.url, 'tag', 'tags', function (err, res) {
+    videosUtils.searchVideo(server.url, 'tag', 'tags', function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(0)
@@ -251,7 +246,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should remove the video', function (done) {
-    utils.removeVideo(server.url, server.accessToken, videoId, function (err) {
+    videosUtils.removeVideo(server.url, server.accessToken, videoId, function (err) {
       if (err) throw err
 
       fs.readdir(pathUtils.join(__dirname, '../../../test1/uploads/'), function (err, files) {
@@ -264,7 +259,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should not have videos', function (done) {
-    utils.getVideosList(server.url, function (err, res) {
+    videosUtils.getVideosList(server.url, function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(0)
@@ -286,12 +281,12 @@ describe('Test a single pod', function () {
       const description = video + ' description'
       const tags = [ 'tag1', 'tag2', 'tag3' ]
 
-      utils.uploadVideo(server.url, server.accessToken, name, description, tags, video, callbackEach)
+      videosUtils.uploadVideo(server.url, server.accessToken, name, description, tags, video, callbackEach)
     }, done)
   })
 
   it('Should have the correct durations', function (done) {
-    utils.getVideosList(server.url, function (err, res) {
+    videosUtils.getVideosList(server.url, function (err, res) {
       if (err) throw err
 
       expect(res.body.total).to.equal(6)
@@ -312,7 +307,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should have the correct thumbnails', function (done) {
-    utils.getVideosList(server.url, function (err, res) {
+    videosUtils.getVideosList(server.url, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -323,7 +318,7 @@ describe('Test a single pod', function () {
         if (err) throw err
         const videoName = video.name.replace(' name', '')
 
-        utils.testImage(server.url, videoName, video.thumbnailPath, function (err, test) {
+        videosUtils.testVideoImage(server.url, videoName, video.thumbnailPath, function (err, test) {
           if (err) throw err
 
           expect(test).to.equal(true)
@@ -334,7 +329,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should list only the two first videos', function (done) {
-    utils.getVideosListPagination(server.url, 0, 2, function (err, res) {
+    videosUtils.getVideosListPagination(server.url, 0, 2, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -348,7 +343,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should list only the next three videos', function (done) {
-    utils.getVideosListPagination(server.url, 2, 3, function (err, res) {
+    videosUtils.getVideosListPagination(server.url, 2, 3, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -363,7 +358,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should list the last video', function (done) {
-    utils.getVideosListPagination(server.url, 5, 6, function (err, res) {
+    videosUtils.getVideosListPagination(server.url, 5, 6, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -376,7 +371,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search the first video', function (done) {
-    utils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -389,7 +384,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search the last two videos', function (done) {
-    utils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -403,7 +398,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search all the webm videos', function (done) {
-    utils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 15, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, 'webm', 'name', 0, 15, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -415,7 +410,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search all the root author videos', function (done) {
-    utils.searchVideoWithPagination(server.url, 'root', 'author', 0, 15, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, 'root', 'author', 0, 15, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -427,7 +422,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search all the 9001 port videos', function (done) {
-    utils.searchVideoWithPagination(server.url, '9001', 'podUrl', 0, 15, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, '9001', 'podUrl', 0, 15, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -439,7 +434,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search all the localhost videos', function (done) {
-    utils.searchVideoWithPagination(server.url, 'localhost', 'podUrl', 0, 15, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, 'localhost', 'podUrl', 0, 15, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -452,7 +447,7 @@ describe('Test a single pod', function () {
 
   it('Should search the good magnetUri video', function (done) {
     const video = videosListBase[0]
-    utils.searchVideoWithPagination(server.url, encodeURIComponent(video.magnetUri), 'magnetUri', 0, 15, function (err, res) {
+    videosUtils.searchVideoWithPagination(server.url, encodeURIComponent(video.magnetUri), 'magnetUri', 0, 15, function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -465,7 +460,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should list and sort by name in descending order', function (done) {
-    utils.getVideosListSort(server.url, '-name', function (err, res) {
+    videosUtils.getVideosListSort(server.url, '-name', function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -483,7 +478,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should search and sort by name in ascending order', function (done) {
-    utils.searchVideoWithSort(server.url, 'webm', 'name', function (err, res) {
+    videosUtils.searchVideoWithSort(server.url, 'webm', 'name', function (err, res) {
       if (err) throw err
 
       const videos = res.body.data
@@ -505,7 +500,7 @@ describe('Test a single pod', function () {
 
     // Keep the logs if the test failed
     if (this.ok) {
-      utils.flushTests(done)
+      serversUtils.flushTests(done)
     } else {
       done()
     }
diff --git a/server/tests/api/users.js b/server/tests/api/users.js
index 68ba9de33..c6c892bf2 100644
--- a/server/tests/api/users.js
+++ b/server/tests/api/users.js
@@ -5,25 +5,30 @@ const expect = chai.expect
 const pathUtils = require('path')
 const series = require('async/series')
 
+const loginUtils = require('../utils/login')
+const podsUtils = require('../utils/pods')
+const serversUtils = require('../utils/servers')
+const usersUtils = require('../utils/users')
+const videosUtils = require('../utils/videos')
 const webtorrent = require(pathUtils.join(__dirname, '../../lib/webtorrent'))
 webtorrent.silent = true
 
-const utils = require('./utils')
-
 describe('Test users', function () {
   let server = null
   let accessToken = null
-  let videoId
+  let accessTokenUser = null
+  let videoId = null
+  let userId = null
 
   before(function (done) {
     this.timeout(20000)
 
     series([
       function (next) {
-        utils.flushTests(next)
+        serversUtils.flushTests(next)
       },
       function (next) {
-        utils.runServer(1, function (server1) {
+        serversUtils.runServer(1, function (server1) {
           server = server1
           next()
         })
@@ -39,7 +44,7 @@ describe('Test users', function () {
 
   it('Should not login with an invalid client id', function (done) {
     const client = { id: 'client', password: server.client.secret }
-    utils.login(server.url, client, server.user, 400, function (err, res) {
+    loginUtils.login(server.url, client, server.user, 400, function (err, res) {
       if (err) throw err
 
       expect(res.body.error).to.equal('invalid_client')
@@ -49,7 +54,7 @@ describe('Test users', function () {
 
   it('Should not login with an invalid client password', function (done) {
     const client = { id: server.client.id, password: 'coucou' }
-    utils.login(server.url, client, server.user, 400, function (err, res) {
+    loginUtils.login(server.url, client, server.user, 400, function (err, res) {
       if (err) throw err
 
       expect(res.body.error).to.equal('invalid_client')
@@ -59,7 +64,7 @@ describe('Test users', function () {
 
   it('Should not login with an invalid username', function (done) {
     const user = { username: 'captain crochet', password: server.user.password }
-    utils.login(server.url, server.client, user, 400, function (err, res) {
+    loginUtils.login(server.url, server.client, user, 400, function (err, res) {
       if (err) throw err
 
       expect(res.body.error).to.equal('invalid_grant')
@@ -69,7 +74,7 @@ describe('Test users', function () {
 
   it('Should not login with an invalid password', function (done) {
     const user = { username: server.user.username, password: 'mewthree' }
-    utils.login(server.url, server.client, user, 400, function (err, res) {
+    loginUtils.login(server.url, server.client, user, 400, function (err, res) {
       if (err) throw err
 
       expect(res.body.error).to.equal('invalid_grant')
@@ -84,21 +89,21 @@ describe('Test users', function () {
     const description = 'my super description'
     const tags = [ 'tag1', 'tag2' ]
     const video = 'video_short.webm'
-    utils.uploadVideo(server.url, accessToken, name, description, tags, video, 401, done)
+    videosUtils.uploadVideo(server.url, accessToken, name, description, tags, video, 401, done)
   })
 
   it('Should not be able to make friends', function (done) {
     accessToken = 'mysupertoken'
-    utils.makeFriends(server.url, accessToken, 401, done)
+    podsUtils.makeFriends(server.url, accessToken, 401, done)
   })
 
   it('Should not be able to quit friends', function (done) {
     accessToken = 'mysupertoken'
-    utils.quitFriends(server.url, accessToken, 401, done)
+    podsUtils.quitFriends(server.url, accessToken, 401, done)
   })
 
   it('Should be able to login', function (done) {
-    utils.login(server.url, server.client, server.user, 200, function (err, res) {
+    loginUtils.login(server.url, server.client, server.user, 200, function (err, res) {
       if (err) throw err
 
       accessToken = res.body.access_token
@@ -111,10 +116,10 @@ describe('Test users', function () {
     const description = 'my super description'
     const tags = [ 'tag1', 'tag2' ]
     const video = 'video_short.webm'
-    utils.uploadVideo(server.url, accessToken, name, description, tags, video, 204, function (err, res) {
+    videosUtils.uploadVideo(server.url, accessToken, name, description, tags, video, 204, function (err, res) {
       if (err) throw err
 
-      utils.getVideosList(server.url, function (err, res) {
+      videosUtils.getVideosList(server.url, function (err, res) {
         if (err) throw err
 
         const video = res.body.data[0]
@@ -131,17 +136,17 @@ describe('Test users', function () {
     const description = 'my super description 2'
     const tags = [ 'tag1' ]
     const video = 'video_short.webm'
-    utils.uploadVideo(server.url, accessToken, name, description, tags, video, 204, done)
+    videosUtils.uploadVideo(server.url, accessToken, name, description, tags, video, 204, done)
   })
 
   it('Should not be able to remove the video with an incorrect token', function (done) {
-    utils.removeVideo(server.url, 'bad_token', videoId, 401, done)
+    videosUtils.removeVideo(server.url, 'bad_token', videoId, 401, done)
   })
 
   it('Should not be able to remove the video with the token of another account')
 
   it('Should be able to remove the video with the correct token', function (done) {
-    utils.removeVideo(server.url, accessToken, videoId, done)
+    videosUtils.removeVideo(server.url, accessToken, videoId, done)
   })
 
   it('Should logout (revoke token)')
@@ -158,12 +163,179 @@ describe('Test users', function () {
 
   it('Should be able to upload a video again')
 
+  it('Should be able to create a new user', function (done) {
+    usersUtils.createUser(server.url, accessToken, 'user_1', 'super password', done)
+  })
+
+  it('Should be able to login with this user', function (done) {
+    server.user = {
+      username: 'user_1',
+      password: 'super password'
+    }
+
+    loginUtils.loginAndGetAccessToken(server, function (err, token) {
+      if (err) throw err
+
+      accessTokenUser = token
+
+      done()
+    })
+  })
+
+  it('Should be able to get the user informations', function (done) {
+    usersUtils.getUserInformation(server.url, accessTokenUser, function (err, res) {
+      if (err) throw err
+
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.id).to.exist
+
+      done()
+    })
+  })
+
+  it('Should be able to upload a video with this user', function (done) {
+    this.timeout(5000)
+
+    const name = 'my super name'
+    const description = 'my super description'
+    const tags = [ 'tag1', 'tag2', 'tag3' ]
+    const file = 'video_short.webm'
+    videosUtils.uploadVideo(server.url, accessTokenUser, name, description, tags, file, done)
+  })
+
+  it('Should list all the users', function (done) {
+    usersUtils.getUsersList(server.url, function (err, res) {
+      if (err) throw err
+
+      const result = res.body
+      const total = result.total
+      const users = result.data
+
+      expect(total).to.equal(2)
+      expect(users).to.be.an('array')
+      expect(users.length).to.equal(2)
+
+      const user = users[0]
+      expect(user.username).to.equal('user_1')
+
+      const rootUser = users[1]
+      expect(rootUser.username).to.equal('root')
+      userId = user.id
+
+      done()
+    })
+  })
+
+  it('Should list only the first user by username asc', function (done) {
+    usersUtils.getUsersListPaginationAndSort(server.url, 0, 1, 'username', function (err, res) {
+      if (err) throw err
+
+      const result = res.body
+      const total = result.total
+      const users = result.data
+
+      expect(total).to.equal(2)
+      expect(users.length).to.equal(1)
+
+      const user = users[0]
+      expect(user.username).to.equal('root')
+
+      done()
+    })
+  })
+
+  it('Should list only the first user by username desc', function (done) {
+    usersUtils.getUsersListPaginationAndSort(server.url, 0, 1, '-username', function (err, res) {
+      if (err) throw err
+
+      const result = res.body
+      const total = result.total
+      const users = result.data
+
+      expect(total).to.equal(2)
+      expect(users.length).to.equal(1)
+
+      const user = users[0]
+      expect(user.username).to.equal('user_1')
+
+      done()
+    })
+  })
+
+  it('Should list only the second user by createdDate desc', function (done) {
+    usersUtils.getUsersListPaginationAndSort(server.url, 0, 1, '-createdDate', function (err, res) {
+      if (err) throw err
+
+      const result = res.body
+      const total = result.total
+      const users = result.data
+
+      expect(total).to.equal(2)
+      expect(users.length).to.equal(1)
+
+      const user = users[0]
+      expect(user.username).to.equal('user_1')
+
+      done()
+    })
+  })
+
+  it('Should list all the users by createdDate asc', function (done) {
+    usersUtils.getUsersListPaginationAndSort(server.url, 0, 2, 'createdDate', function (err, res) {
+      if (err) throw err
+
+      const result = res.body
+      const total = result.total
+      const users = result.data
+
+      expect(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')
+
+      done()
+    })
+  })
+
+  it('Should update the user password', function (done) {
+    usersUtils.updateUser(server.url, userId, accessTokenUser, 'new password', function (err, res) {
+      if (err) throw err
+
+      server.user.password = 'new password'
+      loginUtils.login(server.url, server.client, server.user, 200, done)
+    })
+  })
+
+  it('Should be able to remove this user', function (done) {
+    usersUtils.removeUser(server.url, userId, accessToken, done)
+  })
+
+  it('Should not be able to login with this user', function (done) {
+    // server.user is already set to user 1
+    loginUtils.login(server.url, server.client, server.user, 400, done)
+  })
+
+  it('Should not have videos of this user', function (done) {
+    videosUtils.getVideosList(server.url, function (err, res) {
+      if (err) throw err
+
+      expect(res.body.total).to.equal(1)
+      const video = res.body.data[0]
+      expect(video.author).to.equal('root')
+
+      done()
+    })
+  })
+
   after(function (done) {
     process.kill(-server.app.pid)
 
     // Keep the logs if the test failed
     if (this.ok) {
-      utils.flushTests(done)
+      serversUtils.flushTests(done)
     } else {
       done()
     }
diff --git a/server/tests/api/utils.js b/server/tests/api/utils.js
deleted file mode 100644
index 3cc769f26..000000000
--- a/server/tests/api/utils.js
+++ /dev/null
@@ -1,419 +0,0 @@
-'use strict'
-
-const childProcess = require('child_process')
-const exec = childProcess.exec
-const fork = childProcess.fork
-const fs = require('fs')
-const pathUtils = require('path')
-const request = require('supertest')
-
-const testUtils = {
-  dateIsValid: dateIsValid,
-  flushTests: flushTests,
-  getAllVideosListBy: getAllVideosListBy,
-  getClient: getClient,
-  getFriendsList: getFriendsList,
-  getVideo: getVideo,
-  getVideosList: getVideosList,
-  getVideosListPagination: getVideosListPagination,
-  getVideosListSort: getVideosListSort,
-  login: login,
-  loginAndGetAccessToken: loginAndGetAccessToken,
-  makeFriends: makeFriends,
-  quitFriends: quitFriends,
-  removeVideo: removeVideo,
-  flushAndRunMultipleServers: flushAndRunMultipleServers,
-  runServer: runServer,
-  searchVideo: searchVideo,
-  searchVideoWithPagination: searchVideoWithPagination,
-  searchVideoWithSort: searchVideoWithSort,
-  testImage: testImage,
-  uploadVideo: uploadVideo
-}
-
-// ---------------------- Export functions --------------------
-
-function dateIsValid (dateString) {
-  const dateToCheck = new Date(dateString)
-  const now = new Date()
-
-  // Check if the interval is more than 2 minutes
-  if (now - dateToCheck > 120000) return false
-
-  return true
-}
-
-function flushTests (callback) {
-  exec('npm run clean:server:test', callback)
-}
-
-function getAllVideosListBy (url, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path)
-    .query({ sort: 'createdDate' })
-    .query({ start: 0 })
-    .query({ count: 10000 })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getClient (url, end) {
-  const path = '/api/v1/users/client'
-
-  request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getFriendsList (url, end) {
-  const path = '/api/v1/pods/'
-
-  request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getVideo (url, id, end) {
-  const path = '/api/v1/videos/' + id
-
-  request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getVideosList (url, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path)
-    .query({ sort: 'name' })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getVideosListPagination (url, start, count, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path)
-    .query({ start: start })
-    .query({ count: count })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function getVideosListSort (url, sort, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path)
-    .query({ sort: sort })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function login (url, client, user, expectedStatus, end) {
-  if (!end) {
-    end = expectedStatus
-    expectedStatus = 200
-  }
-
-  const path = '/api/v1/users/token'
-
-  const body = {
-    client_id: client.id,
-    client_secret: client.secret,
-    username: user.username,
-    password: user.password,
-    response_type: 'code',
-    grant_type: 'password',
-    scope: 'upload'
-  }
-
-  request(url)
-    .post(path)
-    .type('form')
-    .send(body)
-    .expect(expectedStatus)
-    .end(end)
-}
-
-function loginAndGetAccessToken (server, callback) {
-  login(server.url, server.client, server.user, 200, function (err, res) {
-    if (err) return callback(err)
-
-    return callback(null, res.body.access_token)
-  })
-}
-
-function makeFriends (url, accessToken, expectedStatus, callback) {
-  if (!callback) {
-    callback = expectedStatus
-    expectedStatus = 204
-  }
-
-  const path = '/api/v1/pods/makefriends'
-
-  // The first pod make friend with the third
-  request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-    .end(function (err, res) {
-      if (err) throw err
-
-      // Wait for the request between pods
-      setTimeout(callback, 1000)
-    })
-}
-
-function quitFriends (url, accessToken, expectedStatus, callback) {
-  if (!callback) {
-    callback = expectedStatus
-    expectedStatus = 204
-  }
-
-  const path = '/api/v1/pods/quitfriends'
-
-  // The first pod make friend with the third
-  request(url)
-    .get(path)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + accessToken)
-    .expect(expectedStatus)
-    .end(function (err, res) {
-      if (err) throw err
-
-      // Wait for the request between pods
-      setTimeout(callback, 1000)
-    })
-}
-
-function removeVideo (url, token, id, expectedStatus, end) {
-  if (!end) {
-    end = expectedStatus
-    expectedStatus = 204
-  }
-
-  const path = '/api/v1/videos'
-
-  request(url)
-    .delete(path + '/' + id)
-    .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + token)
-    .expect(expectedStatus)
-    .end(end)
-}
-
-function flushAndRunMultipleServers (totalServers, serversRun) {
-  let apps = []
-  let urls = []
-  let i = 0
-
-  function anotherServerDone (number, app, url) {
-    apps[number - 1] = app
-    urls[number - 1] = url
-    i++
-    if (i === totalServers) {
-      serversRun(apps, urls)
-    }
-  }
-
-  flushTests(function () {
-    for (let j = 1; j <= totalServers; j++) {
-      // For the virtual buffer
-      setTimeout(function () {
-        runServer(j, function (app, url) {
-          anotherServerDone(j, app, url)
-        })
-      }, 1000 * j)
-    }
-  })
-}
-
-function runServer (number, callback) {
-  const server = {
-    app: null,
-    url: `http://localhost:${9000 + number}`,
-    client: {
-      id: null,
-      secret: null
-    },
-    user: {
-      username: null,
-      password: null
-    }
-  }
-
-  // These actions are async so we need to be sure that they have both been done
-  const serverRunString = {
-    'Connected to mongodb': false,
-    'Server listening on port': false
-  }
-
-  const regexps = {
-    client_id: 'Client id: ([a-f0-9]+)',
-    client_secret: 'Client secret: (.+)',
-    user_username: 'Username: (.+)',
-    user_password: 'User password: (.+)'
-  }
-
-  // Share the environment
-  const env = Object.create(process.env)
-  env.NODE_ENV = 'test'
-  env.NODE_APP_INSTANCE = number
-  const options = {
-    silent: true,
-    env: env,
-    detached: true
-  }
-
-  server.app = fork(pathUtils.join(__dirname, '../../../server.js'), [], options)
-  server.app.stdout.on('data', function onStdout (data) {
-    let dontContinue = false
-
-    // Capture things if we want to
-    for (const key of Object.keys(regexps)) {
-      const regexp = regexps[key]
-      const matches = data.toString().match(regexp)
-      if (matches !== null) {
-        if (key === 'client_id') server.client.id = matches[1]
-        else if (key === 'client_secret') server.client.secret = matches[1]
-        else if (key === 'user_username') server.user.username = matches[1]
-        else if (key === 'user_password') server.user.password = matches[1]
-      }
-    }
-
-    // Check if all required sentences are here
-    for (const key of Object.keys(serverRunString)) {
-      if (data.toString().indexOf(key) !== -1) serverRunString[key] = true
-      if (serverRunString[key] === false) dontContinue = true
-    }
-
-    // If no, there is maybe one thing not already initialized (mongodb...)
-    if (dontContinue === true) return
-
-    server.app.stdout.removeListener('data', onStdout)
-    callback(server)
-  })
-}
-
-function searchVideo (url, search, field, end) {
-  if (!end) {
-    end = field
-    field = null
-  }
-
-  const path = '/api/v1/videos'
-  const req = request(url)
-              .get(path + '/search/' + search)
-              .set('Accept', 'application/json')
-
-  if (field) req.query({ field: field })
-  req.expect(200)
-     .expect('Content-Type', /json/)
-     .end(end)
-}
-
-function searchVideoWithPagination (url, search, field, start, count, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path + '/search/' + search)
-    .query({ start: start })
-    .query({ count: count })
-    .query({ field: field })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function searchVideoWithSort (url, search, sort, end) {
-  const path = '/api/v1/videos'
-
-  request(url)
-    .get(path + '/search/' + search)
-    .query({ sort: sort })
-    .set('Accept', 'application/json')
-    .expect(200)
-    .expect('Content-Type', /json/)
-    .end(end)
-}
-
-function testImage (url, videoName, imagePath, callback) {
-  // Don't test images if the node env is not set
-  // Because we need a special ffmpeg version for this test
-  if (process.env.NODE_TEST_IMAGE) {
-    request(url)
-      .get(imagePath)
-      .expect(200)
-      .end(function (err, res) {
-        if (err) return callback(err)
-
-        fs.readFile(pathUtils.join(__dirname, 'fixtures', videoName + '.jpg'), function (err, data) {
-          if (err) return callback(err)
-
-          callback(null, data.equals(res.body))
-        })
-      })
-  } else {
-    console.log('Do not test images. Enable it by setting NODE_TEST_IMAGE env variable.')
-    callback(null, true)
-  }
-}
-
-function uploadVideo (url, accessToken, name, description, tags, fixture, specialStatus, end) {
-  if (!end) {
-    end = specialStatus
-    specialStatus = 204
-  }
-
-  const path = '/api/v1/videos'
-
-  const req = request(url)
-              .post(path)
-              .set('Accept', 'application/json')
-              .set('Authorization', 'Bearer ' + accessToken)
-              .field('name', name)
-              .field('description', description)
-
-  for (let i = 0; i < tags.length; i++) {
-    req.field('tags[' + i + ']', tags[i])
-  }
-
-  let filepath = ''
-  if (pathUtils.isAbsolute(fixture)) {
-    filepath = fixture
-  } else {
-    filepath = pathUtils.join(__dirname, 'fixtures', fixture)
-  }
-
-  req.attach('videofile', filepath)
-     .expect(specialStatus)
-     .end(end)
-}
-
-// ---------------------------------------------------------------------------
-
-module.exports = testUtils