/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import 'mocha'
-import * as chai from 'chai'
+import { expect } from 'chai'
+import { wait } from '@shared/core-utils'
import {
cleanupTests,
+ createMultipleServers,
doubleFollow,
- flushAndRunMultipleServers,
- getVideo,
- rateVideo,
- ServerInfo,
+ PeerTubeServer,
setAccessTokensToServers,
- uploadVideoAndGetId,
- wait,
waitJobs
-} from '@shared/extra-utils'
-
-const expect = chai.expect
+} from '@shared/server-commands'
describe('Test AP cleaner', function () {
- let servers: ServerInfo[] = []
+ let servers: PeerTubeServer[] = []
let videoUUID1: string
let videoUUID2: string
let videoUUID3: string
videos: { cleanup_remote_interactions: true }
}
}
- servers = await flushAndRunMultipleServers(3, config)
+ servers = await createMultipleServers(3, config)
// Get the access tokens
await setAccessTokensToServers(servers)
// Create 1 comment per video
// Update 1 remote URL and 1 local URL on
- videoUUID1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'server 1' })).uuid
- videoUUID2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'server 2' })).uuid
- videoUUID3 = (await uploadVideoAndGetId({ server: servers[2], videoName: 'server 3' })).uuid
+ videoUUID1 = (await servers[0].videos.quickUpload({ name: 'server 1' })).uuid
+ videoUUID2 = (await servers[1].videos.quickUpload({ name: 'server 2' })).uuid
+ videoUUID3 = (await servers[2].videos.quickUpload({ name: 'server 3' })).uuid
videoUUIDs = [ videoUUID1, videoUUID2, videoUUID3 ]
for (const server of servers) {
for (const uuid of videoUUIDs) {
- await rateVideo(server.url, server.accessToken, uuid, 'like')
- await server.commentsCommand.createThread({ videoId: uuid, text: 'comment' })
+ await server.videos.rate({ id: uuid, rating: 'like' })
+ await server.comments.createThread({ videoId: uuid, text: 'comment' })
}
}
it('Should have the correct likes', async function () {
for (const server of servers) {
for (const uuid of videoUUIDs) {
- const res = await getVideo(server.url, uuid)
- expect(res.body.likes).to.equal(3)
- expect(res.body.dislikes).to.equal(0)
+ const video = await server.videos.get({ id: uuid })
+
+ expect(video.likes).to.equal(3)
+ expect(video.dislikes).to.equal(0)
}
}
})
it('Should destroy server 3 internal likes and correctly clean them', async function () {
this.timeout(20000)
- await servers[2].sqlCommand.deleteAll('accountVideoRate')
+ await servers[2].sql.deleteAll('accountVideoRate')
for (const uuid of videoUUIDs) {
- await servers[2].sqlCommand.setVideoField(uuid, 'likes', '0')
+ await servers[2].sql.setVideoField(uuid, 'likes', '0')
}
await wait(5000)
// Updated rates of my video
{
- const res = await getVideo(servers[0].url, videoUUID1)
- expect(res.body.likes).to.equal(2)
- expect(res.body.dislikes).to.equal(0)
+ const video = await servers[0].videos.get({ id: videoUUID1 })
+ expect(video.likes).to.equal(2)
+ expect(video.dislikes).to.equal(0)
}
// Did not update rates of a remote video
{
- const res = await getVideo(servers[0].url, videoUUID2)
- expect(res.body.likes).to.equal(3)
- expect(res.body.dislikes).to.equal(0)
+ const video = await servers[0].videos.get({ id: videoUUID2 })
+ expect(video.likes).to.equal(3)
+ expect(video.dislikes).to.equal(0)
}
})
for (const server of servers) {
for (const uuid of videoUUIDs) {
- await rateVideo(server.url, server.accessToken, uuid, 'dislike')
+ await server.videos.rate({ id: uuid, rating: 'dislike' })
}
}
for (const server of servers) {
for (const uuid of videoUUIDs) {
- const res = await getVideo(server.url, uuid)
- expect(res.body.likes).to.equal(0)
- expect(res.body.dislikes).to.equal(3)
+ const video = await server.videos.get({ id: uuid })
+ expect(video.likes).to.equal(0)
+ expect(video.dislikes).to.equal(3)
}
}
})
it('Should destroy server 3 internal dislikes and correctly clean them', async function () {
this.timeout(20000)
- await servers[2].sqlCommand.deleteAll('accountVideoRate')
+ await servers[2].sql.deleteAll('accountVideoRate')
for (const uuid of videoUUIDs) {
- await servers[2].sqlCommand.setVideoField(uuid, 'dislikes', '0')
+ await servers[2].sql.setVideoField(uuid, 'dislikes', '0')
}
await wait(5000)
// Updated rates of my video
{
- const res = await getVideo(servers[0].url, videoUUID1)
- expect(res.body.likes).to.equal(0)
- expect(res.body.dislikes).to.equal(2)
+ const video = await servers[0].videos.get({ id: videoUUID1 })
+ expect(video.likes).to.equal(0)
+ expect(video.dislikes).to.equal(2)
}
// Did not update rates of a remote video
{
- const res = await getVideo(servers[0].url, videoUUID2)
- expect(res.body.likes).to.equal(0)
- expect(res.body.dislikes).to.equal(3)
+ const video = await servers[0].videos.get({ id: videoUUID2 })
+ expect(video.likes).to.equal(0)
+ expect(video.dislikes).to.equal(3)
}
})
it('Should destroy server 3 internal shares and correctly clean them', async function () {
this.timeout(20000)
- const preCount = await servers[0].sqlCommand.getCount('videoShare')
+ const preCount = await servers[0].sql.getVideoShareCount()
expect(preCount).to.equal(6)
- await servers[2].sqlCommand.deleteAll('videoShare')
+ await servers[2].sql.deleteAll('videoShare')
await wait(5000)
await waitJobs(servers)
// Still 6 because we don't have remote shares on local videos
- const postCount = await servers[0].sqlCommand.getCount('videoShare')
+ const postCount = await servers[0].sql.getVideoShareCount()
expect(postCount).to.equal(6)
})
this.timeout(20000)
{
- const { total } = await servers[0].commentsCommand.listThreads({ videoId: videoUUID1 })
+ const { total } = await servers[0].comments.listThreads({ videoId: videoUUID1 })
expect(total).to.equal(3)
}
- await servers[2].sqlCommand.deleteAll('videoComment')
+ await servers[2].sql.deleteAll('videoComment')
await wait(5000)
await waitJobs(servers)
{
- const { total } = await servers[0].commentsCommand.listThreads({ videoId: videoUUID1 })
+ const { total } = await servers[0].comments.listThreads({ videoId: videoUUID1 })
expect(total).to.equal(2)
}
})
async function check (like: string, ofServerUrl: string, urlSuffix: string, remote: 'true' | 'false') {
const query = `SELECT "videoId", "accountVideoRate".url FROM "accountVideoRate" ` +
`INNER JOIN video ON "accountVideoRate"."videoId" = video.id AND remote IS ${remote} WHERE "accountVideoRate"."url" LIKE '${like}'`
- const res = await servers[0].sqlCommand.selectQuery(query)
+ const res = await servers[0].sql.selectQuery<{ url: string }>(query)
for (const rate of res) {
const matcher = new RegExp(`^${ofServerUrl}/accounts/root/dislikes/\\d+${urlSuffix}$`)
{
const query = `UPDATE "accountVideoRate" SET url = url || 'stan'`
- await servers[1].sqlCommand.updateQuery(query)
+ await servers[1].sql.updateQuery(query)
await wait(5000)
await waitJobs(servers)
const query = `SELECT "videoId", "videoComment".url, uuid as "videoUUID" FROM "videoComment" ` +
`INNER JOIN video ON "videoComment"."videoId" = video.id AND remote IS ${remote} WHERE "videoComment"."url" LIKE '${like}'`
- const res = await servers[0].sqlCommand.selectQuery(query)
+ const res = await servers[0].sql.selectQuery<{ url: string, videoUUID: string }>(query)
for (const comment of res) {
const matcher = new RegExp(`${ofServerUrl}/videos/watch/${comment.videoUUID}/comments/\\d+${urlSuffix}`)
{
const query = `UPDATE "videoComment" SET url = url || 'kyle'`
- await servers[1].sqlCommand.updateQuery(query)
+ await servers[1].sql.updateQuery(query)
await wait(5000)
await waitJobs(servers)
await checkRemote('kyle')
})
+ it('Should remove unavailable remote resources', async function () {
+ this.timeout(240000)
+
+ async function expectNotDeleted () {
+ {
+ const video = await servers[0].videos.get({ id: uuid })
+
+ expect(video.likes).to.equal(3)
+ expect(video.dislikes).to.equal(0)
+ }
+
+ {
+ const { total } = await servers[0].comments.listThreads({ videoId: uuid })
+ expect(total).to.equal(3)
+ }
+ }
+
+ async function expectDeleted () {
+ {
+ const video = await servers[0].videos.get({ id: uuid })
+
+ expect(video.likes).to.equal(2)
+ expect(video.dislikes).to.equal(0)
+ }
+
+ {
+ const { total } = await servers[0].comments.listThreads({ videoId: uuid })
+ expect(total).to.equal(2)
+ }
+ }
+
+ const uuid = (await servers[0].videos.quickUpload({ name: 'server 1 video 2' })).uuid
+
+ await waitJobs(servers)
+
+ for (const server of servers) {
+ await server.videos.rate({ id: uuid, rating: 'like' })
+ await server.comments.createThread({ videoId: uuid, text: 'comment' })
+ }
+
+ await waitJobs(servers)
+
+ await expectNotDeleted()
+
+ await servers[1].kill()
+
+ await wait(5000)
+ await expectNotDeleted()
+
+ let continueWhile = true
+
+ do {
+ try {
+ await expectDeleted()
+ continueWhile = false
+ } catch {
+ }
+ } while (continueWhile)
+ })
+
after(async function () {
await cleanupTests(servers)
})