X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fredundancy%2Fredundancy-constraints.ts;h=933a2c7760c1f881f9582f0c7127f7ba40b2d983;hb=171efc48e67498406feb6d7873b3482b41505515;hp=b3f6ed1604d6f013f15840919de340a17c51cf3d;hpb=d23dd9fbfc4d26026352c10f81d2795ceaf2908a;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/tests/api/redundancy/redundancy-constraints.ts b/server/tests/api/redundancy/redundancy-constraints.ts
index b3f6ed160..933a2c776 100644
--- a/server/tests/api/redundancy/redundancy-constraints.ts
+++ b/server/tests/api/redundancy/redundancy-constraints.ts
@@ -2,21 +2,13 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import {
-  cleanupTests,
-  flushAndRunServer,
-  killallServers,
-  reRunServer,
-  ServerInfo,
-  setAccessTokensToServers,
-  waitJobs
-} from '@shared/extra-utils'
+import { cleanupTests, createSingleServer, killallServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
 import { VideoPrivacy } from '@shared/models'
 
 describe('Test redundancy constraints', function () {
-  let remoteServer: ServerInfo
-  let localServer: ServerInfo
-  let servers: ServerInfo[]
+  let remoteServer: PeerTubeServer
+  let localServer: PeerTubeServer
+  let servers: PeerTubeServer[]
 
   const remoteServerConfig = {
     redundancy: {
@@ -36,21 +28,21 @@ describe('Test redundancy constraints', function () {
 
   async function uploadWrapper (videoName: string) {
     // Wait for transcoding
-    const { id } = await localServer.videosCommand.upload({ attributes: { name: 'to transcode', privacy: VideoPrivacy.PRIVATE } })
+    const { id } = await localServer.videos.upload({ attributes: { name: 'to transcode', privacy: VideoPrivacy.PRIVATE } })
     await waitJobs([ localServer ])
 
     // Update video to schedule a federation
-    await localServer.videosCommand.update({ id, attributes: { name: videoName, privacy: VideoPrivacy.PUBLIC } })
+    await localServer.videos.update({ id, attributes: { name: videoName, privacy: VideoPrivacy.PUBLIC } })
   }
 
   async function getTotalRedundanciesLocalServer () {
-    const body = await localServer.redundancyCommand.listVideos({ target: 'my-videos' })
+    const body = await localServer.redundancy.listVideos({ target: 'my-videos' })
 
     return body.total
   }
 
   async function getTotalRedundanciesRemoteServer () {
-    const body = await remoteServer.redundancyCommand.listVideos({ target: 'remote-videos' })
+    const body = await remoteServer.redundancy.listVideos({ target: 'remote-videos' })
 
     return body.total
   }
@@ -59,7 +51,7 @@ describe('Test redundancy constraints', function () {
     this.timeout(120000)
 
     {
-      remoteServer = await flushAndRunServer(1, remoteServerConfig)
+      remoteServer = await createSingleServer(1, remoteServerConfig)
     }
 
     {
@@ -70,7 +62,7 @@ describe('Test redundancy constraints', function () {
           }
         }
       }
-      localServer = await flushAndRunServer(2, config)
+      localServer = await createSingleServer(2, config)
     }
 
     servers = [ remoteServer, localServer ]
@@ -78,14 +70,14 @@ describe('Test redundancy constraints', function () {
     // Get the access tokens
     await setAccessTokensToServers(servers)
 
-    await localServer.videosCommand.upload({ attributes: { name: 'video 1 server 2' } })
+    await localServer.videos.upload({ attributes: { name: 'video 1 server 2' } })
 
     await waitJobs(servers)
 
     // Server 1 and server 2 follow each other
-    await remoteServer.followsCommand.follow({ targets: [ localServer.url ] })
+    await remoteServer.follows.follow({ hosts: [ localServer.url ] })
     await waitJobs(servers)
-    await remoteServer.redundancyCommand.updateRedundancy({ host: localServer.host, redundancyAllowed: true })
+    await remoteServer.redundancy.updateRedundancy({ host: localServer.host, redundancyAllowed: true })
 
     await waitJobs(servers)
   })
@@ -94,7 +86,7 @@ describe('Test redundancy constraints', function () {
     this.timeout(120000)
 
     await waitJobs(servers)
-    await remoteServer.serversCommand.waitUntilLog('Duplicated ', 5)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 5)
     await waitJobs(servers)
 
     {
@@ -118,12 +110,12 @@ describe('Test redundancy constraints', function () {
         }
       }
     }
-    await await killallServers([ localServer ])
-    await reRunServer(localServer, config)
+    await killallServers([ localServer ])
+    await localServer.run(config)
 
     await uploadWrapper('video 2 server 2')
 
-    await remoteServer.serversCommand.waitUntilLog('Duplicated ', 10)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 10)
     await waitJobs(servers)
 
     {
@@ -148,11 +140,11 @@ describe('Test redundancy constraints', function () {
       }
     }
     await killallServers([ localServer ])
-    await reRunServer(localServer, config)
+    await localServer.run(config)
 
     await uploadWrapper('video 3 server 2')
 
-    await remoteServer.serversCommand.waitUntilLog('Duplicated ', 15)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 15)
     await waitJobs(servers)
 
     {
@@ -169,11 +161,11 @@ describe('Test redundancy constraints', function () {
   it('Should have redundancy on server 1 and on server 2 with followings filter now server 2 follows server 1', async function () {
     this.timeout(120000)
 
-    await localServer.followsCommand.follow({ targets: [ remoteServer.url ] })
+    await localServer.follows.follow({ hosts: [ remoteServer.url ] })
     await waitJobs(servers)
 
     await uploadWrapper('video 4 server 2')
-    await remoteServer.serversCommand.waitUntilLog('Duplicated ', 20)
+    await remoteServer.servers.waitUntilLog('Duplicated ', 20)
     await waitJobs(servers)
 
     {