1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
4 import * as chai from 'chai'
5 import { HttpStatusCode } from '@shared/core-utils'
6 import { cleanupTests, flushAndRunServer, MockSmtpServer, ServerInfo, setAccessTokensToServers, waitJobs } from '@shared/extra-utils'
8 const expect = chai.expect
10 describe('Test emails', function () {
11 let server: ServerInfo
14 let userAccessToken: string
19 let videoUserUUID: string
21 let verificationString: string
22 let verificationString2: string
24 const emails: object[] = []
27 password: 'super_password'
31 before(async function () {
34 emailPort = await MockSmtpServer.Instance.collectEmails(emails)
36 const overrideConfig = {
38 hostname: 'localhost',
42 server = await flushAndRunServer(1, overrideConfig)
43 await setAccessTokensToServers([ server ])
46 const created = await server.users.create({ username: user.username, password: user.password })
49 userAccessToken = await server.login.getAccessToken(user)
53 const attributes = { name: 'my super user video' }
54 const { uuid } = await server.videos.upload({ token: userAccessToken, attributes })
62 const { uuid, id } = await server.videos.upload({ attributes })
68 describe('When resetting user password', function () {
70 it('Should ask to reset the password', async function () {
73 await server.users.askResetPassword({ email: 'user_1@example.com' })
75 await waitJobs(server)
76 expect(emails).to.have.lengthOf(1)
78 const email = emails[0]
80 expect(email['from'][0]['name']).equal('PeerTube')
81 expect(email['from'][0]['address']).equal('test-admin@localhost')
82 expect(email['to'][0]['address']).equal('user_1@example.com')
83 expect(email['subject']).contains('password')
85 const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
86 expect(verificationStringMatches).not.to.be.null
88 verificationString = verificationStringMatches[1]
89 expect(verificationString).to.have.length.above(2)
91 const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
92 expect(userIdMatches).not.to.be.null
94 userId = parseInt(userIdMatches[1], 10)
95 expect(verificationString).to.not.be.undefined
98 it('Should not reset the password with an invalid verification string', async function () {
99 await server.users.resetPassword({
101 verificationString: verificationString + 'b',
102 password: 'super_password2',
103 expectedStatus: HttpStatusCode.FORBIDDEN_403
107 it('Should reset the password', async function () {
108 await server.users.resetPassword({ userId, verificationString, password: 'super_password2' })
111 it('Should not reset the password with the same verification string', async function () {
112 await server.users.resetPassword({
115 password: 'super_password3',
116 expectedStatus: HttpStatusCode.FORBIDDEN_403
120 it('Should login with this new password', async function () {
121 user.password = 'super_password2'
123 await server.login.getAccessToken(user)
127 describe('When creating a user without password', function () {
129 it('Should send a create password email', async function () {
132 await server.users.create({ username: 'create_password', password: '' })
134 await waitJobs(server)
135 expect(emails).to.have.lengthOf(2)
137 const email = emails[1]
139 expect(email['from'][0]['name']).equal('PeerTube')
140 expect(email['from'][0]['address']).equal('test-admin@localhost')
141 expect(email['to'][0]['address']).equal('create_password@example.com')
142 expect(email['subject']).contains('account')
143 expect(email['subject']).contains('password')
145 const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
146 expect(verificationStringMatches).not.to.be.null
148 verificationString2 = verificationStringMatches[1]
149 expect(verificationString2).to.have.length.above(2)
151 const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
152 expect(userIdMatches).not.to.be.null
154 userId2 = parseInt(userIdMatches[1], 10)
157 it('Should not reset the password with an invalid verification string', async function () {
158 await server.users.resetPassword({
160 verificationString: verificationString2 + 'c',
161 password: 'newly_created_password',
162 expectedStatus: HttpStatusCode.FORBIDDEN_403
166 it('Should reset the password', async function () {
167 await server.users.resetPassword({
169 verificationString: verificationString2,
170 password: 'newly_created_password'
174 it('Should login with this new password', async function () {
175 await server.login.getAccessToken({
176 username: 'create_password',
177 password: 'newly_created_password'
182 describe('When creating an abuse', function () {
183 it('Should send the notification email', async function () {
186 const reason = 'my super bad reason'
187 await server.abuses.report({ videoId, reason })
189 await waitJobs(server)
190 expect(emails).to.have.lengthOf(3)
192 const email = emails[2]
194 expect(email['from'][0]['name']).equal('PeerTube')
195 expect(email['from'][0]['address']).equal('test-admin@localhost')
196 expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
197 expect(email['subject']).contains('abuse')
198 expect(email['text']).contains(videoUUID)
202 describe('When blocking/unblocking user', function () {
204 it('Should send the notification email when blocking a user', async function () {
207 const reason = 'my super bad reason'
208 await server.users.banUser({ userId, reason })
210 await waitJobs(server)
211 expect(emails).to.have.lengthOf(4)
213 const email = emails[3]
215 expect(email['from'][0]['name']).equal('PeerTube')
216 expect(email['from'][0]['address']).equal('test-admin@localhost')
217 expect(email['to'][0]['address']).equal('user_1@example.com')
218 expect(email['subject']).contains(' blocked')
219 expect(email['text']).contains(' blocked')
220 expect(email['text']).contains('bad reason')
223 it('Should send the notification email when unblocking a user', async function () {
226 await server.users.unbanUser({ userId })
228 await waitJobs(server)
229 expect(emails).to.have.lengthOf(5)
231 const email = emails[4]
233 expect(email['from'][0]['name']).equal('PeerTube')
234 expect(email['from'][0]['address']).equal('test-admin@localhost')
235 expect(email['to'][0]['address']).equal('user_1@example.com')
236 expect(email['subject']).contains(' unblocked')
237 expect(email['text']).contains(' unblocked')
241 describe('When blacklisting a video', function () {
242 it('Should send the notification email', async function () {
245 const reason = 'my super reason'
246 await server.blacklist.add({ videoId: videoUserUUID, reason })
248 await waitJobs(server)
249 expect(emails).to.have.lengthOf(6)
251 const email = emails[5]
253 expect(email['from'][0]['name']).equal('PeerTube')
254 expect(email['from'][0]['address']).equal('test-admin@localhost')
255 expect(email['to'][0]['address']).equal('user_1@example.com')
256 expect(email['subject']).contains(' blacklisted')
257 expect(email['text']).contains('my super user video')
258 expect(email['text']).contains('my super reason')
261 it('Should send the notification email', async function () {
264 await server.blacklist.remove({ videoId: videoUserUUID })
266 await waitJobs(server)
267 expect(emails).to.have.lengthOf(7)
269 const email = emails[6]
271 expect(email['from'][0]['name']).equal('PeerTube')
272 expect(email['from'][0]['address']).equal('test-admin@localhost')
273 expect(email['to'][0]['address']).equal('user_1@example.com')
274 expect(email['subject']).contains(' unblacklisted')
275 expect(email['text']).contains('my super user video')
278 it('Should have the manage preferences link in the email', async function () {
279 const email = emails[6]
280 expect(email['text']).to.contain('Manage your notification preferences')
284 describe('When verifying a user email', function () {
286 it('Should ask to send the verification email', async function () {
289 await server.users.askSendVerifyEmail({ email: 'user_1@example.com' })
291 await waitJobs(server)
292 expect(emails).to.have.lengthOf(8)
294 const email = emails[7]
296 expect(email['from'][0]['name']).equal('PeerTube')
297 expect(email['from'][0]['address']).equal('test-admin@localhost')
298 expect(email['to'][0]['address']).equal('user_1@example.com')
299 expect(email['subject']).contains('Verify')
301 const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
302 expect(verificationStringMatches).not.to.be.null
304 verificationString = verificationStringMatches[1]
305 expect(verificationString).to.not.be.undefined
306 expect(verificationString).to.have.length.above(2)
308 const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
309 expect(userIdMatches).not.to.be.null
311 userId = parseInt(userIdMatches[1], 10)
314 it('Should not verify the email with an invalid verification string', async function () {
315 await server.users.verifyEmail({
317 verificationString: verificationString + 'b',
318 isPendingEmail: false,
319 expectedStatus: HttpStatusCode.FORBIDDEN_403
323 it('Should verify the email', async function () {
324 await server.users.verifyEmail({ userId, verificationString })
328 after(async function () {
329 MockSmtpServer.Instance.kill()
331 await cleanupTests([ server ])