From bc503c2a62dcf9aed6b8d90b68f0f27a7755ac01 Mon Sep 17 00:00:00 2001
From: Chocobozzz <florian.bigard@gmail.com>
Date: Wed, 11 May 2016 21:19:34 +0200
Subject: Update to standard 7. Goodbye snake_case, I used to love you

---
 server/tests/api/checkParams.js     | 12 +++----
 server/tests/api/friendsAdvanced.js | 34 ++++++++++----------
 server/tests/api/friendsBasic.js    | 20 ++++++------
 server/tests/api/multiplePods.js    | 50 ++++++++++++++---------------
 server/tests/api/singlePod.js       | 34 ++++++++++----------
 server/tests/api/users.js           | 20 ++++++------
 server/tests/api/utils.js           | 64 ++++++++++++++++++-------------------
 7 files changed, 117 insertions(+), 117 deletions(-)

(limited to 'server/tests/api')

diff --git a/server/tests/api/checkParams.js b/server/tests/api/checkParams.js
index 59ee0bfc3..71113fd39 100644
--- a/server/tests/api/checkParams.js
+++ b/server/tests/api/checkParams.js
@@ -12,8 +12,8 @@ describe('Test parameters validator', function () {
   let server = null
 
   function makePostRequest (path, token, fields, attach, done, fail) {
-    let status_code = 400
-    if (fail !== undefined && fail === false) status_code = 200
+    let statusCode = 400
+    if (fail !== undefined && fail === false) statusCode = 200
 
     const req = request(server.url)
       .post(path)
@@ -26,18 +26,18 @@ describe('Test parameters validator', function () {
       req.field(field, value)
     })
 
-    req.expect(status_code, done)
+    req.expect(statusCode, done)
   }
 
   function makePostBodyRequest (path, fields, done, fail) {
-    let status_code = 400
-    if (fail !== undefined && fail === false) status_code = 200
+    let statusCode = 400
+    if (fail !== undefined && fail === false) statusCode = 200
 
     request(server.url)
       .post(path)
       .set('Accept', 'application/json')
       .send(fields)
-      .expect(status_code, done)
+      .expect(statusCode, done)
   }
 
   // ---------------------------------------------------------------
diff --git a/server/tests/api/friendsAdvanced.js b/server/tests/api/friendsAdvanced.js
index 6f18648d7..833a530dd 100644
--- a/server/tests/api/friendsAdvanced.js
+++ b/server/tests/api/friendsAdvanced.js
@@ -9,44 +9,44 @@ const utils = require('./utils')
 describe('Test advanced friends', function () {
   let servers = []
 
-  function makeFriends (pod_number, callback) {
-    return utils.makeFriends(servers[pod_number - 1].url, callback)
+  function makeFriends (podNumber, callback) {
+    return utils.makeFriends(servers[podNumber - 1].url, callback)
   }
 
-  function quitFriends (pod_number, callback) {
-    return utils.quitFriends(servers[pod_number - 1].url, callback)
+  function quitFriends (podNumber, callback) {
+    return utils.quitFriends(servers[podNumber - 1].url, callback)
   }
 
-  function getFriendsList (pod_number, end) {
-    return utils.getFriendsList(servers[pod_number - 1].url, end)
+  function getFriendsList (podNumber, end) {
+    return utils.getFriendsList(servers[podNumber - 1].url, end)
   }
 
-  function uploadVideo (pod_number, callback) {
+  function uploadVideo (podNumber, callback) {
     const name = 'my super video'
     const description = 'my super description'
     const fixture = 'video_short.webm'
-    const server = servers[pod_number - 1]
+    const server = servers[podNumber - 1]
 
     return utils.uploadVideo(server.url, server.access_token, name, description, fixture, callback)
   }
 
-  function getVideos (pod_number, callback) {
-    return utils.getVideosList(servers[pod_number - 1].url, callback)
+  function getVideos (podNumber, callback) {
+    return utils.getVideosList(servers[podNumber - 1].url, callback)
   }
 
   // ---------------------------------------------------------------
 
   before(function (done) {
     this.timeout(30000)
-    utils.flushAndRunMultipleServers(6, function (servers_run, urls_run) {
-      servers = servers_run
+    utils.flushAndRunMultipleServers(6, function (serversRun, urlsRun) {
+      servers = serversRun
 
-      async.each(servers, function (server, callback_each) {
-        utils.loginAndGetAccessToken(server, function (err, access_token) {
-          if (err) return callback_each(err)
+      async.each(servers, function (server, callbackEach) {
+        utils.loginAndGetAccessToken(server, function (err, accessToken) {
+          if (err) return callbackEach(err)
 
-          server.access_token = access_token
-          callback_each()
+          server.accessToken = accessToken
+          callbackEach()
         })
       }, done)
     })
diff --git a/server/tests/api/friendsBasic.js b/server/tests/api/friendsBasic.js
index 49e51804f..c9e3bc9ad 100644
--- a/server/tests/api/friendsBasic.js
+++ b/server/tests/api/friendsBasic.js
@@ -10,25 +10,25 @@ const utils = require('./utils')
 describe('Test basic friends', function () {
   let servers = []
 
-  function testMadeFriends (servers, server_to_test, callback) {
+  function testMadeFriends (servers, serverToTest, callback) {
     const friends = []
     for (let i = 0; i < servers.length; i++) {
-      if (servers[i].url === server_to_test.url) continue
+      if (servers[i].url === serverToTest.url) continue
       friends.push(servers[i].url)
     }
 
-    utils.getFriendsList(server_to_test.url, function (err, res) {
+    utils.getFriendsList(serverToTest.url, function (err, res) {
       if (err) throw err
 
       const result = res.body
-      const result_urls = [ result[0].url, result[1].url ]
+      const resultUrls = [ result[0].url, result[1].url ]
       expect(result).to.be.an('array')
       expect(result.length).to.equal(2)
-      expect(result_urls[0]).to.not.equal(result_urls[1])
+      expect(resultUrls[0]).to.not.equal(resultUrls[1])
 
-      const error_string = 'Friends url do not correspond for ' + server_to_test.url
-      expect(friends).to.contain(result_urls[0], error_string)
-      expect(friends).to.contain(result_urls[1], error_string)
+      const errorString = 'Friends url do not correspond for ' + serverToTest.url
+      expect(friends).to.contain(resultUrls[0], errorString)
+      expect(friends).to.contain(resultUrls[1], errorString)
       callback()
     })
   }
@@ -37,8 +37,8 @@ describe('Test basic friends', function () {
 
   before(function (done) {
     this.timeout(20000)
-    utils.flushAndRunMultipleServers(3, function (servers_run, urls_run) {
-      servers = servers_run
+    utils.flushAndRunMultipleServers(3, function (serversRun, urlsRun) {
+      servers = serversRun
       done()
     })
   })
diff --git a/server/tests/api/multiplePods.js b/server/tests/api/multiplePods.js
index b361e373b..f1415f6f1 100644
--- a/server/tests/api/multiplePods.js
+++ b/server/tests/api/multiplePods.js
@@ -11,7 +11,7 @@ webtorrent.silent = true
 
 describe('Test multiple pods', function () {
   let servers = []
-  const to_remove = []
+  const toRemove = []
 
   before(function (done) {
     this.timeout(30000)
@@ -19,19 +19,19 @@ describe('Test multiple pods', function () {
     async.series([
       // Run servers
       function (next) {
-        utils.flushAndRunMultipleServers(3, function (servers_run) {
-          servers = servers_run
+        utils.flushAndRunMultipleServers(3, function (serversRun) {
+          servers = serversRun
           next()
         })
       },
       // Get the access tokens
       function (next) {
-        async.each(servers, function (server, callback_each) {
-          utils.loginAndGetAccessToken(server, function (err, access_token) {
-            if (err) return callback_each(err)
+        async.each(servers, function (server, callbackEach) {
+          utils.loginAndGetAccessToken(server, function (err, accessToken) {
+            if (err) return callbackEach(err)
 
-            server.access_token = access_token
-            callback_each()
+            server.accessToken = accessToken
+            callbackEach()
           })
         }, next)
       },
@@ -82,7 +82,7 @@ describe('Test multiple pods', function () {
           if (err) throw err
 
           async.each(servers, function (server, callback) {
-            let base_magnet = null
+            let baseMagnet = null
 
             utils.getVideosList(server.url, function (err, res) {
               if (err) throw err
@@ -104,8 +104,8 @@ describe('Test multiple pods', function () {
               }
 
               // All pods should have the same magnet Uri
-              if (base_magnet === null) {
-                base_magnet = video.magnetUri
+              if (baseMagnet === null) {
+                baseMagnet = video.magnetUri
               } else {
                 expect(video.magnetUri).to.equal.magnetUri
               }
@@ -137,7 +137,7 @@ describe('Test multiple pods', function () {
           if (err) throw err
 
           async.each(servers, function (server, callback) {
-            let base_magnet = null
+            let baseMagnet = null
 
             utils.getVideosList(server.url, function (err, res) {
               if (err) throw err
@@ -159,8 +159,8 @@ describe('Test multiple pods', function () {
               }
 
               // All pods should have the same magnet Uri
-              if (base_magnet === null) {
-                base_magnet = video.magnetUri
+              if (baseMagnet === null) {
+                baseMagnet = video.magnetUri
               } else {
                 expect(video.magnetUri).to.equal.magnetUri
               }
@@ -193,7 +193,7 @@ describe('Test multiple pods', function () {
         function (err) {
           if (err) throw err
 
-          let base_magnet = null
+          let baseMagnet = null
           // All pods should have this video
           async.each(servers, function (server, callback) {
             utils.getVideosList(server.url, function (err, res) {
@@ -235,8 +235,8 @@ describe('Test multiple pods', function () {
               }
 
               // All pods should have the same magnet Uri
-              if (base_magnet === null) {
-                base_magnet = video2.magnetUri
+              if (baseMagnet === null) {
+                baseMagnet = video2.magnetUri
               } else {
                 expect(video2.magnetUri).to.equal.magnetUri
               }
@@ -268,8 +268,8 @@ describe('Test multiple pods', function () {
         if (err) throw err
 
         const video = res.body[0]
-        to_remove.push(res.body[2].id)
-        to_remove.push(res.body[3].id)
+        toRemove.push(res.body[2].id)
+        toRemove.push(res.body[3].id)
 
         webtorrent.add(video.magnetUri, function (torrent) {
           expect(torrent.files).to.exist
@@ -343,10 +343,10 @@ describe('Test multiple pods', function () {
 
       async.series([
         function (next) {
-          utils.removeVideo(servers[2].url, servers[2].access_token, to_remove[0], next)
+          utils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[0], next)
         },
         function (next) {
-          utils.removeVideo(servers[2].url, servers[2].access_token, to_remove[1], next)
+          utils.removeVideo(servers[2].url, servers[2].accessToken, toRemove[1], next)
         }],
         function (err) {
           if (err) throw err
@@ -364,10 +364,10 @@ describe('Test multiple pods', function () {
           expect(videos).to.be.an('array')
           expect(videos.length).to.equal(2)
           expect(videos[0].id).not.to.equal(videos[1].id)
-          expect(videos[0].id).not.to.equal(to_remove[0])
-          expect(videos[1].id).not.to.equal(to_remove[0])
-          expect(videos[0].id).not.to.equal(to_remove[1])
-          expect(videos[1].id).not.to.equal(to_remove[1])
+          expect(videos[0].id).not.to.equal(toRemove[0])
+          expect(videos[1].id).not.to.equal(toRemove[0])
+          expect(videos[0].id).not.to.equal(toRemove[1])
+          expect(videos[1].id).not.to.equal(toRemove[1])
 
           callback()
         })
diff --git a/server/tests/api/singlePod.js b/server/tests/api/singlePod.js
index e8b578770..542dea430 100644
--- a/server/tests/api/singlePod.js
+++ b/server/tests/api/singlePod.js
@@ -14,7 +14,7 @@ const utils = require('./utils')
 
 describe('Test a single pod', function () {
   let server = null
-  let video_id = -1
+  let videoId = -1
 
   before(function (done) {
     this.timeout(20000)
@@ -80,7 +80,7 @@ describe('Test a single pod', function () {
         if (err) throw err
         expect(test).to.equal(true)
 
-        video_id = video.id
+        videoId = video.id
 
         webtorrent.add(video.magnetUri, function (torrent) {
           expect(torrent.files).to.exist
@@ -97,7 +97,7 @@ describe('Test a single pod', function () {
     // Yes, this could be long
     this.timeout(60000)
 
-    utils.getVideo(server.url, video_id, function (err, res) {
+    utils.getVideo(server.url, videoId, function (err, res) {
       if (err) throw err
 
       const video = res.body
@@ -158,7 +158,7 @@ describe('Test a single pod', function () {
   })
 
   it('Should remove the video', function (done) {
-    utils.removeVideo(server.url, server.access_token, video_id, function (err) {
+    utils.removeVideo(server.url, server.accessToken, videoId, function (err) {
       if (err) throw err
 
       fs.readdir(pathUtils.join(__dirname, '../../../test1/uploads/'), function (err, files) {
@@ -187,8 +187,8 @@ describe('Test a single pod', function () {
       'video_short.mp4', 'video_short.ogv', 'video_short.webm',
       'video_short1.webm', 'video_short2.webm', 'video_short3.webm'
     ]
-    async.each(videos, function (video, callback_each) {
-      utils.uploadVideo(server.url, server.access_token, video + ' name', video + ' description', video, callback_each)
+    async.each(videos, function (video, callbackEach) {
+      utils.uploadVideo(server.url, server.accessToken, video + ' name', video + ' description', video, callbackEach)
     }, done)
   })
 
@@ -200,13 +200,13 @@ describe('Test a single pod', function () {
       expect(videos).to.be.an('array')
       expect(videos.length).to.equal(6)
 
-      const videos_by_name = keyBy(videos, 'name')
-      expect(videos_by_name['video_short.mp4 name'].duration).to.equal(5)
-      expect(videos_by_name['video_short.ogv name'].duration).to.equal(5)
-      expect(videos_by_name['video_short.webm name'].duration).to.equal(5)
-      expect(videos_by_name['video_short1.webm name'].duration).to.equal(10)
-      expect(videos_by_name['video_short2.webm name'].duration).to.equal(5)
-      expect(videos_by_name['video_short3.webm name'].duration).to.equal(5)
+      const videosByName = keyBy(videos, 'name')
+      expect(videosByName['video_short.mp4 name'].duration).to.equal(5)
+      expect(videosByName['video_short.ogv name'].duration).to.equal(5)
+      expect(videosByName['video_short.webm name'].duration).to.equal(5)
+      expect(videosByName['video_short1.webm name'].duration).to.equal(10)
+      expect(videosByName['video_short2.webm name'].duration).to.equal(5)
+      expect(videosByName['video_short3.webm name'].duration).to.equal(5)
 
       done()
     })
@@ -216,15 +216,15 @@ describe('Test a single pod', function () {
     utils.getVideosList(server.url, function (err, res) {
       const videos = res.body
 
-      async.each(videos, function (video, callback_each) {
+      async.each(videos, function (video, callbackEach) {
         if (err) throw err
-        const video_name = video.name.replace(' name', '')
+        const videoName = video.name.replace(' name', '')
 
-        utils.testImage(server.url, video_name, video.thumbnailPath, function (err, test) {
+        utils.testImage(server.url, videoName, video.thumbnailPath, function (err, test) {
           if (err) throw err
 
           expect(test).to.equal(true)
-          callback_each()
+          callbackEach()
         })
       }, done)
     })
diff --git a/server/tests/api/users.js b/server/tests/api/users.js
index e5395a79f..57417a69e 100644
--- a/server/tests/api/users.js
+++ b/server/tests/api/users.js
@@ -12,8 +12,8 @@ const utils = require('./utils')
 
 describe('Test users', function () {
   let server = null
-  let access_token = null
-  let video_id
+  let accessToken = null
+  let videoId
 
   before(function (done) {
     this.timeout(20000)
@@ -78,21 +78,21 @@ describe('Test users', function () {
   })
 
   it('Should not be able to upload a video', function (done) {
-    access_token = 'mysupertoken'
-    utils.uploadVideo(server.url, access_token, 'my super name', 'my super description', 'video_short.webm', 401, done)
+    accessToken = 'mysupertoken'
+    utils.uploadVideo(server.url, accessToken, 'my super name', 'my super description', 'video_short.webm', 401, done)
   })
 
   it('Should be able to login', function (done) {
     utils.login(server.url, server.client, server.user, 200, function (err, res) {
       if (err) throw err
 
-      access_token = res.body.access_token
+      accessToken = res.body.access_token
       done()
     })
   })
 
   it('Should upload the video with the correct token', function (done) {
-    utils.uploadVideo(server.url, access_token, 'my super name', 'my super description', 'video_short.webm', 204, function (err, res) {
+    utils.uploadVideo(server.url, accessToken, 'my super name', 'my super description', 'video_short.webm', 204, function (err, res) {
       if (err) throw err
 
       utils.getVideosList(server.url, function (err, res) {
@@ -101,24 +101,24 @@ describe('Test users', function () {
         const video = res.body[0]
         expect(video.author).to.equal('root')
 
-        video_id = video.id
+        videoId = video.id
         done()
       })
     })
   })
 
   it('Should upload the video again with the correct token', function (done) {
-    utils.uploadVideo(server.url, access_token, 'my super name 2', 'my super description 2', 'video_short.webm', 204, done)
+    utils.uploadVideo(server.url, accessToken, 'my super name 2', 'my super description 2', 'video_short.webm', 204, done)
   })
 
   it('Should not be able to remove the video with an incorrect token', function (done) {
-    utils.removeVideo(server.url, 'bad_token', video_id, 401, done)
+    utils.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, access_token, video_id, done)
+    utils.removeVideo(server.url, accessToken, videoId, done)
   })
 
   it('Should logout')
diff --git a/server/tests/api/utils.js b/server/tests/api/utils.js
index 3d3169fde..45f11ac8f 100644
--- a/server/tests/api/utils.js
+++ b/server/tests/api/utils.js
@@ -1,8 +1,8 @@
 'use strict'
 
-const child_process = require('child_process')
-const exec = child_process.exec
-const fork = child_process.fork
+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')
@@ -63,10 +63,10 @@ function getVideosList (url, end) {
     .end(end)
 }
 
-function login (url, client, user, expected_status, end) {
+function login (url, client, user, expectedStatus, end) {
   if (!end) {
-    end = expected_status
-    expected_status = 200
+    end = expectedStatus
+    expectedStatus = 200
   }
 
   const path = '/api/v1/users/token'
@@ -85,7 +85,7 @@ function login (url, client, user, expected_status, end) {
     .post(path)
     .type('form')
     .send(body)
-    .expect(expected_status)
+    .expect(expectedStatus)
     .end(end)
 }
 
@@ -97,10 +97,10 @@ function loginAndGetAccessToken (server, callback) {
   })
 }
 
-function makeFriends (url, expected_status, callback) {
+function makeFriends (url, expectedStatus, callback) {
   if (!callback) {
-    callback = expected_status
-    expected_status = 204
+    callback = expectedStatus
+    expectedStatus = 204
   }
 
   const path = '/api/v1/pods/makefriends'
@@ -109,7 +109,7 @@ function makeFriends (url, expected_status, callback) {
   request(url)
     .get(path)
     .set('Accept', 'application/json')
-    .expect(expected_status)
+    .expect(expectedStatus)
     .end(function (err, res) {
       if (err) throw err
 
@@ -134,10 +134,10 @@ function quitFriends (url, callback) {
     })
 }
 
-function removeVideo (url, token, id, expected_status, end) {
+function removeVideo (url, token, id, expectedStatus, end) {
   if (!end) {
-    end = expected_status
-    expected_status = 204
+    end = expectedStatus
+    expectedStatus = 204
   }
 
   const path = '/api/v1/videos'
@@ -146,11 +146,11 @@ function removeVideo (url, token, id, expected_status, end) {
     .delete(path + '/' + id)
     .set('Accept', 'application/json')
     .set('Authorization', 'Bearer ' + token)
-    .expect(expected_status)
+    .expect(expectedStatus)
     .end(end)
 }
 
-function flushAndRunMultipleServers (total_servers, serversRun) {
+function flushAndRunMultipleServers (totalServers, serversRun) {
   let apps = []
   let urls = []
   let i = 0
@@ -159,13 +159,13 @@ function flushAndRunMultipleServers (total_servers, serversRun) {
     apps[number - 1] = app
     urls[number - 1] = url
     i++
-    if (i === total_servers) {
+    if (i === totalServers) {
       serversRun(apps, urls)
     }
   }
 
   flushTests(function () {
-    for (let j = 1; j <= total_servers; j++) {
+    for (let j = 1; j <= totalServers; j++) {
       // For the virtual buffer
       setTimeout(function () {
         runServer(j, function (app, url) {
@@ -191,7 +191,7 @@ function runServer (number, callback) {
   }
 
   // These actions are async so we need to be sure that they have both been done
-  const server_run_string = {
+  const serverRunString = {
     'Connected to mongodb': false,
     'Server listening on port': false
   }
@@ -215,7 +215,7 @@ function runServer (number, callback) {
 
   server.app = fork(pathUtils.join(__dirname, '../../../server.js'), [], options)
   server.app.stdout.on('data', function onStdout (data) {
-    let dont_continue = false
+    let dontContinue = false
 
     // Capture things if we want to
     for (const key of Object.keys(regexps)) {
@@ -230,13 +230,13 @@ function runServer (number, callback) {
     }
 
     // Check if all required sentences are here
-    for (const key of Object.keys(server_run_string)) {
-      if (data.toString().indexOf(key) !== -1) server_run_string[key] = true
-      if (server_run_string[key] === false) dont_continue = true
+    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 (dont_continue === true) return
+    if (dontContinue === true) return
 
     server.app.stdout.removeListener('data', onStdout)
     callback(server)
@@ -254,14 +254,14 @@ function searchVideo (url, search, end) {
     .end(end)
 }
 
-function testImage (url, video_name, image_path, callback) {
+function testImage (url, videoName, imagePath, callback) {
   request(url)
-    .get(image_path)
+    .get(imagePath)
     .expect(200)
     .end(function (err, res) {
       if (err) return callback(err)
 
-      fs.readFile(pathUtils.join(__dirname, 'fixtures', video_name + '.jpg'), function (err, data) {
+      fs.readFile(pathUtils.join(__dirname, 'fixtures', videoName + '.jpg'), function (err, data) {
         if (err) return callback(err)
 
         callback(null, data.equals(res.body))
@@ -269,10 +269,10 @@ function testImage (url, video_name, image_path, callback) {
     })
 }
 
-function uploadVideo (url, access_token, name, description, fixture, special_status, end) {
+function uploadVideo (url, accessToken, name, description, fixture, specialStatus, end) {
   if (!end) {
-    end = special_status
-    special_status = 204
+    end = specialStatus
+    specialStatus = 204
   }
 
   const path = '/api/v1/videos'
@@ -280,11 +280,11 @@ function uploadVideo (url, access_token, name, description, fixture, special_sta
   request(url)
     .post(path)
     .set('Accept', 'application/json')
-    .set('Authorization', 'Bearer ' + access_token)
+    .set('Authorization', 'Bearer ' + accessToken)
     .field('name', name)
     .field('description', description)
     .attach('videofile', pathUtils.join(__dirname, 'fixtures', fixture))
-    .expect(special_status)
+    .expect(specialStatus)
     .end(end)
 }
 
-- 
cgit v1.2.3