Fixing all the tests to pass

src/lib/server/api/databases/seeds/roles.ts

@@ -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) {

src/lib/server/api/databases/tables/roles.table.ts

@@ -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')

src/lib/server/api/services/iam.service.ts

@@ -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,

src/lib/server/api/tests/iam.service.test.ts

@@ -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()
 	})
 
+	const timeStampDate = new Date()
+	const dbUser = {
+		id: faker.string.uuid(),
+		cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
+		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 resolve', async () => {
+		it('should update user', async () => {
-			const timeStampDate = new Date()
+			userService.findOneById = vi.fn().mockResolvedValueOnce(dbUser)
-			userService.findOneById = vi.fn().mockResolvedValueOnce({
-				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.findOneByUsername = vi.fn().mockResolvedValue(undefined)
-			userService.updateUser = vi.fn().mockResolvedValue({
+			userService.updateUser = vi.fn().mockResolvedValue(dbUser)
-				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,
-			})
 
 			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', {
+				service.updateProfile(faker.string.uuid(), {
-					username: 'test',
+					username: faker.internet.userName(),
 				}),
-			).resolves.toEqual({
+			).resolves.toEqual(dbUser)
-				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,
-			})
 			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', {
+				service.updateProfile(faker.string.uuid(), {
-					username: 'test',
+					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)
 	})
 })

src/lib/server/api/tests/tokens.service.test.ts

@@ -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')
-
-		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
+			const hashedPassword = await new Argon2id().hash('111')
+			hashingService.hash = vi.fn().mockResolvedValue(hashedPassword)
+			const spy_hashingService_hash = vi.spyOn(hashingService, 'hash')
+			const spy_hashingService_verify = vi.spyOn(hashingService, 'verify')
+			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()
-		})
+			expect(spy_hashingService_hash).toBeCalledTimes(1)
-
+			expect(spy_hashingService_verify).toBeCalledTimes(1)
-		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)
 		})
 	})
 })

src/lib/server/api/tests/user_roles.service.test.ts

@@ -1,62 +1,75 @@
-import 'reflect-metadata';
+import 'reflect-metadata'
-import { container } from 'tsyringe';
+import { RoleName } from '$lib/server/api/databases/tables'
-import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { faker } from '@faker-js/faker'
-import { UserRolesService } from '../services/user_roles.service';
+import { container } from 'tsyringe'
-import { UserRolesRepository } from '../repositories/user_roles.repository';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
-import { RolesService } from '../services/roles.service';
+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;
+	let service: UserRolesService
-	const userRolesRepository = vi.mocked(UserRolesRepository.prototype);
+	const userRolesRepository = vi.mocked(UserRolesRepository.prototype)
-	const rolesService = vi.mocked(RolesService.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();
+			rolesService.findOneByNameOrThrow = vi.fn().mockResolvedValue(dbRole satisfies Awaited<ReturnType<typeof rolesService.findOneByNameOrThrow>>)
-		})
+
-		it('should call rolesService.findOneByNameOrThrow', async () => {
+			userRolesRepository.create = vi.fn().mockResolvedValue(dbUserRole satisfies Awaited<ReturnType<typeof userRolesRepository.create>>)
-			expect(spy_rolesService_findOneByNameOrThrow).toBeCalledWith('user');
+
-			expect(spy_rolesService_findOneByNameOrThrow).toBeCalledTimes(1);
+			const spy_rolesService_findOneByNameOrThrow = vi.spyOn(rolesService, 'findOneByNameOrThrow')
-		})
+			const spy_userRolesRepository_create = vi.spyOn(userRolesRepository, 'create')
-		it('should call userRolesRepository.create', async () => {
+
+			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',
+				user_id: userUUID,
-				role_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
+				role_id: dbRole.id,
-				primary: true
+				primary: true,
-			});
+			})
-			expect(spy_userRolesRepository_create).toBeCalledTimes(1);
+			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)
 		})
 	})
-});
+})

src/lib/server/api/tests/users.service.test.ts

@@ -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,154 +36,94 @@ describe('UsersService', () => {
 		vi.resetAllMocks()
 	})
 
+	const timeStampDate = new Date()
+	const dbUser = {
+		id: faker.string.uuid(),
+		cuid: 'ciglo1j8q0000t9j4xq8d6p5e',
+		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,
+	}
+	const dbCredentials = {
+		id: faker.string.uuid(),
+		user_id: dbUser.id,
+		type: CredentialsType.PASSWORD,
+		secret_data: 'hashedPassword',
+		createdAt: timeStampDate,
+		updatedAt: timeStampDate,
+	}
+
 	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',
-			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,
-		} satisfies Awaited<ReturnType<typeof usersRepository.create>>)
-
-		credentialsRepository.create = vi.fn().mockResolvedValue({
-			id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
-			user_id: '3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b',
-			type: CredentialsType.PASSWORD,
-			secret_data: hashedPassword,
-		}) 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')
-		const spy_usersRepository_create = vi.spyOn(usersRepository, 'create')
-		const spy_credentialsRepository_create = vi.spyOn(credentialsRepository, 'create')
-		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 () => {
+			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')
+			const spy_usersRepository_create = vi.spyOn(usersRepository, 'create')
+			const spy_credentialsRepository_create = vi.spyOn(credentialsRepository, 'create')
+			const spy_userRolesService_addRoleToUser = vi.spyOn(userRolesService, 'addRoleToUser')
+			const spy_wishlistsService_createEmptyNoName = vi.spyOn(wishlistsService, 'createEmptyNoName')
+			const spy_collectionsService_createEmptyNoName = vi.spyOn(collectionsService, 'createEmptyNoName')
 			await expect(
 				service.create({
-					firstName: 'test',
+					firstName: faker.person.firstName(),
-					lastName: 'test',
+					lastName: faker.person.lastName(),
-					email: 'test@example.com',
+					email: faker.internet.email(),
-					username: 'test',
+					username: faker.internet.userName(),
-					password: '111',
+					password: faker.string.alphanumeric(10),
-					confirm_password: '111',
+					confirm_password: faker.string.alphanumeric(10),
 				}),
-			).resolves.toEqual({
+			).resolves.toEqual(dbUser)
-				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,
-			})
-		})
-		// 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', () => {
-		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>>
-
-		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 () => {
 			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)
 		})
-		console.log(spy_credentialsRepository_findPasswordCredentialsByUserId.mock.calls)
+	})
-		it('should call find password credentials by user id', async () => {
+	describe('Update User', () => {
+		it('should resolve Password Exiting Credentials', async () => {
+			const hashedPassword = new Argon2id().hash('111')
+			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')
+			await expect(service.updatePassword(dbUser.id, faker.string.alphanumeric(10))).resolves.toBeUndefined()
+			expect(spy_tokensService_createHashToken).toBeCalledTimes(1)
 			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)
 		})
-	})
+		it('Should Create User Password No Existing Credentials', async () => {
-	describe('Update User Password No Existing Credentials', () => {
+			const hashedPassword = new Argon2id().hash('111')
-		const hashedPassword = new Argon2id().hash('111')
+			tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword)
-		tokensService.createHashedToken = vi.fn().mockResolvedValue(hashedPassword) satisfies Awaited<ReturnType<typeof tokensService.createHashedToken>>
+			credentialsRepository.findPasswordCredentialsByUserId = vi.fn().mockResolvedValue(null)
-		credentialsRepository.findPasswordCredentialsByUserId = vi.fn().mockResolvedValue(null) satisfies Awaited<
+			credentialsRepository.create = vi.fn().mockResolvedValue(dbCredentials satisfies Awaited<ReturnType<typeof credentialsRepository.create>>)
-			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>>
 
-		const spy_tokensService_createHashToken = vi.spyOn(tokensService, 'createHashedToken')
+			const spy_tokensService_createHashToken = vi.spyOn(tokensService, 'createHashedToken')
-		const spy_credentialsRepository_create = vi.spyOn(credentialsRepository, 'create')
+			const spy_credentialsRepository_create = vi.spyOn(credentialsRepository, 'create')
-		const spy_credentialsRepository_findPasswordCredentialsByUserId = vi.spyOn(credentialsRepository, 'findPasswordCredentialsByUserId')
+			const spy_credentialsRepository_findPasswordCredentialsByUserId = vi.spyOn(credentialsRepository, 'findPasswordCredentialsByUserId')
 
-		it('should resolve with no current credential for user', async () => {
+			await expect(service.updatePassword(dbUser.id, faker.string.alphanumeric(10))).resolves.not.toThrow()
-			await expect(service.updatePassword('3e0e9f0f-0a0b-4f0b-8f0b-0a0b4f0b8f0b', '111')).resolves.not.toThrow()
-		})
-		it('should generate a hashed token', async () => {
 			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)
 		})
 	})