/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
-import { UserNotification, UserNotificationSetting, UserNotificationType } from '../../models/users'
-import { ServerInfo } from '..'
import { expect } from 'chai'
import { inspect } from 'util'
+import { AbuseState, PluginType } from '@shared/models'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { UserNotification, UserNotificationSetting, UserNotificationSettingValue, UserNotificationType } from '../../models/users'
+import { MockSmtpServer } from '../miscs/email'
+import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
+import { doubleFollow } from '../server/follows'
+import { flushAndRunMultipleServers, ServerInfo } from '../server/servers'
+import { getUserNotificationSocket } from '../socket/socket-io'
+import { setAccessTokensToServers, userLogin } from './login'
+import { createUser, getMyUserInformation } from './users'
-function updateMyNotificationSettings (url: string, token: string, settings: UserNotificationSetting, statusCodeExpected = 204) {
+function updateMyNotificationSettings (
+ url: string,
+ token: string,
+ settings: UserNotificationSetting,
+ statusCodeExpected = HttpStatusCode.NO_CONTENT_204
+) {
const path = '/api/v1/users/me/notification-settings'
return makePutBodyRequest({
count: number,
unread?: boolean,
sort = '-createdAt',
- statusCodeExpected = 200
+ statusCodeExpected = HttpStatusCode.OK_200
) {
const path = '/api/v1/users/me/notifications'
})
}
-function markAsReadNotifications (url: string, token: string, ids: number[], statusCodeExpected = 204) {
+function markAsReadNotifications (url: string, token: string, ids: number[], statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
const path = '/api/v1/users/me/notifications/read'
return makePostBodyRequest({
})
}
-function markAsReadAllNotifications (url: string, token: string, statusCodeExpected = 204) {
+function markAsReadAllNotifications (url: string, token: string, statusCodeExpected = HttpStatusCode.NO_CONTENT_204) {
const path = '/api/v1/users/me/notifications/read-all'
return makePostBodyRequest({
type CheckerBaseParams = {
server: ServerInfo
- emails: object[]
+ emails: any[]
socketNotifications: UserNotification[]
token: string
check?: { web: boolean, mail: boolean }
if (checkType === 'presence') {
const obj = inspect(base.socketNotifications, { depth: 5 })
- expect(socketNotification, 'The socket notification is absent when is should be present. ' + obj).to.not.be.undefined
+ 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 is should not be present. ' + obj).to.be.undefined
+ expect(socketNotification, 'The socket notification is present when it should not be present. ' + obj).to.be.undefined
}
}
.find(e => emailNotificationFinder(e))
if (checkType === 'presence') {
- expect(email, 'The email is absent when is should be present. ' + inspect(base.emails)).to.not.be.undefined
+ const emails = base.emails.map(e => e.text)
+ expect(email, 'The email is absent when is should be present. ' + inspect(emails)).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, videoUUID?: string) {
- expect(video.name).to.be.a('string')
- expect(video.name).to.not.be.empty
- if (videoName) expect(video.name).to.equal(videoName)
+ if (videoName) {
+ expect(video.name).to.be.a('string')
+ expect(video.name).to.not.be.empty
+ expect(video.name).to.equal(videoName)
+ }
- expect(video.uuid).to.be.a('string')
- expect(video.uuid).to.not.be.empty
- if (videoUUID) expect(video.uuid).to.equal(videoUUID)
+ if (videoUUID) {
+ expect(video.uuid).to.be.a('string')
+ expect(video.uuid).to.not.be.empty
+ expect(video.uuid).to.equal(videoUUID)
+ }
expect(video.id).to.be.a('number')
}
}
async function checkNewVideoAbuseForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
- const notificationType = UserNotificationType.NEW_VIDEO_ABUSE_FOR_MODERATORS
+ const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
function notificationChecker (notification: UserNotification, type: CheckerType) {
if (type === 'presence') {
expect(notification).to.not.be.undefined
expect(notification.type).to.equal(notificationType)
- expect(notification.videoAbuse.id).to.be.a('number')
- checkVideo(notification.videoAbuse.video, videoName, videoUUID)
+ expect(notification.abuse.id).to.be.a('number')
+ checkVideo(notification.abuse.video, videoName, videoUUID)
} else {
expect(notification).to.satisfy((n: UserNotification) => {
- return n === undefined || n.videoAbuse === undefined || n.videoAbuse.video.uuid !== videoUUID
+ return n === undefined || n.abuse === undefined || n.abuse.video.uuid !== videoUUID
})
}
}
await checkNotification(base, notificationChecker, emailNotificationFinder, type)
}
+async function checkNewAbuseMessage (base: CheckerBaseParams, abuseId: number, message: string, toEmail: string, type: CheckerType) {
+ const notificationType = UserNotificationType.ABUSE_NEW_MESSAGE
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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(base, notificationChecker, emailNotificationFinder, type)
+}
+
+async function checkAbuseStateChange (base: CheckerBaseParams, abuseId: number, state: AbuseState, type: CheckerType) {
+ const notificationType = UserNotificationType.ABUSE_STATE_CHANGE
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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(base, notificationChecker, emailNotificationFinder, type)
+}
+
+async function checkNewCommentAbuseForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
+ const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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, videoUUID)
+ } else {
+ expect(notification).to.satisfy((n: UserNotification) => {
+ return n === undefined || n.abuse === undefined || n.abuse.comment.video.uuid !== videoUUID
+ })
+ }
+ }
+
+ function emailNotificationFinder (email: object) {
+ const text = email['text']
+ return text.indexOf(videoUUID) !== -1 && text.indexOf('abuse') !== -1
+ }
+
+ await checkNotification(base, notificationChecker, emailNotificationFinder, type)
+}
+
+async function checkNewAccountAbuseForModerators (base: CheckerBaseParams, displayName: string, type: CheckerType) {
+ const notificationType = UserNotificationType.NEW_ABUSE_FOR_MODERATORS
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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(base, notificationChecker, emailNotificationFinder, type)
+}
+
async function checkVideoAutoBlacklistForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
- const notificationType = UserNotificationType.VIDEO_AUTO_BLOCK_FOR_MODERATORS
+ const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
function notificationChecker (notification: UserNotification, type: CheckerType) {
if (type === 'presence') {
blacklistType: 'blacklist' | 'unblacklist'
) {
const notificationType = blacklistType === 'blacklist'
- ? UserNotificationType.BLOCK_ON_MY_VIDEO
- : UserNotificationType.UNBLOCK_ON_MY_VIDEO
+ ? UserNotificationType.BLACKLIST_ON_MY_VIDEO
+ : UserNotificationType.UNBLACKLIST_ON_MY_VIDEO
function notificationChecker (notification: UserNotification) {
expect(notification).to.not.be.undefined
await checkNotification(base, notificationChecker, emailNotificationFinder, 'presence')
}
+async function checkNewPeerTubeVersion (base: CheckerBaseParams, latestVersion: string, type: CheckerType) {
+ const notificationType = UserNotificationType.NEW_PEERTUBE_VERSION
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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(base, notificationChecker, emailNotificationFinder, type)
+}
+
+async function checkNewPluginVersion (base: CheckerBaseParams, pluginType: PluginType, pluginName: string, type: CheckerType) {
+ const notificationType = UserNotificationType.NEW_PLUGIN_VERSION
+
+ function notificationChecker (notification: UserNotification, type: CheckerType) {
+ if (type === '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(base, notificationChecker, emailNotificationFinder, type)
+}
+
+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,
+ newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+ }
+}
+
+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 flushAndRunMultipleServers(serversCount, Object.assign(overrideConfig, overrideConfigArg))
+
+ await setAccessTokensToServers(servers)
+
+ if (serversCount > 1) {
+ await doubleFollow(servers[0], servers[1])
+ }
+
+ const user = {
+ username: 'user_1',
+ password: 'super password'
+ }
+ await createUser({
+ url: servers[0].url,
+ accessToken: servers[0].accessToken,
+ username: user.username,
+ password: user.password,
+ videoQuota: 10 * 1000 * 1000
+ })
+ const userAccessToken = await userLogin(servers[0], user)
+
+ await updateMyNotificationSettings(servers[0].url, userAccessToken, getAllNotificationsSettings())
+ await updateMyNotificationSettings(servers[0].url, servers[0].accessToken, getAllNotificationsSettings())
+
+ if (serversCount > 1) {
+ await updateMyNotificationSettings(servers[1].url, servers[1].accessToken, getAllNotificationsSettings())
+ }
+
+ {
+ const socket = getUserNotificationSocket(servers[0].url, userAccessToken)
+ socket.on('new-notification', n => userNotifications.push(n))
+ }
+ {
+ const socket = getUserNotificationSocket(servers[0].url, servers[0].accessToken)
+ socket.on('new-notification', n => adminNotifications.push(n))
+ }
+
+ if (serversCount > 1) {
+ const socket = getUserNotificationSocket(servers[1].url, servers[1].accessToken)
+ socket.on('new-notification', n => adminNotificationsServer2.push(n))
+ }
+
+ const resChannel = await getMyUserInformation(servers[0].url, servers[0].accessToken)
+ const channelId = resChannel.body.videoChannels[0].id
+
+ return {
+ userNotifications,
+ adminNotifications,
+ adminNotificationsServer2,
+ userAccessToken,
+ emails,
+ servers,
+ channelId
+ }
+}
+
// ---------------------------------------------------------------------------
export {
CheckerBaseParams,
CheckerType,
+ getAllNotificationsSettings,
checkNotification,
markAsReadAllNotifications,
checkMyVideoImportIsFinished,
updateMyNotificationSettings,
checkNewVideoAbuseForModerators,
checkVideoAutoBlacklistForModerators,
+ checkNewAbuseMessage,
+ checkAbuseStateChange,
getUserNotifications,
markAsReadNotifications,
getLastNotification,
- checkNewInstanceFollower
+ checkNewInstanceFollower,
+ prepareNotificationsTest,
+ checkNewCommentAbuseForModerators,
+ checkNewAccountAbuseForModerators,
+ checkNewPeerTubeVersion,
+ checkNewPluginVersion
}