server/tests/api/server/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 {
   6   addVideoChannel,
   7   addVideoCommentThread,
   8   cleanupTests,
   9   createUser,
  10   doubleFollow,
  11   flushAndRunMultipleServers,
  12   ServerInfo,
  13   setAccessTokensToServers,
  14   uploadVideo,
  15   userLogin,
  16   viewVideo,
  17   wait,
  18   waitJobs
  19 } from '@shared/extra-utils'
  20 import { ActivityType, VideoPlaylistPrivacy } from '@shared/models'
  21
  22 const expect = chai.expect
  23
  24 describe('Test stats (excluding redundancy)', function () {
  25   let servers: ServerInfo[] = []
  26   let channelId
  27   const user = {
  28     username: 'user1',
  29     password: 'super_password'
  30   }
  31
  32   before(async function () {
  33     this.timeout(60000)
  34
  35     servers = await flushAndRunMultipleServers(3)
  36
  37     await setAccessTokensToServers(servers)
  38
  39     await doubleFollow(servers[0], servers[1])
  40
  41     await createUser({ url: servers[0].url, accessToken: servers[0].accessToken, username: user.username, password: user.password })
  42
  43     const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { fixture: 'video_short.webm' })
  44     const videoUUID = resVideo.body.video.uuid
  45
  46     await addVideoCommentThread(servers[0].url, servers[0].accessToken, videoUUID, 'comment')
  47
  48     await viewVideo(servers[0].url, videoUUID)
  49
  50     // Wait the video views repeatable job
  51     await wait(8000)
  52
  53     await servers[2].followsCommand.follow({ targets: [ servers[0].url ] })
  54     await waitJobs(servers)
  55   })
  56
  57   it('Should have the correct stats on instance 1', async function () {
  58     const data = await servers[0].statsCommand.get()
  59
  60     expect(data.totalLocalVideoComments).to.equal(1)
  61     expect(data.totalLocalVideos).to.equal(1)
  62     expect(data.totalLocalVideoViews).to.equal(1)
  63     expect(data.totalLocalVideoFilesSize).to.equal(218910)
  64     expect(data.totalUsers).to.equal(2)
  65     expect(data.totalVideoComments).to.equal(1)
  66     expect(data.totalVideos).to.equal(1)
  67     expect(data.totalInstanceFollowers).to.equal(2)
  68     expect(data.totalInstanceFollowing).to.equal(1)
  69     expect(data.totalLocalPlaylists).to.equal(0)
  70   })
  71
  72   it('Should have the correct stats on instance 2', async function () {
  73     const data = await servers[1].statsCommand.get()
  74
  75     expect(data.totalLocalVideoComments).to.equal(0)
  76     expect(data.totalLocalVideos).to.equal(0)
  77     expect(data.totalLocalVideoViews).to.equal(0)
  78     expect(data.totalLocalVideoFilesSize).to.equal(0)
  79     expect(data.totalUsers).to.equal(1)
  80     expect(data.totalVideoComments).to.equal(1)
  81     expect(data.totalVideos).to.equal(1)
  82     expect(data.totalInstanceFollowers).to.equal(1)
  83     expect(data.totalInstanceFollowing).to.equal(1)
  84     expect(data.totalLocalPlaylists).to.equal(0)
  85   })
  86
  87   it('Should have the correct stats on instance 3', async function () {
  88     const data = await servers[2].statsCommand.get()
  89
  90     expect(data.totalLocalVideoComments).to.equal(0)
  91     expect(data.totalLocalVideos).to.equal(0)
  92     expect(data.totalLocalVideoViews).to.equal(0)
  93     expect(data.totalUsers).to.equal(1)
  94     expect(data.totalVideoComments).to.equal(1)
  95     expect(data.totalVideos).to.equal(1)
  96     expect(data.totalInstanceFollowing).to.equal(1)
  97     expect(data.totalInstanceFollowers).to.equal(0)
  98     expect(data.totalLocalPlaylists).to.equal(0)
  99   })
 100
 101   it('Should have the correct total videos stats after an unfollow', async function () {
 102     this.timeout(15000)
 103
 104     await servers[2].followsCommand.unfollow({ target: servers[0] })
 105     await waitJobs(servers)
 106
 107     const data = await servers[2].statsCommand.get()
 108
 109     expect(data.totalVideos).to.equal(0)
 110   })
 111
 112   it('Should have the correct active user stats', async function () {
 113     const server = servers[0]
 114
 115     {
 116       const data = await server.statsCommand.get()
 117
 118       expect(data.totalDailyActiveUsers).to.equal(1)
 119       expect(data.totalWeeklyActiveUsers).to.equal(1)
 120       expect(data.totalMonthlyActiveUsers).to.equal(1)
 121     }
 122
 123     {
 124       await userLogin(server, user)
 125
 126       const data = await server.statsCommand.get()
 127
 128       expect(data.totalDailyActiveUsers).to.equal(2)
 129       expect(data.totalWeeklyActiveUsers).to.equal(2)
 130       expect(data.totalMonthlyActiveUsers).to.equal(2)
 131     }
 132   })
 133
 134   it('Should have the correct active channel stats', async function () {
 135     const server = servers[0]
 136
 137     {
 138       const data = await server.statsCommand.get()
 139
 140       expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
 141       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
 142       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
 143     }
 144
 145     {
 146       const channelAttributes = {
 147         name: 'stats_channel',
 148         displayName: 'My stats channel'
 149       }
 150       const resChannel = await addVideoChannel(server.url, server.accessToken, channelAttributes)
 151       channelId = resChannel.body.videoChannel.id
 152
 153       const data = await server.statsCommand.get()
 154
 155       expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
 156       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
 157       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
 158     }
 159
 160     {
 161       await uploadVideo(server.url, server.accessToken, { fixture: 'video_short.webm', channelId })
 162
 163       const data = await server.statsCommand.get()
 164
 165       expect(data.totalLocalDailyActiveVideoChannels).to.equal(2)
 166       expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(2)
 167       expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(2)
 168     }
 169   })
 170
 171   it('Should have the correct playlist stats', async function () {
 172     const server = servers[0]
 173
 174     {
 175       const data = await server.statsCommand.get()
 176       expect(data.totalLocalPlaylists).to.equal(0)
 177     }
 178
 179     {
 180       await server.playlistsCommand.create({
 181         attributes: {
 182           displayName: 'playlist for count',
 183           privacy: VideoPlaylistPrivacy.PUBLIC,
 184           videoChannelId: channelId
 185         }
 186       })
 187
 188       const data = await server.statsCommand.get()
 189       expect(data.totalLocalPlaylists).to.equal(1)
 190     }
 191   })
 192
 193   it('Should correctly count video file sizes if transcoding is enabled', async function () {
 194     this.timeout(60000)
 195
 196     await servers[0].configCommand.updateCustomSubConfig({
 197       newConfig: {
 198         transcoding: {
 199           enabled: true,
 200           webtorrent: {
 201             enabled: true
 202           },
 203           hls: {
 204             enabled: true
 205           },
 206           resolutions: {
 207             '0p': false,
 208             '240p': false,
 209             '360p': false,
 210             '480p': false,
 211             '720p': false,
 212             '1080p': false,
 213             '1440p': false,
 214             '2160p': false
 215           }
 216         }
 217       }
 218     })
 219
 220     await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video', fixture: 'video_short.webm' })
 221
 222     await waitJobs(servers)
 223
 224     {
 225       const data = await servers[1].statsCommand.get()
 226       expect(data.totalLocalVideoFilesSize).to.equal(0)
 227     }
 228
 229     {
 230       const data = await servers[0].statsCommand.get()
 231       expect(data.totalLocalVideoFilesSize).to.be.greaterThan(500000)
 232       expect(data.totalLocalVideoFilesSize).to.be.lessThan(600000)
 233     }
 234   })
 235
 236   it('Should have the correct AP stats', async function () {
 237     this.timeout(60000)
 238
 239     await servers[0].configCommand.updateCustomSubConfig({
 240       newConfig: {
 241         transcoding: {
 242           enabled: false
 243         }
 244       }
 245     })
 246
 247     const first = await servers[1].statsCommand.get()
 248
 249     for (let i = 0; i < 10; i++) {
 250       await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
 251     }
 252
 253     await waitJobs(servers)
 254
 255     await wait(6000)
 256
 257     const second = await servers[1].statsCommand.get()
 258     expect(second.totalActivityPubMessagesProcessed).to.be.greaterThan(first.totalActivityPubMessagesProcessed)
 259
 260     const apTypes: ActivityType[] = [
 261       'Create', 'Update', 'Delete', 'Follow', 'Accept', 'Announce', 'Undo', 'Like', 'Reject', 'View', 'Dislike', 'Flag'
 262     ]
 263
 264     const processed = apTypes.reduce(
 265       (previous, type) => previous + second['totalActivityPub' + type + 'MessagesSuccesses'],
 266       0
 267     )
 268     expect(second.totalActivityPubMessagesProcessed).to.equal(processed)
 269     expect(second.totalActivityPubMessagesSuccesses).to.equal(processed)
 270
 271     expect(second.totalActivityPubMessagesErrors).to.equal(0)
 272
 273     for (const apType of apTypes) {
 274       expect(second['totalActivityPub' + apType + 'MessagesErrors']).to.equal(0)
 275     }
 276
 277     await wait(6000)
 278
 279     const third = await servers[1].statsCommand.get()
 280     expect(third.totalActivityPubMessagesWaiting).to.equal(0)
 281     expect(third.activityPubMessagesProcessedPerSecond).to.be.lessThan(second.activityPubMessagesProcessedPerSecond)
 282   })
 283
 284   after(async function () {
 285     await cleanupTests(servers)
 286   })
 287 })