Refactor live manager

[github/Chocobozzz/PeerTube.git] / server / tests / api / server / stats.ts

diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index 9f785a80eb0259a34aaf57db9ad21ab74e8f22bc..304181a6d5e6765efbd641be53a91efc5b77746d 100644 (file)
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -3,8 +3,10 @@
 import 'mocha'
 import * as chai from 'chai'
 import {
+  addVideoChannel,
   cleanupTests,
   createUser,
+  createVideoPlaylist,
   doubleFollow,
   flushAndRunMultipleServers,
   follow,
@@ -21,11 +23,14 @@ import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { getStats } from '../../../../shared/extra-utils/server/stats'
 import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
 import { ServerStats } from '../../../../shared/models/server/server-stats.model'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { ActivityType } from '@shared/models'
 
 const expect = chai.expect
 
 describe('Test stats (excluding redundancy)', function () {
   let servers: ServerInfo[] = []
+  let channelId
   const user = {
     username: 'user1',
     password: 'super_password'
@@ -69,6 +74,7 @@ describe('Test stats (excluding redundancy)', function () {
     expect(data.totalVideos).to.equal(1)
     expect(data.totalInstanceFollowers).to.equal(2)
     expect(data.totalInstanceFollowing).to.equal(1)
+    expect(data.totalLocalPlaylists).to.equal(0)
   })
 
   it('Should have the correct stats on instance 2', async function () {
@@ -84,6 +90,7 @@ describe('Test stats (excluding redundancy)', function () {
     expect(data.totalVideos).to.equal(1)
     expect(data.totalInstanceFollowers).to.equal(1)
     expect(data.totalInstanceFollowing).to.equal(1)
+    expect(data.totalLocalPlaylists).to.equal(0)
   })
 
   it('Should have the correct stats on instance 3', async function () {
@@ -98,6 +105,7 @@ describe('Test stats (excluding redundancy)', function () {
     expect(data.totalVideos).to.equal(1)
     expect(data.totalInstanceFollowing).to.equal(1)
     expect(data.totalInstanceFollowers).to.equal(0)
+    expect(data.totalLocalPlaylists).to.equal(0)
   })
 
   it('Should have the correct total videos stats after an unfollow', async function () {
@@ -112,7 +120,7 @@ describe('Test stats (excluding redundancy)', function () {
     expect(data.totalVideos).to.equal(0)
   })
 
-  it('Should have the correct active users stats', async function () {
+  it('Should have the correct active user stats', async function () {
     const server = servers[0]
 
     {
@@ -134,8 +142,71 @@ describe('Test stats (excluding redundancy)', function () {
     }
   })
 
+  it('Should have the correct active channel stats', async function () {
+    const server = servers[0]
+
+    {
+      const res = await getStats(server.url)
+      const data: ServerStats = res.body
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
+    }
+
+    {
+      const channelAttributes = {
+        name: 'stats_channel',
+        displayName: 'My stats channel'
+      }
+      const resChannel = await addVideoChannel(server.url, server.accessToken, channelAttributes)
+      channelId = resChannel.body.videoChannel.id
+
+      const res = await getStats(server.url)
+      const data: ServerStats = res.body
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(1)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(1)
+    }
+
+    {
+      await uploadVideo(server.url, server.accessToken, { fixture: 'video_short.webm', channelId })
+
+      const res = await getStats(server.url)
+      const data: ServerStats = res.body
+      expect(data.totalLocalDailyActiveVideoChannels).to.equal(2)
+      expect(data.totalLocalWeeklyActiveVideoChannels).to.equal(2)
+      expect(data.totalLocalMonthlyActiveVideoChannels).to.equal(2)
+    }
+  })
+
+  it('Should have the correct playlist stats', async function () {
+    const server = servers[0]
+
+    {
+      const resStats = await getStats(server.url)
+      const dataStats: ServerStats = resStats.body
+      expect(dataStats.totalLocalPlaylists).to.equal(0)
+    }
+
+    {
+      await createVideoPlaylist({
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: {
+          displayName: 'playlist for count',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: channelId
+        }
+      })
+
+      const resStats = await getStats(server.url)
+      const dataStats: ServerStats = resStats.body
+      expect(dataStats.totalLocalPlaylists).to.equal(1)
+    }
+  })
+
   it('Should correctly count video file sizes if transcoding is enabled', async function () {
-    this.timeout(20000)
+    this.timeout(60000)
 
     await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
       transcoding: {
@@ -153,6 +224,7 @@ describe('Test stats (excluding redundancy)', function () {
           '480p': false,
           '720p': false,
           '1080p': false,
+          '1440p': false,
           '2160p': false
         }
       }
@@ -171,34 +243,58 @@ describe('Test stats (excluding redundancy)', function () {
     {
       const res = await getStats(servers[0].url)
       const data: ServerStats = res.body
-      expect(data.totalLocalVideoFilesSize).to.be.greaterThan(300000)
-      expect(data.totalLocalVideoFilesSize).to.be.lessThan(400000)
+      expect(data.totalLocalVideoFilesSize).to.be.greaterThan(500000)
+      expect(data.totalLocalVideoFilesSize).to.be.lessThan(600000)
     }
   })
 
   it('Should have the correct AP stats', async function () {
     this.timeout(60000)
 
-    for (let i = 0; i < 10; i++) {
-      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
-    }
+    await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
+      transcoding: {
+        enabled: false
+      }
+    })
 
     const res1 = await getStats(servers[1].url)
     const first = res1.body as ServerStats
 
+    for (let i = 0; i < 10; i++) {
+      await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'video' })
+    }
+
     await waitJobs(servers)
 
+    await wait(6000)
+
     const res2 = await getStats(servers[1].url)
     const second: ServerStats = res2.body
 
-    expect(second.totalActivityPubMessagesWaiting).to.equal(0)
     expect(second.totalActivityPubMessagesProcessed).to.be.greaterThan(first.totalActivityPubMessagesProcessed)
+    const apTypes: ActivityType[] = [
+      'Create', 'Update', 'Delete', 'Follow', 'Accept', 'Announce', 'Undo', 'Like', 'Reject', 'View', 'Dislike', 'Flag'
+    ]
+
+    const processed = apTypes.reduce(
+      (previous, type) => previous + second['totalActivityPub' + type + 'MessagesSuccesses'],
+      0
+    )
+    expect(second.totalActivityPubMessagesProcessed).to.equal(processed)
+    expect(second.totalActivityPubMessagesSuccesses).to.equal(processed)
+
+    expect(second.totalActivityPubMessagesErrors).to.equal(0)
+
+    for (const apType of apTypes) {
+      expect(second['totalActivityPub' + apType + 'MessagesErrors']).to.equal(0)
+    }
 
-    await wait(5000)
+    await wait(6000)
 
     const res3 = await getStats(servers[1].url)
     const third: ServerStats = res3.body
 
+    expect(third.totalActivityPubMessagesWaiting).to.equal(0)
     expect(third.activityPubMessagesProcessedPerSecond).to.be.lessThan(second.activityPubMessagesProcessedPerSecond)
   })