Support video views/viewers stats in server

 * Add "currentTime" and "event" body params to view endpoint
 * Merge watching and view endpoints
 * Introduce WatchAction AP activity
 * Add tables to store viewer information of local videos
 * Add endpoints to fetch video views/viewers stats of local videos
 * Refactor views/viewers handlers
 * Support "views" and "viewers" counters for both VOD and live videos

21 files changed, 879 insertions, 269 deletions

diff --git a/server/tests/api/activitypub/client.ts b/server/tests/api/activitypub/client.ts
index e69ab3cb9..655fa30d0 100644
--- a/server/tests/api/activitypub/client.ts
+++ b/server/tests/api/activitypub/client.ts
@@ -2,6 +2,8 @@
 
 import 'mocha'
 import * as chai from 'chai'
+import { processViewersStats } from '@server/tests/shared'
+import { HttpStatusCode, VideoPlaylistPrivacy, WatchActionObject } from '@shared/models'
 import {
   cleanupTests,
   createMultipleServers,
@@ -11,7 +13,6 @@ import {
   setAccessTokensToServers,
   setDefaultVideoChannel
 } from '@shared/server-commands'
-import { HttpStatusCode, VideoPlaylistPrivacy } from '@shared/models'
 
 const expect = chai.expect
 
@@ -115,6 +116,23 @@ describe('Test activitypub', function () {
     expect(res.header.location).to.equal('http://localhost:' + servers[0].port + '/videos/watch/' + video.uuid)
   })
 
+  it('Should return the watch action', async function () {
+    this.timeout(50000)
+
+    await servers[0].views.simulateViewer({ id: video.uuid, currentTimes: [ 0, 2 ] })
+    await processViewersStats(servers)
+
+    const res = await makeActivityPubGetRequest(servers[0].url, '/videos/local-viewer/1', HttpStatusCode.OK_200)
+
+    const object: WatchActionObject = res.body
+    expect(object.type).to.equal('WatchAction')
+    expect(object.duration).to.equal('PT2S')
+    expect(object.actionStatus).to.equal('CompletedActionStatus')
+    expect(object.watchSections).to.have.lengthOf(1)
+    expect(object.watchSections[0].startTimestamp).to.equal(0)
+    expect(object.watchSections[0].endTimestamp).to.equal(2)
+  })
+
   after(async function () {
     await cleanupTests(servers)
   })
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index c9adeef4a..259d7e783 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -33,3 +33,4 @@ import './videos-common-filters'
 import './video-files'
 import './videos-history'
 import './videos-overviews'
+import './views'
diff --git a/server/tests/api/check-params/videos-history.ts b/server/tests/api/check-params/videos-history.ts
index 82f38b7b4..c1b2d8bf3 100644
--- a/server/tests/api/check-params/videos-history.ts
+++ b/server/tests/api/check-params/videos-history.ts
@@ -17,7 +17,7 @@ import {
 describe('Test videos history API validator', function () {
   const myHistoryPath = '/api/v1/users/me/history/videos'
   const myHistoryRemove = myHistoryPath + '/remove'
-  let watchingPath: string
+  let viewPath: string
   let server: PeerTubeServer
   let videoId: number
 
@@ -31,51 +31,15 @@ describe('Test videos history API validator', function () {
     await setAccessTokensToServers([ server ])
 
     const { id, uuid } = await server.videos.upload()
-    watchingPath = '/api/v1/videos/' + uuid + '/watching'
+    viewPath = '/api/v1/videos/' + uuid + '/views'
     videoId = id
   })
 
   describe('When notifying a user is watching a video', function () {
 
-    it('Should fail with an unauthenticated user', async function () {
-      const fields = { currentTime: 5 }
-      await makePutBodyRequest({ url: server.url, path: watchingPath, fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-    })
-
-    it('Should fail with an incorrect video id', async function () {
+    it('Should fail with a bad token', async function () {
       const fields = { currentTime: 5 }
-      const path = '/api/v1/videos/blabla/watching'
-      await makePutBodyRequest({
-        url: server.url,
-        path,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
-    })
-
-    it('Should fail with an unknown video', async function () {
-      const fields = { currentTime: 5 }
-      const path = '/api/v1/videos/d91fff41-c24d-4508-8e13-3bd5902c3b02/watching'
-
-      await makePutBodyRequest({
-        url: server.url,
-        path,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.NOT_FOUND_404
-      })
-    })
-
-    it('Should fail with a bad current time', async function () {
-      const fields = { currentTime: 'hello' }
-      await makePutBodyRequest({
-        url: server.url,
-        path: watchingPath,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
+      await makePutBodyRequest({ url: server.url, path: viewPath, fields, token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should succeed with the correct parameters', async function () {
@@ -83,7 +47,7 @@ describe('Test videos history API validator', function () {
 
       await makePutBodyRequest({
         url: server.url,
-        path: watchingPath,
+        path: viewPath,
         fields,
         token: server.accessToken,
         expectedStatus: HttpStatusCode.NO_CONTENT_204
diff --git a/server/tests/api/check-params/views.ts b/server/tests/api/check-params/views.ts
new file mode 100644
index 000000000..185b04af1
--- /dev/null
+++ b/server/tests/api/check-params/views.ts
@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@shared/server-commands'
+
+describe('Test videos views', function () {
+  let servers: PeerTubeServer[]
+  let liveVideoId: string
+  let videoId: string
+  let remoteVideoId: string
+  let userAccessToken: string
+
+  before(async function () {
+    this.timeout(30000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await servers[0].config.enableLive({ allowReplay: false, transcoding: false });
+
+    ({ uuid: videoId } = await servers[0].videos.quickUpload({ name: 'video' }));
+    ({ uuid: remoteVideoId } = await servers[1].videos.quickUpload({ name: 'video' }));
+    ({ uuid: liveVideoId } = await servers[0].live.create({
+      fields: {
+        name: 'live',
+        privacy: VideoPrivacy.PUBLIC,
+        channelId: servers[0].store.channel.id
+      }
+    }))
+
+    userAccessToken = await servers[0].users.generateUserAndToken('user')
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('When viewing a video', async function () {
+
+    // TODO: implement it when we'll remove backward compatibility in REST API
+    it('Should fail without current time')
+
+    it('Should fail with an invalid current time', async function () {
+      await servers[0].views.view({ id: videoId, currentTime: -1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].views.view({ id: videoId, currentTime: 10, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with correct parameters', async function () {
+      await servers[0].views.view({ id: videoId, currentTime: 1 })
+    })
+  })
+
+  describe('When getting overall stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId: remoteVideoId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId: videoId, token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getOverallStats({
+        videoId: videoId,
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId })
+    })
+  })
+
+  describe('When getting timeserie stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: remoteVideoId,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: videoId,
+        token: null,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: videoId,
+        token: userAccessToken,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail with an invalid metric', async function () {
+      await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'hello' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'viewers' })
+    })
+  })
+
+  describe('When getting retention stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: remoteVideoId,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: videoId,
+        token: null,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: videoId,
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail on live video', async function () {
+      await servers[0].videoStats.getRetentionStats({ videoId: liveVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getRetentionStats({ videoId })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/live/index.ts b/server/tests/api/live/index.ts
index 105416b8d..71bc150d8 100644
--- a/server/tests/api/live/index.ts
+++ b/server/tests/api/live/index.ts
@@ -3,5 +3,4 @@ import './live-socket-messages'
 import './live-permanent'
 import './live-rtmps'
 import './live-save-replay'
-import './live-views'
 import './live'
diff --git a/server/tests/api/live/live-socket-messages.ts b/server/tests/api/live/live-socket-messages.ts
index 50b16443e..7668ed5b9 100644
--- a/server/tests/api/live/live-socket-messages.ts
+++ b/server/tests/api/live/live-socket-messages.ts
@@ -140,8 +140,8 @@ describe('Test live', function () {
       expect(localLastVideoViews).to.equal(0)
       expect(remoteLastVideoViews).to.equal(0)
 
-      await servers[0].videos.view({ id: liveVideoUUID })
-      await servers[1].videos.view({ id: liveVideoUUID })
+      await servers[0].views.simulateView({ id: liveVideoUUID })
+      await servers[1].views.simulateView({ id: liveVideoUUID })
 
       await waitJobs(servers)
 
diff --git a/server/tests/api/live/live-views.ts b/server/tests/api/live/live-views.ts
deleted file mode 100644
index 446d0913c..000000000
--- a/server/tests/api/live/live-views.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-
-import 'mocha'
-import * as chai from 'chai'
-import { FfmpegCommand } from 'fluent-ffmpeg'
-import { wait } from '@shared/core-utils'
-import { VideoPrivacy } from '@shared/models'
-import {
-  cleanupTests,
-  createMultipleServers,
-  doubleFollow,
-  PeerTubeServer,
-  setAccessTokensToServers,
-  setDefaultVideoChannel,
-  stopFfmpeg,
-  waitJobs,
-  waitUntilLivePublishedOnAllServers
-} from '@shared/server-commands'
-
-const expect = chai.expect
-
-describe('Live views', function () {
-  let servers: PeerTubeServer[] = []
-
-  before(async function () {
-    this.timeout(120000)
-
-    servers = await createMultipleServers(2)
-
-    // Get the access tokens
-    await setAccessTokensToServers(servers)
-    await setDefaultVideoChannel(servers)
-
-    await servers[0].config.updateCustomSubConfig({
-      newConfig: {
-        live: {
-          enabled: true,
-          allowReplay: true,
-          transcoding: {
-            enabled: false
-          }
-        }
-      }
-    })
-
-    // Server 1 and server 2 follow each other
-    await doubleFollow(servers[0], servers[1])
-  })
-
-  let liveVideoId: string
-  let command: FfmpegCommand
-
-  async function countViewers (expectedViewers: number) {
-    for (const server of servers) {
-      const video = await server.videos.get({ id: liveVideoId })
-      expect(video.viewers).to.equal(expectedViewers)
-    }
-  }
-
-  async function countViews (expectedViews: number) {
-    for (const server of servers) {
-      const video = await server.videos.get({ id: liveVideoId })
-      expect(video.views).to.equal(expectedViews)
-    }
-  }
-
-  before(async function () {
-    this.timeout(30000)
-
-    const liveAttributes = {
-      name: 'live video',
-      channelId: servers[0].store.channel.id,
-      privacy: VideoPrivacy.PUBLIC
-    }
-
-    const live = await servers[0].live.create({ fields: liveAttributes })
-    liveVideoId = live.uuid
-
-    command = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
-    await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
-    await waitJobs(servers)
-  })
-
-  it('Should display no views and viewers for a live', async function () {
-    await countViews(0)
-    await countViewers(0)
-  })
-
-  it('Should view a live twice and display 1 view/viewer', async function () {
-    this.timeout(30000)
-
-    await servers[0].videos.view({ id: liveVideoId })
-    await servers[0].videos.view({ id: liveVideoId })
-
-    await waitJobs(servers)
-    await countViewers(1)
-
-    await wait(7000)
-    await countViews(1)
-  })
-
-  it('Should wait and display 0 viewers while still have 1 view', async function () {
-    this.timeout(30000)
-
-    await wait(12000)
-    await waitJobs(servers)
-
-    await countViews(1)
-    await countViewers(0)
-  })
-
-  it('Should view a live on a remote and on local and display 2 viewers and 3 views', async function () {
-    this.timeout(30000)
-
-    await servers[0].videos.view({ id: liveVideoId })
-    await servers[1].videos.view({ id: liveVideoId })
-    await servers[1].videos.view({ id: liveVideoId })
-    await waitJobs(servers)
-
-    await countViewers(2)
-
-    await wait(7000)
-    await waitJobs(servers)
-
-    await countViews(3)
-  })
-
-  after(async function () {
-    await stopFfmpeg(command)
-    await cleanupTests(servers)
-  })
-})
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
index 3f2286278..0f7ffcb4c 100644
--- a/server/tests/api/redundancy/redundancy.ts
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -87,7 +87,7 @@ async function createServers (strategy: VideoRedundancyStrategy | null, addition
     const { id } = await servers[1].videos.upload({ attributes: { name: 'video 1 server 2' } })
     video1Server2 = await servers[1].videos.get({ id })
 
-    await servers[1].videos.view({ id })
+    await servers[1].views.simulateView({ id })
   }
 
   await waitJobs(servers)
@@ -447,8 +447,8 @@ describe('Test videos redundancy', function () {
     it('Should view 2 times the first video to have > min_views config', async function () {
       this.timeout(80000)
 
-      await servers[0].videos.view({ id: video1Server2.uuid })
-      await servers[2].videos.view({ id: video1Server2.uuid })
+      await servers[0].views.simulateView({ id: video1Server2.uuid })
+      await servers[2].views.simulateView({ id: video1Server2.uuid })
 
       await wait(10000)
       await waitJobs(servers)
@@ -516,8 +516,8 @@ describe('Test videos redundancy', function () {
     it('Should have 1 redundancy on the first video', async function () {
       this.timeout(160000)
 
-      await servers[0].videos.view({ id: video1Server2.uuid })
-      await servers[2].videos.view({ id: video1Server2.uuid })
+      await servers[0].views.simulateView({ id: video1Server2.uuid })
+      await servers[2].views.simulateView({ id: video1Server2.uuid })
 
       await wait(10000)
       await waitJobs(servers)
diff --git a/server/tests/api/server/reverse-proxy.ts b/server/tests/api/server/reverse-proxy.ts
index 968d98e96..fa2063536 100644
--- a/server/tests/api/server/reverse-proxy.ts
+++ b/server/tests/api/server/reverse-proxy.ts
@@ -41,8 +41,8 @@ describe('Test application behind a reverse proxy', function () {
   it('Should view a video only once with the same IP by default', async function () {
     this.timeout(20000)
 
-    await server.videos.view({ id: videoId })
-    await server.videos.view({ id: videoId })
+    await server.views.simulateView({ id: videoId })
+    await server.views.simulateView({ id: videoId })
 
     // Wait the repeatable job
     await wait(8000)
@@ -54,8 +54,8 @@ describe('Test application behind a reverse proxy', function () {
   it('Should view a video 2 times with the X-Forwarded-For header set', async function () {
     this.timeout(20000)
 
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.1,127.0.0.1' })
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.2,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.1,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.2,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
@@ -67,8 +67,8 @@ describe('Test application behind a reverse proxy', function () {
   it('Should view a video only once with the same client IP in the X-Forwarded-For header', async function () {
     this.timeout(20000)
 
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.4,0.0.0.3,::ffff:127.0.0.1' })
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.5,0.0.0.3,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.4,0.0.0.3,::ffff:127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.5,0.0.0.3,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
@@ -80,8 +80,8 @@ describe('Test application behind a reverse proxy', function () {
   it('Should view a video two times with a different client IP in the X-Forwarded-For header', async function () {
     this.timeout(20000)
 
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.6,127.0.0.1' })
-    await server.videos.view({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.7,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.6,127.0.0.1' })
+    await server.views.simulateView({ id: videoId, xForwardedFor: '0.0.0.8,0.0.0.7,127.0.0.1' })
 
     // Wait the repeatable job
     await wait(8000)
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index 2296c0cb9..a9ae236fb 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -38,7 +38,7 @@ describe('Test stats (excluding redundancy)', function () {
 
     await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
 
-    await servers[0].videos.view({ id: uuid })
+    await servers[0].views.simulateView({ id: uuid })
 
     // Wait the video views repeatable job
     await wait(8000)
diff --git a/server/tests/api/videos/index.ts b/server/tests/api/videos/index.ts
index 7dc826353..27b119f30 100644
--- a/server/tests/api/videos/index.ts
+++ b/server/tests/api/videos/index.ts
@@ -16,4 +16,3 @@ import './video-schedule-update'
 import './videos-common-filters'
 import './videos-history'
 import './videos-overview'
-import './videos-views-cleaner'
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index a9df262dc..84c1515a3 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -504,21 +504,22 @@ describe('Test multiple servers', function () {
     it('Should view multiple videos on owned servers', async function () {
       this.timeout(30000)
 
-      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].views.simulateView({ id: localVideosServer3[0] })
       await wait(1000)
 
-      await servers[2].videos.view({ id: localVideosServer3[0] })
-      await servers[2].videos.view({ id: localVideosServer3[1] })
+      await servers[2].views.simulateView({ id: localVideosServer3[0] })
+      await servers[2].views.simulateView({ id: localVideosServer3[1] })
 
       await wait(1000)
 
-      await servers[2].videos.view({ id: localVideosServer3[0] })
-      await servers[2].videos.view({ id: localVideosServer3[0] })
+      await servers[2].views.simulateView({ id: localVideosServer3[0] })
+      await servers[2].views.simulateView({ id: localVideosServer3[0] })
 
       await waitJobs(servers)
 
-      // Wait the repeatable job
-      await wait(6000)
+      for (const server of servers) {
+        await server.debug.sendCommand({ body: { command: 'process-video-views-buffer' } })
+      }
 
       await waitJobs(servers)
 
@@ -537,23 +538,24 @@ describe('Test multiple servers', function () {
       this.timeout(45000)
 
       const tasks: Promise<any>[] = []
-      tasks.push(servers[0].videos.view({ id: remoteVideosServer1[0] }))
-      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
-      tasks.push(servers[1].videos.view({ id: remoteVideosServer2[0] }))
-      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[0] }))
-      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
-      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
-      tasks.push(servers[2].videos.view({ id: remoteVideosServer3[1] }))
-      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
-      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
-      tasks.push(servers[2].videos.view({ id: localVideosServer3[1] }))
+      tasks.push(servers[0].views.simulateView({ id: remoteVideosServer1[0] }))
+      tasks.push(servers[1].views.simulateView({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[1].views.simulateView({ id: remoteVideosServer2[0] }))
+      tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[0] }))
+      tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].views.simulateView({ id: remoteVideosServer3[1] }))
+      tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
+      tasks.push(servers[2].views.simulateView({ id: localVideosServer3[1] }))
 
       await Promise.all(tasks)
 
       await waitJobs(servers)
 
-      // Wait the repeatable job
-      await wait(16000)
+      for (const server of servers) {
+        await server.debug.sendCommand({ body: { command: 'process-video-views-buffer' } })
+      }
 
       await waitJobs(servers)
 
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index d37043aef..0e429fef7 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -179,22 +179,21 @@ describe('Test a single server', function () {
     it('Should have the views updated', async function () {
       this.timeout(20000)
 
-      await server.videos.view({ id: videoId })
-      await server.videos.view({ id: videoId })
-      await server.videos.view({ id: videoId })
+      await server.views.simulateView({ id: videoId })
+      await server.views.simulateView({ id: videoId })
+      await server.views.simulateView({ id: videoId })
 
       await wait(1500)
 
-      await server.videos.view({ id: videoId })
-      await server.videos.view({ id: videoId })
+      await server.views.simulateView({ id: videoId })
+      await server.views.simulateView({ id: videoId })
 
       await wait(1500)
 
-      await server.videos.view({ id: videoId })
-      await server.videos.view({ id: videoId })
+      await server.views.simulateView({ id: videoId })
+      await server.views.simulateView({ id: videoId })
 
-      // Wait the repeatable job
-      await wait(8000)
+      await server.debug.sendCommand({ body: { command: 'process-video-views-buffer' } })
 
       const video = await server.videos.get({ id: videoId })
       expect(video.views).to.equal(3)
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 09a4bfa70..6f495c42d 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -466,8 +466,8 @@ describe('Test video channels', function () {
 
     {
       // video has been posted on channel servers[0].store.videoChannel.id since last update
-      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.1,127.0.0.1' })
-      await servers[0].videos.view({ id: videoUUID, xForwardedFor: '0.0.0.2,127.0.0.1' })
+      await servers[0].views.simulateView({ id: videoUUID, xForwardedFor: '0.0.0.1,127.0.0.1' })
+      await servers[0].views.simulateView({ id: videoUUID, xForwardedFor: '0.0.0.2,127.0.0.1' })
 
       // Wait the repeatable job
       await wait(8000)
diff --git a/server/tests/api/videos/videos-history.ts b/server/tests/api/videos/videos-history.ts
index 8648c97f0..b1b3ff10a 100644
--- a/server/tests/api/videos/videos-history.ts
+++ b/server/tests/api/videos/videos-history.ts
@@ -3,15 +3,8 @@
 import 'mocha'
 import * as chai from 'chai'
 import { wait } from '@shared/core-utils'
-import { HttpStatusCode, Video } from '@shared/models'
-import {
-  cleanupTests,
-  createSingleServer,
-  HistoryCommand,
-  killallServers,
-  PeerTubeServer,
-  setAccessTokensToServers
-} from '@shared/server-commands'
+import { Video } from '@shared/models'
+import { cleanupTests, createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
 
 const expect = chai.expect
 
@@ -23,7 +16,6 @@ describe('Test videos history', function () {
   let video3UUID: string
   let video3WatchedDate: Date
   let userAccessToken: string
-  let command: HistoryCommand
 
   before(async function () {
     this.timeout(30000)
@@ -32,30 +24,26 @@ describe('Test videos history', function () {
 
     await setAccessTokensToServers([ server ])
 
-    command = server.history
+    // 10 seconds long
+    const fixture = 'video_59fps.mp4'
 
     {
-      const { id, uuid } = await server.videos.upload({ attributes: { name: 'video 1' } })
+      const { id, uuid } = await server.videos.upload({ attributes: { name: 'video 1', fixture } })
       video1UUID = uuid
       video1Id = id
     }
 
     {
-      const { uuid } = await server.videos.upload({ attributes: { name: 'video 2' } })
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 2', fixture } })
       video2UUID = uuid
     }
 
     {
-      const { uuid } = await server.videos.upload({ attributes: { name: 'video 3' } })
+      const { uuid } = await server.videos.upload({ attributes: { name: 'video 3', fixture } })
       video3UUID = uuid
     }
 
-    const user = {
-      username: 'user_1',
-      password: 'super password'
-    }
-    await server.users.create({ username: user.username, password: user.password })
-    userAccessToken = await server.login.getAccessToken(user)
+    userAccessToken = await server.users.generateUserAndToken('user_1')
   })
 
   it('Should get videos, without watching history', async function () {
@@ -70,8 +58,8 @@ describe('Test videos history', function () {
   })
 
   it('Should watch the first and second video', async function () {
-    await command.watchVideo({ videoId: video2UUID, currentTime: 8 })
-    await command.watchVideo({ videoId: video1UUID, currentTime: 3 })
+    await server.views.view({ id: video2UUID, token: server.accessToken, currentTime: 8 })
+    await server.views.view({ id: video1UUID, token: server.accessToken, currentTime: 3 })
   })
 
   it('Should return the correct history when listing, searching and getting videos', async function () {
@@ -124,9 +112,9 @@ describe('Test videos history', function () {
 
   it('Should have these videos when listing my history', async function () {
     video3WatchedDate = new Date()
-    await command.watchVideo({ videoId: video3UUID, currentTime: 2 })
+    await server.views.view({ id: video3UUID, token: server.accessToken, currentTime: 2 })
 
-    const body = await command.list()
+    const body = await server.history.list()
 
     expect(body.total).to.equal(3)
 
@@ -137,14 +125,14 @@ describe('Test videos history', function () {
   })
 
   it('Should not have videos history on another user', async function () {
-    const body = await command.list({ token: userAccessToken })
+    const body = await server.history.list({ token: userAccessToken })
 
     expect(body.total).to.equal(0)
     expect(body.data).to.have.lengthOf(0)
   })
 
   it('Should be able to search through videos in my history', async function () {
-    const body = await command.list({ search: '2' })
+    const body = await server.history.list({ search: '2' })
     expect(body.total).to.equal(1)
 
     const videos = body.data
@@ -152,11 +140,11 @@ describe('Test videos history', function () {
   })
 
   it('Should clear my history', async function () {
-    await command.removeAll({ beforeDate: video3WatchedDate.toISOString() })
+    await server.history.removeAll({ beforeDate: video3WatchedDate.toISOString() })
   })
 
   it('Should have my history cleared', async function () {
-    const body = await command.list()
+    const body = await server.history.list()
     expect(body.total).to.equal(1)
 
     const videos = body.data
@@ -168,7 +156,10 @@ describe('Test videos history', function () {
       videosHistoryEnabled: false
     })
 
-    await command.watchVideo({ videoId: video2UUID, currentTime: 8, expectedStatus: HttpStatusCode.CONFLICT_409 })
+    await server.views.view({ id: video2UUID, token: server.accessToken, currentTime: 8 })
+
+    const { data } = await server.history.list()
+    expect(data[0].name).to.not.equal('video 2')
   })
 
   it('Should re-enable videos history', async function () {
@@ -176,14 +167,10 @@ describe('Test videos history', function () {
       videosHistoryEnabled: true
     })
 
-    await command.watchVideo({ videoId: video1UUID, currentTime: 8 })
+    await server.views.view({ id: video2UUID, token: server.accessToken, currentTime: 8 })
 
-    const body = await command.list()
-    expect(body.total).to.equal(2)
-
-    const videos = body.data
-    expect(videos[0].name).to.equal('video 1')
-    expect(videos[1].name).to.equal('video 3')
+    const { data } = await server.history.list()
+    expect(data[0].name).to.equal('video 2')
   })
 
   it('Should not clean old history', async function () {
@@ -197,7 +184,7 @@ describe('Test videos history', function () {
 
     // Should still have history
 
-    const body = await command.list()
+    const body = await server.history.list()
     expect(body.total).to.equal(2)
   })
 
@@ -210,25 +197,25 @@ describe('Test videos history', function () {
 
     await wait(6000)
 
-    const body = await command.list()
+    const body = await server.history.list()
     expect(body.total).to.equal(0)
   })
 
   it('Should delete a specific history element', async function () {
     {
-      await command.watchVideo({ videoId: video1UUID, currentTime: 4 })
-      await command.watchVideo({ videoId: video2UUID, currentTime: 8 })
+      await server.views.view({ id: video1UUID, token: server.accessToken, currentTime: 4 })
+      await server.views.view({ id: video2UUID, token: server.accessToken, currentTime: 8 })
     }
 
     {
-      const body = await command.list()
+      const body = await server.history.list()
       expect(body.total).to.equal(2)
     }
 
     {
-      await command.removeElement({ videoId: video1Id })
+      await server.history.removeElement({ videoId: video1Id })
 
-      const body = await command.list()
+      const body = await server.history.list()
       expect(body.total).to.equal(1)
       expect(body.data[0].uuid).to.equal(video2UUID)
     }
diff --git a/server/tests/api/views/index.ts b/server/tests/api/views/index.ts
new file mode 100644
index 000000000..5e06b31fb
--- /dev/null
+++ b/server/tests/api/views/index.ts
@@ -0,0 +1,5 @@
+export * from './video-views-counter'
+export * from './video-views-overall-stats'
+export * from './video-views-retention-stats'
+export * from './video-views-timeserie-stats'
+export * from './videos-views-cleaner'
diff --git a/server/tests/api/views/video-views-counter.ts b/server/tests/api/views/video-views-counter.ts
new file mode 100644
index 000000000..b68aaa350
--- /dev/null
+++ b/server/tests/api/views/video-views-counter.ts
@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import * as chai from 'chai'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { prepareViewsServers, prepareViewsVideos, processViewsBuffer } from '@server/tests/shared'
+import { wait } from '@shared/core-utils'
+import { cleanupTests, PeerTubeServer, stopFfmpeg, waitJobs } from '@shared/server-commands'
+
+const expect = chai.expect
+
+describe('Test video views/viewers counters', function () {
+  let servers: PeerTubeServer[]
+
+  async function checkCounter (field: 'views' | 'viewers', id: string, expected: number) {
+    for (const server of servers) {
+      const video = await server.videos.get({ id })
+
+      const messageSuffix = video.isLive
+        ? 'live video'
+        : 'vod video'
+
+      expect(video[field]).to.equal(expected, `${field} not valid on server ${server.serverNumber} for ${messageSuffix} ${video.uuid}`)
+    }
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await prepareViewsServers()
+  })
+
+  describe('Test views counter on VOD', function () {
+    let videoUUID: string
+
+    before(async function () {
+      this.timeout(30000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
+      videoUUID = uuid
+
+      await waitJobs(servers)
+    })
+
+    it('Should not view a video if watch time is below the threshold', async function () {
+      await servers[0].views.simulateViewer({ id: videoUUID, currentTimes: [ 1, 2 ] })
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', videoUUID, 0)
+    })
+
+    it('Should view a video if watch time is above the threshold', async function () {
+      await servers[0].views.simulateViewer({ id: videoUUID, currentTimes: [ 1, 4 ] })
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', videoUUID, 1)
+    })
+
+    it('Should not view again this video with the same IP', async function () {
+      await servers[0].views.simulateViewer({ id: videoUUID, currentTimes: [ 1, 4 ] })
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', videoUUID, 1)
+    })
+
+    it('Should view the video from server 2 and send the event', async function () {
+      await servers[1].views.simulateViewer({ id: videoUUID, currentTimes: [ 1, 4 ] })
+      await waitJobs(servers)
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', videoUUID, 2)
+    })
+  })
+
+  describe('Test views and viewers counters on live and VOD', function () {
+    let liveVideoId: string
+    let vodVideoId: string
+    let command: FfmpegCommand
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId, liveVideoId, ffmpegCommand: command } = await prepareViewsVideos({ servers, live: true, vod: true }))
+    })
+
+    it('Should display no views and viewers', async function () {
+      await checkCounter('views', liveVideoId, 0)
+      await checkCounter('viewers', liveVideoId, 0)
+
+      await checkCounter('views', vodVideoId, 0)
+      await checkCounter('viewers', vodVideoId, 0)
+    })
+
+    it('Should view twice and display 1 view/viewer', async function () {
+      this.timeout(30000)
+
+      await servers[0].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35 ] })
+      await servers[0].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35 ] })
+      await servers[0].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+      await servers[0].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+
+      await waitJobs(servers)
+      await checkCounter('viewers', liveVideoId, 1)
+      await checkCounter('viewers', vodVideoId, 1)
+
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', liveVideoId, 1)
+      await checkCounter('views', vodVideoId, 1)
+    })
+
+    it('Should wait and display 0 viewers but still have 1 view', async function () {
+      this.timeout(30000)
+
+      await wait(12000)
+      await waitJobs(servers)
+
+      await checkCounter('views', liveVideoId, 1)
+      await checkCounter('viewers', liveVideoId, 0)
+
+      await checkCounter('views', vodVideoId, 1)
+      await checkCounter('viewers', vodVideoId, 0)
+    })
+
+    it('Should view on a remote and on local and display 2 viewers and 3 views', async function () {
+      this.timeout(30000)
+
+      await servers[0].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+      await servers[1].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+      await servers[1].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+
+      await servers[0].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35 ] })
+      await servers[1].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35 ] })
+      await servers[1].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35 ] })
+
+      await waitJobs(servers)
+
+      await checkCounter('viewers', liveVideoId, 2)
+      await checkCounter('viewers', vodVideoId, 2)
+
+      await processViewsBuffer(servers)
+
+      await checkCounter('views', liveVideoId, 3)
+      await checkCounter('views', vodVideoId, 3)
+    })
+
+    after(async function () {
+      await stopFfmpeg(command)
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/views/video-views-overall-stats.ts b/server/tests/api/views/video-views-overall-stats.ts
new file mode 100644
index 000000000..22761d6ec
--- /dev/null
+++ b/server/tests/api/views/video-views-overall-stats.ts
@@ -0,0 +1,291 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import * as chai from 'chai'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { prepareViewsServers, prepareViewsVideos, processViewersStats } from '@server/tests/shared'
+import { cleanupTests, PeerTubeServer, stopFfmpeg, waitJobs } from '@shared/server-commands'
+
+const expect = chai.expect
+
+describe('Test views overall stats', function () {
+  let servers: PeerTubeServer[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await prepareViewsServers()
+  })
+
+  describe('Test rates and comments of local videos on VOD', function () {
+    let vodVideoId: string
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId } = await prepareViewsVideos({ servers, live: false, vod: true }))
+    })
+
+    it('Should have the appropriate likes', async function () {
+      this.timeout(60000)
+
+      await servers[0].videos.rate({ id: vodVideoId, rating: 'like' })
+      await servers[1].videos.rate({ id: vodVideoId, rating: 'like' })
+
+      await waitJobs(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+
+      expect(stats.likes).to.equal(2)
+      expect(stats.dislikes).to.equal(0)
+    })
+
+    it('Should have the appropriate dislikes', async function () {
+      this.timeout(60000)
+
+      await servers[0].videos.rate({ id: vodVideoId, rating: 'dislike' })
+      await servers[1].videos.rate({ id: vodVideoId, rating: 'dislike' })
+
+      await waitJobs(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+
+      expect(stats.likes).to.equal(0)
+      expect(stats.dislikes).to.equal(2)
+    })
+
+    it('Should have the appropriate comments', async function () {
+      this.timeout(60000)
+
+      await servers[0].comments.createThread({ videoId: vodVideoId, text: 'root' })
+      await servers[0].comments.addReplyToLastThread({ text: 'reply' })
+      await servers[1].comments.createThread({ videoId: vodVideoId, text: 'root' })
+
+      await waitJobs(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+      expect(stats.comments).to.equal(3)
+    })
+  })
+
+  describe('Test watch time stats of local videos on live and VOD', function () {
+    let vodVideoId: string
+    let liveVideoId: string
+    let command: FfmpegCommand
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId, liveVideoId, ffmpegCommand: command } = await prepareViewsVideos({ servers, live: true, vod: true }))
+    })
+
+    it('Should display overall stats of a video with no viewers', async function () {
+      for (const videoId of [ liveVideoId, vodVideoId ]) {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId })
+
+        expect(stats.views).to.equal(0)
+        expect(stats.averageWatchTime).to.equal(0)
+        expect(stats.totalWatchTime).to.equal(0)
+      }
+    })
+
+    it('Should display overall stats with 1 viewer below the watch time limit', async function () {
+      this.timeout(60000)
+
+      for (const videoId of [ liveVideoId, vodVideoId ]) {
+        await servers[0].views.simulateViewer({ id: videoId, currentTimes: [ 0, 1 ] })
+      }
+
+      await processViewersStats(servers)
+
+      for (const videoId of [ liveVideoId, vodVideoId ]) {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId })
+
+        expect(stats.views).to.equal(0)
+        expect(stats.averageWatchTime).to.equal(1)
+        expect(stats.totalWatchTime).to.equal(1)
+      }
+    })
+
+    it('Should display overall stats with 2 viewers', async function () {
+      this.timeout(60000)
+
+      {
+        await servers[0].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 3 ] })
+        await servers[0].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35, 40 ] })
+
+        await processViewersStats(servers)
+
+        {
+          const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+          expect(stats.views).to.equal(1)
+          expect(stats.averageWatchTime).to.equal(2)
+          expect(stats.totalWatchTime).to.equal(4)
+        }
+
+        {
+          const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
+          expect(stats.views).to.equal(1)
+          expect(stats.averageWatchTime).to.equal(21)
+          expect(stats.totalWatchTime).to.equal(41)
+        }
+      }
+    })
+
+    it('Should display overall stats with a remote viewer below the watch time limit', async function () {
+      this.timeout(60000)
+
+      for (const videoId of [ liveVideoId, vodVideoId ]) {
+        await servers[1].views.simulateViewer({ id: videoId, currentTimes: [ 0, 2 ] })
+      }
+
+      await processViewersStats(servers)
+
+      {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+
+        expect(stats.views).to.equal(1)
+        expect(stats.averageWatchTime).to.equal(2)
+        expect(stats.totalWatchTime).to.equal(6)
+      }
+
+      {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
+
+        expect(stats.views).to.equal(1)
+        expect(stats.averageWatchTime).to.equal(14)
+        expect(stats.totalWatchTime).to.equal(43)
+      }
+    })
+
+    it('Should display overall stats with a remote viewer above the watch time limit', async function () {
+      this.timeout(60000)
+
+      await servers[1].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
+      await servers[1].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 45 ] })
+      await processViewersStats(servers)
+
+      {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
+        expect(stats.views).to.equal(2)
+        expect(stats.averageWatchTime).to.equal(3)
+        expect(stats.totalWatchTime).to.equal(11)
+      }
+
+      {
+        const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
+        expect(stats.views).to.equal(2)
+        expect(stats.averageWatchTime).to.equal(22)
+        expect(stats.totalWatchTime).to.equal(88)
+      }
+    })
+
+    after(async function () {
+      await stopFfmpeg(command)
+    })
+  })
+
+  describe('Test watchers peak stats of local videos on VOD', function () {
+    let videoUUID: string
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId: videoUUID } = await prepareViewsVideos({ servers, live: true, vod: true }))
+    })
+
+    it('Should not have watchers peak', async function () {
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
+
+      expect(stats.viewersPeak).to.equal(0)
+      expect(stats.viewersPeakDate).to.be.null
+    })
+
+    it('Should have watcher peak with 1 watcher', async function () {
+      this.timeout(60000)
+
+      const before = new Date()
+      await servers[0].views.simulateViewer({ id: videoUUID, currentTimes: [ 0, 2 ] })
+      const after = new Date()
+
+      await processViewersStats(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
+
+      expect(stats.viewersPeak).to.equal(1)
+      expect(new Date(stats.viewersPeakDate)).to.be.above(before).and.below(after)
+    })
+
+    it('Should have watcher peak with 2 watchers', async function () {
+      this.timeout(60000)
+
+      const before = new Date()
+      await servers[0].views.view({ id: videoUUID, currentTime: 0 })
+      await servers[1].views.view({ id: videoUUID, currentTime: 0 })
+      await servers[0].views.view({ id: videoUUID, currentTime: 2 })
+      await servers[1].views.view({ id: videoUUID, currentTime: 2 })
+      const after = new Date()
+
+      await processViewersStats(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
+
+      expect(stats.viewersPeak).to.equal(2)
+      expect(new Date(stats.viewersPeakDate)).to.be.above(before).and.below(after)
+    })
+  })
+
+  describe('Test countries', function () {
+
+    it('Should not report countries if geoip is disabled', async function () {
+      this.timeout(60000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
+      await waitJobs(servers)
+
+      await servers[1].views.view({ id: uuid, xForwardedFor: '8.8.8.8,127.0.0.1', currentTime: 1 })
+
+      await processViewersStats(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: uuid })
+      expect(stats.countries).to.have.lengthOf(0)
+    })
+
+    it('Should report countries if geoip is enabled', async function () {
+      this.timeout(60000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
+      await waitJobs(servers)
+
+      await Promise.all([
+        servers[0].kill(),
+        servers[1].kill()
+      ])
+
+      const config = { geo_ip: { enabled: true } }
+      await Promise.all([
+        servers[0].run(config),
+        servers[1].run(config)
+      ])
+
+      await servers[0].views.view({ id: uuid, xForwardedFor: '8.8.8.8,127.0.0.1', currentTime: 1 })
+      await servers[1].views.view({ id: uuid, xForwardedFor: '8.8.8.4,127.0.0.1', currentTime: 3 })
+      await servers[1].views.view({ id: uuid, xForwardedFor: '80.67.169.12,127.0.0.1', currentTime: 2 })
+
+      await processViewersStats(servers)
+
+      const stats = await servers[0].videoStats.getOverallStats({ videoId: uuid })
+      expect(stats.countries).to.have.lengthOf(2)
+
+      expect(stats.countries[0].isoCode).to.equal('US')
+      expect(stats.countries[0].viewers).to.equal(2)
+
+      expect(stats.countries[1].isoCode).to.equal('FR')
+      expect(stats.countries[1].viewers).to.equal(1)
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/views/video-views-retention-stats.ts b/server/tests/api/views/video-views-retention-stats.ts
new file mode 100644
index 000000000..98be7bfdb
--- /dev/null
+++ b/server/tests/api/views/video-views-retention-stats.ts
@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import * as chai from 'chai'
+import { prepareViewsServers, prepareViewsVideos, processViewersStats } from '@server/tests/shared'
+import { cleanupTests, PeerTubeServer } from '@shared/server-commands'
+
+const expect = chai.expect
+
+describe('Test views retention stats', function () {
+  let servers: PeerTubeServer[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await prepareViewsServers()
+  })
+
+  describe('Test retention stats on VOD', function () {
+    let vodVideoId: string
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId } = await prepareViewsVideos({ servers, live: false, vod: true }))
+    })
+
+    it('Should display empty retention', async function () {
+      const { data } = await servers[0].videoStats.getRetentionStats({ videoId: vodVideoId })
+      expect(data).to.have.lengthOf(6)
+
+      for (let i = 0; i < 6; i++) {
+        expect(data[i].second).to.equal(i)
+        expect(data[i].retentionPercent).to.equal(0)
+      }
+    })
+
+    it('Should display appropriate retention metrics', async function () {
+      await servers[0].views.simulateViewer({ xForwardedFor: '127.0.0.2,127.0.0.1', id: vodVideoId, currentTimes: [ 0, 1 ] })
+      await servers[0].views.simulateViewer({ xForwardedFor: '127.0.0.3,127.0.0.1', id: vodVideoId, currentTimes: [ 1, 3 ] })
+      await servers[1].views.simulateViewer({ xForwardedFor: '127.0.0.2,127.0.0.1', id: vodVideoId, currentTimes: [ 4 ] })
+      await servers[1].views.simulateViewer({ xForwardedFor: '127.0.0.3,127.0.0.1', id: vodVideoId, currentTimes: [ 0, 1 ] })
+
+      await processViewersStats(servers)
+
+      const { data } = await servers[0].videoStats.getRetentionStats({ videoId: vodVideoId })
+      expect(data).to.have.lengthOf(6)
+
+      expect(data.map(d => d.retentionPercent)).to.deep.equal([ 50, 75, 25, 25, 25, 0 ])
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/views/video-views-timeserie-stats.ts b/server/tests/api/views/video-views-timeserie-stats.ts
new file mode 100644
index 000000000..98c041cdf
--- /dev/null
+++ b/server/tests/api/views/video-views-timeserie-stats.ts
@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import * as chai from 'chai'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { prepareViewsServers, prepareViewsVideos, processViewersStats } from '@server/tests/shared'
+import { VideoStatsTimeserie, VideoStatsTimeserieMetric } from '@shared/models'
+import { cleanupTests, PeerTubeServer, stopFfmpeg } from '@shared/server-commands'
+
+const expect = chai.expect
+
+describe('Test views timeserie stats', function () {
+  const availableMetrics: VideoStatsTimeserieMetric[] = [ 'viewers' ]
+
+  let servers: PeerTubeServer[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await prepareViewsServers()
+  })
+
+  describe('Common metric tests', function () {
+    let vodVideoId: string
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId } = await prepareViewsVideos({ servers, live: false, vod: true }))
+    })
+
+    it('Should display empty metric stats', async function () {
+      for (const metric of availableMetrics) {
+        const { data } = await servers[0].videoStats.getTimeserieStats({ videoId: vodVideoId, metric })
+
+        expect(data).to.have.lengthOf(30)
+
+        for (const d of data) {
+          expect(d.value).to.equal(0)
+        }
+      }
+    })
+  })
+
+  describe('Test viewer and watch time metrics on live and VOD', function () {
+    let vodVideoId: string
+    let liveVideoId: string
+    let command: FfmpegCommand
+
+    function expectTimeserieData (result: VideoStatsTimeserie, lastValue: number) {
+      const { data } = result
+      expect(data).to.have.lengthOf(30)
+
+      const last = data[data.length - 1]
+
+      const today = new Date().getDate()
+      expect(new Date(last.date).getDate()).to.equal(today)
+      expect(last.value).to.equal(lastValue)
+
+      for (let i = 0; i < data.length - 2; i++) {
+        expect(data[i].value).to.equal(0)
+      }
+    }
+
+    before(async function () {
+      this.timeout(60000);
+
+      ({ vodVideoId, liveVideoId, ffmpegCommand: command } = await prepareViewsVideos({ servers, live: true, vod: true }))
+    })
+
+    it('Should display appropriate viewers metrics', async function () {
+      for (const videoId of [ vodVideoId, liveVideoId ]) {
+        await servers[0].views.simulateViewer({ id: videoId, currentTimes: [ 0, 3 ] })
+        await servers[1].views.simulateViewer({ id: videoId, currentTimes: [ 0, 5 ] })
+      }
+
+      await processViewersStats(servers)
+
+      for (const videoId of [ vodVideoId, liveVideoId ]) {
+        const result = await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'viewers' })
+        expectTimeserieData(result, 2)
+      }
+    })
+
+    it('Should display appropriate watch time metrics', async function () {
+      for (const videoId of [ vodVideoId, liveVideoId ]) {
+        const result = await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'aggregateWatchTime' })
+        expectTimeserieData(result, 8)
+
+        await servers[1].views.simulateViewer({ id: videoId, currentTimes: [ 0, 1 ] })
+      }
+
+      await processViewersStats(servers)
+
+      for (const videoId of [ vodVideoId, liveVideoId ]) {
+        const result = await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'aggregateWatchTime' })
+        expectTimeserieData(result, 9)
+      }
+    })
+
+    after(async function () {
+      await stopFfmpeg(command)
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/videos/videos-views-cleaner.ts b/server/tests/api/views/videos-views-cleaner.ts
index e6815a4a8..ef988837f 100644
--- a/server/tests/api/videos/videos-views-cleaner.ts
+++ b/server/tests/api/views/videos-views-cleaner.ts
@@ -34,10 +34,10 @@ describe('Test video views cleaner', function () {
 
     await waitJobs(servers)
 
-    await servers[0].videos.view({ id: videoIdServer1 })
-    await servers[1].videos.view({ id: videoIdServer1 })
-    await servers[0].videos.view({ id: videoIdServer2 })
-    await servers[1].videos.view({ id: videoIdServer2 })
+    await servers[0].views.simulateView({ id: videoIdServer1 })
+    await servers[1].views.simulateView({ id: videoIdServer1 })
+    await servers[0].views.simulateView({ id: videoIdServer2 })
+    await servers[1].views.simulateView({ id: videoIdServer2 })
 
     await waitJobs(servers)
   })