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