Thream/api
Archived
2
1
Fork 0
Code Issues Pull Requests Releases Activity

feat: usage of ESM modules imports (instead of CommonJS) (#5)

Browse Source 
Replace `jest` with `tap`.
This commit is contained in:
Divlo
2022-03-20 11:49:27 +01:00
committed by GitHub
parent 91a0e2a76f
commit 19b6f96ecf
70 changed files with 8017 additions and 6318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/services/users/[userId]/__test__/get.test.ts
View File

@ -1,31 +1,54 @@
import tap from 'tap'
import sinon from 'sinon'
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
import { userSettingsExample } from '../../../../models/UserSettings.js'
import { prismaMock } from '../../../../__test__/setup.js'
describe('GET /users/[userId]', () => {
it('succeeds', async () => {
prismaMock.guild.findMany.mockResolvedValue([])
prismaMock.user.findUnique.mockResolvedValue(userExample)
prismaMock.userSetting.findFirst.mockResolvedValue(userSettingsExample)
await tap.test('GET /users/[userId]', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'guild').value({
findMany: async () => {
return []
}
})
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return userExample
}
})
sinon.stub(prisma, 'userSetting').value({
findFirst: async () => {
return userSettingsExample
}
})
const response = await application.inject({
method: 'GET',
url: `/users/${userExample.id}`
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.user.id).toEqual(userExample.id)
expect(responseJson.user.name).toEqual(userExample.name)
t.equal(response.statusCode, 200)
t.equal(responseJson.user.id, userExample.id)
t.equal(responseJson.user.name, userExample.name)
})
it('fails with not found user', async () => {
prismaMock.userSetting.findFirst.mockResolvedValue(null)
await t.test('fails with not found user', async (t) => {
sinon.stub(prisma, 'userSetting').value({
findFirst: async () => {
return null
}
})
const response = await application.inject({
method: 'GET',
url: `/users/1`
})
const responseJson = response.json()
expect(response.statusCode).toEqual(404)
expect(responseJson.message).toEqual('User not found')
t.equal(response.statusCode, 404)
t.equal(responseJson.message, 'User not found')
})
})

63
src/services/users/confirm-email/__test__/get.test.ts
View File

@ -1,31 +1,23 @@
import { application } from '../../../../application.js'
import { userExample } from '../../../../models/User.js'
import { prismaMock } from '../../../../__test__/setup.js'
import tap from 'tap'
import sinon from 'sinon'
describe('GET /users/confirm-email', () => {
it('should succeeds', async () => {
prismaMock.user.findFirst.mockResolvedValue(userExample)
prismaMock.user.update.mockResolvedValue({
...userExample,
isConfirmed: true,
temporaryToken: null
})
const response = await application.inject({
method: 'GET',
url: '/users/confirm-email',
query: {
temporaryToken: userExample.temporaryToken ?? ''
}
})
expect(response.statusCode).toEqual(200)
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
await tap.test('GET /users/confirm-email', async (t) => {
t.afterEach(() => {
sinon.restore()
})
it('should fails with invalid `temporaryToken`', async () => {
prismaMock.user.findFirst.mockResolvedValue(null)
prismaMock.user.update.mockResolvedValue({
...userExample,
isConfirmed: true,
temporaryToken: null
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return userExample
},
update: async () => {
return { ...userExample, isConfirmed: true, temporaryToken: null }
}
})
const response = await application.inject({
method: 'GET',
@ -34,6 +26,25 @@ describe('GET /users/confirm-email', () => {
temporaryToken: userExample.temporaryToken ?? ''
}
})
expect(response.statusCode).toEqual(403)
t.equal(response.statusCode, 200)
})
await t.test('should fails with invalid `temporaryToken`', async (t) => {
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return null
},
update: async () => {
return { ...userExample, isConfirmed: true, temporaryToken: null }
}
})
const response = await application.inject({
method: 'GET',
url: '/users/confirm-email',
query: {
temporaryToken: userExample.temporaryToken ?? ''
}
})
t.equal(response.statusCode, 403)
})
})

23
src/services/users/current/__test__/get.test.ts
View File

@ -1,8 +1,15 @@
import tap from 'tap'
import sinon from 'sinon'
import { application } from '../../../../application.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
describe('GET /users/current', () => {
it('succeeds', async () => {
await tap.test('GET /users/current', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
const { accessToken, user } = await authenticateUserTest()
const response = await application.inject({
method: 'GET',
@ -12,18 +19,16 @@ describe('GET /users/current', () => {
}
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.user.name).toEqual(user.name)
expect(responseJson.user.strategies).toEqual(
expect.arrayContaining(['local'])
)
t.equal(response.statusCode, 200)
t.equal(responseJson.user.name, user.name)
t.strictSame(responseJson.user.strategies, ['local'])
})
it('fails with unauthenticated user', async () => {
await t.test('fails with unauthenticated user', async (t) => {
const response = await application.inject({
method: 'GET',
url: '/users/current'
})
expect(response.statusCode).toEqual(401)
t.equal(response.statusCode, 401)
})
})

103
src/services/users/current/__test__/put.test.ts
View File

@ -1,15 +1,29 @@
import { application } from '../../../../application.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
import { prismaMock } from '../../../../__test__/setup.js'
import { userExample } from '../../../../models/User.js'
import tap from 'tap'
import sinon from 'sinon'
describe('PUT /users/current', () => {
it('succeeds with valid accessToken and valid name', async () => {
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
await tap.test('PUT /users/current', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds with valid accessToken and valid name', async (t) => {
const newName = 'John Doe'
const { accessToken, user } = await authenticateUserTest()
prismaMock.user.update.mockResolvedValue({
...user,
name: newName
const { accessToken, user, userStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'user').value({
...userStubValue,
findFirst: async () => {
return null
},
update: async () => {
return {
...user,
name: newName
}
}
})
const response = await application.inject({
method: 'PUT',
@ -22,16 +36,24 @@ describe('PUT /users/current', () => {
}
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.user.name).toEqual(newName)
t.equal(response.statusCode, 200)
t.equal(responseJson.user.name, newName)
})
it('succeeds and only update the status', async () => {
await t.test('succeeds and only update the status', async (t) => {
const newStatus = '👀 Working on secret projects...'
const { accessToken, user } = await authenticateUserTest()
prismaMock.user.update.mockResolvedValue({
...user,
status: newStatus
const { accessToken, user, userStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'user').value({
...userStubValue,
findFirst: async () => {
return null
},
update: async () => {
return {
...user,
status: newStatus
}
}
})
const response = await application.inject({
method: 'PUT',
@ -44,15 +66,20 @@ describe('PUT /users/current', () => {
}
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.user.name).toEqual(user.name)
expect(responseJson.user.status).toEqual(newStatus)
t.equal(response.statusCode, 200)
t.equal(responseJson.user.name, user.name)
t.equal(responseJson.user.status, newStatus)
})
it('fails with name already used', async () => {
await t.test('fails with name already used', async (t) => {
const newName = 'John Doe'
prismaMock.user.findFirst.mockResolvedValue(userExample)
const { accessToken } = await authenticateUserTest()
const { accessToken, user, userStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'user').value({
...userStubValue,
findFirst: async () => {
return user
}
})
const response = await application.inject({
method: 'PUT',
url: '/users/current',
@ -63,10 +90,10 @@ describe('PUT /users/current', () => {
name: newName
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('fails with invalid website url', async () => {
await t.test('fails with invalid website url', async (t) => {
const newWebsite = 'invalid website url'
const { accessToken } = await authenticateUserTest()
const response = await application.inject({
@ -79,15 +106,23 @@ describe('PUT /users/current', () => {
website: newWebsite
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('succeeds with valid website url', async () => {
await t.test('succeeds with valid website url', async (t) => {
const newWebsite = 'https://somerandomwebsite.com'
const { accessToken, user } = await authenticateUserTest()
prismaMock.user.update.mockResolvedValue({
...user,
website: newWebsite
const { accessToken, user, userStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'user').value({
...userStubValue,
findFirst: async () => {
return null
},
update: async () => {
return {
...user,
website: newWebsite
}
}
})
const response = await application.inject({
method: 'PUT',
@ -100,8 +135,8 @@ describe('PUT /users/current', () => {
}
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.user.name).toEqual(user.name)
expect(responseJson.user.website).toEqual(newWebsite)
t.equal(response.statusCode, 200)
t.equal(responseJson.user.name, user.name)
t.equal(responseJson.user.website, newWebsite)
})
})

8
src/services/users/current/logo/put.ts
View File

@ -7,8 +7,8 @@ import { fastifyErrors } from '../../../../models/utils.js'
import prisma from '../../../../tools/database/prisma.js'
import { uploadFile } from '../../../../tools/utils/uploadFile.js'
import {
maximumImageSize,
supportedImageMimetype
MAXIMUM_IMAGE_SIZE,
SUPPORTED_IMAGE_MIMETYPE
} from '../../../../tools/configurations/index.js'
const putServiceSchema: FastifySchema = {
@ -52,8 +52,8 @@ export const putCurrentUserLogo: FastifyPluginAsync = async (fastify) => {
fastify,
request,
folderInUploadsFolder: 'users',
maximumFileSize: maximumImageSize,
supportedFileMimetype: supportedImageMimetype
maximumFileSize: MAXIMUM_IMAGE_SIZE,
supportedFileMimetype: SUPPORTED_IMAGE_MIMETYPE
})
await prisma.user.update({
where: { id: request.user.current.id },

98
src/services/users/current/settings/__test__/put.test.ts
View File

@ -1,48 +1,72 @@
import tap from 'tap'
import sinon from 'sinon'
import { application } from '../../../../../application.js'
import { authenticateUserTest } from '../../../../../__test__/utils/authenticateUserTest.js'
import { prismaMock } from '../../../../../__test__/setup.js'
import prisma from '../../../../../tools/database/prisma.js'
import { userSettingsExample } from '../../../../../models/UserSettings.js'
describe('PUT /users/current/settings', () => {
it('succeeds and edit the theme, language, isPublicEmail and isPublicGuilds', async () => {
const newSettings = {
theme: 'light',
language: 'fr',
isPublicEmail: true,
isPublicGuilds: true
}
prismaMock.userSetting.findFirst.mockResolvedValue(userSettingsExample)
prismaMock.userSetting.update.mockResolvedValue({
...userSettingsExample,
...newSettings
})
const { accessToken } = await authenticateUserTest()
const response = await application.inject({
method: 'PUT',
url: '/users/current/settings',
headers: {
authorization: `Bearer ${accessToken}`
},
payload: newSettings
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.settings.theme).toEqual(newSettings.theme)
expect(responseJson.settings.language).toEqual(newSettings.language)
expect(responseJson.settings.isPublicEmail).toEqual(
newSettings.isPublicEmail
)
expect(responseJson.settings.isPublicGuilds).toEqual(
newSettings.isPublicGuilds
)
await tap.test('PUT /users/current/settings', async (t) => {
t.afterEach(() => {
sinon.restore()
})
it('fails with invalid language', async () => {
await t.test(
'succeeds and edit the theme, language, isPublicEmail and isPublicGuilds',
async (t) => {
const newSettings = {
theme: 'light',
language: 'fr',
isPublicEmail: true,
isPublicGuilds: true
}
const { accessToken, userSettingStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'userSetting').value({
...userSettingStubValue,
findFirst: async () => {
return userSettingsExample
},
update: async () => {
return {
...userSettingsExample,
...newSettings
}
}
})
const response = await application.inject({
method: 'PUT',
url: '/users/current/settings',
headers: {
authorization: `Bearer ${accessToken}`
},
payload: newSettings
})
const responseJson = response.json()
t.equal(response.statusCode, 200)
t.equal(responseJson.settings.theme, newSettings.theme)
t.equal(responseJson.settings.language, newSettings.language)
t.equal(responseJson.settings.isPublicEmail, newSettings.isPublicEmail)
t.equal(responseJson.settings.isPublicGuilds, newSettings.isPublicGuilds)
}
)
await t.test('fails with invalid language', async (t) => {
const newSettings = {
language: 'somerandomlanguage'
}
prismaMock.userSetting.findFirst.mockResolvedValue(userSettingsExample)
const { accessToken } = await authenticateUserTest()
const { accessToken, userSettingStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'userSetting').value({
...userSettingStubValue,
findFirst: async () => {
return userSettingsExample
},
update: async () => {
return {
...userSettingsExample,
...newSettings
}
}
})
const response = await application.inject({
method: 'PUT',
url: '/users/current/settings',
@ -51,6 +75,6 @@ describe('PUT /users/current/settings', () => {
},
payload: newSettings
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
})

64
src/services/users/refresh-token/__test__/post.test.ts
View File

@ -1,46 +1,72 @@
import tap from 'tap'
import sinon from 'sinon'
import { application } from '../../../../application.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
import prisma from '../../../../tools/database/prisma.js'
import { refreshTokenExample } from '../../../../models/RefreshToken.js'
import { expiresIn } from '../../../../tools/utils/jwtToken.js'
import { prismaMock } from '../../../../__test__/setup.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
describe('POST /users/refresh-token', () => {
it('succeeds', async () => {
const { refreshToken } = await authenticateUserTest()
prismaMock.refreshToken.findFirst.mockResolvedValue({
...refreshTokenExample,
id: 1,
token: refreshToken
await tap.test('POST /users/refresh-token', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
const { accessToken, refreshToken, refreshTokenStubValue } =
await authenticateUserTest()
sinon.stub(prisma, 'refreshToken').value({
...refreshTokenStubValue,
findFirst: async () => {
return {
...refreshTokenExample,
id: 1,
token: refreshToken
}
}
})
const response = await application.inject({
method: 'POST',
url: '/users/refresh-token',
headers: {
authorization: `Bearer ${accessToken}`
},
payload: { refreshToken }
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.type).toEqual('Bearer')
expect(responseJson.expiresIn).toEqual(expiresIn)
expect(typeof responseJson.accessToken).toEqual('string')
t.equal(response.statusCode, 200)
t.equal(responseJson.type, 'Bearer')
t.equal(responseJson.expiresIn, expiresIn)
t.type(responseJson.accessToken, 'string')
})
it('fails with refreshToken noty saved in database', async () => {
await t.test('fails with refreshToken not saved in database', async (t) => {
sinon.stub(prisma, 'refreshToken').value({
findFirst: async () => {
return null
}
})
const response = await application.inject({
method: 'POST',
url: '/users/refresh-token',
payload: { refreshToken: 'somerandomtoken' }
})
expect(response.statusCode).toEqual(403)
t.equal(response.statusCode, 403)
})
it('fails with invalid jwt refreshToken', async () => {
const { refreshToken } = await authenticateUserTest()
prismaMock.refreshToken.findFirst.mockResolvedValue(refreshTokenExample)
await t.test('fails with invalid jwt refreshToken', async (t) => {
const { refreshToken, refreshTokenStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'refreshToken').value({
...refreshTokenStubValue,
findFirst: async () => {
return refreshTokenExample
}
})
const response = await application.inject({
method: 'POST',
url: '/users/refresh-token',
payload: { refreshToken }
})
expect(response.statusCode).toEqual(403)
t.equal(response.statusCode, 403)
})
})

105
src/services/users/reset-password/__test__/post.test.ts
View File

@ -1,66 +1,115 @@
import tap from 'tap'
import sinon from 'sinon'
import ms from 'ms'
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
import { userSettingsExample } from '../../../../models/UserSettings.js'
import { prismaMock } from '../../../../__test__/setup.js'
import { emailTransporter } from '../../../../tools/email/emailTransporter.js'
describe('POST /users/reset-password', () => {
it('succeeds', async () => {
prismaMock.user.findUnique.mockResolvedValue(userExample)
prismaMock.userSetting.findFirst.mockResolvedValue(userSettingsExample)
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
expect(response.statusCode).toEqual(200)
await tap.test('POST /users/reset-password', async (t) => {
t.afterEach(() => {
sinon.restore()
})
it("fails with email that doesn't exist", async () => {
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return userExample
},
update: async () => {
return {
...userExample,
temporaryExpirationToken: new Date(Date.now() + ms('1 hour')),
temporaryToken: 'random-token'
}
}
})
sinon.stub(prisma, 'userSetting').value({
findFirst: async () => {
return userSettingsExample
}
})
sinon.stub(emailTransporter, 'sendMail').value(() => {})
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 200)
})
it('fails with unconfirmed account', async () => {
prismaMock.user.findUnique.mockResolvedValue({
...userExample,
isConfirmed: false
await t.test("fails with email that doesn't exist", async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return null
}
})
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it("fails if userSettings doenst' exist", async () => {
prismaMock.user.findUnique.mockResolvedValue(userExample)
prismaMock.userSetting.findFirst.mockResolvedValue(null)
await t.test('fails with unconfirmed account', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return {
...userExample,
isConfirmed: false
}
}
})
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('fails with a request already in progress', async () => {
prismaMock.user.findUnique.mockResolvedValue({
...userExample,
temporaryExpirationToken: new Date(Date.now() + ms('1 hour'))
await t.test("fails if userSettings doesn't exist", async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return userExample
}
})
sinon.stub(prisma, 'userSetting').value({
findFirst: async () => {
return null
}
})
prismaMock.userSetting.findFirst.mockResolvedValue(userSettingsExample)
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
await t.test('fails with a request already in progress', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return {
...userExample,
temporaryToken: 'random-token',
temporaryExpirationToken: new Date(Date.now() + ms('1 hour'))
}
}
})
sinon.stub(prisma, 'userSetting').value({
findFirst: async () => {
return userSettingsExample
}
})
const response = await application.inject({
method: 'POST',
url: '/users/reset-password?redirectURI=https://redirecturi.com',
payload: { email: userExample.email }
})
t.equal(response.statusCode, 400)
})
})

65
src/services/users/reset-password/__test__/put.test.ts
View File

@ -1,28 +1,30 @@
import tap from 'tap'
import sinon from 'sinon'
import ms from 'ms'
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
import { prismaMock } from '../../../../__test__/setup.js'
describe('PUT /users/reset-password', () => {
it('succeeds', async () => {
prismaMock.user.findFirst.mockResolvedValue({
...userExample,
temporaryExpirationToken: new Date(Date.now() + ms('1 hour'))
})
const response = await application.inject({
method: 'PUT',
url: '/users/reset-password',
payload: {
password: 'new password',
temporaryToken: userExample.temporaryToken
}
})
expect(response.statusCode).toEqual(200)
await tap.test('PUT /users/reset-password', async (t) => {
t.afterEach(() => {
sinon.restore()
})
it('fails with expired temporaryToken', async () => {
prismaMock.user.findFirst.mockResolvedValue(userExample)
await t.test('succeeds', async (t) => {
const temporaryToken = 'random-token'
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return {
...userExample,
temporaryToken,
temporaryExpirationToken: new Date(Date.now() + ms('1 hour'))
}
},
update: async () => {
return userExample
}
})
const response = await application.inject({
method: 'PUT',
url: '/users/reset-password',
@ -31,6 +33,31 @@ describe('PUT /users/reset-password', () => {
temporaryToken: userExample.temporaryToken
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 200)
})
await t.test('fails with expired temporaryToken', async (t) => {
const temporaryToken = 'random-token'
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return {
...userExample,
temporaryToken,
temporaryExpirationToken: new Date(Date.now() - ms('1 hour'))
}
},
update: async () => {
return userExample
}
})
const response = await application.inject({
method: 'PUT',
url: '/users/reset-password',
payload: {
password: 'new password',
temporaryToken: userExample.temporaryToken
}
})
t.equal(response.statusCode, 400)
})
})

12
src/services/users/reset-password/post.ts
View File

@ -70,6 +70,12 @@ export const postResetPasswordUser: FastifyPluginAsync = async (fastify) => {
'A request to reset-password is already in progress'
)
}
const userSettings = await prisma.userSetting.findFirst({
where: { userId: user.id }
})
if (userSettings == null) {
throw fastify.httpErrors.badRequest()
}
const temporaryToken = randomUUID()
await prisma.user.update({
where: {
@ -80,12 +86,6 @@ export const postResetPasswordUser: FastifyPluginAsync = async (fastify) => {
temporaryToken
}
})
const userSettings = await prisma.userSetting.findFirst({
where: { userId: user.id }
})
if (userSettings == null) {
throw fastify.httpErrors.badRequest()
}
await sendEmail({
type: 'reset-password',
email,

82
src/services/users/signin/__test__/post.test.ts
View File

@ -1,46 +1,68 @@
import tap from 'tap'
import sinon from 'sinon'
import bcrypt from 'bcryptjs'
import { application } from '../../../../application.js'
import { refreshTokenExample } from '../../../../models/RefreshToken.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
import { refreshTokenExample } from '../../../../models/RefreshToken.js'
import { expiresIn } from '../../../../tools/utils/jwtToken.js'
import { prismaMock } from '../../../../__test__/setup.js'
const payload = {
email: userExample.email,
password: userExample.password
}
describe('POST /users/signin', () => {
it('succeeds', async () => {
prismaMock.user.findUnique.mockResolvedValue({
...userExample,
password: await bcrypt.hash(userExample.password as string, 12)
await tap.test('POST /users/signin', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return {
...userExample,
password: await bcrypt.hash(payload.password as string, 12)
}
}
})
sinon.stub(prisma, 'refreshToken').value({
create: async () => {
return refreshTokenExample
}
})
prismaMock.refreshToken.create.mockResolvedValue(refreshTokenExample)
const response = await application.inject({
method: 'POST',
url: '/users/signin',
payload
})
const responseJson = response.json()
expect(response.statusCode).toEqual(200)
expect(responseJson.type).toEqual('Bearer')
expect(responseJson.expiresIn).toEqual(expiresIn)
t.equal(response.statusCode, 200)
t.equal(responseJson.type, 'Bearer')
t.equal(responseJson.expiresIn, expiresIn)
})
it('fails with invalid user', async () => {
prismaMock.user.findUnique.mockResolvedValue(null)
await t.test('fails with invalid user', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: () => {
return null
}
})
const response = await application.inject({
method: 'POST',
url: '/users/signin',
payload
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('fails with invalid email', async () => {
prismaMock.user.findUnique.mockResolvedValue(null)
await t.test('fails with invalid email', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: () => {
return null
}
})
const response = await application.inject({
method: 'POST',
url: '/users/signin',
@ -49,32 +71,40 @@ describe('POST /users/signin', () => {
email: 'incorrect-email'
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it("fails if user hasn't got a password", async () => {
prismaMock.user.findUnique.mockResolvedValue({
...userExample,
password: null
await t.test("fails if user hasn't got a password", async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: () => {
return {
...userExample,
password: null
}
}
})
const response = await application.inject({
method: 'POST',
url: '/users/signin',
payload
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('fails with incorrect password', async () => {
prismaMock.user.findUnique.mockResolvedValue(userExample)
await t.test('fails with incorrect password', async (t) => {
sinon.stub(prisma, 'user').value({
findUnique: async () => {
return userExample
}
})
const response = await application.inject({
method: 'POST',
url: '/users/signin',
payload: {
...payload,
password: userExample.password
password: 'incorrect-password'
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
})

32
src/services/users/signout/__test__/delete.test.ts
View File

@ -1,13 +1,23 @@
import { application } from '../../../../application.js'
import { prismaMock } from '../../../../__test__/setup.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
import tap from 'tap'
import sinon from 'sinon'
describe('DELETE /users/signout', () => {
it('succeeds', async () => {
prismaMock.refreshToken.deleteMany.mockResolvedValue({
count: 1
import { application } from '../../../../application.js'
import { authenticateUserTest } from '../../../../__test__/utils/authenticateUserTest.js'
import prisma from '../../../../tools/database/prisma.js'
await tap.test('DELETE /users/signout', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
const { accessToken, refreshTokenStubValue } = await authenticateUserTest()
sinon.stub(prisma, 'refreshToken').value({
...refreshTokenStubValue,
deleteMany: async () => {
return { count: 1 }
}
})
const { accessToken } = await authenticateUserTest()
const response = await application.inject({
method: 'DELETE',
url: '/users/signout',
@ -15,14 +25,14 @@ describe('DELETE /users/signout', () => {
authorization: `Bearer ${accessToken}`
}
})
expect(response.statusCode).toEqual(200)
t.equal(response.statusCode, 200)
})
it('fails with empty authorization header', async () => {
await t.test('fails with empty authorized header', async (t) => {
const response = await application.inject({
method: 'DELETE',
url: '/users/signout'
})
expect(response.statusCode).toEqual(401)
t.equal(response.statusCode, 401)
})
})

36
src/services/users/signout/__test__/post.test.ts
View File

@ -1,25 +1,41 @@
import { application } from '../../../../application.js'
import { refreshTokenExample } from '../../../../models/RefreshToken.js'
import { prismaMock } from '../../../../__test__/setup.js'
import tap from 'tap'
import sinon from 'sinon'
describe('POST /users/signout', () => {
it('succeeds', async () => {
prismaMock.refreshToken.findFirst.mockResolvedValue(refreshTokenExample)
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { refreshTokenExample } from '../../../../models/RefreshToken.js'
await tap.test('POST /users/signout', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'refreshToken').value({
findFirst: async () => {
return refreshTokenExample
},
delete: async () => {}
})
const response = await application.inject({
method: 'POST',
url: '/users/signout',
payload: { refreshToken: refreshTokenExample.token }
})
expect(response.statusCode).toEqual(200)
t.equal(response.statusCode, 200)
})
it('fails with invalid refreshToken', async () => {
prismaMock.refreshToken.findFirst.mockResolvedValue(null)
await t.test('fails with invalid refreshToken', async (t) => {
sinon.stub(prisma, 'refreshToken').value({
findFirst: async () => {
return null
}
})
const response = await application.inject({
method: 'POST',
url: '/users/signout',
payload: { refreshToken: 'somerandomtoken' }
})
expect(response.statusCode).toEqual(404)
t.equal(response.statusCode, 404)
})
})

61
src/services/users/signup/__test__/post.test.ts
View File

@ -1,7 +1,11 @@
import tap from 'tap'
import sinon from 'sinon'
import { application } from '../../../../application.js'
import prisma from '../../../../tools/database/prisma.js'
import { userExample } from '../../../../models/User.js'
import { userSettingsExample } from '../../../../models/UserSettings.js'
import { prismaMock } from '../../../../__test__/setup.js'
import { emailTransporter } from '../../../../tools/email/emailTransporter.js'
const payload = {
name: userExample.name,
@ -11,26 +15,44 @@ const payload = {
language: userSettingsExample.language
}
describe('POST /users/signup', () => {
it('succeeds', async () => {
prismaMock.user.findFirst.mockResolvedValue(null)
prismaMock.user.create.mockResolvedValue(userExample)
prismaMock.userSetting.create.mockResolvedValue(userSettingsExample)
await tap.test('POST /users/signup', async (t) => {
t.afterEach(() => {
sinon.restore()
})
await t.test('succeeds', async (t) => {
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return null
},
create: async () => {
return userExample
}
})
sinon.stub(prisma, 'userSetting').value({
create: async () => {
return userSettingsExample
}
})
sinon.stub(emailTransporter, 'sendMail').value(() => {})
const response = await application.inject({
method: 'POST',
url: '/users/signup',
payload
})
const responseJson = response.json()
expect(response.statusCode).toEqual(201)
expect(responseJson.user.name).toEqual(userExample.name)
expect(responseJson.user.email).toEqual(userExample.email)
t.equal(response.statusCode, 201)
t.equal(responseJson.user.name, userExample.name)
t.equal(responseJson.user.email, userExample.email)
})
it('fails with invalid email', async () => {
prismaMock.user.findFirst.mockResolvedValue(null)
prismaMock.user.create.mockResolvedValue(userExample)
prismaMock.userSetting.create.mockResolvedValue(userSettingsExample)
await t.test('fails with invalid email', async (t) => {
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return null
}
})
sinon.stub(emailTransporter, 'sendMail').value(() => {})
const response = await application.inject({
method: 'POST',
url: '/users/signup',
@ -39,16 +61,21 @@ describe('POST /users/signup', () => {
email: 'incorrect-email'
}
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
it('fails with already taken `name` or `email`', async () => {
prismaMock.user.findFirst.mockResolvedValue(userExample)
await t.test('fails with already taken `name` or `email`', async (t) => {
sinon.stub(prisma, 'user').value({
findFirst: async () => {
return userExample
}
})
sinon.stub(emailTransporter, 'sendMail').value(() => {})
const response = await application.inject({
method: 'POST',
url: '/users/signup',
payload
})
expect(response.statusCode).toEqual(400)
t.equal(response.statusCode, 400)
})
})