BradNut/boredgame
1
0
Fork 0
mirror of https://github.com/BradNut/boredgame synced 2025-09-08 17:40:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixing all the tests to pass

Browse source
This commit is contained in:
Bradley Shellnut 2024-09-13 17:21:22 -07:00
parent 68182da4ce
commit b1527e7782
7 changed files with 227 additions and 249 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/lib/server/api/databases/seeds/roles.ts
View file

@ -1,5 +1,5 @@
import * as schema from '$lib/server/api/databases/tables'
import { type db } from '$lib/server/api/packages/drizzle'
import type { db } from '$lib/server/api/packages/drizzle'
import roles from './data/roles.json'
export default async function seed(db: db) {

7
src/lib/server/api/databases/tables/roles.table.ts
View file

@ -4,6 +4,13 @@ import { pgTable, text, uuid } from 'drizzle-orm/pg-core'
import { timestamps } from '../../common/utils/table'
import { user_roles } from './userRoles.table'
export enum RoleName {
ADMIN = 'admin',
EDITOR = 'editor',
MODERATOR = 'moderator',
USER = 'user',
}
export const rolesTable = pgTable('roles', {
id: uuid('id').primaryKey().defaultRandom(),
cuid: text('cuid')

4
src/lib/server/api/services/iam.service.ts
View file

@ -44,13 +44,13 @@ export class IamService {
}
const existingUserForNewUsername = await this.usersService.findOneByUsername(data.username)
if (existingUserForNewUsername && existingUserForNewUsername.id !== userId) {
if (existingUserForNewUsername && existingUserForNewUsername.id !== user.id) {
return {
error: 'Username already in use',
}
}
return this.usersService.updateUser(userId, {
return this.usersService.updateUser(user.id, {
first_name: data.firstName,
last_name: data.lastName,
username: data.username !== user.username ? data.username : user.username,

101
src/lib/server/api/tests/iam.service.test.ts
View file

@ -2,6 +2,7 @@ import 'reflect-metadata'
import { IamService } from '$lib/server/api/services/iam.service'
import { LuciaService } from '$lib/server/api/services/lucia.service'
import { UsersService } from '$lib/server/api/services/users.service'
import { faker } from '@faker-js/faker'
import { container } from 'tsyringe'
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
@ -25,60 +26,36 @@ describe('IamService', () => {
vi.resetAllMocks()
})
describe('Update Profile', () => {
it('should resolve', async () => {
const timeStampDate = new Date()
userService.findOneById = vi.fn().mockResolvedValueOnce({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
const dbUser = {
id: faker.string.uuid(),
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
first_name: 'test',
last_name: 'test',
email: 'test@example.com',
username: 'test',
first_name: faker.person.firstName(),
last_name: faker.person.lastName(),
email: faker.internet.email(),
username: faker.internet.userName(),
verified: false,
receive_email: false,
mfa_enabled: false,
theme: 'system',
createdAt: timeStampDate,
updatedAt: timeStampDate,
})
}
describe('Update Profile', () => {
it('should update user', async () => {
userService.findOneById = vi.fn().mockResolvedValueOnce(dbUser)
userService.findOneByUsername = vi.fn().mockResolvedValue(undefined)
userService.updateUser = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
first_name: 'test',
last_name: 'test',
email: 'test@example.com',
username: 'test',
verified: false,
receive_email: false,
mfa_enabled: false,
theme: 'system',
createdAt: timeStampDate,
updatedAt: timeStampDate,
})
userService.updateUser = vi.fn().mockResolvedValue(dbUser)
const spy_userService_findOneById = vi.spyOn(userService, 'findOneById')
const spy_userService_findOneByUsername = vi.spyOn(userService, 'findOneByUsername')
const spy_userService_updateUser = vi.spyOn(userService, 'updateUser')
await expect(
service.updateProfile('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b', {
username: 'test',
service.updateProfile(faker.string.uuid(), {
username: faker.internet.userName(),
}),
).resolves.toEqual({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
first_name: 'test',
last_name: 'test',
email: 'test@example.com',
username: 'test',
verified: false,
receive_email: false,
mfa_enabled: false,
theme: 'system',
createdAt: timeStampDate,
updatedAt: timeStampDate,
})
).resolves.toEqual(dbUser)
expect(spy_userService_findOneById).toBeCalledTimes(1)
expect(spy_userService_findOneByUsername).toBeCalledTimes(1)
expect(spy_userService_updateUser).toBeCalledTimes(1)
@ -91,8 +68,8 @@ describe('IamService', () => {
const spy_userService_findOneByUsername = vi.spyOn(userService, 'findOneByUsername')
const spy_userService_updateUser = vi.spyOn(userService, 'updateUser')
await expect(
service.updateProfile('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b', {
username: 'test',
service.updateProfile(faker.string.uuid(), {
username: faker.internet.userName(),
}),
).resolves.toEqual({
error: 'User not found',
@ -101,5 +78,47 @@ describe('IamService', () => {
expect(spy_userService_findOneByUsername).toBeCalledTimes(0)
expect(spy_userService_updateUser).toBeCalledTimes(0)
})
it('should error on duplicate username', async () => {
userService.findOneById = vi.fn().mockResolvedValueOnce(dbUser)
userService.findOneByUsername = vi.fn().mockResolvedValue({
id: faker.string.uuid(),
})
userService.updateUser = vi.fn().mockResolvedValue(dbUser)
const spy_userService_findOneById = vi.spyOn(userService, 'findOneById')
const spy_userService_findOneByUsername = vi.spyOn(userService, 'findOneByUsername')
const spy_userService_updateUser = vi.spyOn(userService, 'updateUser')
await expect(
service.updateProfile(faker.string.uuid(), {
username: faker.internet.userName(),
}),
).resolves.toEqual({
error: 'Username already in use',
})
expect(spy_userService_findOneById).toBeCalledTimes(1)
expect(spy_userService_findOneByUsername).toBeCalledTimes(1)
expect(spy_userService_updateUser).toBeCalledTimes(0)
})
})
it('should not error if the user id of new username is the current user id', async () => {
userService.findOneById = vi.fn().mockResolvedValueOnce(dbUser)
userService.findOneByUsername = vi.fn().mockResolvedValue({
id: dbUser.id,
})
userService.updateUser = vi.fn().mockResolvedValue(dbUser)
const spy_userService_findOneById = vi.spyOn(userService, 'findOneById')
const spy_userService_findOneByUsername = vi.spyOn(userService, 'findOneByUsername')
const spy_userService_updateUser = vi.spyOn(userService, 'updateUser')
await expect(
service.updateProfile(dbUser.id, {
username: dbUser.id,
}),
).resolves.toEqual(dbUser)
expect(spy_userService_findOneById).toBeCalledTimes(1)
expect(spy_userService_findOneByUsername).toBeCalledTimes(1)
expect(spy_userService_updateUser).toBeCalledTimes(1)
})
})

28
src/lib/server/api/tests/tokens.service.test.ts
View file

@ -1,7 +1,7 @@
import 'reflect-metadata'
import { Argon2id } from 'oslo/password'
import { container } from 'tsyringe'
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import { afterAll, beforeAll, describe, expect, expectTypeOf, it, vi } from 'vitest'
import { HashingService } from '../services/hashing.service'
import { TokensService } from '../services/tokens.service'
@ -18,30 +18,28 @@ describe('TokensService', () => {
})
describe('Generate Token', () => {
const hashedPassword = new Argon2id().hash('111')
it('should resolve', async () => {
const hashedPassword = await new Argon2id().hash('111')
hashingService.hash = vi.fn().mockResolvedValue(hashedPassword)
hashingService.verify = vi.fn().mockResolvedValue(true)
const spy_hashingService_hash = vi.spyOn(hashingService, 'hash')
const spy_hashingService_verify = vi.spyOn(hashingService, 'verify')
it('should resolve', async () => {
expect(service.createHashedToken('111')).resolves.string
await expectTypeOf(service.createHashedToken('111')).resolves.toBeString()
expect(spy_hashingService_hash).toBeCalledTimes(1)
expect(spy_hashingService_verify).toBeCalledTimes(0)
})
it('should generate a token that is verifiable', async () => {
hashingService.hash = vi.fn().mockResolvedValue(await new Argon2id().hash('111'))
hashingService.verify = vi.fn().mockResolvedValue(true)
const spy_hashingService_hash = vi.spyOn(hashingService, 'hash')
const spy_hashingService_verify = vi.spyOn(hashingService, 'verify')
const token = await service.createHashedToken('111')
expect(token).not.toBeNaN()
expect(token).not.toBeUndefined()
expect(token).not.toBeNull()
const verifiable = await service.verifyHashedToken(token, '111')
expect(verifiable).toBeTruthy()
})
it('should generate a hashed token', async () => {
expect(spy_hashingService_hash).toHaveBeenCalledTimes(2)
})
it('should verify a hashed token', async () => {
expect(spy_hashingService_verify).toHaveBeenCalledTimes(1)
expect(spy_hashingService_hash).toBeCalledTimes(1)
expect(spy_hashingService_verify).toBeCalledTimes(1)
})
})
})

105
src/lib/server/api/tests/user_roles.service.test.ts
View file

@ -1,62 +1,75 @@
import 'reflect-metadata';
import { container } from 'tsyringe';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { UserRolesService } from '../services/user_roles.service';
import { UserRolesRepository } from '../repositories/user_roles.repository';
import { RolesService } from '../services/roles.service';
import 'reflect-metadata'
import { RoleName } from '$lib/server/api/databases/tables'
import { faker } from '@faker-js/faker'
import { container } from 'tsyringe'
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import { UserRolesRepository } from '../repositories/user_roles.repository'
import { RolesService } from '../services/roles.service'
import { UserRolesService } from '../services/user_roles.service'
describe('UserRolesService', () => {
let service: UserRolesService;
const userRolesRepository = vi.mocked(UserRolesRepository.prototype);
const rolesService = vi.mocked(RolesService.prototype);
let service: UserRolesService
const userRolesRepository = vi.mocked(UserRolesRepository.prototype)
const rolesService = vi.mocked(RolesService.prototype)
beforeAll(() => {
service = container
.register<UserRolesRepository>(UserRolesRepository, { useValue: userRolesRepository })
.register<RolesService>(RolesService, { useValue: rolesService })
.resolve(UserRolesService);
});
.resolve(UserRolesService)
})
afterAll(() => {
vi.resetAllMocks()
});
})
const timeStampDate = new Date()
const roleUUID = faker.string.uuid()
const userUUID = faker.string.uuid()
const dbRole = {
id: roleUUID,
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
name: RoleName.ADMIN,
createdAt: timeStampDate,
updatedAt: timeStampDate,
}
const dbUserRole = {
id: faker.string.uuid(),
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
role_id: roleUUID,
user_id: userUUID,
primary: true,
createdAt: timeStampDate,
updatedAt: timeStampDate,
}
describe('Create User Role', () => {
rolesService.findOneByNameOrThrow = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
name: 'user',
createdAt: new Date(),
updatedAt: new Date()
} satisfies Awaited<ReturnType<typeof rolesService.findOneByNameOrThrow>>);
userRolesRepository.create = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8fff',
role_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
primary: true,
createdAt: new Date(),
updatedAt: new Date()
} satisfies Awaited<ReturnType<typeof userRolesRepository.create>>);
const spy_rolesService_findOneByNameOrThrow = vi.spyOn(rolesService, 'findOneByNameOrThrow');
const spy_userRolesRepository_create = vi.spyOn(userRolesRepository, 'create');
it('should resolve', async () => {
await expect(service.addRoleToUser('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8fff', 'user', true)).resolves.not.toThrowError();
})
it('should call rolesService.findOneByNameOrThrow', async () => {
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledWith('user');
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledTimes(1);
})
it('should call userRolesRepository.create', async () => {
rolesService.findOneByNameOrThrow = vi.fn().mockResolvedValue(dbRole satisfies Awaited<ReturnType<typeof rolesService.findOneByNameOrThrow>>)
userRolesRepository.create = vi.fn().mockResolvedValue(dbUserRole satisfies Awaited<ReturnType<typeof userRolesRepository.create>>)
const spy_rolesService_findOneByNameOrThrow = vi.spyOn(rolesService, 'findOneByNameOrThrow')
const spy_userRolesRepository_create = vi.spyOn(userRolesRepository, 'create')
await expect(service.addRoleToUser(userUUID, RoleName.ADMIN, true)).resolves.not.toThrowError()
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledWith(RoleName.ADMIN)
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledTimes(1)
expect(spy_userRolesRepository_create).toBeCalledWith({
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8fff',
role_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
primary: true
});
expect(spy_userRolesRepository_create).toBeCalledTimes(1);
user_id: userUUID,
role_id: dbRole.id,
primary: true,
})
expect(spy_userRolesRepository_create).toBeCalledTimes(1)
})
it('should error on no role found', async () => {
rolesService.findOneByNameOrThrow = vi.fn().mockResolvedValue(undefined)
const spy_rolesService_findOneByNameOrThrow = vi.spyOn(rolesService, 'findOneByNameOrThrow')
await expect(service.addRoleToUser(userUUID, RoleName.ADMIN, true)).rejects.toThrowError(`Role with name ${RoleName.ADMIN} not found`)
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledWith(RoleName.ADMIN)
expect(spy_rolesService_findOneByNameOrThrow).toBeCalledTimes(1)
})
})
})
});

161
src/lib/server/api/tests/users.service.test.ts
View file

@ -1,8 +1,9 @@
import 'reflect-metadata'
import { CredentialsType } from '$lib/server/api/databases/tables'
import { faker } from '@faker-js/faker'
import { Argon2id } from 'oslo/password'
import { container } from 'tsyringe'
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import { CredentialsRepository } from '../repositories/credentials.repository'
import { UsersRepository } from '../repositories/users.repository'
import { CollectionsService } from '../services/collections.service'
@ -35,38 +36,38 @@ describe('UsersService', () => {
vi.resetAllMocks()
})
describe('Create User', () => {
const date = new Date()
const hashedPassword = new Argon2id().hash('111')
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword)
usersRepository.create = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
const timeStampDate = new Date()
const dbUser = {
id: faker.string.uuid(),
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
first_name: 'test',
last_name: 'test',
email: 'test@example.com',
username: 'test',
first_name: faker.person.firstName(),
last_name: faker.person.lastName(),
email: faker.internet.email(),
username: faker.internet.userName(),
verified: false,
receive_email: false,
mfa_enabled: false,
theme: 'system',
createdAt: date,
updatedAt: date,
} satisfies Awaited<ReturnType<typeof usersRepository.create>>)
credentialsRepository.create = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
createdAt: timeStampDate,
updatedAt: timeStampDate,
}
const dbCredentials = {
id: faker.string.uuid(),
user_id: dbUser.id,
type: CredentialsType.PASSWORD,
secret_data: hashedPassword,
}) satisfies Awaited<ReturnType<typeof credentialsRepository.create>>
secret_data: 'hashedPassword',
createdAt: timeStampDate,
updatedAt: timeStampDate,
}
describe('Create User', () => {
it('should resolve', async () => {
const hashedPassword = new Argon2id().hash('111')
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword)
usersRepository.create = vi.fn().mockResolvedValue(dbUser satisfies Awaited<ReturnType<typeof usersRepository.create>>)
credentialsRepository.create = vi.fn().mockResolvedValue(dbCredentials satisfies Awaited<ReturnType<typeof credentialsRepository.create>>)
userRolesService.addRoleToUser = vi.fn().mockResolvedValue(undefined)
wishlistsService.createEmptyNoName = vi.fn().mockResolvedValue(undefined)
collectionsService.createEmptyNoName = vi.fn().mockResolvedValue(undefined)
const spy_tokensService_createHashToken = vi.spyOn(tokensService, 'createHashedToken')
@ -75,114 +76,54 @@ describe('UsersService', () => {
const spy_userRolesService_addRoleToUser = vi.spyOn(userRolesService, 'addRoleToUser')
const spy_wishlistsService_createEmptyNoName = vi.spyOn(wishlistsService, 'createEmptyNoName')
const spy_collectionsService_createEmptyNoName = vi.spyOn(collectionsService, 'createEmptyNoName')
it('should resolve', async () => {
await expect(
service.create({
firstName: 'test',
lastName: 'test',
email: 'test@example.com',
username: 'test',
password: '111',
confirm_password: '111',
firstName: faker.person.firstName(),
lastName: faker.person.lastName(),
email: faker.internet.email(),
username: faker.internet.userName(),
password: faker.string.alphanumeric(10),
confirm_password: faker.string.alphanumeric(10),
}),
).resolves.toEqual({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
first_name: 'test',
last_name: 'test',
email: 'test@example.com',
username: 'test',
verified: false,
receive_email: false,
mfa_enabled: false,
theme: 'system',
createdAt: date,
updatedAt: date,
).resolves.toEqual(dbUser)
expect(spy_tokensService_createHashToken).toBeCalledTimes(1)
expect(spy_usersRepository_create).toBeCalledTimes(1)
expect(spy_credentialsRepository_create).toBeCalledTimes(1)
expect(spy_userRolesService_addRoleToUser).toBeCalledTimes(1)
expect(spy_wishlistsService_createEmptyNoName).toBeCalledTimes(1)
expect(spy_collectionsService_createEmptyNoName).toBeCalledTimes(1)
})
})
// it('should generate a hashed token', async () => {
// expect(spy_tokensService_createHashToken).toBeCalledTimes(1)
// })
// it('should create a new user', async () => {
// expect(spy_usersRepository_create).toBeCalledTimes(1)
// })
// it('should create a new credential', async () => {
// expect(spy_credentialsRepository_create).toBeCalledTimes(1)
// })
// it('should add role to user', async () => {
// expect(spy_userRolesService_addRoleToUser).toBeCalledTimes(1)
// })
// it('should create a new wishlist', async () => {
// expect(spy_wishlistsService_createEmptyNoName).toBeCalledTimes(1)
// })
// it('should create a new collection', async () => {
// expect(spy_collectionsService_createEmptyNoName).toBeCalledTimes(1)
// })
})
describe('Update User Password Exiting Credentials', () => {
describe('Update User', () => {
it('should resolve Password Exiting Credentials', async () => {
const hashedPassword = new Argon2id().hash('111')
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword) satisfies Awaited<ReturnType<typeof tokensService.createHashedToken>>
credentialsRepository.update = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
type: 'PASSWORD',
secret_data: hashedPassword,
}) satisfies Awaited<ReturnType<typeof credentialsRepository.update>>
credentialsRepository.findPasswordCredentialsByUserId = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
type: 'PASSWORD',
secret_data: hashedPassword,
}) satisfies Awaited<ReturnType<typeof credentialsRepository.findPasswordCredentialsByUserId>>
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword)
credentialsRepository.update = vi.fn().mockResolvedValue(dbCredentials satisfies Awaited<ReturnType<typeof credentialsRepository.update>>)
credentialsRepository.findPasswordCredentialsByUserId = vi
.fn()
.mockResolvedValue(dbCredentials satisfies Awaited<ReturnType<typeof credentialsRepository.findPasswordCredentialsByUserId>>)
const spy_tokensService_createHashToken = vi.spyOn(tokensService, 'createHashedToken')
const spy_credentialsRepository_findPasswordCredentialsByUserId = vi.spyOn(credentialsRepository, 'findPasswordCredentialsByUserId')
const spy_credentialsRepository_update = vi.spyOn(credentialsRepository, 'update')
it('should resolve', async () => {
await expect(service.updatePassword('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b', '111')).resolves.toBeUndefined()
})
console.log(spy_tokensService_createHashToken.mock.calls)
it('should generate a hashed token', async () => {
await expect(service.updatePassword(dbUser.id, faker.string.alphanumeric(10))).resolves.toBeUndefined()
expect(spy_tokensService_createHashToken).toBeCalledTimes(1)
})
console.log(spy_credentialsRepository_findPasswordCredentialsByUserId.mock.calls)
it('should call find password credentials by user id', async () => {
expect(spy_credentialsRepository_findPasswordCredentialsByUserId).toBeCalledTimes(1)
})
console.log(spy_credentialsRepository_update.mock.calls)
it('should update the credential when user has credential', async () => {
expect(spy_credentialsRepository_update).toBeCalledTimes(1)
})
})
describe('Update User Password No Existing Credentials', () => {
it('Should Create User Password No Existing Credentials', async () => {
const hashedPassword = new Argon2id().hash('111')
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword) satisfies Awaited<ReturnType<typeof tokensService.createHashedToken>>
credentialsRepository.findPasswordCredentialsByUserId = vi.fn().mockResolvedValue(null) satisfies Awaited<
ReturnType<typeof credentialsRepository.findPasswordCredentialsByUserId>
>
credentialsRepository.create = vi.fn().mockResolvedValue({
id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
type: 'PASSWORD',
secret_data: hashedPassword,
}) satisfies Awaited<ReturnType<typeof credentialsRepository.create>>
tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword)
credentialsRepository.findPasswordCredentialsByUserId = vi.fn().mockResolvedValue(null)
credentialsRepository.create = vi.fn().mockResolvedValue(dbCredentials satisfies Awaited<ReturnType<typeof credentialsRepository.create>>)
const spy_tokensService_createHashToken = vi.spyOn(tokensService, 'createHashedToken')
const spy_credentialsRepository_create = vi.spyOn(credentialsRepository, 'create')
const spy_credentialsRepository_findPasswordCredentialsByUserId = vi.spyOn(credentialsRepository, 'findPasswordCredentialsByUserId')
it('should resolve with no current credential for user', async () => {
await expect(service.updatePassword('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b', '111')).resolves.not.toThrow()
})
it('should generate a hashed token', async () => {
await expect(service.updatePassword(dbUser.id, faker.string.alphanumeric(10))).resolves.not.toThrow()
expect(spy_tokensService_createHashToken).toBeCalledTimes(1)
})
it('should call find password credentials by user id', async () => {
expect(spy_credentialsRepository_findPasswordCredentialsByUserId).toBeCalledTimes(1)
})
it('should create a new credential when user has no credential', async () => {
expect(spy_credentialsRepository_create).toHaveBeenCalledTimes(1)
})
})