/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import 'mocha'
-import * as chai from 'chai'
+import { expect } from 'chai'
import {
- addAccountToAccountBlocklist,
- addVideoCommentReply,
- addVideoCommentThread,
checkCommentMention,
CheckerBaseParams,
checkNewCommentOnMyVideo,
- cleanupTests,
- getVideoCommentThreads,
- getVideoThreadComments,
MockSmtpServer,
- prepareNotificationsTest,
- removeAccountFromAccountBlocklist,
- ServerInfo,
- updateMyUser,
- uploadVideo,
- waitJobs
-} from '@shared/extra-utils'
-import { UserNotification, VideoCommentThreadTree } from '@shared/models'
-
-const expect = chai.expect
+ prepareNotificationsTest
+} from '@server/tests/shared'
+import { UserNotification } from '@shared/models'
+import { cleanupTests, PeerTubeServer, waitJobs } from '@shared/server-commands'
describe('Test comments notifications', function () {
- let servers: ServerInfo[] = []
- let userAccessToken: string
+ let servers: PeerTubeServer[] = []
+ let userToken: string
let userNotifications: UserNotification[] = []
let emails: object[] = []
const res = await prepareNotificationsTest(2)
emails = res.emails
- userAccessToken = res.userAccessToken
+ userToken = res.userAccessToken
servers = res.servers
userNotifications = res.userNotifications
})
server: servers[0],
emails,
socketNotifications: userNotifications,
- token: userAccessToken
+ token: userToken
}
})
it('Should not send a new comment notification after a comment on another video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
- const commentId = resComment.body.comment.id
+ const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+ const commentId = created.id
await waitJobs(servers)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
})
it('Should not send a new comment notification if I comment my own video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, 'comment')
- const commentId = resComment.body.comment.id
+ const created = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: 'comment' })
+ const commentId = created.id
await waitJobs(servers)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
})
it('Should not send a new comment notification if the account is muted', async function () {
this.timeout(20000)
- await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
+ await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
- const commentId = resComment.body.comment.id
+ const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+ const commentId = created.id
await waitJobs(servers)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'absence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'absence' })
- await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
+ await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
})
it('Should send a new comment notification after a local comment on my video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
- const commentId = resComment.body.comment.id
+ const created = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
+ const commentId = created.id
await waitJobs(servers)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
})
it('Should send a new comment notification after a remote comment on my video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
await waitJobs(servers)
- await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
+ await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
await waitJobs(servers)
- const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
- expect(resComment.body.data).to.have.lengthOf(1)
- const commentId = resComment.body.data[0].id
+ const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+ expect(data).to.have.lengthOf(1)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
+ const commentId = data[0].id
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId: commentId, commentId, checkType: 'presence' })
})
it('Should send a new comment notification after a local reply on my video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
- const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, 'comment')
- const threadId = resThread.body.comment.id
+ const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: 'comment' })
- const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'reply')
- const commentId = resComment.body.comment.id
+ const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
await waitJobs(servers)
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
})
it('Should send a new comment notification after a remote reply on my video', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
await waitJobs(servers)
{
- const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
- const threadId = resThread.body.comment.id
- await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply')
+ const created = await servers[1].comments.createThread({ videoId: uuid, text: 'comment' })
+ const threadId = created.id
+ await servers[1].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'reply' })
}
await waitJobs(servers)
- const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
- expect(resThread.body.data).to.have.lengthOf(1)
- const threadId = resThread.body.data[0].id
+ const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+ expect(data).to.have.lengthOf(1)
- const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId)
- const tree = resComments.body as VideoCommentThreadTree
+ const threadId = data[0].id
+ const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
expect(tree.children).to.have.lengthOf(1)
const commentId = tree.children[0].comment.id
- await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
+ await checkNewCommentOnMyVideo({ ...baseParams, shortUUID, threadId, commentId, checkType: 'presence' })
})
it('Should convert markdown in comment to html', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'cool video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'cool video' } })
- await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, commentText)
+ await servers[0].comments.createThread({ videoId: uuid, text: commentText })
await waitJobs(servers)
describe('Mention notifications', function () {
let baseParams: CheckerBaseParams
+ const byAccountDisplayName = 'super root name'
before(async () => {
baseParams = {
server: servers[0],
emails,
socketNotifications: userNotifications,
- token: userAccessToken
+ token: userToken
}
- await updateMyUser({
- url: servers[0].url,
- accessToken: servers[0].accessToken,
- displayName: 'super root name'
- })
-
- await updateMyUser({
- url: servers[1].url,
- accessToken: servers[1].accessToken,
- displayName: 'super root 2 name'
- })
+ await servers[0].users.updateMe({ displayName: 'super root name' })
+ await servers[1].users.updateMe({ displayName: 'super root 2 name' })
})
it('Should not send a new mention comment notification if I mention the video owner', async function () {
this.timeout(10000)
- const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ token: userToken, attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
- const commentId = resComment.body.comment.id
+ const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+ await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
})
it('Should not send a new mention comment notification if I mention myself', async function () {
this.timeout(10000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, userAccessToken, uuid, '@user_1 hello')
- const commentId = resComment.body.comment.id
+ const { id: commentId } = await servers[0].comments.createThread({ token: userToken, videoId: uuid, text: '@user_1 hello' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+ await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
})
it('Should not send a new mention notification if the account is muted', async function () {
this.timeout(10000)
- await addAccountToAccountBlocklist(servers[0].url, userAccessToken, 'root')
+ await servers[0].blocklist.addToMyBlocklist({ token: userToken, account: 'root' })
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
- const resComment = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello')
- const commentId = resComment.body.comment.id
+ const { id: commentId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, commentId, commentId, 'super root name', 'absence')
+ await checkCommentMention({ ...baseParams, shortUUID, threadId: commentId, commentId, byAccountDisplayName, checkType: 'absence' })
- await removeAccountFromAccountBlocklist(servers[0].url, userAccessToken, 'root')
+ await servers[0].blocklist.removeFromMyBlocklist({ token: userToken, account: 'root' })
})
it('Should not send a new mention notification if the remote account mention a local account', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
await waitJobs(servers)
- const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, '@user_1 hello')
- const threadId = resThread.body.comment.id
+ const { id: threadId } = await servers[1].comments.createThread({ videoId: uuid, text: '@user_1 hello' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'absence')
+
+ const byAccountDisplayName = 'super root 2 name'
+ await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'absence' })
})
it('Should send a new mention notification after local comments', async function () {
this.timeout(10000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
- const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
- const threadId = resThread.body.comment.id
+ const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hellotext: 1' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root name', 'presence')
+ await checkCommentMention({ ...baseParams, shortUUID, threadId, commentId: threadId, byAccountDisplayName, checkType: 'presence' })
- const resComment = await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, 'hello 2 @user_1')
- const commentId = resComment.body.comment.id
+ const { id: commentId } = await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: 'hello 2 @user_1' })
await waitJobs(servers)
- await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root name', 'presence')
+ await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
})
it('Should send a new mention notification after remote comments', async function () {
this.timeout(20000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid, shortUUID } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
await waitJobs(servers)
const text1 = `hello @user_1@localhost:${servers[0].port} 1`
- const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, text1)
- const server2ThreadId = resThread.body.comment.id
+ const { id: server2ThreadId } = await servers[1].comments.createThread({ videoId: uuid, text: text1 })
await waitJobs(servers)
- const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
- expect(resThread2.body.data).to.have.lengthOf(1)
- const server1ThreadId = resThread2.body.data[0].id
- await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence')
+ const { data } = await servers[0].comments.listThreads({ videoId: uuid })
+ expect(data).to.have.lengthOf(1)
+
+ const byAccountDisplayName = 'super root 2 name'
+ const threadId = data[0].id
+ await checkCommentMention({ ...baseParams, shortUUID, commentId: threadId, threadId, byAccountDisplayName, checkType: 'presence' })
const text2 = `@user_1@localhost:${servers[0].port} hello 2 @root@localhost:${servers[0].port}`
- await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text2)
+ await servers[1].comments.addReply({ videoId: uuid, toCommentId: server2ThreadId, text: text2 })
await waitJobs(servers)
- const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId)
- const tree = resComments.body as VideoCommentThreadTree
+ const tree = await servers[0].comments.getThread({ videoId: uuid, threadId })
expect(tree.children).to.have.lengthOf(1)
const commentId = tree.children[0].comment.id
- await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence')
+ await checkCommentMention({ ...baseParams, shortUUID, commentId, threadId, byAccountDisplayName, checkType: 'presence' })
})
it('Should convert markdown in comment to html', async function () {
this.timeout(10000)
- const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name: 'super video' })
- const uuid = resVideo.body.video.uuid
+ const { uuid } = await servers[0].videos.upload({ attributes: { name: 'super video' } })
- const resThread = await addVideoCommentThread(servers[0].url, servers[0].accessToken, uuid, '@user_1 hello 1')
- const threadId = resThread.body.comment.id
+ const { id: threadId } = await servers[0].comments.createThread({ videoId: uuid, text: '@user_1 hello 1' })
- await addVideoCommentReply(servers[0].url, servers[0].accessToken, uuid, threadId, '@user_1 ' + commentText)
+ await servers[0].comments.addReply({ videoId: uuid, toCommentId: threadId, text: '@user_1 ' + commentText })
await waitJobs(servers)