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 { MockSmtpServer } from '@server/tests/shared'
   6 import { HttpStatusCode } from '@shared/models'
   7 import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/server-commands'
   8
   9 const expect = chai.expect
  10
  11 describe('Test emails', function () {
  12   let server: PeerTubeServer
  13   let userId: number
  14   let userId2: number
  15   let userAccessToken: string
  16
  17   let videoShortUUID: string
  18   let videoId: number
  19
  20   let videoUserUUID: string
  21
  22   let verificationString: string
  23   let verificationString2: string
  24
  25   const emails: object[] = []
  26   const user = {
  27     username: 'user_1',
  28     password: 'super_password'
  29   }
  30   let emailPort: number
  31
  32   before(async function () {
  33     this.timeout(50000)
  34
  35     emailPort = await MockSmtpServer.Instance.collectEmails(emails)
  36
  37     const overrideConfig = {
  38       smtp: {
  39         hostname: 'localhost',
  40         port: emailPort
  41       }
  42     }
  43     server = await createSingleServer(1, overrideConfig)
  44     await setAccessTokensToServers([ server ])
  45
  46     {
  47       const created = await server.users.create({ username: user.username, password: user.password })
  48       userId = created.id
  49
  50       userAccessToken = await server.login.getAccessToken(user)
  51     }
  52
  53     {
  54       const attributes = { name: 'my super user video' }
  55       const { uuid } = await server.videos.upload({ token: userAccessToken, attributes })
  56       videoUserUUID = uuid
  57     }
  58
  59     {
  60       const attributes = {
  61         name: 'my super name'
  62       }
  63       const { shortUUID, id } = await server.videos.upload({ attributes })
  64       videoShortUUID = shortUUID
  65       videoId = id
  66     }
  67   })
  68
  69   describe('When resetting user password', function () {
  70
  71     it('Should ask to reset the password', async function () {
  72       this.timeout(10000)
  73
  74       await server.users.askResetPassword({ email: 'user_1@example.com' })
  75
  76       await waitJobs(server)
  77       expect(emails).to.have.lengthOf(1)
  78
  79       const email = emails[0]
  80
  81       expect(email['from'][0]['name']).equal('PeerTube')
  82       expect(email['from'][0]['address']).equal('test-admin@localhost')
  83       expect(email['to'][0]['address']).equal('user_1@example.com')
  84       expect(email['subject']).contains('password')
  85
  86       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
  87       expect(verificationStringMatches).not.to.be.null
  88
  89       verificationString = verificationStringMatches[1]
  90       expect(verificationString).to.have.length.above(2)
  91
  92       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
  93       expect(userIdMatches).not.to.be.null
  94
  95       userId = parseInt(userIdMatches[1], 10)
  96       expect(verificationString).to.not.be.undefined
  97     })
  98
  99     it('Should not reset the password with an invalid verification string', async function () {
 100       await server.users.resetPassword({
 101         userId,
 102         verificationString: verificationString + 'b',
 103         password: 'super_password2',
 104         expectedStatus: HttpStatusCode.FORBIDDEN_403
 105       })
 106     })
 107
 108     it('Should reset the password', async function () {
 109       await server.users.resetPassword({ userId, verificationString, password: 'super_password2' })
 110     })
 111
 112     it('Should not reset the password with the same verification string', async function () {
 113       await server.users.resetPassword({
 114         userId,
 115         verificationString,
 116         password: 'super_password3',
 117         expectedStatus: HttpStatusCode.FORBIDDEN_403
 118       })
 119     })
 120
 121     it('Should login with this new password', async function () {
 122       user.password = 'super_password2'
 123
 124       await server.login.getAccessToken(user)
 125     })
 126   })
 127
 128   describe('When creating a user without password', function () {
 129
 130     it('Should send a create password email', async function () {
 131       this.timeout(10000)
 132
 133       await server.users.create({ username: 'create_password', password: '' })
 134
 135       await waitJobs(server)
 136       expect(emails).to.have.lengthOf(2)
 137
 138       const email = emails[1]
 139
 140       expect(email['from'][0]['name']).equal('PeerTube')
 141       expect(email['from'][0]['address']).equal('test-admin@localhost')
 142       expect(email['to'][0]['address']).equal('create_password@example.com')
 143       expect(email['subject']).contains('account')
 144       expect(email['subject']).contains('password')
 145
 146       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
 147       expect(verificationStringMatches).not.to.be.null
 148
 149       verificationString2 = verificationStringMatches[1]
 150       expect(verificationString2).to.have.length.above(2)
 151
 152       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 153       expect(userIdMatches).not.to.be.null
 154
 155       userId2 = parseInt(userIdMatches[1], 10)
 156     })
 157
 158     it('Should not reset the password with an invalid verification string', async function () {
 159       await server.users.resetPassword({
 160         userId: userId2,
 161         verificationString: verificationString2 + 'c',
 162         password: 'newly_created_password',
 163         expectedStatus: HttpStatusCode.FORBIDDEN_403
 164       })
 165     })
 166
 167     it('Should reset the password', async function () {
 168       await server.users.resetPassword({
 169         userId: userId2,
 170         verificationString: verificationString2,
 171         password: 'newly_created_password'
 172       })
 173     })
 174
 175     it('Should login with this new password', async function () {
 176       await server.login.getAccessToken({
 177         username: 'create_password',
 178         password: 'newly_created_password'
 179       })
 180     })
 181   })
 182
 183   describe('When creating an abuse', function () {
 184
 185     it('Should send the notification email', async function () {
 186       this.timeout(10000)
 187
 188       const reason = 'my super bad reason'
 189       await server.abuses.report({ token: userAccessToken, 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(videoShortUUID)
 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 server.users.banUser({ userId, 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 server.users.unbanUser({ userId })
 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.blacklist.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.blacklist.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 server.users.askSendVerifyEmail({ email: '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 server.users.verifyEmail({
 318         userId,
 319         verificationString: verificationString + 'b',
 320         isPendingEmail: false,
 321         expectedStatus: HttpStatusCode.FORBIDDEN_403
 322       })
 323     })
 324
 325     it('Should verify the email', async function () {
 326       await server.users.verifyEmail({ userId, verificationString })
 327     })
 328   })
 329
 330   after(async function () {
 331     MockSmtpServer.Instance.kill()
 332
 333     await cleanupTests([ server ])
 334   })
 335 })