[github/Chocobozzz/PeerTube.git] / shared / extra-utils / users / user-notifications.ts

/* tslint:disable:no-unused-expression */

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'

function updateMyNotificationSettings (url: string, token: string, settings: UserNotificationSetting, statusCodeExpected = 204) {
  const path = '/api/v1/users/me/notification-settings'

  return makePutBodyRequest({
    url,
    path,
    token,
    fields: settings,
    statusCodeExpected
  })
}

async function getUserNotifications (
  url: string,
  token: string,
  start: number,
  count: number,
  unread?: boolean,
  sort = '-createdAt',
  statusCodeExpected = 200
) {
  const path = '/api/v1/users/me/notifications'

  return makeGetRequest({
    url,
    path,
    token,
    query: {
      start,
      count,
      sort,
      unread
    },
    statusCodeExpected
  })
}

function markAsReadNotifications (url: string, token: string, ids: number[], statusCodeExpected = 204) {
  const path = '/api/v1/users/me/notifications/read'

  return makePostBodyRequest({
    url,
    path,
    token,
    fields: { ids },
    statusCodeExpected
  })
}
function markAsReadAllNotifications (url: string, token: string, statusCodeExpected = 204) {
  const path = '/api/v1/users/me/notifications/read-all'

  return makePostBodyRequest({
    url,
    path,
    token,
    statusCodeExpected
  })
}

async function getLastNotification (serverUrl: string, accessToken: string) {
  const res = await getUserNotifications(serverUrl, accessToken, 0, 1, undefined, '-createdAt')

  if (res.body.total === 0) return undefined

  return res.body.data[0] as UserNotification
}

type CheckerBaseParams = {
  server: ServerInfo
  emails: object[]
  socketNotifications: UserNotification[]
  token: string,
  check?: { web: boolean, mail: boolean }
}

type CheckerType = 'presence' | 'absence'

async function checkNotification (
  base: CheckerBaseParams,
  notificationChecker: (notification: UserNotification, type: CheckerType) => void,
  emailNotificationFinder: (email: object) => boolean,
  checkType: CheckerType
) {
  const check = base.check || { web: true, mail: true }

  if (check.web) {
    const notification = await getLastNotification(base.server.url, base.token)

    if (notification || checkType !== 'absence') {
      notificationChecker(notification, checkType)
    }

    const socketNotification = base.socketNotifications.find(n => {
      try {
        notificationChecker(n, 'presence')
        return true
      } catch {
        return false
      }
    })

    if (checkType === 'presence') {
      const obj = inspect(base.socketNotifications, { depth: 5 })
      expect(socketNotification, 'The socket notification is absent. ' + obj).to.not.be.undefined
    } else {
      const obj = inspect(socketNotification, { depth: 5 })
      expect(socketNotification, 'The socket notification is present. ' + obj).to.be.undefined
    }
  }

  if (check.mail) {
    // Last email
    const email = base.emails
                      .slice()
                      .reverse()
                      .find(e => emailNotificationFinder(e))

    if (checkType === 'presence') {
      expect(email, 'The email is absent. ' + inspect(base.emails)).to.not.be.undefined
    } else {
      expect(email, 'The email is 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)

  expect(video.uuid).to.be.a('string')
  expect(video.uuid).to.not.be.empty
  if (videoUUID) expect(video.uuid).to.equal(videoUUID)

  expect(video.id).to.be.a('number')
}

function checkActor (actor: any) {
  expect(actor.displayName).to.be.a('string')
  expect(actor.displayName).to.not.be.empty
  expect(actor.host).to.not.be.undefined
}

function checkComment (comment: any, commentId: number, threadId: number) {
  expect(comment.id).to.equal(commentId)
  expect(comment.threadId).to.equal(threadId)
}

async function checkNewVideoFromSubscription (base: CheckerBaseParams, videoName: string, videoUUID: string, type: CheckerType) {
  const notificationType = UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === 'presence') {
      expect(notification).to.not.be.undefined
      expect(notification.type).to.equal(notificationType)

      checkVideo(notification.video, videoName, videoUUID)
      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 emailFinder (email: object) {
    const text = email[ 'text' ]
    return text.indexOf(videoUUID) !== -1 && text.indexOf('Your subscription') !== -1
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkVideoIsPublished (base: CheckerBaseParams, videoName: string, videoUUID: string, type: CheckerType) {
  const notificationType = UserNotificationType.MY_VIDEO_PUBLISHED

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === 'presence') {
      expect(notification).to.not.be.undefined
      expect(notification.type).to.equal(notificationType)

      checkVideo(notification.video, videoName, videoUUID)
      checkActor(notification.video.channel)
    } else {
      expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
    }
  }

  function emailFinder (email: object) {
    const text: string = email[ 'text' ]
    return text.includes(videoUUID) && text.includes('Your video')
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkMyVideoImportIsFinished (
  base: CheckerBaseParams,
  videoName: string,
  videoUUID: string,
  url: string,
  success: boolean,
  type: CheckerType
) {
  const notificationType = success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === '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, videoUUID)
    } else {
      expect(notification.videoImport).to.satisfy(i => i === undefined || i.targetUrl !== url)
    }
  }

  function emailFinder (email: object) {
    const text: string = email[ 'text' ]
    const toFind = success ? ' finished' : ' error'

    return text.includes(url) && text.includes(toFind)
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkUserRegistered (base: CheckerBaseParams, username: string, type: CheckerType) {
  const notificationType = UserNotificationType.NEW_USER_REGISTRATION

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === 'presence') {
      expect(notification).to.not.be.undefined
      expect(notification.type).to.equal(notificationType)

      checkActor(notification.account)
      expect(notification.account.name).to.equal(username)
    } else {
      expect(notification).to.satisfy(n => n.type !== notificationType || n.account.name !== username)
    }
  }

  function emailFinder (email: object) {
    const text: string = email[ 'text' ]

    return text.includes(' registered ') && text.includes(username)
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkNewActorFollow (
  base: CheckerBaseParams,
  followType: 'channel' | 'account',
  followerName: string,
  followerDisplayName: string,
  followingDisplayName: string,
  type: CheckerType
) {
  const notificationType = UserNotificationType.NEW_FOLLOW

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === '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

      expect(notification.actorFollow.following.displayName).to.equal(followingDisplayName)
      expect(notification.actorFollow.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 emailFinder (email: object) {
    const text: string = email[ 'text' ]

    return text.includes('Your ' + followType) && text.includes(followingDisplayName) && text.includes(followerDisplayName)
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkNewInstanceFollower (base: CheckerBaseParams, followerHost: string, type: CheckerType) {
  const notificationType = UserNotificationType.NEW_INSTANCE_FOLLOWER

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === 'presence') {
      expect(notification).to.not.be.undefined
      expect(notification.type).to.equal(notificationType)

      checkActor(notification.actorFollow.follower)
      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 emailFinder (email: object) {
    const text: string = email[ 'text' ]

    return text.includes('instance has a new follower') && text.includes(followerHost)
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkCommentMention (
  base: CheckerBaseParams,
  uuid: string,
  commentId: number,
  threadId: number,
  byAccountDisplayName: string,
  type: CheckerType
) {
  const notificationType = UserNotificationType.COMMENT_MENTION

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === '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, uuid)
    } else {
      expect(notification).to.satisfy(n => n.type !== notificationType || n.comment.id !== commentId)
    }
  }

  function emailFinder (email: object) {
    const text: string = email[ 'text' ]

    return text.includes(' mentioned ') && text.includes(uuid) && text.includes(byAccountDisplayName)
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

let lastEmailCount = 0
async function checkNewCommentOnMyVideo (base: CheckerBaseParams, uuid: string, commentId: number, threadId: number, type: CheckerType) {
  const notificationType = UserNotificationType.NEW_COMMENT_ON_MY_VIDEO

  function notificationChecker (notification: UserNotification, type: CheckerType) {
    if (type === '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, uuid)
    } else {
      expect(notification).to.satisfy((n: UserNotification) => {
        return n === undefined || n.comment === undefined || n.comment.id !== commentId
      })
    }
  }

  const commentUrl = `http://localhost:${base.server.port}/videos/watch/${uuid};threadId=${threadId}`
  function emailFinder (email: object) {
    return email[ 'text' ].indexOf(commentUrl) !== -1
  }

  await checkNotification(base, notificationChecker, emailFinder, type)

  if (type === 'presence') {
    // We cannot detect email duplicates, so check we received another email
    expect(base.emails).to.have.length.above(lastEmailCount)
    lastEmailCount = base.emails.length
  }
}

async function checkNewVideoAbuseForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
  const notificationType = UserNotificationType.NEW_VIDEO_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)
    } else {
      expect(notification).to.satisfy((n: UserNotification) => {
        return n === undefined || n.videoAbuse === undefined || n.videoAbuse.video.uuid !== videoUUID
      })
    }
  }

  function emailFinder (email: object) {
    const text = email[ 'text' ]
    return text.indexOf(videoUUID) !== -1 && text.indexOf('abuse') !== -1
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkVideoAutoBlacklistForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
  const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_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.video.id).to.be.a('number')
      checkVideo(notification.video, videoName, videoUUID)
    } else {
      expect(notification).to.satisfy((n: UserNotification) => {
        return n === undefined || n.video === undefined || n.video.uuid !== videoUUID
      })
    }
  }

  function emailFinder (email: object) {
    const text = email[ 'text' ]
    return text.indexOf(videoUUID) !== -1 && email[ 'text' ].indexOf('video-auto-blacklist/list') !== -1
  }

  await checkNotification(base, notificationChecker, emailFinder, type)
}

async function checkNewBlacklistOnMyVideo (
  base: CheckerBaseParams,
  videoUUID: string,
  videoName: string,
  blacklistType: 'blacklist' | 'unblacklist'
) {
  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, videoUUID)
  }

  function emailFinder (email: object) {
    const text = email[ 'text' ]
    return text.indexOf(videoUUID) !== -1 && text.indexOf(' ' + blacklistType) !== -1
  }

  await checkNotification(base, notificationChecker, emailFinder, 'presence')
}

// ---------------------------------------------------------------------------

export {
  CheckerBaseParams,
  CheckerType,
  checkNotification,
  markAsReadAllNotifications,
  checkMyVideoImportIsFinished,
  checkUserRegistered,
  checkVideoIsPublished,
  checkNewVideoFromSubscription,
  checkNewActorFollow,
  checkNewCommentOnMyVideo,
  checkNewBlacklistOnMyVideo,
  checkCommentMention,
  updateMyNotificationSettings,
  checkNewVideoAbuseForModerators,
  checkVideoAutoBlacklistForModerators,
  getUserNotifications,
  markAsReadNotifications,
  getLastNotification,
  checkNewInstanceFollower
}
Commit	Line	Data
cef534ed C	1	/* tslint:disable:no-unused-expression */
	2
	3	import { makeGetRequest, makePostBodyRequest, makePutBodyRequest } from '../requests/requests'
	4	import { UserNotification, UserNotificationSetting, UserNotificationType } from '../../models/users'
	5	import { ServerInfo } from '..'
	6	import { expect } from 'chai'
dc133480	7	import { inspect } from 'util'
cef534ed C	8
	9	function updateMyNotificationSettings (url: string, token: string, settings: UserNotificationSetting, statusCodeExpected = 204) {
	10	const path = '/api/v1/users/me/notification-settings'
	11
	12	return makePutBodyRequest({
	13	url,
	14	path,
	15	token,
	16	fields: settings,
	17	statusCodeExpected
	18	})
	19	}
	20
7ccddd7b	21	async function getUserNotifications (
dc133480 C	22	url: string,
	23	token: string,
	24	start: number,
	25	count: number,
	26	unread?: boolean,
	27	sort = '-createdAt',
	28	statusCodeExpected = 200
	29	) {
cef534ed C	30	const path = '/api/v1/users/me/notifications'
	31
	32	return makeGetRequest({
	33	url,
	34	path,
	35	token,
	36	query: {
	37	start,
	38	count,
dc133480 C	39	sort,
dc133480 C	40	unread
cef534ed C	41	},
	42	statusCodeExpected
	43	})
	44	}
	45
	46	function markAsReadNotifications (url: string, token: string, ids: number[], statusCodeExpected = 204) {
	47	const path = '/api/v1/users/me/notifications/read'
	48
	49	return makePostBodyRequest({
	50	url,
	51	path,
	52	token,
	53	fields: { ids },
	54	statusCodeExpected
	55	})
	56	}
2f1548fd C	57	function markAsReadAllNotifications (url: string, token: string, statusCodeExpected = 204) {
	58	const path = '/api/v1/users/me/notifications/read-all'
	59
	60	return makePostBodyRequest({
	61	url,
	62	path,
	63	token,
	64	statusCodeExpected
	65	})
	66	}
cef534ed C	67
cef534ed C	68	async function getLastNotification (serverUrl: string, accessToken: string) {
dc133480	69	const res = await getUserNotifications(serverUrl, accessToken, 0, 1, undefined, '-createdAt')
cef534ed C	70
	71	if (res.body.total === 0) return undefined
	72
	73	return res.body.data[0] as UserNotification
	74	}
	75
	76	type CheckerBaseParams = {
	77	server: ServerInfo
	78	emails: object[]
	79	socketNotifications: UserNotification[]
	80	token: string,
	81	check?: { web: boolean, mail: boolean }
	82	}
	83
	84	type CheckerType = 'presence' \| 'absence'
	85
	86	async function checkNotification (
	87	base: CheckerBaseParams,
dc133480	88	notificationChecker: (notification: UserNotification, type: CheckerType) => void,
cef534ed	89	emailNotificationFinder: (email: object) => boolean,
dc133480	90	checkType: CheckerType
cef534ed C	91	) {
	92	const check = base.check \|\| { web: true, mail: true }
	93
	94	if (check.web) {
	95	const notification = await getLastNotification(base.server.url, base.token)
cef534ed	96
dc133480 C	97	if (notification \|\| checkType !== 'absence') {
	98	notificationChecker(notification, checkType)
	99	}
cef534ed	100
dc133480 C	101	const socketNotification = base.socketNotifications.find(n => {
	102	try {
	103	notificationChecker(n, 'presence')
	104	return true
	105	} catch {
	106	return false
	107	}
	108	})
	109
	110	if (checkType === 'presence') {
f7cc67b4 C	111	const obj = inspect(base.socketNotifications, { depth: 5 })
f7cc67b4 C	112	expect(socketNotification, 'The socket notification is absent. ' + obj).to.not.be.undefined
dc133480	113	} else {
f7cc67b4 C	114	const obj = inspect(socketNotification, { depth: 5 })
f7cc67b4 C	115	expect(socketNotification, 'The socket notification is present. ' + obj).to.be.undefined
dc133480	116	}
cef534ed C	117	}
	118
	119	if (check.mail) {
	120	// Last email
	121	const email = base.emails
	122	.slice()
	123	.reverse()
	124	.find(e => emailNotificationFinder(e))
	125
dc133480 C	126	if (checkType === 'presence') {
	127	expect(email, 'The email is absent. ' + inspect(base.emails)).to.not.be.undefined
	128	} else {
	129	expect(email, 'The email is present. ' + inspect(email)).to.be.undefined
	130	}
cef534ed C	131	}
	132	}
	133
dc133480 C	134	function checkVideo (video: any, videoName?: string, videoUUID?: string) {
	135	expect(video.name).to.be.a('string')
	136	expect(video.name).to.not.be.empty
	137	if (videoName) expect(video.name).to.equal(videoName)
	138
	139	expect(video.uuid).to.be.a('string')
	140	expect(video.uuid).to.not.be.empty
	141	if (videoUUID) expect(video.uuid).to.equal(videoUUID)
	142
	143	expect(video.id).to.be.a('number')
	144	}
	145
f7cc67b4 C	146	function checkActor (actor: any) {
	147	expect(actor.displayName).to.be.a('string')
	148	expect(actor.displayName).to.not.be.empty
38967f7b	149	expect(actor.host).to.not.be.undefined
dc133480 C	150	}
	151
	152	function checkComment (comment: any, commentId: number, threadId: number) {
	153	expect(comment.id).to.equal(commentId)
	154	expect(comment.threadId).to.equal(threadId)
	155	}
	156
cef534ed C	157	async function checkNewVideoFromSubscription (base: CheckerBaseParams, videoName: string, videoUUID: string, type: CheckerType) {
	158	const notificationType = UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION
	159
dc133480	160	function notificationChecker (notification: UserNotification, type: CheckerType) {
cef534ed C	161	if (type === 'presence') {
	162	expect(notification).to.not.be.undefined
	163	expect(notification.type).to.equal(notificationType)
dc133480 C	164
	165	checkVideo(notification.video, videoName, videoUUID)
	166	checkActor(notification.video.channel)
cef534ed	167	} else {
7ccddd7b JM	168	expect(notification).to.satisfy((n: UserNotification) => {
	169	return n === undefined \|\| n.type !== UserNotificationType.NEW_VIDEO_FROM_SUBSCRIPTION \|\| n.video.name !== videoName
	170	})
cef534ed C	171	}
	172	}
	173
dc133480	174	function emailFinder (email: object) {
7ccddd7b JM	175	const text = email[ 'text' ]
7ccddd7b JM	176	return text.indexOf(videoUUID) !== -1 && text.indexOf('Your subscription') !== -1
dc133480 C	177	}
	178
	179	await checkNotification(base, notificationChecker, emailFinder, type)
	180	}
	181
	182	async function checkVideoIsPublished (base: CheckerBaseParams, videoName: string, videoUUID: string, type: CheckerType) {
	183	const notificationType = UserNotificationType.MY_VIDEO_PUBLISHED
	184
	185	function notificationChecker (notification: UserNotification, type: CheckerType) {
	186	if (type === 'presence') {
	187	expect(notification).to.not.be.undefined
	188	expect(notification.type).to.equal(notificationType)
	189
	190	checkVideo(notification.video, videoName, videoUUID)
	191	checkActor(notification.video.channel)
	192	} else {
	193	expect(notification.video).to.satisfy(v => v === undefined \|\| v.name !== videoName)
	194	}
cef534ed C	195	}
	196
	197	function emailFinder (email: object) {
dc133480 C	198	const text: string = email[ 'text' ]
dc133480 C	199	return text.includes(videoUUID) && text.includes('Your video')
cef534ed C	200	}
cef534ed C	201
dc133480 C	202	await checkNotification(base, notificationChecker, emailFinder, type)
	203	}
	204
	205	async function checkMyVideoImportIsFinished (
	206	base: CheckerBaseParams,
	207	videoName: string,
	208	videoUUID: string,
	209	url: string,
	210	success: boolean,
	211	type: CheckerType
	212	) {
	213	const notificationType = success ? UserNotificationType.MY_VIDEO_IMPORT_SUCCESS : UserNotificationType.MY_VIDEO_IMPORT_ERROR
	214
	215	function notificationChecker (notification: UserNotification, type: CheckerType) {
	216	if (type === 'presence') {
	217	expect(notification).to.not.be.undefined
	218	expect(notification.type).to.equal(notificationType)
	219
	220	expect(notification.videoImport.targetUrl).to.equal(url)
	221
	222	if (success) checkVideo(notification.videoImport.video, videoName, videoUUID)
	223	} else {
	224	expect(notification.videoImport).to.satisfy(i => i === undefined \|\| i.targetUrl !== url)
	225	}
	226	}
	227
	228	function emailFinder (email: object) {
	229	const text: string = email[ 'text' ]
	230	const toFind = success ? ' finished' : ' error'
	231
	232	return text.includes(url) && text.includes(toFind)
	233	}
	234
	235	await checkNotification(base, notificationChecker, emailFinder, type)
cef534ed C	236	}
cef534ed C	237
f7cc67b4 C	238	async function checkUserRegistered (base: CheckerBaseParams, username: string, type: CheckerType) {
	239	const notificationType = UserNotificationType.NEW_USER_REGISTRATION
	240
	241	function notificationChecker (notification: UserNotification, type: CheckerType) {
	242	if (type === 'presence') {
	243	expect(notification).to.not.be.undefined
	244	expect(notification.type).to.equal(notificationType)
	245
	246	checkActor(notification.account)
	247	expect(notification.account.name).to.equal(username)
	248	} else {
	249	expect(notification).to.satisfy(n => n.type !== notificationType \|\| n.account.name !== username)
	250	}
	251	}
	252
	253	function emailFinder (email: object) {
	254	const text: string = email[ 'text' ]
	255
	256	return text.includes(' registered ') && text.includes(username)
	257	}
	258
	259	await checkNotification(base, notificationChecker, emailFinder, type)
	260	}
	261
	262	async function checkNewActorFollow (
	263	base: CheckerBaseParams,
	264	followType: 'channel' \| 'account',
	265	followerName: string,
	266	followerDisplayName: string,
	267	followingDisplayName: string,
	268	type: CheckerType
	269	) {
	270	const notificationType = UserNotificationType.NEW_FOLLOW
	271
	272	function notificationChecker (notification: UserNotification, type: CheckerType) {
	273	if (type === 'presence') {
	274	expect(notification).to.not.be.undefined
	275	expect(notification.type).to.equal(notificationType)
	276
	277	checkActor(notification.actorFollow.follower)
	278	expect(notification.actorFollow.follower.displayName).to.equal(followerDisplayName)
	279	expect(notification.actorFollow.follower.name).to.equal(followerName)
ebff55d8	280	expect(notification.actorFollow.follower.host).to.not.be.undefined
f7cc67b4	281
f7cc67b4 C	282	expect(notification.actorFollow.following.displayName).to.equal(followingDisplayName)
	283	expect(notification.actorFollow.following.type).to.equal(followType)
	284	} else {
	285	expect(notification).to.satisfy(n => {
	286	return n.type !== notificationType \|\|
	287	(n.actorFollow.follower.name !== followerName && n.actorFollow.following !== followingDisplayName)
	288	})
	289	}
	290	}
	291
	292	function emailFinder (email: object) {
	293	const text: string = email[ 'text' ]
	294
	295	return text.includes('Your ' + followType) && text.includes(followingDisplayName) && text.includes(followerDisplayName)
	296	}
	297
	298	await checkNotification(base, notificationChecker, emailFinder, type)
	299	}
	300
883993c8 C	301	async function checkNewInstanceFollower (base: CheckerBaseParams, followerHost: string, type: CheckerType) {
	302	const notificationType = UserNotificationType.NEW_INSTANCE_FOLLOWER
	303
	304	function notificationChecker (notification: UserNotification, type: CheckerType) {
	305	if (type === 'presence') {
	306	expect(notification).to.not.be.undefined
	307	expect(notification.type).to.equal(notificationType)
	308
	309	checkActor(notification.actorFollow.follower)
	310	expect(notification.actorFollow.follower.name).to.equal('peertube')
	311	expect(notification.actorFollow.follower.host).to.equal(followerHost)
	312
	313	expect(notification.actorFollow.following.name).to.equal('peertube')
	314	} else {
	315	expect(notification).to.satisfy(n => {
	316	return n.type !== notificationType \|\| n.actorFollow.follower.host !== followerHost
	317	})
	318	}
	319	}
	320
	321	function emailFinder (email: object) {
	322	const text: string = email[ 'text' ]
	323
	324	return text.includes('instance has a new follower') && text.includes(followerHost)
	325	}
	326
	327	await checkNotification(base, notificationChecker, emailFinder, type)
	328	}
	329
f7cc67b4 C	330	async function checkCommentMention (
	331	base: CheckerBaseParams,
	332	uuid: string,
	333	commentId: number,
	334	threadId: number,
	335	byAccountDisplayName: string,
	336	type: CheckerType
	337	) {
	338	const notificationType = UserNotificationType.COMMENT_MENTION
	339
	340	function notificationChecker (notification: UserNotification, type: CheckerType) {
	341	if (type === 'presence') {
	342	expect(notification).to.not.be.undefined
	343	expect(notification.type).to.equal(notificationType)
	344
	345	checkComment(notification.comment, commentId, threadId)
	346	checkActor(notification.comment.account)
	347	expect(notification.comment.account.displayName).to.equal(byAccountDisplayName)
	348
	349	checkVideo(notification.comment.video, undefined, uuid)
	350	} else {
	351	expect(notification).to.satisfy(n => n.type !== notificationType \|\| n.comment.id !== commentId)
	352	}
	353	}
	354
	355	function emailFinder (email: object) {
	356	const text: string = email[ 'text' ]
	357
	358	return text.includes(' mentioned ') && text.includes(uuid) && text.includes(byAccountDisplayName)
	359	}
	360
	361	await checkNotification(base, notificationChecker, emailFinder, type)
	362	}
	363
cef534ed C	364	let lastEmailCount = 0
	365	async function checkNewCommentOnMyVideo (base: CheckerBaseParams, uuid: string, commentId: number, threadId: number, type: CheckerType) {
	366	const notificationType = UserNotificationType.NEW_COMMENT_ON_MY_VIDEO
	367
dc133480	368	function notificationChecker (notification: UserNotification, type: CheckerType) {
cef534ed C	369	if (type === 'presence') {
	370	expect(notification).to.not.be.undefined
	371	expect(notification.type).to.equal(notificationType)
dc133480 C	372
	373	checkComment(notification.comment, commentId, threadId)
	374	checkActor(notification.comment.account)
	375	checkVideo(notification.comment.video, undefined, uuid)
cef534ed C	376	} else {
	377	expect(notification).to.satisfy((n: UserNotification) => {
	378	return n === undefined \|\| n.comment === undefined \|\| n.comment.id !== commentId
	379	})
	380	}
	381	}
	382
7243f84d	383	const commentUrl = `http://localhost:${base.server.port}/videos/watch/${uuid};threadId=${threadId}`
cef534ed C	384	function emailFinder (email: object) {
	385	return email[ 'text' ].indexOf(commentUrl) !== -1
	386	}
	387
dc133480	388	await checkNotification(base, notificationChecker, emailFinder, type)
cef534ed C	389
	390	if (type === 'presence') {
	391	// We cannot detect email duplicates, so check we received another email
	392	expect(base.emails).to.have.length.above(lastEmailCount)
	393	lastEmailCount = base.emails.length
	394	}
	395	}
	396
	397	async function checkNewVideoAbuseForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
	398	const notificationType = UserNotificationType.NEW_VIDEO_ABUSE_FOR_MODERATORS
	399
dc133480	400	function notificationChecker (notification: UserNotification, type: CheckerType) {
cef534ed C	401	if (type === 'presence') {
	402	expect(notification).to.not.be.undefined
	403	expect(notification.type).to.equal(notificationType)
dc133480 C	404
	405	expect(notification.videoAbuse.id).to.be.a('number')
	406	checkVideo(notification.videoAbuse.video, videoName, videoUUID)
cef534ed C	407	} else {
	408	expect(notification).to.satisfy((n: UserNotification) => {
	409	return n === undefined \|\| n.videoAbuse === undefined \|\| n.videoAbuse.video.uuid !== videoUUID
	410	})
	411	}
	412	}
	413
cef534ed C	414	function emailFinder (email: object) {
	415	const text = email[ 'text' ]
	416	return text.indexOf(videoUUID) !== -1 && text.indexOf('abuse') !== -1
	417	}
	418
dc133480	419	await checkNotification(base, notificationChecker, emailFinder, type)
cef534ed C	420	}
cef534ed C	421
7ccddd7b JM	422	async function checkVideoAutoBlacklistForModerators (base: CheckerBaseParams, videoUUID: string, videoName: string, type: CheckerType) {
	423	const notificationType = UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
	424
	425	function notificationChecker (notification: UserNotification, type: CheckerType) {
	426	if (type === 'presence') {
	427	expect(notification).to.not.be.undefined
	428	expect(notification.type).to.equal(notificationType)
	429
	430	expect(notification.video.id).to.be.a('number')
	431	checkVideo(notification.video, videoName, videoUUID)
	432	} else {
	433	expect(notification).to.satisfy((n: UserNotification) => {
	434	return n === undefined \|\| n.video === undefined \|\| n.video.uuid !== videoUUID
	435	})
	436	}
	437	}
	438
	439	function emailFinder (email: object) {
	440	const text = email[ 'text' ]
	441	return text.indexOf(videoUUID) !== -1 && email[ 'text' ].indexOf('video-auto-blacklist/list') !== -1
	442	}
	443
	444	await checkNotification(base, notificationChecker, emailFinder, type)
	445	}
	446
cef534ed C	447	async function checkNewBlacklistOnMyVideo (
	448	base: CheckerBaseParams,
	449	videoUUID: string,
	450	videoName: string,
	451	blacklistType: 'blacklist' \| 'unblacklist'
	452	) {
	453	const notificationType = blacklistType === 'blacklist'
	454	? UserNotificationType.BLACKLIST_ON_MY_VIDEO
	455	: UserNotificationType.UNBLACKLIST_ON_MY_VIDEO
	456
dc133480	457	function notificationChecker (notification: UserNotification) {
cef534ed C	458	expect(notification).to.not.be.undefined
	459	expect(notification.type).to.equal(notificationType)
	460
	461	const video = blacklistType === 'blacklist' ? notification.videoBlacklist.video : notification.video
	462
dc133480	463	checkVideo(video, videoName, videoUUID)
cef534ed C	464	}
	465
	466	function emailFinder (email: object) {
	467	const text = email[ 'text' ]
	468	return text.indexOf(videoUUID) !== -1 && text.indexOf(' ' + blacklistType) !== -1
	469	}
	470
dc133480	471	await checkNotification(base, notificationChecker, emailFinder, 'presence')
cef534ed C	472	}
	473
	474	// ---------------------------------------------------------------------------
	475
	476	export {
	477	CheckerBaseParams,
	478	CheckerType,
	479	checkNotification,
2f1548fd	480	markAsReadAllNotifications,
dc133480	481	checkMyVideoImportIsFinished,
f7cc67b4	482	checkUserRegistered,
dc133480	483	checkVideoIsPublished,
cef534ed	484	checkNewVideoFromSubscription,
f7cc67b4	485	checkNewActorFollow,
cef534ed C	486	checkNewCommentOnMyVideo,
cef534ed C	487	checkNewBlacklistOnMyVideo,
f7cc67b4	488	checkCommentMention,
cef534ed C	489	updateMyNotificationSettings,
cef534ed C	490	checkNewVideoAbuseForModerators,
7ccddd7b	491	checkVideoAutoBlacklistForModerators,
cef534ed C	492	getUserNotifications,
cef534ed C	493	markAsReadNotifications,
883993c8 C	494	getLastNotification,
883993c8 C	495	checkNewInstanceFollower
cef534ed	496	}