mirror of https://github.com/Chocobozzz/PeerTube
857 lines
30 KiB
TypeScript
857 lines
30 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
|
|
|
|
import { expect } from 'chai'
|
|
import { inspect } from 'util'
|
|
import {
|
|
AbuseState,
|
|
PluginType,
|
|
UserNotification,
|
|
UserNotificationSetting,
|
|
UserNotificationSettingValue,
|
|
UserNotificationType
|
|
} from '@shared/models'
|
|
import {
|
|
createMultipleServers,
|
|
doubleFollow,
|
|
PeerTubeServer,
|
|
setAccessTokensToServers,
|
|
setDefaultAccountAvatar,
|
|
setDefaultChannelAvatar,
|
|
setDefaultVideoChannel
|
|
} from '@shared/server-commands'
|
|
import { MockSmtpServer } from './mock-servers'
|
|
|
|
type CheckerBaseParams = {
|
|
server: PeerTubeServer
|
|
emails: any[]
|
|
socketNotifications: UserNotification[]
|
|
token: string
|
|
check?: { web: boolean, mail: boolean }
|
|
}
|
|
|
|
type CheckerType = 'presence' | 'absence'
|
|
|
|
function getAllNotificationsSettings (): UserNotificationSetting {
|
|
return {
|
|
newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
myVideoStudioEditionFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
|
|
newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
|
|
}
|
|
}
|
|
|
|
async function checkNewVideoFromSubscription (options: CheckerBaseParams & {
|
|
videoName: string
|
|
shortUUID: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { videoName, shortUUID } = options
|
|
const notificationType = UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkVideo(notification.video, videoName, shortUUID)
|
|
checkActor(notification.video.channel)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.type !== UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION || n.video.name !== videoName
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
return text.indexOf(shortUUID) !== -1 && text.indexOf('Your subscription') !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkVideoIsPublished (options: CheckerBaseParams & {
|
|
videoName: string
|
|
shortUUID: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { videoName, shortUUID } = options
|
|
const notificationType = UserNotificationType.MY_VIDEO_PUBLISHED
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkVideo(notification.video, videoName, shortUUID)
|
|
checkActor(notification.video.channel)
|
|
} else {
|
|
expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
return text.includes(shortUUID) && text.includes('Your video')
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkVideoStudioEditionIsFinished (options: CheckerBaseParams & {
|
|
videoName: string
|
|
shortUUID: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { videoName, shortUUID } = options
|
|
const notificationType = UserNotificationType.MY_VIDEO_STUDIO_EDITION_FINISHED
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkVideo(notification.video, videoName, shortUUID)
|
|
checkActor(notification.video.channel)
|
|
} else {
|
|
expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
return text.includes(shortUUID) && text.includes('Edition of your video')
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkMyVideoImportIsFinished (options: CheckerBaseParams & {
|
|
videoName: string
|
|
shortUUID: string
|
|
url: string
|
|
success: boolean
|
|
checkType: CheckerType
|
|
}) {
|
|
const { videoName, shortUUID, url, success } = options
|
|
|
|
const notificationType = success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.videoImport.targetUrl).to.equal(url)
|
|
|
|
if (success) checkVideo(notification.videoImport.video, videoName, shortUUID)
|
|
} else {
|
|
expect(notification.videoImport).to.satisfy(i => i === undefined || i.targetUrl !== url)
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
const toFind = success ? ' finished' : ' error'
|
|
|
|
return text.includes(url) && text.includes(toFind)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkUserRegistered (options: CheckerBaseParams & {
|
|
username: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { username } = options
|
|
const notificationType = UserNotificationType.NEW_USER_REGISTRATION
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkActor(notification.account, { withAvatar: false })
|
|
expect(notification.account.name).to.equal(username)
|
|
} else {
|
|
expect(notification).to.satisfy(n => n.type !== notificationType || n.account.name !== username)
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
|
|
return text.includes(' registered.') && text.includes(username)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewActorFollow (options: CheckerBaseParams & {
|
|
followType: 'channel' | 'account'
|
|
followerName: string
|
|
followerDisplayName: string
|
|
followingDisplayName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { followType, followerName, followerDisplayName, followingDisplayName } = options
|
|
const notificationType = UserNotificationType.NEW_FOLLOW
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkActor(notification.actorFollow.follower)
|
|
expect(notification.actorFollow.follower.displayName).to.equal(followerDisplayName)
|
|
expect(notification.actorFollow.follower.name).to.equal(followerName)
|
|
expect(notification.actorFollow.follower.host).to.not.be.undefined
|
|
|
|
const following = notification.actorFollow.following
|
|
expect(following.displayName).to.equal(followingDisplayName)
|
|
expect(following.type).to.equal(followType)
|
|
} else {
|
|
expect(notification).to.satisfy(n => {
|
|
return n.type !== notificationType ||
|
|
(n.actorFollow.follower.name !== followerName && n.actorFollow.following !== followingDisplayName)
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
|
|
return text.includes(followType) && text.includes(followingDisplayName) && text.includes(followerDisplayName)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewInstanceFollower (options: CheckerBaseParams & {
|
|
followerHost: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { followerHost } = options
|
|
const notificationType = UserNotificationType.NEW_INSTANCE_FOLLOWER
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkActor(notification.actorFollow.follower, { withAvatar: false })
|
|
expect(notification.actorFollow.follower.name).to.equal('peertube')
|
|
expect(notification.actorFollow.follower.host).to.equal(followerHost)
|
|
|
|
expect(notification.actorFollow.following.name).to.equal('peertube')
|
|
} else {
|
|
expect(notification).to.satisfy(n => {
|
|
return n.type !== notificationType || n.actorFollow.follower.host !== followerHost
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
|
|
return text.includes('instance has a new follower') && text.includes(followerHost)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkAutoInstanceFollowing (options: CheckerBaseParams & {
|
|
followerHost: string
|
|
followingHost: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { followerHost, followingHost } = options
|
|
const notificationType = UserNotificationType.AUTO_INSTANCE_FOLLOWING
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
const following = notification.actorFollow.following
|
|
|
|
checkActor(following, { withAvatar: false })
|
|
expect(following.name).to.equal('peertube')
|
|
expect(following.host).to.equal(followingHost)
|
|
|
|
expect(notification.actorFollow.follower.name).to.equal('peertube')
|
|
expect(notification.actorFollow.follower.host).to.equal(followerHost)
|
|
} else {
|
|
expect(notification).to.satisfy(n => {
|
|
return n.type !== notificationType || n.actorFollow.following.host !== followingHost
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
|
|
return text.includes(' automatically followed a new instance') && text.includes(followingHost)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkCommentMention (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
commentId: number
|
|
threadId: number
|
|
byAccountDisplayName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { shortUUID, commentId, threadId, byAccountDisplayName } = options
|
|
const notificationType = UserNotificationType.COMMENT_MENTION
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkComment(notification.comment, commentId, threadId)
|
|
checkActor(notification.comment.account)
|
|
expect(notification.comment.account.displayName).to.equal(byAccountDisplayName)
|
|
|
|
checkVideo(notification.comment.video, undefined, shortUUID)
|
|
} else {
|
|
expect(notification).to.satisfy(n => n.type !== notificationType || n.comment.id !== commentId)
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text: string = email['text']
|
|
|
|
return text.includes(' mentioned ') && text.includes(shortUUID) && text.includes(byAccountDisplayName)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
let lastEmailCount = 0
|
|
|
|
async function checkNewCommentOnMyVideo (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
commentId: number
|
|
threadId: number
|
|
checkType: CheckerType
|
|
}) {
|
|
const { server, shortUUID, commentId, threadId, checkType, emails } = options
|
|
const notificationType = UserNotificationType.NEW_COMMENT_ON_MY_VIDEO
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
checkComment(notification.comment, commentId, threadId)
|
|
checkActor(notification.comment.account)
|
|
checkVideo(notification.comment.video, undefined, shortUUID)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.comment === undefined || n.comment.id !== commentId
|
|
})
|
|
}
|
|
}
|
|
|
|
const commentUrl = `http://localhost:${server.port}/w/${shortUUID};threadId=${threadId}`
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
return email['text'].indexOf(commentUrl) !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
|
|
if (checkType === 'presence') {
|
|
// We cannot detect email duplicates, so check we received another email
|
|
expect(emails).to.have.length.above(lastEmailCount)
|
|
lastEmailCount = emails.length
|
|
}
|
|
}
|
|
|
|
async function checkNewVideoAbuseForModerators (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
videoName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { shortUUID, videoName } = options
|
|
const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.abuse.id).to.be.a('number')
|
|
checkVideo(notification.abuse.video, videoName, shortUUID)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.abuse === undefined || n.abuse.video.shortUUID !== shortUUID
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewAbuseMessage (options: CheckerBaseParams & {
|
|
abuseId: number
|
|
message: string
|
|
toEmail: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { abuseId, message, toEmail } = options
|
|
const notificationType = UserNotificationType.ABUSE_NEW_MESSAGE
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.abuse.id).to.equal(abuseId)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.type !== notificationType || n.abuse === undefined || n.abuse.id !== abuseId
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
const to = email['to'].filter(t => t.address === toEmail)
|
|
|
|
return text.indexOf(message) !== -1 && to.length !== 0
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkAbuseStateChange (options: CheckerBaseParams & {
|
|
abuseId: number
|
|
state: AbuseState
|
|
checkType: CheckerType
|
|
}) {
|
|
const { abuseId, state } = options
|
|
const notificationType = UserNotificationType.ABUSE_STATE_CHANGE
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.abuse.id).to.equal(abuseId)
|
|
expect(notification.abuse.state).to.equal(state)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.abuse === undefined || n.abuse.id !== abuseId
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
|
|
const contains = state === AbuseState.ACCEPTED
|
|
? ' accepted'
|
|
: ' rejected'
|
|
|
|
return text.indexOf(contains) !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewCommentAbuseForModerators (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
videoName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { shortUUID, videoName } = options
|
|
const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.abuse.id).to.be.a('number')
|
|
checkVideo(notification.abuse.comment.video, videoName, shortUUID)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.abuse === undefined || n.abuse.comment.video.shortUUID !== shortUUID
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
return text.indexOf(shortUUID) !== -1 && text.indexOf('abuse') !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewAccountAbuseForModerators (options: CheckerBaseParams & {
|
|
displayName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { displayName } = options
|
|
const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.abuse.id).to.be.a('number')
|
|
expect(notification.abuse.account.displayName).to.equal(displayName)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.abuse === undefined || n.abuse.account.displayName !== displayName
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
return text.indexOf(displayName) !== -1 && text.indexOf('abuse') !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkVideoAutoBlacklistForModerators (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
videoName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { shortUUID, videoName } = options
|
|
const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.videoBlacklist.video.id).to.be.a('number')
|
|
checkVideo(notification.videoBlacklist.video, videoName, shortUUID)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.video === undefined || n.video.shortUUID !== shortUUID
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
return text.indexOf(shortUUID) !== -1 && email['text'].indexOf('video-auto-blacklist/list') !== -1
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewBlacklistOnMyVideo (options: CheckerBaseParams & {
|
|
shortUUID: string
|
|
videoName: string
|
|
blacklistType: 'blacklist' | 'unblacklist'
|
|
}) {
|
|
const { videoName, shortUUID, blacklistType } = options
|
|
const notificationType = blacklistType === 'blacklist'
|
|
? UserNotificationType.BLACKLIST_ON_MY_VIDEO
|
|
: UserNotificationType.UNBLACKLIST_ON_MY_VIDEO
|
|
|
|
function notificationChecker (notification: UserNotification) {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
const video = blacklistType === 'blacklist' ? notification.videoBlacklist.video : notification.video
|
|
|
|
checkVideo(video, videoName, shortUUID)
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
const blacklistText = blacklistType === 'blacklist'
|
|
? 'blacklisted'
|
|
: 'unblacklisted'
|
|
|
|
return text.includes(shortUUID) && text.includes(blacklistText)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder, checkType: 'presence' })
|
|
}
|
|
|
|
async function checkNewPeerTubeVersion (options: CheckerBaseParams & {
|
|
latestVersion: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { latestVersion } = options
|
|
const notificationType = UserNotificationType.NEW_PEERTUBE_VERSION
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.peertube).to.exist
|
|
expect(notification.peertube.latestVersion).to.equal(latestVersion)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.peertube === undefined || n.peertube.latestVersion !== latestVersion
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
|
|
return text.includes(latestVersion)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function checkNewPluginVersion (options: CheckerBaseParams & {
|
|
pluginType: PluginType
|
|
pluginName: string
|
|
checkType: CheckerType
|
|
}) {
|
|
const { pluginName, pluginType } = options
|
|
const notificationType = UserNotificationType.NEW_PLUGIN_VERSION
|
|
|
|
function notificationChecker (notification: UserNotification, checkType: CheckerType) {
|
|
if (checkType === 'presence') {
|
|
expect(notification).to.not.be.undefined
|
|
expect(notification.type).to.equal(notificationType)
|
|
|
|
expect(notification.plugin.name).to.equal(pluginName)
|
|
expect(notification.plugin.type).to.equal(pluginType)
|
|
} else {
|
|
expect(notification).to.satisfy((n: UserNotification) => {
|
|
return n === undefined || n.plugin === undefined || n.plugin.name !== pluginName
|
|
})
|
|
}
|
|
}
|
|
|
|
function emailNotificationFinder (email: object) {
|
|
const text = email['text']
|
|
|
|
return text.includes(pluginName)
|
|
}
|
|
|
|
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
|
|
}
|
|
|
|
async function prepareNotificationsTest (serversCount = 3, overrideConfigArg: any = {}) {
|
|
const userNotifications: UserNotification[] = []
|
|
const adminNotifications: UserNotification[] = []
|
|
const adminNotificationsServer2: UserNotification[] = []
|
|
const emails: object[] = []
|
|
|
|
const port = await MockSmtpServer.Instance.collectEmails(emails)
|
|
|
|
const overrideConfig = {
|
|
smtp: {
|
|
hostname: 'localhost',
|
|
port
|
|
},
|
|
signup: {
|
|
limit: 20
|
|
}
|
|
}
|
|
const servers = await createMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
|
|
|
|
await setAccessTokensToServers(servers)
|
|
await setDefaultVideoChannel(servers)
|
|
await setDefaultChannelAvatar(servers)
|
|
await setDefaultAccountAvatar(servers)
|
|
|
|
if (servers[1]) {
|
|
await servers[1].config.enableStudio()
|
|
await servers[1].config.enableLive({ allowReplay: true, transcoding: false })
|
|
}
|
|
|
|
if (serversCount > 1) {
|
|
await doubleFollow(servers[0], servers[1])
|
|
}
|
|
|
|
const user = { username: 'user_1', password: 'super password' }
|
|
await servers[0].users.create({ ...user, videoQuota: 10 * 1000 * 1000 })
|
|
const userAccessToken = await servers[0].login.getAccessToken(user)
|
|
|
|
await servers[0].notifications.updateMySettings({ token: userAccessToken, settings: getAllNotificationsSettings() })
|
|
await servers[0].users.updateMyAvatar({ token: userAccessToken, fixture: 'avatar.png' })
|
|
await servers[0].channels.updateImage({ channelName: 'user_1_channel', token: userAccessToken, fixture: 'avatar.png', type: 'avatar' })
|
|
|
|
await servers[0].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
|
|
|
|
if (serversCount > 1) {
|
|
await servers[1].notifications.updateMySettings({ settings: getAllNotificationsSettings() })
|
|
}
|
|
|
|
{
|
|
const socket = servers[0].socketIO.getUserNotificationSocket({ token: userAccessToken })
|
|
socket.on('new-notification', n => userNotifications.push(n))
|
|
}
|
|
{
|
|
const socket = servers[0].socketIO.getUserNotificationSocket()
|
|
socket.on('new-notification', n => adminNotifications.push(n))
|
|
}
|
|
|
|
if (serversCount > 1) {
|
|
const socket = servers[1].socketIO.getUserNotificationSocket()
|
|
socket.on('new-notification', n => adminNotificationsServer2.push(n))
|
|
}
|
|
|
|
const { videoChannels } = await servers[0].users.getMyInfo()
|
|
const channelId = videoChannels[0].id
|
|
|
|
return {
|
|
userNotifications,
|
|
adminNotifications,
|
|
adminNotificationsServer2,
|
|
userAccessToken,
|
|
emails,
|
|
servers,
|
|
channelId
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export {
|
|
getAllNotificationsSettings,
|
|
|
|
CheckerBaseParams,
|
|
CheckerType,
|
|
checkMyVideoImportIsFinished,
|
|
checkUserRegistered,
|
|
checkAutoInstanceFollowing,
|
|
checkVideoIsPublished,
|
|
checkNewVideoFromSubscription,
|
|
checkNewActorFollow,
|
|
checkNewCommentOnMyVideo,
|
|
checkNewBlacklistOnMyVideo,
|
|
checkCommentMention,
|
|
checkNewVideoAbuseForModerators,
|
|
checkVideoAutoBlacklistForModerators,
|
|
checkNewAbuseMessage,
|
|
checkAbuseStateChange,
|
|
checkNewInstanceFollower,
|
|
prepareNotificationsTest,
|
|
checkNewCommentAbuseForModerators,
|
|
checkNewAccountAbuseForModerators,
|
|
checkNewPeerTubeVersion,
|
|
checkNewPluginVersion,
|
|
checkVideoStudioEditionIsFinished
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
async function checkNotification (options: CheckerBaseParams & {
|
|
notificationChecker: (notification: UserNotification, checkType: CheckerType) => void
|
|
emailNotificationFinder: (email: object) => boolean
|
|
checkType: CheckerType
|
|
}) {
|
|
const { server, token, checkType, notificationChecker, emailNotificationFinder, socketNotifications, emails } = options
|
|
|
|
const check = options.check || { web: true, mail: true }
|
|
|
|
if (check.web) {
|
|
const notification = await server.notifications.getLatest({ token })
|
|
|
|
if (notification || checkType !== 'absence') {
|
|
notificationChecker(notification, checkType)
|
|
}
|
|
|
|
const socketNotification = socketNotifications.find(n => {
|
|
try {
|
|
notificationChecker(n, 'presence')
|
|
return true
|
|
} catch {
|
|
return false
|
|
}
|
|
})
|
|
|
|
if (checkType === 'presence') {
|
|
const obj = inspect(socketNotifications, { depth: 5 })
|
|
expect(socketNotification, 'The socket notification is absent when it should be present. ' + obj).to.not.be.undefined
|
|
} else {
|
|
const obj = inspect(socketNotification, { depth: 5 })
|
|
expect(socketNotification, 'The socket notification is present when it should not be present. ' + obj).to.be.undefined
|
|
}
|
|
}
|
|
|
|
if (check.mail) {
|
|
// Last email
|
|
const email = emails
|
|
.slice()
|
|
.reverse()
|
|
.find(e => emailNotificationFinder(e))
|
|
|
|
if (checkType === 'presence') {
|
|
const texts = emails.map(e => e.text)
|
|
expect(email, 'The email is absent when is should be present. ' + inspect(texts)).to.not.be.undefined
|
|
} else {
|
|
expect(email, 'The email is present when is should not be present. ' + inspect(email)).to.be.undefined
|
|
}
|
|
}
|
|
}
|
|
|
|
function checkVideo (video: any, videoName?: string, shortUUID?: string) {
|
|
if (videoName) {
|
|
expect(video.name).to.be.a('string')
|
|
expect(video.name).to.not.be.empty
|
|
expect(video.name).to.equal(videoName)
|
|
}
|
|
|
|
if (shortUUID) {
|
|
expect(video.shortUUID).to.be.a('string')
|
|
expect(video.shortUUID).to.not.be.empty
|
|
expect(video.shortUUID).to.equal(shortUUID)
|
|
}
|
|
|
|
expect(video.id).to.be.a('number')
|
|
}
|
|
|
|
function checkActor (actor: any, options: { withAvatar?: boolean } = {}) {
|
|
const { withAvatar = true } = options
|
|
|
|
expect(actor.displayName).to.be.a('string')
|
|
expect(actor.displayName).to.not.be.empty
|
|
expect(actor.host).to.not.be.undefined
|
|
|
|
if (withAvatar) {
|
|
expect(actor.avatars).to.be.an('array')
|
|
expect(actor.avatars).to.have.lengthOf(2)
|
|
expect(actor.avatars[0].path).to.exist.and.not.empty
|
|
}
|
|
}
|
|
|
|
function checkComment (comment: any, commentId: number, threadId: number) {
|
|
expect(comment.id).to.equal(commentId)
|
|
expect(comment.threadId).to.equal(threadId)
|
|
}
|