]> git.immae.eu Git - github/Chocobozzz/PeerTube.git/blob - server/tests/api/views/video-views-overall-stats.ts
72b072c963dd31e2382aea79a8d20f19e4c08293
[github/Chocobozzz/PeerTube.git] / 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 })