[github/Chocobozzz/PeerTube.git] / server / tests / api / server / email.ts

/* tslint:disable:no-unused-expression */

import * as chai from 'chai'
import 'mocha'
import {
  addVideoToBlacklist,
  askResetPassword,
  askSendVerifyEmail,
  blockUser,
  createUser, removeVideoFromBlacklist,
  reportVideoAbuse,
  resetPassword,
  runServer,
  unblockUser,
  uploadVideo,
  userLogin,
  verifyEmail,
  flushTests,
  killallServers,
  ServerInfo,
  setAccessTokensToServers
} from '../../../../shared/utils'
import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
import { waitJobs } from '../../../../shared/utils/server/jobs'

const expect = chai.expect

describe('Test emails', function () {
  let server: ServerInfo
  let userId: number
  let userAccessToken: string
  let videoUUID: string
  let videoUserUUID: string
  let verificationString: string
  const emails: object[] = []
  const user = {
    username: 'user_1',
    password: 'super_password'
  }

  before(async function () {
    this.timeout(30000)

    await MockSmtpServer.Instance.collectEmails(emails)

    await flushTests()

    const overrideConfig = {
      smtp: {
        hostname: 'localhost'
      }
    }
    server = await runServer(1, overrideConfig)
    await setAccessTokensToServers([ server ])

    {
      const res = await createUser(server.url, server.accessToken, user.username, user.password)
      userId = res.body.user.id

      userAccessToken = await userLogin(server, user)
    }

    {
      const attributes = {
        name: 'my super user video'
      }
      const res = await uploadVideo(server.url, userAccessToken, attributes)
      videoUserUUID = res.body.video.uuid
    }

    {
      const attributes = {
        name: 'my super name'
      }
      const res = await uploadVideo(server.url, server.accessToken, attributes)
      videoUUID = res.body.video.uuid
    }
  })

  describe('When resetting user password', function () {

    it('Should ask to reset the password', async function () {
      this.timeout(10000)

      await askResetPassword(server.url, 'user_1@example.com')

      await waitJobs(server)
      expect(emails).to.have.lengthOf(1)

      const email = emails[0]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains('password')

      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
      expect(verificationStringMatches).not.to.be.null

      verificationString = verificationStringMatches[1]
      expect(verificationString).to.have.length.above(2)

      const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
      expect(userIdMatches).not.to.be.null

      userId = parseInt(userIdMatches[1], 10)
      expect(verificationString).to.not.be.undefined
    })

    it('Should not reset the password with an invalid verification string', async function () {
      await resetPassword(server.url, userId, verificationString + 'b', 'super_password2', 403)
    })

    it('Should reset the password', async function () {
      await resetPassword(server.url, userId, verificationString, 'super_password2')
    })

    it('Should login with this new password', async function () {
      user.password = 'super_password2'

      await userLogin(server, user)
    })
  })

  describe('When creating a video abuse', function () {
    it('Should send the notification email', async function () {
      this.timeout(10000)

      const reason = 'my super bad reason'
      await reportVideoAbuse(server.url, server.accessToken, videoUUID, reason)

      await waitJobs(server)
      expect(emails).to.have.lengthOf(2)

      const email = emails[1]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('admin1@example.com')
      expect(email['subject']).contains('abuse')
      expect(email['text']).contains(videoUUID)
    })
  })

  describe('When blocking/unblocking user', async function () {
    it('Should send the notification email when blocking a user', async function () {
      this.timeout(10000)

      const reason = 'my super bad reason'
      await blockUser(server.url, userId, server.accessToken, 204, reason)

      await waitJobs(server)
      expect(emails).to.have.lengthOf(3)

      const email = emails[2]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains(' blocked')
      expect(email['text']).contains(' blocked')
      expect(email['text']).contains(reason)
    })

    it('Should send the notification email when unblocking a user', async function () {
      this.timeout(10000)

      await unblockUser(server.url, userId, server.accessToken, 204)

      await waitJobs(server)
      expect(emails).to.have.lengthOf(4)

      const email = emails[3]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains(' unblocked')
      expect(email['text']).contains(' unblocked')
    })
  })

  describe('When blacklisting a video', function () {
    it('Should send the notification email', async function () {
      this.timeout(10000)

      const reason = 'my super reason'
      await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)

      await waitJobs(server)
      expect(emails).to.have.lengthOf(5)

      const email = emails[4]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains(' blacklisted')
      expect(email['text']).contains('my super user video')
      expect(email['text']).contains('my super reason')
    })

    it('Should send the notification email', async function () {
      this.timeout(10000)

      await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)

      await waitJobs(server)
      expect(emails).to.have.lengthOf(6)

      const email = emails[5]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains(' unblacklisted')
      expect(email['text']).contains('my super user video')
    })
  })

  describe('When verifying a user email', function () {

    it('Should ask to send the verification email', async function () {
      this.timeout(10000)

      await askSendVerifyEmail(server.url, 'user_1@example.com')

      await waitJobs(server)
      expect(emails).to.have.lengthOf(7)

      const email = emails[6]

      expect(email['from'][0]['name']).equal('localhost:9001')
      expect(email['from'][0]['address']).equal('test-admin@localhost')
      expect(email['to'][0]['address']).equal('user_1@example.com')
      expect(email['subject']).contains('Verify')

      const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
      expect(verificationStringMatches).not.to.be.null

      verificationString = verificationStringMatches[1]
      expect(verificationString).to.not.be.undefined
      expect(verificationString).to.have.length.above(2)

      const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
      expect(userIdMatches).not.to.be.null

      userId = parseInt(userIdMatches[1], 10)
    })

    it('Should not verify the email with an invalid verification string', async function () {
      await verifyEmail(server.url, userId, verificationString + 'b', 403)
    })

    it('Should verify the email', async function () {
      await verifyEmail(server.url, userId, verificationString)
    })
  })

  after(async function () {
    MockSmtpServer.Instance.kill()
    killallServers([ server ])
  })
})
Commit	Line	Data
f076daa7 C	1	/* tslint:disable:no-unused-expression */
	2
	3	import * as chai from 'chai'
	4	import 'mocha'
eacb25c4	5	import {
26b7305a	6	addVideoToBlacklist,
eacb25c4	7	askResetPassword,
d9eaee39	8	askSendVerifyEmail,
eacb25c4	9	blockUser,
26b7305a	10	createUser, removeVideoFromBlacklist,
eacb25c4 C	11	reportVideoAbuse,
	12	resetPassword,
	13	runServer,
	14	unblockUser,
	15	uploadVideo,
d9eaee39	16	userLogin,
9639bd17	17	verifyEmail,
	18	flushTests,
	19	killallServers,
	20	ServerInfo,
	21	setAccessTokensToServers
	22	} from '../../../../shared/utils'
af37210c	23	import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
9639bd17	24	import { waitJobs } from '../../../../shared/utils/server/jobs'
f076daa7 C	25
	26	const expect = chai.expect
	27
	28	describe('Test emails', function () {
	29	let server: ServerInfo
	30	let userId: number
26b7305a	31	let userAccessToken: string
ba75d268	32	let videoUUID: string
26b7305a	33	let videoUserUUID: string
f076daa7 C	34	let verificationString: string
	35	const emails: object[] = []
	36	const user = {
	37	username: 'user_1',
	38	password: 'super_password'
	39	}
	40
	41	before(async function () {
	42	this.timeout(30000)
	43
af37210c	44	await MockSmtpServer.Instance.collectEmails(emails)
f076daa7 C	45
	46	await flushTests()
	47
	48	const overrideConfig = {
	49	smtp: {
	50	hostname: 'localhost'
	51	}
	52	}
	53	server = await runServer(1, overrideConfig)
f076daa7 C	54	await setAccessTokensToServers([ server ])
f076daa7 C	55
ba75d268 C	56	{
	57	const res = await createUser(server.url, server.accessToken, user.username, user.password)
	58	userId = res.body.user.id
26b7305a C	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
ba75d268 C	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	}
f076daa7 C	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
3cd0734f	87	await waitJobs(server)
f076daa7 C	88	expect(emails).to.have.lengthOf(1)
	89
	90	const email = emails[0]
	91
4759fedc	92	expect(email['from'][0]['name']).equal('localhost:9001')
f076daa7 C	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
ba75d268 C	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
3cd0734f	132	await waitJobs(server)
ba75d268 C	133	expect(emails).to.have.lengthOf(2)
	134
	135	const email = emails[1]
	136
4759fedc	137	expect(email['from'][0]['name']).equal('localhost:9001')
ba75d268 C	138	expect(email['from'][0]['address']).equal('test-admin@localhost')
	139	expect(email['to'][0]['address']).equal('admin1@example.com')
	140	expect(email['subject']).contains('abuse')
	141	expect(email['text']).contains(videoUUID)
	142	})
	143	})
	144
eacb25c4 C	145	describe('When blocking/unblocking user', async function () {
	146	it('Should send the notification email when blocking a user', async function () {
	147	this.timeout(10000)
	148
	149	const reason = 'my super bad reason'
	150	await blockUser(server.url, userId, server.accessToken, 204, reason)
	151
	152	await waitJobs(server)
	153	expect(emails).to.have.lengthOf(3)
	154
	155	const email = emails[2]
	156
4759fedc	157	expect(email['from'][0]['name']).equal('localhost:9001')
eacb25c4 C	158	expect(email['from'][0]['address']).equal('test-admin@localhost')
	159	expect(email['to'][0]['address']).equal('user_1@example.com')
	160	expect(email['subject']).contains(' blocked')
	161	expect(email['text']).contains(' blocked')
	162	expect(email['text']).contains(reason)
	163	})
	164
	165	it('Should send the notification email when unblocking a user', async function () {
	166	this.timeout(10000)
	167
	168	await unblockUser(server.url, userId, server.accessToken, 204)
	169
	170	await waitJobs(server)
	171	expect(emails).to.have.lengthOf(4)
	172
	173	const email = emails[3]
	174
4759fedc	175	expect(email['from'][0]['name']).equal('localhost:9001')
eacb25c4 C	176	expect(email['from'][0]['address']).equal('test-admin@localhost')
	177	expect(email['to'][0]['address']).equal('user_1@example.com')
	178	expect(email['subject']).contains(' unblocked')
	179	expect(email['text']).contains(' unblocked')
	180	})
	181	})
	182
26b7305a C	183	describe('When blacklisting a video', function () {
	184	it('Should send the notification email', async function () {
	185	this.timeout(10000)
	186
	187	const reason = 'my super reason'
	188	await addVideoToBlacklist(server.url, server.accessToken, videoUserUUID, reason)
	189
	190	await waitJobs(server)
	191	expect(emails).to.have.lengthOf(5)
	192
	193	const email = emails[4]
	194
4759fedc	195	expect(email['from'][0]['name']).equal('localhost:9001')
26b7305a C	196	expect(email['from'][0]['address']).equal('test-admin@localhost')
	197	expect(email['to'][0]['address']).equal('user_1@example.com')
	198	expect(email['subject']).contains(' blacklisted')
	199	expect(email['text']).contains('my super user video')
	200	expect(email['text']).contains('my super reason')
	201	})
	202
	203	it('Should send the notification email', async function () {
	204	this.timeout(10000)
	205
	206	await removeVideoFromBlacklist(server.url, server.accessToken, videoUserUUID)
	207
	208	await waitJobs(server)
	209	expect(emails).to.have.lengthOf(6)
	210
	211	const email = emails[5]
	212
4759fedc	213	expect(email['from'][0]['name']).equal('localhost:9001')
26b7305a C	214	expect(email['from'][0]['address']).equal('test-admin@localhost')
	215	expect(email['to'][0]['address']).equal('user_1@example.com')
	216	expect(email['subject']).contains(' unblacklisted')
	217	expect(email['text']).contains('my super user video')
	218	})
	219	})
	220
d9eaee39 JM	221	describe('When verifying a user email', function () {
	222
	223	it('Should ask to send the verification email', async function () {
	224	this.timeout(10000)
	225
	226	await askSendVerifyEmail(server.url, 'user_1@example.com')
	227
	228	await waitJobs(server)
	229	expect(emails).to.have.lengthOf(7)
	230
	231	const email = emails[6]
	232
4759fedc	233	expect(email['from'][0]['name']).equal('localhost:9001')
d9eaee39 JM	234	expect(email['from'][0]['address']).equal('test-admin@localhost')
	235	expect(email['to'][0]['address']).equal('user_1@example.com')
	236	expect(email['subject']).contains('Verify')
	237
	238	const verificationStringMatches = /verificationString=([a-z0-9]+)/.exec(email['text'])
	239	expect(verificationStringMatches).not.to.be.null
	240
	241	verificationString = verificationStringMatches[1]
	242	expect(verificationString).to.not.be.undefined
	243	expect(verificationString).to.have.length.above(2)
	244
	245	const userIdMatches = /userId=([0-9]+)/.exec(email['text'])
	246	expect(userIdMatches).not.to.be.null
	247
	248	userId = parseInt(userIdMatches[1], 10)
	249	})
	250
	251	it('Should not verify the email with an invalid verification string', async function () {
	252	await verifyEmail(server.url, userId, verificationString + 'b', 403)
	253	})
	254
	255	it('Should verify the email', async function () {
	256	await verifyEmail(server.url, userId, verificationString)
	257	})
	258	})
	259
f076daa7	260	after(async function () {
89ada4e2	261	MockSmtpServer.Instance.kill()
f076daa7	262	killallServers([ server ])
f076daa7 C	263	})
f076daa7 C	264	})