server/tests/api/views/video-views-overall-stats.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import { FfmpegCommand } from 'fluent-ffmpeg'
   6 import { prepareViewsServers, prepareViewsVideos, processViewersStats } from '@server/tests/shared'
   7 import { cleanupTests, PeerTubeServer, stopFfmpeg, waitJobs } from '@shared/server-commands'
   8
   9 const expect = chai.expect
  10
  11 describe('Test views overall stats', function () {
  12   let servers: PeerTubeServer[]
  13
  14   before(async function () {
  15     this.timeout(120000)
  16
  17     servers = await prepareViewsServers()
  18   })
  19
  20   describe('Test watch time stats of local videos on live and VOD', function () {
  21     let vodVideoId: string
  22     let liveVideoId: string
  23     let command: FfmpegCommand
  24
  25     before(async function () {
  26       this.timeout(120000);
  27
  28       ({ vodVideoId, liveVideoId, ffmpegCommand: command } = await prepareViewsVideos({ servers, live: true, vod: true }))
  29     })
  30
  31     it('Should display overall stats of a video with no viewers', async function () {
  32       for (const videoId of [ liveVideoId, vodVideoId ]) {
  33         const stats = await servers[0].videoStats.getOverallStats({ videoId })
  34         const video = await servers[0].videos.get({ id: videoId })
  35
  36         expect(video.views).to.equal(0)
  37         expect(stats.averageWatchTime).to.equal(0)
  38         expect(stats.totalWatchTime).to.equal(0)
  39       }
  40     })
  41
  42     it('Should display overall stats with 1 viewer below the watch time limit', async function () {
  43       this.timeout(60000)
  44
  45       for (const videoId of [ liveVideoId, vodVideoId ]) {
  46         await servers[0].views.simulateViewer({ id: videoId, currentTimes: [ 0, 1 ] })
  47       }
  48
  49       await processViewersStats(servers)
  50
  51       for (const videoId of [ liveVideoId, vodVideoId ]) {
  52         const stats = await servers[0].videoStats.getOverallStats({ videoId })
  53         const video = await servers[0].videos.get({ id: videoId })
  54
  55         expect(video.views).to.equal(0)
  56         expect(stats.averageWatchTime).to.equal(1)
  57         expect(stats.totalWatchTime).to.equal(1)
  58       }
  59     })
  60
  61     it('Should display overall stats with 2 viewers', async function () {
  62       this.timeout(60000)
  63
  64       {
  65         await servers[0].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 3 ] })
  66         await servers[0].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 35, 40 ] })
  67
  68         await processViewersStats(servers)
  69
  70         {
  71           const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
  72           const video = await servers[0].videos.get({ id: vodVideoId })
  73
  74           expect(video.views).to.equal(1)
  75           expect(stats.averageWatchTime).to.equal(2)
  76           expect(stats.totalWatchTime).to.equal(4)
  77         }
  78
  79         {
  80           const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
  81           const video = await servers[0].videos.get({ id: liveVideoId })
  82
  83           expect(video.views).to.equal(1)
  84           expect(stats.averageWatchTime).to.equal(21)
  85           expect(stats.totalWatchTime).to.equal(41)
  86         }
  87       }
  88     })
  89
  90     it('Should display overall stats with a remote viewer below the watch time limit', async function () {
  91       this.timeout(60000)
  92
  93       for (const videoId of [ liveVideoId, vodVideoId ]) {
  94         await servers[1].views.simulateViewer({ id: videoId, currentTimes: [ 0, 2 ] })
  95       }
  96
  97       await processViewersStats(servers)
  98
  99       {
 100         const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
 101         const video = await servers[0].videos.get({ id: vodVideoId })
 102
 103         expect(video.views).to.equal(1)
 104         expect(stats.averageWatchTime).to.equal(2)
 105         expect(stats.totalWatchTime).to.equal(6)
 106       }
 107
 108       {
 109         const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
 110         const video = await servers[0].videos.get({ id: liveVideoId })
 111
 112         expect(video.views).to.equal(1)
 113         expect(stats.averageWatchTime).to.equal(14)
 114         expect(stats.totalWatchTime).to.equal(43)
 115       }
 116     })
 117
 118     it('Should display overall stats with a remote viewer above the watch time limit', async function () {
 119       this.timeout(60000)
 120
 121       await servers[1].views.simulateViewer({ id: vodVideoId, currentTimes: [ 0, 5 ] })
 122       await servers[1].views.simulateViewer({ id: liveVideoId, currentTimes: [ 0, 45 ] })
 123       await processViewersStats(servers)
 124
 125       {
 126         const stats = await servers[0].videoStats.getOverallStats({ videoId: vodVideoId })
 127         const video = await servers[0].videos.get({ id: vodVideoId })
 128
 129         expect(video.views).to.equal(2)
 130         expect(stats.averageWatchTime).to.equal(3)
 131         expect(stats.totalWatchTime).to.equal(11)
 132       }
 133
 134       {
 135         const stats = await servers[0].videoStats.getOverallStats({ videoId: liveVideoId })
 136         const video = await servers[0].videos.get({ id: liveVideoId })
 137
 138         expect(video.views).to.equal(2)
 139         expect(stats.averageWatchTime).to.equal(22)
 140         expect(stats.totalWatchTime).to.equal(88)
 141       }
 142     })
 143
 144     after(async function () {
 145       await stopFfmpeg(command)
 146     })
 147   })
 148
 149   describe('Test watchers peak stats of local videos on VOD', function () {
 150     let videoUUID: string
 151
 152     before(async function () {
 153       this.timeout(120000);
 154
 155       ({ vodVideoId: videoUUID } = await prepareViewsVideos({ servers, live: true, vod: true }))
 156     })
 157
 158     it('Should not have watchers peak', async function () {
 159       const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
 160
 161       expect(stats.viewersPeak).to.equal(0)
 162       expect(stats.viewersPeakDate).to.be.null
 163     })
 164
 165     it('Should have watcher peak with 1 watcher', async function () {
 166       this.timeout(60000)
 167
 168       const before = new Date()
 169       await servers[0].views.simulateViewer({ id: videoUUID, currentTimes: [ 0, 2 ] })
 170       const after = new Date()
 171
 172       await processViewersStats(servers)
 173
 174       const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
 175
 176       expect(stats.viewersPeak).to.equal(1)
 177       expect(new Date(stats.viewersPeakDate)).to.be.above(before).and.below(after)
 178     })
 179
 180     it('Should have watcher peak with 2 watchers', async function () {
 181       this.timeout(60000)
 182
 183       const before = new Date()
 184       await servers[0].views.view({ id: videoUUID, currentTime: 0 })
 185       await servers[1].views.view({ id: videoUUID, currentTime: 0 })
 186       await servers[0].views.view({ id: videoUUID, currentTime: 2 })
 187       await servers[1].views.view({ id: videoUUID, currentTime: 2 })
 188       const after = new Date()
 189
 190       await processViewersStats(servers)
 191
 192       const stats = await servers[0].videoStats.getOverallStats({ videoId: videoUUID })
 193
 194       expect(stats.viewersPeak).to.equal(2)
 195       expect(new Date(stats.viewersPeakDate)).to.be.above(before).and.below(after)
 196     })
 197   })
 198
 199   describe('Test countries', function () {
 200
 201     it('Should not report countries if geoip is disabled', async function () {
 202       this.timeout(120000)
 203
 204       const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
 205       await waitJobs(servers)
 206
 207       await servers[1].views.view({ id: uuid, xForwardedFor: '8.8.8.8,127.0.0.1', currentTime: 1 })
 208
 209       await processViewersStats(servers)
 210
 211       const stats = await servers[0].videoStats.getOverallStats({ videoId: uuid })
 212       expect(stats.countries).to.have.lengthOf(0)
 213     })
 214
 215     it('Should report countries if geoip is enabled', async function () {
 216       this.timeout(240000)
 217
 218       const { uuid } = await servers[0].videos.quickUpload({ name: 'video' })
 219       await waitJobs(servers)
 220
 221       await Promise.all([
 222         servers[0].kill(),
 223         servers[1].kill()
 224       ])
 225
 226       const config = { geo_ip: { enabled: true } }
 227       await Promise.all([
 228         servers[0].run(config),
 229         servers[1].run(config)
 230       ])
 231
 232       await servers[0].views.view({ id: uuid, xForwardedFor: '8.8.8.8,127.0.0.1', currentTime: 1 })
 233       await servers[1].views.view({ id: uuid, xForwardedFor: '8.8.8.4,127.0.0.1', currentTime: 3 })
 234       await servers[1].views.view({ id: uuid, xForwardedFor: '80.67.169.12,127.0.0.1', currentTime: 2 })
 235
 236       await processViewersStats(servers)
 237
 238       const stats = await servers[0].videoStats.getOverallStats({ videoId: uuid })
 239       expect(stats.countries).to.have.lengthOf(2)
 240
 241       expect(stats.countries[0].isoCode).to.equal('US')
 242       expect(stats.countries[0].viewers).to.equal(2)
 243
 244       expect(stats.countries[1].isoCode).to.equal('FR')
 245       expect(stats.countries[1].viewers).to.equal(1)
 246     })
 247   })
 248
 249   after(async function () {
 250     await cleanupTests(servers)
 251   })
 252 })