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