server/tests/api/server/email.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import 'mocha'
   4 import * as chai from 'chai'
   5 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
   6 import {
   7   addVideoToBlacklist,
   8   askResetPassword,
   9   askSendVerifyEmail,
  10   blockUser,
  11   cleanupTests,
  12   createUser,
  13   flushAndRunServer,
  14   removeVideoFromBlacklist,
  15   resetPassword,
  16   ServerInfo,
  17   setAccessTokensToServers,
  18   unblockUser,
  19   uploadVideo,
  20   userLogin,
  21   verifyEmail
  22 } from '../../../../shared/extra-utils'
  23 import { MockSmtpServer } from '../../../../shared/extra-utils/mock-servers/mock-email'
  24 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
  25
  26 const expect = chai.expect
  27
  28 describe('Test emails', function () {
  29   let server: ServerInfo
  30   let userId: number
  31   let userId2: number
  32   let userAccessToken: string
  33
  34   let videoUUID: string
  35   let videoId: number
  36
  37   let videoUserUUID: string
  38
  39   let verificationString: string
  40   let verificationString2: string
  41
  42   const emails: object[] = []
  43   const user = {
  44     username: 'user_1',
  45     password: 'super_password'
  46   }
  47   let emailPort: number
  48
  49   before(async function () {
  50     this.timeout(50000)
  51
  52     emailPort = await MockSmtpServer.Instance.collectEmails(emails)
  53
  54     const overrideConfig = {
  55       smtp: {
  56         hostname: 'localhost',
  57         port: emailPort
  58       }
  59     }
  60     server = await flushAndRunServer(1, overrideConfig)
  61     await setAccessTokensToServers([ server ])
  62
  63     {
  64       const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
  65       userId = res.body.user.id
  66
  67       userAccessToken = await userLogin(server, user)
  68     }
  69
  70     {
  71       const attributes = {
  72         name: 'my super user video'
  73       }
  74       const res = await uploadVideo(server.url, userAccessToken, attributes)
  75       videoUserUUID = res.body.video.uuid
  76     }
  77
  78     {
  79       const attributes = {
  80         name: 'my super name'
  81       }
  82       const res = await uploadVideo(server.url, server.accessToken, attributes)
  83       videoUUID = res.body.video.uuid
  84       videoId = res.body.video.id
  85     }
  86   })
  87
  88   describe('When resetting user password', function () {
  89
  90     it('Should ask to reset the password', async function () {
  91       this.timeout(10000)
  92
  93       await askResetPassword(server.url, 'user_1@example.com')
  94
  95       await waitJobs(server)
  96       expect(emails).to.have.lengthOf(1)
  97
  98       const email = emails[0]
  99
 100       expect(email['from'][0]['name']).equal('PeerTube')
 101       expect(email['from'][0]['address']).equal('test-admin@localhost')
 102       expect(email['to'][0]['address']).equal('user_1@example.com')
 103       expect(email['subject']).contains('password')
 104
 105       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
 106       expect(verificationStringMatches).not.to.be.null
 107
 108       verificationString = verificationStringMatches[1]
 109       expect(verificationString).to.have.length.above(2)
 110
 111       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 112       expect(userIdMatches).not.to.be.null
 113
 114       userId = parseInt(userIdMatches[1], 10)
 115       expect(verificationString).to.not.be.undefined
 116     })
 117
 118     it('Should not reset the password with an invalid verification string', async function () {
 119       await resetPassword(server.url, userId, verificationString + 'b', 'super_password2', HttpStatusCode.FORBIDDEN_403)
 120     })
 121
 122     it('Should reset the password', async function () {
 123       await resetPassword(server.url, userId, verificationString, 'super_password2')
 124     })
 125
 126     it('Should not reset the password with the same verification string', async function () {
 127       await resetPassword(server.url, userId, verificationString, 'super_password3', HttpStatusCode.FORBIDDEN_403)
 128     })
 129
 130     it('Should login with this new password', async function () {
 131       user.password = 'super_password2'
 132
 133       await userLogin(server, user)
 134     })
 135   })
 136
 137   describe('When creating a user without password', function () {
 138     it('Should send a create password email', async function () {
 139       this.timeout(10000)
 140
 141       await createUser({
 142         url: server.url,
 143         accessToken: server.accessToken,
 144         username: 'create_password',
 145         password: ''
 146       })
 147
 148       await waitJobs(server)
 149       expect(emails).to.have.lengthOf(2)
 150
 151       const email = emails[1]
 152
 153       expect(email['from'][0]['name']).equal('PeerTube')
 154       expect(email['from'][0]['address']).equal('test-admin@localhost')
 155       expect(email['to'][0]['address']).equal('create_password@example.com')
 156       expect(email['subject']).contains('account')
 157       expect(email['subject']).contains('password')
 158
 159       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
 160       expect(verificationStringMatches).not.to.be.null
 161
 162       verificationString2 = verificationStringMatches[1]
 163       expect(verificationString2).to.have.length.above(2)
 164
 165       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 166       expect(userIdMatches).not.to.be.null
 167
 168       userId2 = parseInt(userIdMatches[1], 10)
 169     })
 170
 171     it('Should not reset the password with an invalid verification string', async function () {
 172       await resetPassword(server.url, userId2, verificationString2 + 'c', 'newly_created_password', HttpStatusCode.FORBIDDEN_403)
 173     })
 174
 175     it('Should reset the password', async function () {
 176       await resetPassword(server.url, userId2, verificationString2, 'newly_created_password')
 177     })
 178
 179     it('Should login with this new password', async function () {
 180       await userLogin(server, {
 181         username: 'create_password',
 182         password: 'newly_created_password'
 183       })
 184     })
 185   })
 186
 187   describe('When creating an abuse', function () {
 188     it('Should send the notification email', async function () {
 189       this.timeout(10000)
 190
 191       const reason = 'my super bad reason'
 192       await server.abusesCommand.report({ videoId, reason })
 193
 194       await waitJobs(server)
 195       expect(emails).to.have.lengthOf(3)
 196
 197       const email = emails[2]
 198
 199       expect(email['from'][0]['name']).equal('PeerTube')
 200       expect(email['from'][0]['address']).equal('test-admin@localhost')
 201       expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
 202       expect(email['subject']).contains('abuse')
 203       expect(email['text']).contains(videoUUID)
 204     })
 205   })
 206
 207   describe('When blocking/unblocking user', function () {
 208
 209     it('Should send the notification email when blocking a user', async function () {
 210       this.timeout(10000)
 211
 212       const reason = 'my super bad reason'
 213       await blockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204, reason)
 214
 215       await waitJobs(server)
 216       expect(emails).to.have.lengthOf(4)
 217
 218       const email = emails[3]
 219
 220       expect(email['from'][0]['name']).equal('PeerTube')
 221       expect(email['from'][0]['address']).equal('test-admin@localhost')
 222       expect(email['to'][0]['address']).equal('user_1@example.com')
 223       expect(email['subject']).contains(' blocked')
 224       expect(email['text']).contains(' blocked')
 225       expect(email['text']).contains('bad reason')
 226     })
 227
 228     it('Should send the notification email when unblocking a user', async function () {
 229       this.timeout(10000)
 230
 231       await unblockUser(server.url, userId, server.accessToken, HttpStatusCode.NO_CONTENT_204)
 232
 233       await waitJobs(server)
 234       expect(emails).to.have.lengthOf(5)
 235
 236       const email = emails[4]
 237
 238       expect(email['from'][0]['name']).equal('PeerTube')
 239       expect(email['from'][0]['address']).equal('test-admin@localhost')
 240       expect(email['to'][0]['address']).equal('user_1@example.com')
 241       expect(email['subject']).contains(' unblocked')
 242       expect(email['text']).contains(' unblocked')
 243     })
 244   })
 245
 246   describe('When blacklisting a video', function () {
 247     it('Should send the notification email', async function () {
 248       this.timeout(10000)
 249
 250       const reason = 'my super reason'
 251       await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)
 252
 253       await waitJobs(server)
 254       expect(emails).to.have.lengthOf(6)
 255
 256       const email = emails[5]
 257
 258       expect(email['from'][0]['name']).equal('PeerTube')
 259       expect(email['from'][0]['address']).equal('test-admin@localhost')
 260       expect(email['to'][0]['address']).equal('user_1@example.com')
 261       expect(email['subject']).contains(' blacklisted')
 262       expect(email['text']).contains('my super user video')
 263       expect(email['text']).contains('my super reason')
 264     })
 265
 266     it('Should send the notification email', async function () {
 267       this.timeout(10000)
 268
 269       await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)
 270
 271       await waitJobs(server)
 272       expect(emails).to.have.lengthOf(7)
 273
 274       const email = emails[6]
 275
 276       expect(email['from'][0]['name']).equal('PeerTube')
 277       expect(email['from'][0]['address']).equal('test-admin@localhost')
 278       expect(email['to'][0]['address']).equal('user_1@example.com')
 279       expect(email['subject']).contains(' unblacklisted')
 280       expect(email['text']).contains('my super user video')
 281     })
 282
 283     it('Should have the manage preferences link in the email', async function () {
 284       const email = emails[6]
 285       expect(email['text']).to.contain('Manage your notification preferences')
 286     })
 287   })
 288
 289   describe('When verifying a user email', function () {
 290
 291     it('Should ask to send the verification email', async function () {
 292       this.timeout(10000)
 293
 294       await askSendVerifyEmail(server.url, 'user_1@example.com')
 295
 296       await waitJobs(server)
 297       expect(emails).to.have.lengthOf(8)
 298
 299       const email = emails[7]
 300
 301       expect(email['from'][0]['name']).equal('PeerTube')
 302       expect(email['from'][0]['address']).equal('test-admin@localhost')
 303       expect(email['to'][0]['address']).equal('user_1@example.com')
 304       expect(email['subject']).contains('Verify')
 305
 306       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
 307       expect(verificationStringMatches).not.to.be.null
 308
 309       verificationString = verificationStringMatches[1]
 310       expect(verificationString).to.not.be.undefined
 311       expect(verificationString).to.have.length.above(2)
 312
 313       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 314       expect(userIdMatches).not.to.be.null
 315
 316       userId = parseInt(userIdMatches[1], 10)
 317     })
 318
 319     it('Should not verify the email with an invalid verification string', async function () {
 320       await verifyEmail(server.url, userId, verificationString + 'b', false, HttpStatusCode.FORBIDDEN_403)
 321     })
 322
 323     it('Should verify the email', async function () {
 324       await verifyEmail(server.url, userId, verificationString)
 325     })
 326   })
 327
 328   after(async function () {
 329     MockSmtpServer.Instance.kill()
 330
 331     await cleanupTests([ server ])
 332   })
 333 })