10 files changed, 83 insertions, 38 deletions

diff --git a/server/tests/api/check-params/abuses.ts b/server/tests/api/check-params/abuses.ts
index c4b051723..bc2cc640f 100644
--- a/server/tests/api/check-params/abuses.ts
+++ b/server/tests/api/check-params/abuses.ts
@@ -269,7 +269,7 @@ describe('Test abuses API validators', function () {
       await makePostBodyRequest({ url: server.url, path, token: userToken, fields })
     })
 
-    it('Should succeed with the corret parameters (advanced)', async function () {
+    it('Should succeed with the correct parameters (advanced)', async function () {
       const fields: AbuseCreate = {
         video: {
           id: server.store.videoCreated.id,
@@ -333,7 +333,7 @@ describe('Test abuses API validators', function () {
       await command.addMessage({ token: userToken, abuseId, message: 'a'.repeat(5000), expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
-    it('Should suceed with the correct params', async function () {
+    it('Should succeed with the correct params', async function () {
       const res = await command.addMessage({ token: userToken, abuseId, message })
       messageId = res.body.abuseMessage.id
     })
diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts
index 9b8fbe3e2..b9caf394d 100644
--- a/server/tests/api/live/live.ts
+++ b/server/tests/api/live/live.ts
@@ -610,7 +610,7 @@ describe('Test live', function () {
     }
 
     before(async function () {
-      this.timeout(160000)
+      this.timeout(300000)
 
       liveVideoId = await createLiveWrapper({ saveReplay: false, permanent: false })
       liveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: false })
@@ -654,7 +654,7 @@ describe('Test live', function () {
     })
 
     it('Should save a non permanent live replay', async function () {
-      this.timeout(120000)
+      this.timeout(240000)
 
       await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
 
diff --git a/server/tests/api/moderation/abuses.ts b/server/tests/api/moderation/abuses.ts
index 7bf49c7ec..568fbefcf 100644
--- a/server/tests/api/moderation/abuses.ts
+++ b/server/tests/api/moderation/abuses.ts
@@ -168,7 +168,7 @@ describe('Test abuses', function () {
         expect(abuse2.reporterAccount.name).to.equal('root')
         expect(abuse2.reporterAccount.host).to.equal(servers[0].host)
 
-        expect(abuse2.video.id).to.equal(servers[1].store.videoCreated.id)
+        expect(abuse2.video.uuid).to.equal(servers[1].store.videoCreated.uuid)
 
         expect(abuse2.comment).to.be.null
 
@@ -530,7 +530,7 @@ describe('Test abuses', function () {
     it('Should keep the comment abuse when deleting the comment', async function () {
       this.timeout(10000)
 
-      const commentServer2 = await getComment(servers[0], servers[1].store.videoCreated.id)
+      const commentServer2 = await getComment(servers[0], servers[1].store.videoCreated.uuid)
 
       await servers[0].comments.delete({ videoId: servers[1].store.videoCreated.uuid, commentId: commentServer2.id })
 
diff --git a/server/tests/api/notifications/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index a7cc529f8..a11289236 100644
--- a/server/tests/api/notifications/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -545,7 +545,7 @@ describe('Test user notifications', function () {
       await servers[1].subscriptions.remove({ uri: 'user_1_channel@localhost:' + servers[0].port })
     })
 
-    // PeerTube does not support accout -> account follows
+    // PeerTube does not support account -> account follows
     // it('Should notify when a local account is following one of our channel', async function () {
     //   this.timeout(50000)
     //
diff --git a/server/tests/api/search/search-index.ts b/server/tests/api/search/search-index.ts
index 287abe455..53b91e1cb 100644
--- a/server/tests/api/search/search-index.ts
+++ b/server/tests/api/search/search-index.ts
@@ -136,14 +136,14 @@ describe('Test index search', function () {
       expect(video.account.url).to.equal('https://framatube.org/accounts/framasoft')
       // TODO: remove, deprecated in 4.2
       expect(video.account.avatar).to.exist
-      expect(video.account.avatars.length).to.equal(1, 'Account should have one avatar image')
+      expect(video.account.avatars.length).to.equal(2, 'Account should have one avatar image')
 
       expect(video.channel.host).to.equal('framatube.org')
       expect(video.channel.name).to.equal('joinpeertube')
       expect(video.channel.url).to.equal('https://framatube.org/video-channels/joinpeertube')
       // TODO: remove, deprecated in 4.2
       expect(video.channel.avatar).to.exist
-      expect(video.channel.avatars.length).to.equal(1, 'Channel should have one avatar image')
+      expect(video.channel.avatars.length).to.equal(2, 'Channel should have one avatar image')
     }
 
     const baseSearch: VideosSearchQuery = {
@@ -322,7 +322,7 @@ describe('Test index search', function () {
       expect(videoChannel.host).to.equal('framatube.org')
       // TODO: remove, deprecated in 4.2
       expect(videoChannel.avatar).to.exist
-      expect(videoChannel.avatars.length).to.equal(1, 'Channel should have two avatar images')
+      expect(videoChannel.avatars.length).to.equal(2, 'Channel should have two avatar images')
       expect(videoChannel.displayName).to.exist
 
       expect(videoChannel.ownerAccount.url).to.equal('https://framatube.org/accounts/framasoft')
@@ -330,7 +330,7 @@ describe('Test index search', function () {
       expect(videoChannel.ownerAccount.host).to.equal('framatube.org')
       // TODO: remove, deprecated in 4.2
       expect(videoChannel.ownerAccount.avatar).to.exist
-      expect(videoChannel.ownerAccount.avatars.length).to.equal(1, 'Account should have two avatar images')
+      expect(videoChannel.ownerAccount.avatars.length).to.equal(2, 'Account should have two avatar images')
     }
 
     it('Should make a simple search and not have results', async function () {
diff --git a/server/tests/api/server/contact-form.ts b/server/tests/api/server/contact-form.ts
index 4f01f6fd5..d6165b293 100644
--- a/server/tests/api/server/contact-form.ts
+++ b/server/tests/api/server/contact-form.ts
@@ -61,7 +61,7 @@ describe('Test contact form', function () {
     expect(email['text']).contains('my super message')
   })
 
-  it('Should not have duplicated email adress in text message', async function () {
+  it('Should not have duplicated email address in text message', async function () {
     const text = emails[0]['text'] as string
 
     const matches = text.match(/toto@example.com/g)
diff --git a/server/tests/api/server/reverse-proxy.ts b/server/tests/api/server/reverse-proxy.ts
index fa2063536..0a1565faf 100644
--- a/server/tests/api/server/reverse-proxy.ts
+++ b/server/tests/api/server/reverse-proxy.ts
@@ -7,6 +7,7 @@ import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServ
 
 describe('Test application behind a reverse proxy', function () {
   let server: PeerTubeServer
+  let userAccessToken: string
   let videoId: string
 
   before(async function () {
@@ -34,6 +35,8 @@ describe('Test application behind a reverse proxy', function () {
     server = await createSingleServer(1, config)
     await setAccessTokensToServers([ server ])
 
+    userAccessToken = await server.users.generateUserAndToken('user')
+
     const { uuid } = await server.videos.upload()
     videoId = uuid
   })
@@ -93,7 +96,7 @@ describe('Test application behind a reverse proxy', function () {
   it('Should rate limit logins', async function () {
     const user = { username: 'root', password: 'fail' }
 
-    for (let i = 0; i < 19; i++) {
+    for (let i = 0; i < 18; i++) {
       await server.login.login({ user, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     }
 
@@ -141,6 +144,12 @@ describe('Test application behind a reverse proxy', function () {
     await server.videos.get({ id: videoId, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
   })
 
+  it('Should rate limit API calls with a user but not with an admin', async function () {
+    await server.videos.get({ id: videoId, token: userAccessToken, expectedStatus: HttpStatusCode.TOO_MANY_REQUESTS_429 })
+
+    await server.videos.get({ id: videoId, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+  })
+
   after(async function () {
     await cleanupTests([ server ])
   })
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 01b4c2eab..d15daeba5 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -380,7 +380,7 @@ describe('Test users', function () {
     })
 
     it('Should disable webtorrent, enable HLS, and update my quota', async function () {
-      this.timeout(60000)
+      this.timeout(160000)
 
       {
         const config = await server.config.getCustomConfig()
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 6f495c42d..42e0cf431 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -478,6 +478,25 @@ describe('Test video channels', function () {
     }
   })
 
+  it('Should report correct total views count', async function () {
+    // check if there's the property
+    {
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
+
+      for (const channel of data) {
+        expect(channel).to.haveOwnProperty('totalViews')
+        expect(channel.totalViews).to.be.a('number')
+      }
+    }
+
+    // Check if the totalViews count can be updated
+    {
+      const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
+      const channelWithView = data.find(channel => channel.id === servers[0].store.channel.id)
+      expect(channelWithView.totalViews).to.equal(2)
+    }
+  })
+
   it('Should report correct videos count', async function () {
     const { data } = await servers[0].channels.listByAccount({ accountName, withStats: true })
 
diff --git a/server/tests/helpers/core-utils.ts b/server/tests/helpers/core-utils.ts
index fa0a71341..e3e5eb45c 100644
--- a/server/tests/helpers/core-utils.ts
+++ b/server/tests/helpers/core-utils.ts
@@ -6,47 +6,64 @@ import { snakeCase } from 'lodash'
 import validator from 'validator'
 import { getAverageBitrate, getMaxBitrate } from '@shared/core-utils'
 import { VideoResolution } from '@shared/models'
-import { objectConverter, parseBytes } from '../../helpers/core-utils'
+import { objectConverter, parseBytes, parseDurationToMs } from '../../helpers/core-utils'
 
 const expect = chai.expect
 
 describe('Parse Bytes', function () {
 
-  it('Should pass when given valid value', async function () {
+  it('Should pass on valid value', async function () {
     // just return it
-    expect(parseBytes(1024)).to.be.eq(1024)
-    expect(parseBytes(1048576)).to.be.eq(1048576)
-    expect(parseBytes('1024')).to.be.eq(1024)
-    expect(parseBytes('1048576')).to.be.eq(1048576)
+    expect(parseBytes(-1024)).to.equal(-1024)
+    expect(parseBytes(1024)).to.equal(1024)
+    expect(parseBytes(1048576)).to.equal(1048576)
+    expect(parseBytes('1024')).to.equal(1024)
+    expect(parseBytes('1048576')).to.equal(1048576)
 
     // sizes
-    expect(parseBytes('1B')).to.be.eq(1024)
-    expect(parseBytes('1MB')).to.be.eq(1048576)
-    expect(parseBytes('1GB')).to.be.eq(1073741824)
-    expect(parseBytes('1TB')).to.be.eq(1099511627776)
+    expect(parseBytes('1B')).to.equal(1024)
+    expect(parseBytes('1MB')).to.equal(1048576)
+    expect(parseBytes('1GB')).to.equal(1073741824)
+    expect(parseBytes('1TB')).to.equal(1099511627776)
 
-    expect(parseBytes('5GB')).to.be.eq(5368709120)
-    expect(parseBytes('5TB')).to.be.eq(5497558138880)
+    expect(parseBytes('5GB')).to.equal(5368709120)
+    expect(parseBytes('5TB')).to.equal(5497558138880)
 
-    expect(parseBytes('1024B')).to.be.eq(1048576)
-    expect(parseBytes('1024MB')).to.be.eq(1073741824)
-    expect(parseBytes('1024GB')).to.be.eq(1099511627776)
-    expect(parseBytes('1024TB')).to.be.eq(1125899906842624)
+    expect(parseBytes('1024B')).to.equal(1048576)
+    expect(parseBytes('1024MB')).to.equal(1073741824)
+    expect(parseBytes('1024GB')).to.equal(1099511627776)
+    expect(parseBytes('1024TB')).to.equal(1125899906842624)
 
     // with whitespace
-    expect(parseBytes('1 GB')).to.be.eq(1073741824)
-    expect(parseBytes('1\tGB')).to.be.eq(1073741824)
+    expect(parseBytes('1 GB')).to.equal(1073741824)
+    expect(parseBytes('1\tGB')).to.equal(1073741824)
 
     // sum value
-    expect(parseBytes('1TB 1024MB')).to.be.eq(1100585369600)
-    expect(parseBytes('4GB 1024MB')).to.be.eq(5368709120)
-    expect(parseBytes('4TB 1024GB')).to.be.eq(5497558138880)
-    expect(parseBytes('4TB 1024GB 0MB')).to.be.eq(5497558138880)
-    expect(parseBytes('1024TB 1024GB 1024MB')).to.be.eq(1127000492212224)
+    expect(parseBytes('1TB 1024MB')).to.equal(1100585369600)
+    expect(parseBytes('4GB 1024MB')).to.equal(5368709120)
+    expect(parseBytes('4TB 1024GB')).to.equal(5497558138880)
+    expect(parseBytes('4TB 1024GB 0MB')).to.equal(5497558138880)
+    expect(parseBytes('1024TB 1024GB 1024MB')).to.equal(1127000492212224)
+  })
+
+  it('Should be invalid when given invalid value', async function () {
+    expect(parseBytes('6GB 1GB')).to.equal(6)
+  })
+})
+
+describe('Parse duration', function () {
+
+  it('Should pass when given valid value', async function () {
+    expect(parseDurationToMs(35)).to.equal(35)
+    expect(parseDurationToMs(-35)).to.equal(-35)
+    expect(parseDurationToMs('35 seconds')).to.equal(35 * 1000)
+    expect(parseDurationToMs('1 minute')).to.equal(60 * 1000)
+    expect(parseDurationToMs('1 hour')).to.equal(3600 * 1000)
+    expect(parseDurationToMs('35 hours')).to.equal(3600 * 35 * 1000)
   })
 
   it('Should be invalid when given invalid value', async function () {
-    expect(parseBytes('6GB 1GB')).to.be.eq(6)
+    expect(parseBytes('35m 5s')).to.equal(35)
   })
 })