server/tests/api/server/email.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import 'mocha'
   5 import {
   6   addVideoToBlacklist,
   7   askResetPassword,
   8   askSendVerifyEmail,
   9   blockUser,
  10   cleanupTests,
  11   createUser,
  12   flushAndRunServer,
  13   removeVideoFromBlacklist,
  14   reportVideoAbuse,
  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/miscs/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 userAccessToken: string
  32   let videoUUID: string
  33   let videoUserUUID: string
  34   let verificationString: string
  35   const emails: object[] = []
  36   const user = {
  37     username: 'user_1',
  38     password: 'super_password'
  39   }
  40   let emailPort: number
  41
  42   before(async function () {
  43     this.timeout(50000)
  44
  45     emailPort = await MockSmtpServer.Instance.collectEmails(emails)
  46
  47     const overrideConfig = {
  48       smtp: {
  49         hostname: 'localhost',
  50         port: emailPort
  51       }
  52     }
  53     server = await flushAndRunServer(1, overrideConfig)
  54     await setAccessTokensToServers([ server ])
  55
  56     {
  57       const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
  58       userId = res.body.user.id
  59
  60       userAccessToken = await userLogin(server, user)
  61     }
  62
  63     {
  64       const attributes = {
  65         name: 'my super user video'
  66       }
  67       const res = await uploadVideo(server.url, userAccessToken, attributes)
  68       videoUserUUID = res.body.video.uuid
  69     }
  70
  71     {
  72       const attributes = {
  73         name: 'my super name'
  74       }
  75       const res = await uploadVideo(server.url, server.accessToken, attributes)
  76       videoUUID = res.body.video.uuid
  77     }
  78   })
  79
  80   describe('When resetting user password', function () {
  81
  82     it('Should ask to reset the password', async function () {
  83       this.timeout(10000)
  84
  85       await askResetPassword(server.url, 'user_1@example.com')
  86
  87       await waitJobs(server)
  88       expect(emails).to.have.lengthOf(1)
  89
  90       const email = emails[0]
  91
  92       expect(email['from'][0]['name']).equal('localhost:' + server.port)
  93       expect(email['from'][0]['address']).equal('test-admin@localhost')
  94       expect(email['to'][0]['address']).equal('user_1@example.com')
  95       expect(email['subject']).contains('password')
  96
  97       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
  98       expect(verificationStringMatches).not.to.be.null
  99
 100       verificationString = verificationStringMatches[1]
 101       expect(verificationString).to.have.length.above(2)
 102
 103       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 104       expect(userIdMatches).not.to.be.null
 105
 106       userId = parseInt(userIdMatches[1], 10)
 107       expect(verificationString).to.not.be.undefined
 108     })
 109
 110     it('Should not reset the password with an invalid verification string', async function () {
 111       await resetPassword(server.url, userId, verificationString + 'b', 'super_password2', 403)
 112     })
 113
 114     it('Should reset the password', async function () {
 115       await resetPassword(server.url, userId, verificationString, 'super_password2')
 116     })
 117
 118     it('Should login with this new password', async function () {
 119       user.password = 'super_password2'
 120
 121       await userLogin(server, user)
 122     })
 123   })
 124
 125   describe('When creating a video abuse', function () {
 126     it('Should send the notification email', async function () {
 127       this.timeout(10000)
 128
 129       const reason = 'my super bad reason'
 130       await reportVideoAbuse(server.url, server.accessToken, videoUUID, reason)
 131
 132       await waitJobs(server)
 133       expect(emails).to.have.lengthOf(2)
 134
 135       const email = emails[1]
 136
 137       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 138       expect(email['from'][0]['address']).equal('test-admin@localhost')
 139       expect(email['to'][0]['address']).equal('admin' + server.internalServerNumber + '@example.com')
 140       expect(email['subject']).contains('abuse')
 141       expect(email['text']).contains(videoUUID)
 142     })
 143   })
 144
 145   describe('When blocking/unblocking user', function () {
 146
 147     it('Should send the notification email when blocking a user', async function () {
 148       this.timeout(10000)
 149
 150       const reason = 'my super bad reason'
 151       await blockUser(server.url, userId, server.accessToken, 204, reason)
 152
 153       await waitJobs(server)
 154       expect(emails).to.have.lengthOf(3)
 155
 156       const email = emails[2]
 157
 158       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 159       expect(email['from'][0]['address']).equal('test-admin@localhost')
 160       expect(email['to'][0]['address']).equal('user_1@example.com')
 161       expect(email['subject']).contains(' blocked')
 162       expect(email['text']).contains(' blocked')
 163       expect(email['text']).contains(reason)
 164     })
 165
 166     it('Should send the notification email when unblocking a user', async function () {
 167       this.timeout(10000)
 168
 169       await unblockUser(server.url, userId, server.accessToken, 204)
 170
 171       await waitJobs(server)
 172       expect(emails).to.have.lengthOf(4)
 173
 174       const email = emails[3]
 175
 176       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 177       expect(email['from'][0]['address']).equal('test-admin@localhost')
 178       expect(email['to'][0]['address']).equal('user_1@example.com')
 179       expect(email['subject']).contains(' unblocked')
 180       expect(email['text']).contains(' unblocked')
 181     })
 182   })
 183
 184   describe('When blacklisting a video', function () {
 185     it('Should send the notification email', async function () {
 186       this.timeout(10000)
 187
 188       const reason = 'my super reason'
 189       await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)
 190
 191       await waitJobs(server)
 192       expect(emails).to.have.lengthOf(5)
 193
 194       const email = emails[4]
 195
 196       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 197       expect(email['from'][0]['address']).equal('test-admin@localhost')
 198       expect(email['to'][0]['address']).equal('user_1@example.com')
 199       expect(email['subject']).contains(' blacklisted')
 200       expect(email['text']).contains('my super user video')
 201       expect(email['text']).contains('my super reason')
 202     })
 203
 204     it('Should send the notification email', async function () {
 205       this.timeout(10000)
 206
 207       await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)
 208
 209       await waitJobs(server)
 210       expect(emails).to.have.lengthOf(6)
 211
 212       const email = emails[5]
 213
 214       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 215       expect(email['from'][0]['address']).equal('test-admin@localhost')
 216       expect(email['to'][0]['address']).equal('user_1@example.com')
 217       expect(email['subject']).contains(' unblacklisted')
 218       expect(email['text']).contains('my super user video')
 219     })
 220   })
 221
 222   describe('When verifying a user email', function () {
 223
 224     it('Should ask to send the verification email', async function () {
 225       this.timeout(10000)
 226
 227       await askSendVerifyEmail(server.url, 'user_1@example.com')
 228
 229       await waitJobs(server)
 230       expect(emails).to.have.lengthOf(7)
 231
 232       const email = emails[6]
 233
 234       expect(email['from'][0]['name']).equal('localhost:' + server.port)
 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('Verify')
 238
 239       const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
 240       expect(verificationStringMatches).not.to.be.null
 241
 242       verificationString = verificationStringMatches[1]
 243       expect(verificationString).to.not.be.undefined
 244       expect(verificationString).to.have.length.above(2)
 245
 246       const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
 247       expect(userIdMatches).not.to.be.null
 248
 249       userId = parseInt(userIdMatches[1], 10)
 250     })
 251
 252     it('Should not verify the email with an invalid verification string', async function () {
 253       await verifyEmail(server.url, userId, verificationString + 'b', false, 403)
 254     })
 255
 256     it('Should verify the email', async function () {
 257       await verifyEmail(server.url, userId, verificationString)
 258     })
 259   })
 260
 261   after(async function () {
 262     MockSmtpServer.Instance.kill()
 263
 264     await cleanupTests([ server ])
 265   })
 266 })