Sync-in · Sovereign platform for file storage, sharing, synchronization, and collaboration.
TypeScript cloud-alternativecollaborationcollaborative-editingdropboxfile-serverfile-sharingfile-storagefile-syncfull-text-searchhomelabnextcloudon-premiseopen-sourceprivacy-firstprivate-cloudrealtimesecureself-hostedstorage-serverwebdav
test(backend:users): improve coverage
johaven331e29b6afc0
diff --git a/backend/src/applications/users/services/admin-users-manager.service.spec.ts b/backend/src/applications/users/services/admin-users-manager.service.spec.tsindex 7e9a827a..03f069ef 100644--- a/backend/src/applications/users/services/admin-users-manager.service.spec.ts+++ b/backend/src/applications/users/services/admin-users-manager.service.spec.ts@@ -4,38 +4,538 @@* See the LICENSE file for licensing details*/+import { HttpException } from '@nestjs/common'import { Test, TestingModule } from '@nestjs/testing'import { AuthManager } from '../../../authentication/services/auth-manager.service'-import { Cache } from '../../../infrastructure/cache/services/cache.service'-import { DB_TOKEN_PROVIDER } from '../../../infrastructure/database/constants'+import { GROUP_TYPE } from '../constants/group'+import { USER_GROUP_ROLE, USER_ROLE } from '../constants/user'+import type { CreateOrUpdateGroupDto } from '../dto/create-or-update-group.dto'+import { CreateUserDto, UpdateUserDto, UpdateUserFromGroupDto } from '../dto/create-or-update-user.dto'+import type { AdminDeleteUserDto } from '../dto/delete-user.dto'+import type { SearchMembersDto } from '../dto/search-members.dto'+import type { UserPasswordDto } from '../dto/user-password.dto'+import { UserModel } from '../models/user.model'import { AdminUsersManager } from './admin-users-manager.service'import { AdminUsersQueries } from './admin-users-queries.service'-import { UsersManager } from './users-manager.service'-import { UsersQueries } from './users-queries.service'++// mock file utils used by the service (delete/rename user space)+jest.mock('../../files/utils/files', () => ({+ isPathExists: jest.fn(),+ moveFiles: jest.fn(),+ removeFiles: jest.fn()+}))++// mock hash/anonymize utilities (preserve other module exports)+jest.mock('../../../common/functions', () => {+ const actual = jest.requireActual('../../../common/functions')+ return {+ ...actual,+ hashPassword: jest.fn(async (pwd: string) => `hashed:${pwd}`),+ anonymizePassword: jest.fn((dto: any) => ({ ...dto, password: '***' }))+ }+})++// Alias FS mocks (avoid repetitions)+const fs = jest.requireMock('../../files/utils/files') as { isPathExists: jest.Mock; moveFiles: jest.Mock; removeFiles: jest.Mock }++// Helper utilities+const expectHttp = async (p: Promise<any>) => expect(p).rejects.toBeInstanceOf(HttpException)+const spyMakePaths = () => jest.spyOn(UserModel.prototype, 'makePaths').mockResolvedValueOnce(undefined)describe(AdminUsersManager.name, () => {let service: AdminUsersManager+ // deep mocks+ let authManagerMock: { setCookies: jest.Mock }+ let adminQueriesMock: {+ listUsers: jest.Mock+ usersQueries: {+ listGuests: jest.Mock+ from: jest.Mock+ createUserOrGuest: jest.Mock+ updateUserOrGuest: jest.Mock+ deleteUser: jest.Mock+ compareUserPassword: jest.Mock+ checkGroupNameExists: jest.Mock+ checkUserExists: jest.Mock+ searchUsersOrGroups: jest.Mock+ }+ updateUserGroups: jest.Mock+ updateGuestManagers: jest.Mock+ deleteUser: jest.Mock+ groupFromName: jest.Mock+ browseGroupMembers: jest.Mock+ browseRootGroupMembers: jest.Mock+ groupFromId: jest.Mock+ createGroup: jest.Mock+ updateGroup: jest.Mock+ deleteGroup: jest.Mock+ addUsersToGroup: jest.Mock+ updateUserFromGroup: jest.Mock+ removeUserFromGroup: jest.Mock+ }++ const setUser = (u: any) => adminQueriesMock.listUsers.mockResolvedValueOnce(u)+ const setGuest = (g: any) => adminQueriesMock.usersQueries.listGuests.mockResolvedValueOnce(g)++ const baseUser = {+ id: 10,+ login: 'john',+ email: '[email protected]',+ isActive: true,+ role: USER_ROLE.USER,+ groups: [{ id: 1 }, { id: 3 }]+ } as any+beforeAll(async () => {+ authManagerMock = { setCookies: jest.fn() }++ adminQueriesMock = {+ listUsers: jest.fn(),+ usersQueries: {+ listGuests: jest.fn(),+ from: jest.fn(),+ createUserOrGuest: jest.fn(),+ updateUserOrGuest: jest.fn(),+ deleteUser: jest.fn(),+ compareUserPassword: jest.fn(),+ checkGroupNameExists: jest.fn(),+ checkUserExists: jest.fn(),+ searchUsersOrGroups: jest.fn()+ },+ updateUserGroups: jest.fn(),+ updateGuestManagers: jest.fn(),+ deleteUser: jest.fn(),+ groupFromName: jest.fn(),+ browseGroupMembers: jest.fn(),+ browseRootGroupMembers: jest.fn(),+ groupFromId: jest.fn(),+ createGroup: jest.fn(),+ updateGroup: jest.fn(),+ deleteGroup: jest.fn(),+ addUsersToGroup: jest.fn(),+ updateUserFromGroup: jest.fn(),+ removeUserFromGroup: jest.fn()+ }+const module: TestingModule = await Test.createTestingModule({- providers: [- AdminUsersManager,- AdminUsersQueries,- UsersQueries,- { provide: AuthManager, useValue: {} },- { provide: UsersManager, useValue: {} },- { provide: DB_TOKEN_PROVIDER, useValue: {} },- {- provide: Cache,- useValue: {}- }- ]+ providers: [AdminUsersManager, { provide: AuthManager, useValue: authManagerMock }, { provide: AdminUsersQueries, useValue: adminQueriesMock }]}).compile()+ module.useLogger(['fatal'])service = module.get<AdminUsersManager>(AdminUsersManager)})+ beforeEach(() => {+ jest.clearAllMocks()+ })+it('should be defined', () => {expect(service).toBeDefined()})++ describe('getUser / getGuest', () => {+ it('user ok + not found + guest ok', async () => {+ setUser(baseUser)+ expect(await service.getUser(10)).toEqual(baseUser)+ expect(adminQueriesMock.listUsers).toHaveBeenCalledWith(10)++ setUser(null)+ await expectHttp(service.getUser(999))++ const guest = { id: 22, login: 'guest', email: 'g@x', managers: [], role: USER_ROLE.GUEST }+ setGuest(guest as any)+ expect(await service.getGuest(22)).toEqual(guest)+ expect(adminQueriesMock.usersQueries.listGuests).toHaveBeenCalledWith(22, 0, true)+ })+ })++ describe('createUserOrGuest', () => {+ it.each([+ { role: USER_ROLE.USER, asAdmin: false, id: 101, exp: 'UserModel' },+ { role: USER_ROLE.GUEST, asAdmin: true, id: 202, exp: 'AdminGuest' },+ { role: USER_ROLE.USER, asAdmin: true, id: 707, exp: 'AdminUser' },+ { role: USER_ROLE.GUEST, asAdmin: false, id: 808, exp: 'UserModel' }+ ])('creation matrix ($role / asAdmin=$asAdmin)', async ({ role, asAdmin, id, exp }) => {+ const dto: CreateUserDto = { login: 'alice', email: 'a@x', password: 'pwd', managers: role === USER_ROLE.GUEST ? [1] : [] } as any+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ adminQueriesMock.usersQueries.createUserOrGuest.mockResolvedValueOnce(id)+ spyMakePaths()++ if (exp === 'AdminUser') setUser({ id, login: 'alice', role })+ if (exp === 'AdminGuest') setGuest({ id, login: 'alice', role } as any)++ const res = await (service as any).createUserOrGuest(dto, role, asAdmin)++ if (exp === 'UserModel') {+ expect(res).toBeInstanceOf(UserModel)+ expect((res as any).id).toBe(id)+ } else if (exp === 'AdminUser') {+ expect(adminQueriesMock.listUsers).toHaveBeenCalledWith(id)+ } else {+ expect(adminQueriesMock.usersQueries.listGuests).toHaveBeenCalledWith(id, 0, true)+ }+ expect(adminQueriesMock.usersQueries.createUserOrGuest).toHaveBeenCalledWith(+ expect.objectContaining({ login: 'alice', email: 'a@x', password: 'hashed:pwd' }),+ role+ )+ })++ it('creation errors: duplication and DB error', async () => {+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce({ login: 'dup', email: 'dup@x' })+ await expectHttp(service.createUserOrGuest({ login: 'dup', email: 'dup@x', password: 'p', managers: [] } as any, USER_ROLE.USER, false))++ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ adminQueriesMock.usersQueries.createUserOrGuest.mockRejectedValueOnce(new Error('db fail'))+ await expectHttp(service.createUserOrGuest({ login: 'bob', email: 'b@x', password: 'p', managers: [] } as any, USER_ROLE.USER, false))+ })+ })++ describe('updateUserOrGuest - USER branch', () => {+ it('full update + FS rename + groups diff', async () => {+ const current = { ...baseUser, groups: [{ id: 1 }, { id: 3 }] }+ setUser(current)+ const updated = { ...current, login: 'johnny', email: 'j@new' }+ setUser(updated)++ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ fs.isPathExists.mockResolvedValueOnce(true)+ fs.isPathExists.mockResolvedValueOnce(false)+ fs.moveFiles.mockResolvedValueOnce(undefined)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ adminQueriesMock.updateUserGroups.mockResolvedValueOnce(undefined)++ const dto: UpdateUserDto = { login: 'johnny', email: 'j@new', isActive: true, password: 'newpwd', groups: [3, 5] }+ const res = await service.updateUserOrGuest(current.id, dto)++ expect(adminQueriesMock.usersQueries.updateUserOrGuest).toHaveBeenCalledWith(+ current.id,+ expect.objectContaining({ login: 'johnny', email: 'j@new', isActive: true, passwordAttempts: 0, password: 'hashed:newpwd' }),+ undefined+ )+ expect(adminQueriesMock.updateUserGroups).toHaveBeenCalledWith(current.id, { add: [5], delete: [1] })+ expect(res).toEqual(updated)+ })++ it('login/email conflict', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(true)+ await expectHttp(service.updateUserOrGuest(current.id, { login: 'taken' } as any))++ setUser(current)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(true)+ await expectHttp(service.updateUserOrGuest(current.id, { email: 'dup@x' } as any))+ expect(adminQueriesMock.usersQueries.updateUserOrGuest).not.toHaveBeenCalled()+ })++ it('renameUserSpace impossible (new space exists)', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ fs.isPathExists.mockResolvedValueOnce(true) // current+ fs.isPathExists.mockResolvedValueOnce(true) // new already exists+ fs.moveFiles.mockResolvedValue(undefined)+ await expectHttp(service.updateUserOrGuest(current.id, { login: 'new' } as any))+ })++ it('DB update false => INTERNAL_SERVER_ERROR', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(false)+ await expectHttp(service.updateUserOrGuest(current.id, { email: 'e@x' } as any))+ })++ it('updateUserGroups fails', async () => {+ const current = { ...baseUser, groups: [{ id: 1 }] }+ setUser(current)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ adminQueriesMock.updateUserGroups.mockRejectedValueOnce(new Error('group error'))+ await expectHttp(service.updateUserOrGuest(current.id, { groups: [2] } as any))+ })++ it('no change when login or email unchanged', async () => {+ const current = { ...baseUser }+ setUser(current)+ setUser(current)+ expect(await service.updateUserOrGuest(current.id, { login: current.login } as any)).toEqual(current)+ expect(adminQueriesMock.usersQueries.checkUserExists).not.toHaveBeenCalled()++ setUser(current)+ setUser(current)+ expect(await service.updateUserOrGuest(current.id, { email: current.email } as any)).toEqual(current)+ expect(adminQueriesMock.usersQueries.updateUserOrGuest).not.toHaveBeenCalled()+ })++ it('default branch (unknown field)', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ const updated = { ...current, language: 'fr' } as any+ setUser(updated)++ const res = await service.updateUserOrGuest(current.id, { language: 'fr' } as any)+ expect(adminQueriesMock.usersQueries.updateUserOrGuest).toHaveBeenCalledWith(current.id, expect.objectContaining({ language: 'fr' }), undefined)+ expect(res).toEqual(updated)+ })+ })++ describe('updateUserOrGuest - GUEST branch', () => {+ it('update guest + managers diff', async () => {+ const guest = { id: 33, login: 'g', email: 'g@x', managers: [{ id: 2 }, { id: 7 }], role: USER_ROLE.GUEST }+ setGuest(guest as any)+ const updatedGuest = { ...guest, email: 'new@x' }+ setGuest(updatedGuest as any)++ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ adminQueriesMock.updateGuestManagers.mockResolvedValueOnce(undefined)++ const res = await service.updateUserOrGuest(guest.id, { email: 'new@x', managers: [7, 9] } as UpdateUserDto, USER_ROLE.GUEST)+ expect(adminQueriesMock.usersQueries.updateUserOrGuest).toHaveBeenCalledWith(guest.id, { email: 'new@x' }, USER_ROLE.GUEST)+ expect(adminQueriesMock.updateGuestManagers).toHaveBeenCalledWith(guest.id, { add: [9], delete: [2] })+ expect(res).toEqual(updatedGuest)+ })++ it('validations updateGuest', async () => {+ expect(() => service.updateGuest(1, {} as any)).toThrow(/no changes to update/i)+ expect(() => service.updateGuest(1, { managers: [] } as any)).toThrow(/guest must have at least one manager/i)+ })++ it('updateGuestManagers échoue', async () => {+ const guest = { id: 33, login: 'g', email: 'g@x', managers: [{ id: 2 }], role: USER_ROLE.GUEST }+ setGuest(guest as any)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ adminQueriesMock.updateGuestManagers.mockRejectedValueOnce(new Error('mgr error'))+ await expectHttp(service.updateUserOrGuest(guest.id, { managers: [3] } as any, USER_ROLE.GUEST))+ })+ })++ describe('deleteUserOrGuest / deleteGuest', () => {+ it('delete user + optional space and errors', async () => {+ adminQueriesMock.deleteUser.mockResolvedValueOnce(true)+ fs.isPathExists.mockResolvedValueOnce(true)+ fs.removeFiles.mockResolvedValueOnce(undefined)+ await expect(service.deleteUserOrGuest(10, 'john', { deleteSpace: true, isGuest: false })).resolves.toBeUndefined()+ expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(10, 'john')+ expect(fs.isPathExists).toHaveBeenCalled()+ expect(fs.removeFiles).toHaveBeenCalled()++ adminQueriesMock.deleteUser.mockRejectedValueOnce(new Error('db crash'))+ await expectHttp(service.deleteUserOrGuest(10, 'john', { deleteSpace: false } as any))+ })++ it('deleteGuest -> getGuest then delete', async () => {+ setGuest({ id: 77, login: 'g77' } as any)+ adminQueriesMock.deleteUser.mockResolvedValueOnce(true)+ fs.isPathExists.mockResolvedValueOnce(false)+ await expect(service.deleteGuest(77)).resolves.toBeUndefined()+ expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(77, 'g77')+ })+ })++ describe('deleteUserFromAdmin', () => {+ it('admin password incorrect / deletion ok', async () => {+ const admin = new UserModel({ id: 1 } as any, true)+ adminQueriesMock.usersQueries.compareUserPassword.mockResolvedValueOnce(false)+ await expectHttp(service.deleteUserFromAdmin(admin, 10, { adminPassword: 'bad' } as AdminDeleteUserDto))++ adminQueriesMock.usersQueries.compareUserPassword.mockResolvedValueOnce(true)+ adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 10, login: 'to-del' } as any)+ adminQueriesMock.deleteUser.mockResolvedValueOnce(true)+ await service.deleteUserFromAdmin(admin, 10, { adminPassword: 'ok', deleteSpace: true } as any)+ expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(10, 'to-del')+ })+ })++ describe('groups', () => {+ it('browseGroups with/without name + NOT_FOUND', async () => {+ adminQueriesMock.groupFromName.mockResolvedValueOnce({ id: 5, name: 'dev', type: GROUP_TYPE.USER })+ adminQueriesMock.browseGroupMembers.mockResolvedValueOnce([{ id: 1 }, { id: 2 }])+ const withName = await service.browseGroups('dev', GROUP_TYPE.USER)+ expect(withName.parentGroup).toEqual({ id: 5, name: 'dev', type: GROUP_TYPE.USER })+ expect(withName.members).toHaveLength(2)++ adminQueriesMock.browseRootGroupMembers.mockResolvedValueOnce([{ id: 3 }])+ const root = await service.browseGroups(undefined, GROUP_TYPE.USER)+ expect(root.parentGroup).toBeUndefined()+ expect(root.members).toEqual([{ id: 3 }])++ adminQueriesMock.groupFromName.mockResolvedValueOnce(null)+ await expectHttp(service.browseGroups('unknown'))+ })++ it('getGroup OK / NOT_FOUND', async () => {+ adminQueriesMock.groupFromId.mockResolvedValueOnce({ id: 9 })+ expect(await service.getGroup(9)).toEqual({ id: 9 })+ adminQueriesMock.groupFromId.mockResolvedValueOnce(null)+ await expectHttp(service.getGroup(999))+ })++ it('createGroup OK + validations + creation error', async () => {+ const dto: CreateOrUpdateGroupDto = { name: 'team', type: GROUP_TYPE.USER } as any+ adminQueriesMock.usersQueries.checkGroupNameExists.mockResolvedValueOnce(false)+ adminQueriesMock.createGroup.mockResolvedValueOnce(123)+ adminQueriesMock.groupFromId.mockResolvedValueOnce({ id: 123, name: 'team' })+ expect(await service.createGroup(dto)).toEqual({ id: 123, name: 'team' })++ await expectHttp(service.createGroup({} as any))++ adminQueriesMock.usersQueries.checkGroupNameExists.mockResolvedValueOnce(true)+ await expectHttp(service.createGroup(dto))+ expect(adminQueriesMock.createGroup).toHaveBeenCalledTimes(1) // only the first one OK++ adminQueriesMock.usersQueries.checkGroupNameExists.mockResolvedValueOnce(false)+ adminQueriesMock.createGroup.mockRejectedValueOnce(new Error('db err'))+ await expectHttp(service.createGroup(dto))+ })++ it('updateGroup success / failure', async () => {+ adminQueriesMock.usersQueries.checkGroupNameExists.mockResolvedValueOnce(false)+ adminQueriesMock.updateGroup.mockResolvedValueOnce(true)+ adminQueriesMock.groupFromId.mockResolvedValueOnce({ id: 5, name: 'new' })+ expect(await service.updateGroup(5, { name: 'new' } as any)).toEqual({ id: 5, name: 'new' })++ adminQueriesMock.updateGroup.mockResolvedValueOnce(false)+ await expectHttp(service.updateGroup(5, {} as any))+ })++ it('deleteGroup success / fail', async () => {+ adminQueriesMock.deleteGroup.mockResolvedValueOnce(true)+ await expect(service.deleteGroup(5)).resolves.toBeUndefined()+ adminQueriesMock.deleteGroup.mockResolvedValueOnce(false)+ await expectHttp(service.deleteGroup(6))+ })++ it('addUsersToGroup: NOT_FOUND + error', async () => {+ adminQueriesMock.groupFromId.mockResolvedValueOnce(null)+ await expectHttp(service.addUsersToGroup(1, [2, 3]))++ adminQueriesMock.groupFromId.mockResolvedValueOnce({ id: 1, type: GROUP_TYPE.USER })+ adminQueriesMock.addUsersToGroup.mockRejectedValueOnce(new Error('bad users'))+ await expectHttp(service.addUsersToGroup(1, [2]))+ })++ it('updateUserFromGroup / removeUserFromGroup BAD_REQUEST errors', async () => {+ adminQueriesMock.updateUserFromGroup.mockRejectedValueOnce(new Error('bad role'))+ await expectHttp(service.updateUserFromGroup(1, 2, { role: USER_GROUP_ROLE.MEMBER } as UpdateUserFromGroupDto))++ adminQueriesMock.removeUserFromGroup.mockRejectedValueOnce(new Error('not member'))+ await expectHttp(service.removeUserFromGroup(1, 2))+ })+ })++ describe('searchMembers', () => {+ it('forwards to usersQueries.searchUsersOrGroups', async () => {+ const dto = { search: 'jo' } as SearchMembersDto+ adminQueriesMock.usersQueries.searchUsersOrGroups.mockResolvedValueOnce([{ id: 1 }])+ expect(await service.searchMembers(dto)).toEqual([{ id: 1 }])+ expect(adminQueriesMock.usersQueries.searchUsersOrGroups).toHaveBeenCalledWith(dto)+ })+ })++ describe('impersonation', () => {+ const res: any = {}+ it('self / bad password / ok + logout (guard + non-admin + admin)', async () => {+ const admin = new UserModel({ id: 5 } as any, true)+ await expectHttp(service.impersonateUser(admin, 5, { password: 'x' } as UserPasswordDto, res))++ adminQueriesMock.usersQueries.compareUserPassword.mockResolvedValueOnce(false)+ await expectHttp(service.impersonateUser(admin, 6, { password: 'bad' } as any, res))++ const admin2 = new UserModel({ id: 5, clientId: 'c1' } as any, true)+ adminQueriesMock.usersQueries.compareUserPassword.mockResolvedValueOnce(true)+ adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 6, login: 'user' } as any)+ authManagerMock.setCookies.mockResolvedValueOnce({ accessToken: 't' })+ expect(await service.impersonateUser(admin2, 6, { password: 'ok' } as any, res)).toEqual({ accessToken: 't' })++ const notImpersonated = new UserModel({ id: 1 } as any, true)+ await expectHttp(service.logoutImpersonateUser(notImpersonated, res))++ const impersonated = new UserModel({ id: 2, impersonatedFromId: 9, impersonatedClientId: 'X' } as any, true)+ adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 9, role: USER_ROLE.USER } as any)+ await expectHttp(service.logoutImpersonateUser(impersonated, res))++ adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 9, role: USER_ROLE.ADMINISTRATOR } as any)+ authManagerMock.setCookies.mockResolvedValueOnce({ accessToken: 'admin' })+ expect(await service.logoutImpersonateUser(impersonated, res)).toEqual({ accessToken: 'admin' })+ })+ })++ describe('listing', () => {+ it('forwards listUsers and listGuests', async () => {+ const users = [{ id: 1 }]+ adminQueriesMock.listUsers.mockResolvedValueOnce(users as any)+ expect(await service.listUsers()).toEqual(users)+ expect(adminQueriesMock.listUsers).toHaveBeenCalledWith()++ const guests = [{ id: 2 }]+ adminQueriesMock.usersQueries.listGuests.mockResolvedValueOnce(guests as any)+ expect(await service.listGuests()).toEqual(guests)+ expect(adminQueriesMock.usersQueries.listGuests).toHaveBeenCalledWith(null, null, true)+ })+ })++ describe('createGuest', () => {+ it('adds the creator as default manager and returns admin guest', async () => {+ const creator = new UserModel({ id: 88 } as any, true)+ const dto: CreateUserDto = { login: 'gg', email: 'g@x', password: 'pwd', managers: [] } as any+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ adminQueriesMock.usersQueries.createUserOrGuest.mockResolvedValueOnce(505)+ spyMakePaths()+ const expectedGuest = { id: 505, login: 'gg', role: USER_ROLE.GUEST }+ setGuest(expectedGuest as any)++ expect(await service.createGuest(creator, dto)).toEqual(expectedGuest)+ expect(adminQueriesMock.usersQueries.createUserOrGuest).toHaveBeenCalledWith(+ expect.objectContaining({ login: 'gg', email: 'g@x', managers: [88] }),+ USER_ROLE.GUEST+ )+ })+ })++ describe('updateGuest wrapper', () => {+ it('updateGuest() -> success', async () => {+ const guest = { id: 33, login: 'g', email: 'g@x', managers: [{ id: 2 }], role: USER_ROLE.GUEST }+ const updatedGuest = { ...guest, email: 'new@x' }+ setGuest(guest as any)+ adminQueriesMock.usersQueries.updateUserOrGuest.mockResolvedValueOnce(true)+ setGuest(updatedGuest as any)+ expect(await service.updateGuest(guest.id, { email: 'new@x' } as any)).toEqual(updatedGuest)+ })+ })++ describe('deleteUserSpace', () => {+ it('space not existing / removeFiles failure', async () => {+ fs.isPathExists.mockResolvedValueOnce(false)+ await expect(service.deleteUserSpace('nobody')).resolves.toBeUndefined()++ fs.isPathExists.mockResolvedValueOnce(true)+ fs.removeFiles.mockRejectedValueOnce(new Error('fs error'))+ await expectHttp(service.deleteUserSpace('bob'))+ })+ })++ describe('renameUserSpace error handling', () => {+ it('moveFiles throws then restore', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ fs.isPathExists.mockResolvedValueOnce(true)+ fs.isPathExists.mockResolvedValueOnce(false)+ fs.moveFiles.mockRejectedValueOnce(new Error('io error'))+ fs.moveFiles.mockResolvedValueOnce(undefined)+ await expectHttp(service.updateUserOrGuest(current.id, { login: 'new-login' } as any))+ expect(fs.moveFiles).toHaveBeenCalledTimes(2)+ })++ it('current space missing -> early return', async () => {+ const current = { ...baseUser }+ setUser(current)+ adminQueriesMock.usersQueries.checkUserExists.mockResolvedValueOnce(false)+ fs.isPathExists.mockResolvedValueOnce(false)+ await expectHttp(service.updateUserOrGuest(current.id, { login: 'new-login' } as any))+ expect(fs.moveFiles).not.toHaveBeenCalled()+ })+ })})diff --git a/backend/src/applications/users/services/admin-users-manager.service.ts b/backend/src/applications/users/services/admin-users-manager.service.tsindex 382729b0..0390e528 100644--- a/backend/src/applications/users/services/admin-users-manager.service.ts+++ b/backend/src/applications/users/services/admin-users-manager.service.ts@@ -235,7 +235,7 @@ export class AdminUsersManager {}async getGroup(groupId: number): Promise<AdminGroup> {- const group = this.adminQueries.groupFromId(groupId)+ const group = await this.adminQueries.groupFromId(groupId)if (!group) {throw new HttpException('Group not found', HttpStatus.NOT_FOUND)}@@ -350,30 +350,6 @@ export class AdminUsersManager {}}- private async renameUserSpace(oldLogin: string, newLogin: string): Promise<boolean> {- const currentUserSpace: string = UserModel.getHomePath(oldLogin)- if (await isPathExists(currentUserSpace)) {- const newUserSpace: string = UserModel.getHomePath(newLogin)- if (await isPathExists(newUserSpace)) {- this.logger.warn(`${this.renameUserSpace.name} - user space *${newLogin}* already exists : ${newUserSpace}`)- return false- } else {- try {- await moveFiles(currentUserSpace, newUserSpace)- return true- } catch (e) {- // try to restore- await moveFiles(newUserSpace, currentUserSpace, true)- this.logger.error(`${this.renameUserSpace.name} - unable to rename user space from *${currentUserSpace}* to *${newUserSpace}* : ${e}`)- return false- }- }- } else {- this.logger.warn(`${this.renameUserSpace.name} - user space *${oldLogin}* does not exist : ${currentUserSpace}`)- return false- }- }-checkUser(user: User | AdminUser | GuestUser, checkOnly: true): voidcheckUser(user: User | AdminUser | GuestUser, checkOnly?: false): UserModelcheckUser(user: User | AdminUser | GuestUser, checkOnly = false): UserModel | void {@@ -385,6 +361,28 @@ export class AdminUsersManager {}}+ private async renameUserSpace(oldLogin: string, newLogin: string): Promise<boolean> {+ const currentUserSpace: string = UserModel.getHomePath(oldLogin)+ if (!(await isPathExists(currentUserSpace))) {+ this.logger.warn(`${this.renameUserSpace.name} - user space *${oldLogin}* does not exist : ${currentUserSpace}`)+ return false+ }+ const newUserSpace: string = UserModel.getHomePath(newLogin)+ if (await isPathExists(newUserSpace)) {+ this.logger.warn(`${this.renameUserSpace.name} - user space *${newLogin}* already exists : ${newUserSpace}`)+ return false+ }+ try {+ await moveFiles(currentUserSpace, newUserSpace)+ return true+ } catch (e) {+ // try to restore+ await moveFiles(newUserSpace, currentUserSpace, true)+ this.logger.error(`${this.renameUserSpace.name} - unable to rename user space from *${currentUserSpace}* to *${newUserSpace}* : ${e}`)+ return false+ }+ }+private async checkGroupNameExists(groupName: string): Promise<void> {if (await this.adminQueries.usersQueries.checkGroupNameExists(groupName)) {throw new HttpException('Name already used', HttpStatus.BAD_REQUEST)diff --git a/backend/src/applications/users/services/users-manager.service.spec.ts b/backend/src/applications/users/services/users-manager.service.spec.tsindex 6d43efd7..386df94d 100755--- a/backend/src/applications/users/services/users-manager.service.spec.ts+++ b/backend/src/applications/users/services/users-manager.service.spec.ts@@ -5,12 +5,19 @@*/import { Test, TestingModule } from '@nestjs/testing'+import bcrypt from 'bcryptjs'+import path from 'node:path'+import { Readable } from 'node:stream'import { AuthManager } from '../../../authentication/services/auth-manager.service'+import { comparePassword } from '../../../common/functions'+import * as imageModule from '../../../common/image'import { pngMimeType, svgMimeType } from '../../../common/image'import { Cache } from '../../../infrastructure/cache/services/cache.service'import { DB_TOKEN_PROVIDER } from '../../../infrastructure/database/constants'+import * as filesUtilsModule from '../../files/utils/files'import { fileName, isPathExists } from '../../files/utils/files'-import { USER_ROLE } from '../constants/user'+import { MEMBER_TYPE } from '../constants/member'+import { USER_GROUP_ROLE, USER_MAX_PASSWORD_ATTEMPTS, USER_ROLE } from '../constants/user'import { CreateUserDto } from '../dto/create-or-update-user.dto'import { DeleteUserDto } from '../dto/delete-user.dto'import { UserModel } from '../models/user.model'@@ -20,6 +27,20 @@ import { AdminUsersQueries } from './admin-users-queries.service'import { UsersManager } from './users-manager.service'import { UsersQueries } from './users-queries.service'+jest.mock('../../../common/functions', () => {+ const actual = jest.requireActual('../../../common/functions')+ return { ...actual, comparePassword: jest.fn() }+})+jest.mock('bcryptjs', () => ({ __esModule: true, default: { hash: jest.fn(() => Promise.resolve('hashed-password')) } }))+jest.mock('../../../common/image', () => {+ const actual = jest.requireActual('../../../common/image')+ return {+ ...actual,+ generateAvatar: jest.fn(() => Readable.from([Buffer.from('PNGDATA')])),+ convertImageToBase64: jest.fn(() => Promise.resolve('BASE64_IMAGE'))+ }+})+describe(UsersManager.name, () => {let usersManager: UsersManagerlet adminUsersManager: AdminUsersManager@@ -27,6 +48,27 @@ describe(UsersManager.name, () => {let usersQueriesService: UsersQuerieslet userTest: UserModellet deleteUserDto: DeleteUserDto+ const flush = () => new Promise<void>((r) => setImmediate(r))+ const okStream = (d = 'OK') => {+ const s: any = Readable.from([Buffer.from(d)])+ s.truncated = false+ return s+ }+ const errStream = (msg = 'err', truncated = false) => {+ const s: any = new Readable({+ read() {+ this.destroy(new Error(msg))+ }+ })+ s.truncated = truncated+ return s+ }+ const mkReq = (mimetype: string, stream: any, user = userTest) => ({ user, file: jest.fn().mockResolvedValue({ mimetype, file: stream }) })+ const ensurePaths = async () => {+ if (!(await isPathExists(userTest.homePath))) {+ await userTest.makePaths()+ }+ }beforeAll(async () => {const module: TestingModule = await Test.createTestingModule({@@ -37,85 +79,69 @@ describe(UsersManager.name, () => {UsersQueries,{ provide: AuthManager, useValue: {} },{ provide: DB_TOKEN_PROVIDER, useValue: {} },- {- provide: Cache,- useValue: {}- }+ { provide: Cache, useValue: {} }]}).compile()-module.useLogger(['fatal'])- usersManager = module.get<UsersManager>(UsersManager)- adminUsersManager = module.get<AdminUsersManager>(AdminUsersManager)- adminUsersQueries = module.get<AdminUsersQueries>(AdminUsersQueries)- usersQueriesService = module.get<UsersQueries>(UsersQueries)- // mocks+ usersManager = module.get(UsersManager)+ adminUsersManager = module.get(AdminUsersManager)+ adminUsersQueries = module.get(AdminUsersQueries)+ usersQueriesService = module.get(UsersQueries)userTest = new UserModel(generateUserTest(), false)deleteUserDto = { deleteSpace: true } satisfies DeleteUserDto})+ afterEach(() => jest.restoreAllMocks())+afterAll(async () => {- // clean created user pathawait expect(adminUsersManager.deleteUserSpace(userTest.login)).resolves.not.toThrow()})- it('should be defined', () => {- expect(usersManager).toBeDefined()- expect(adminUsersManager).toBeDefined()- expect(usersQueriesService).toBeDefined()- expect(userTest).toBeDefined()- })-- it('should get the user with|without password', async () => {+ it('instances + findUser/me/fromUserId + impersonation', async () => {+ expect(usersManager && adminUsersManager && usersQueriesService && userTest).toBeDefined()usersQueriesService.from = jest.fn().mockReturnValue(userTest)- const findUserWithoutPwd: any = await usersManager.findUser(userTest.login, true)- expect(findUserWithoutPwd).toBeInstanceOf(UserModel)- expect(findUserWithoutPwd.password).toBeUndefined()- const findUserWithPwd = await usersManager.findUser(userTest.login, false)- expect(findUserWithPwd).toBeInstanceOf(UserModel)- expect(findUserWithPwd.password).toBeDefined()- expect(usersQueriesService.from).toHaveBeenCalledTimes(2)- const me: any = await usersManager.me(userTest)- // check the default value of the findUser function- expect(me).toBeInstanceOf(Object)- expect(me.user.password).toBeUndefined()- expect(await usersManager.me(userTest)).toBeInstanceOf(Object)+ const u1: any = await usersManager.findUser(userTest.login, true)+ expect(u1).toBeInstanceOf(UserModel)+ expect(u1.password).toBeUndefined()+ const u2 = await usersManager.findUser(userTest.login, false)+ expect(u2).toBeInstanceOf(UserModel)+ expect(u2.password).toBeDefined()+ const me1: any = await usersManager.me(userTest)+ expect(me1.user.password).toBeUndefined()usersQueriesService.from = jest.fn().mockReturnValue(null)+ await expect(usersManager.findUser('unknown')).resolves.toBeNull()await expect(usersManager.me({ id: 0 } as UserModel)).rejects.toThrow()- expect(usersQueriesService.from).toHaveBeenCalled()+ usersQueriesService.from = jest.fn().mockResolvedValue(null)+ await expect(usersManager.fromUserId(123)).resolves.toBeNull()+ const authUser = new UserModel({ ...generateUserTest(), id: 42, clientId: 'CID', impersonatedFromId: 1 } as any, true)+ const fromUser = new UserModel({ ...generateUserTest(), id: 42 }, true)+ usersQueriesService.from = jest.fn().mockResolvedValue(fromUser)+ const me2 = await usersManager.me(authUser)+ expect(me2.user.impersonated).toBe(true)+ expect(me2.user.clientId).toBe('CID')})- it('should create the user paths', async () => {- await expect(userTest.makePaths()).resolves.not.toThrow()+ it('paths + avatars (default/generate) + create/delete user', async () => {+ await expect(ensurePaths()).resolves.not.toThrow()expect(await isPathExists(userTest.filesPath)).toBe(true)- })-- it('should get the default user avatar', async () => {usersQueriesService.from = jest.fn().mockReturnValueOnce(userTest)- const [path, mime] = await usersManager.getAvatar(userTest.login)- expect(fileName(path)).toBe('avatar.svg')- expect(mime).toBe(svgMimeType)- })-- it('should generate the user avatar', async () => {+ const [p0, m0] = await usersManager.getAvatar(userTest.login)+ expect(fileName(p0)).toBe('avatar.svg')+ expect(m0).toBe(svgMimeType)usersQueriesService.from = jest.fn().mockReturnValueOnce(null)await expect(usersManager.getAvatar('#', true)).rejects.toThrow('does not exist')usersQueriesService.from = jest.fn().mockReturnValue(userTest)expect(await usersManager.getAvatar(userTest.login, true)).toBeUndefined()- const [path, mime] = await usersManager.getAvatar(userTest.login)- expect(fileName(path)).toBe('avatar.png')- expect(mime).toBe(pngMimeType)- })+ const [p1, m1] = await usersManager.getAvatar(userTest.login)+ expect(fileName(p1)).toBe('avatar.png')+ expect(m1).toBe(pngMimeType)- it('should create user that does not exist', async () => {usersQueriesService.checkUserExists = jest.fn().mockReturnValue(undefined)usersQueriesService.createUserOrGuest = jest.fn().mockReturnValue(888)- const user = await adminUsersManager.createUserOrGuest(userTest satisfies CreateUserDto, USER_ROLE.USER)- expect(user).toBeInstanceOf(UserModel)- expect(await isPathExists(user.filesPath)).toBe(true)- })+ const created = await adminUsersManager.createUserOrGuest(userTest satisfies CreateUserDto, USER_ROLE.USER)+ expect(created).toBeInstanceOf(UserModel)+ expect(await isPathExists(created.filesPath)).toBe(true)- it('should not create an existing user', async () => {usersQueriesService.checkUserExists = jest.fn().mockReturnValueOnce({ login: userTest.login, email: '' })@@ -127,23 +153,429 @@ describe(UsersManager.name, () => {throw new Error('testing')})await expect(adminUsersManager.createUserOrGuest(userTest satisfies CreateUserDto, USER_ROLE.USER)).rejects.toThrow()- })- it('should delete user', async () => {adminUsersQueries.deleteUser = jest.fn().mockReturnValue(true)await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).resolves.not.toThrow()expect(await isPathExists(userTest.filesPath)).toBe(false)- })-- it('should pass even if the user does not exist', async () => {adminUsersQueries.deleteUser = jest.fn().mockReturnValue(false)await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).resolves.not.toThrow()- })-- it('should throw an error on user creation', async () => {adminUsersQueries.deleteUser = jest.fn().mockImplementation(() => {throw new Error('testing')})await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).rejects.toThrow()})++ it('logUser branches: forbidden/locked/bad/good', async () => {+ const linkUser = new UserModel({ ...generateUserTest(), role: USER_ROLE.LINK }, false)+ await expect(usersManager.logUser(linkUser, 'x', '127.0.0.1')).rejects.toThrow('Account is not allowed')++ const uLocked = new UserModel({ ...generateUserTest(), isActive: false, passwordAttempts: 5 }, false)+ const errSpy = jest.spyOn((usersManager as any)['logger'], 'error').mockImplementation(() => undefined as any)+ const updSpy1 = jest.spyOn(usersManager, 'updateAccesses').mockRejectedValue(new Error('reject-locked'))+ await expect(usersManager.logUser(uLocked, 'pwd', 'ip')).rejects.toThrow('Account locked')+ await flush()+ expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('reject-locked'))+ expect(updSpy1).toHaveBeenCalledWith(uLocked, 'ip', false)+ ;(comparePassword as jest.Mock).mockResolvedValue(false)+ const uBad = new UserModel({ ...generateUserTest(), isActive: true, passwordAttempts: 0 }, false)+ const errSpy2 = jest.spyOn((usersManager as any)['logger'], 'error').mockImplementation(() => undefined as any)+ const updSpy2 = jest.spyOn(usersManager, 'updateAccesses').mockRejectedValue(new Error('reject-auth'))+ const out = await usersManager.logUser(uBad, 'bad', '1.1.1.1')+ expect(out).toBeNull()+ await flush()+ expect(errSpy2).toHaveBeenCalledWith(expect.stringContaining('reject-auth'))+ expect(updSpy2).toHaveBeenCalledWith(uBad, '1.1.1.1', false)+ ;(comparePassword as jest.Mock).mockResolvedValue(true)+ const uGood = new UserModel({ ...generateUserTest(), isActive: true, passwordAttempts: 0 }, false)+ const updSpy3 = jest.spyOn(usersManager, 'updateAccesses').mockResolvedValue(undefined)+ const pathsSpy = jest.spyOn(uGood, 'makePaths').mockResolvedValue(undefined)+ const out2 = await usersManager.logUser(uGood, 'good', '8.8.8.8')+ expect(out2).toBe(uGood)+ expect(updSpy3).toHaveBeenCalledWith(uGood, '8.8.8.8', true)+ expect(pathsSpy).toHaveBeenCalled()+ })++ it('compareUserPassword + updateLanguage + updatePassword branches', async () => {+ usersQueriesService.compareUserPassword = jest.fn().mockResolvedValue(true)+ await expect(usersManager.compareUserPassword(1, 'p')).resolves.toBe(true)+ expect(usersQueriesService.compareUserPassword).toHaveBeenCalledWith(1, 'p')++ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(false)+ await expect(usersManager.updateLanguage(userTest, { language: '' })).rejects.toThrow('Unable to update language')+ expect(usersQueriesService.updateUserOrGuest).toHaveBeenCalledWith(userTest.id, { language: null })+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updateLanguage(userTest, { language: 'fr' })).resolves.toBeUndefined()++ usersQueriesService.selectUserProperties = jest.fn().mockResolvedValue(null)+ await expect(usersManager.updatePassword(userTest, { oldPassword: 'a', newPassword: 'b' })).rejects.toThrow('Unable to check password')+ usersQueriesService.selectUserProperties = jest.fn().mockResolvedValue({ password: 'HASH' })+ ;(comparePassword as jest.Mock).mockResolvedValue(false)+ await expect(usersManager.updatePassword(userTest, { oldPassword: 'a', newPassword: 'b' })).rejects.toThrow('Password mismatch')+ ;(comparePassword as jest.Mock).mockResolvedValue(true)+ ;(bcrypt.hash as unknown as jest.Mock).mockResolvedValue('HASHED')+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updatePassword(userTest, { oldPassword: 'a', newPassword: 'b' })).resolves.toBeUndefined()+ expect(usersQueriesService.updateUserOrGuest).toHaveBeenCalledWith(userTest.id, { password: 'HASHED' })+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(false)+ usersQueriesService.selectUserProperties = jest.fn().mockResolvedValue({ password: 'HASH' })+ ;(comparePassword as jest.Mock).mockResolvedValue(true)+ ;(bcrypt.hash as unknown as jest.Mock).mockResolvedValue('HASHED2')+ await expect(usersManager.updatePassword(userTest, { oldPassword: 'a', newPassword: 'b' })).rejects.toThrow('Unable to update password')+ })++ it('updateNotification + updateAccesses branches', async () => {+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(false)+ await expect(usersManager.updateNotification(userTest, { notification: 1 })).rejects.toThrow('Unable to update notification')+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updateNotification(userTest, { notification: 2 })).resolves.toBeUndefined()++ const prevAccess1 = new Date('2021-01-01T00:00:00Z')+ const u1 = new UserModel(+ { ...generateUserTest(), isActive: true, passwordAttempts: 3, currentIp: '1.2.3.4', currentAccess: prevAccess1 } as any,+ false+ )+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updateAccesses(u1, '5.6.7.8', true)).resolves.toBeUndefined()+ const payload1 = (usersQueriesService.updateUserOrGuest as jest.Mock).mock.calls[0][1]+ expect(payload1).toMatchObject({ lastIp: '1.2.3.4', currentIp: '5.6.7.8', passwordAttempts: 0, isActive: true })+ expect(payload1.lastAccess).toBe(prevAccess1)+ expect(payload1.currentAccess).toBeInstanceOf(Date)++ const prevAccess2 = new Date('2022-02-02T00:00:00Z')+ const u2 = new UserModel(+ {+ ...generateUserTest(),+ isActive: true,+ passwordAttempts: USER_MAX_PASSWORD_ATTEMPTS - 1,+ currentIp: 'old.ip',+ currentAccess: prevAccess2+ } as any,+ false+ )+ usersQueriesService.updateUserOrGuest = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updateAccesses(u2, 'new.ip', false)).resolves.toBeUndefined()+ const payload2 = (usersQueriesService.updateUserOrGuest as jest.Mock).mock.calls[0][1]+ expect(payload2.passwordAttempts).toBe(USER_MAX_PASSWORD_ATTEMPTS)+ expect(payload2.isActive).toBe(false)+ expect(payload2.lastAccess).toBe(prevAccess2)+ expect(payload2.lastIp).toBe('old.ip')+ expect(payload2.currentIp).toBe('new.ip')+ expect(payload2.currentAccess).toBeInstanceOf(Date)+ })++ it('avatars advanced: generateIsNotExists, failure branches, base64 fallback', async () => {+ await ensurePaths()+ usersManager.findUser = jest.fn().mockResolvedValue({ getInitials: () => 'UT' } as unknown as UserModel)+ const [p, m] = (await usersManager.getAvatar(userTest.login, false, true)) as [string, string]+ expect(fileName(p)).toBe('avatar.png')+ expect(m).toBe(pngMimeType)+ jest.spyOn(imageModule, 'generateAvatar').mockImplementation(() => errStream('gen error'))+ await expect(usersManager.getAvatar(userTest.login, true)).rejects.toThrow('Unable to create avatar')+ usersManager.findUser = jest.fn().mockResolvedValue(null)+ await expect(usersManager.getAvatar(userTest.login, true)).rejects.toThrow('avatar not found')+ const s1 = await usersManager.getAvatarBase64(userTest.login)+ expect(s1).toBe('BASE64_IMAGE')+ ;(imageModule.convertImageToBase64 as jest.Mock).mockClear()+ const s2 = await usersManager.getAvatarBase64('non-existent-login')+ expect(s2).toBe('BASE64_IMAGE')+ expect(imageModule.convertImageToBase64).toHaveBeenCalledWith(expect.stringMatching(/avatar\.svg$/))+ })++ it('updateAvatar branches: mime error, stream error, truncated, move fail, success', async () => {+ await ensurePaths()+ await expect(usersManager.updateAvatar(mkReq('text/plain', okStream('X')) as any)).rejects.toThrow('Unsupported file type')+ await expect(usersManager.updateAvatar(mkReq('image/png', errStream('stream error')) as any)).rejects.toThrow('Unable to upload avatar')++ const t = okStream('OK')+ t.truncated = true+ const mvSpy = jest.spyOn(filesUtilsModule, 'moveFiles').mockResolvedValue(undefined)+ await expect(usersManager.updateAvatar(mkReq('image/png', t) as any)).rejects.toThrow('Image is too large (5MB max)')+ expect(mvSpy).not.toHaveBeenCalled()++ jest.spyOn(filesUtilsModule, 'moveFiles').mockRejectedValue(new Error('mv fail'))+ await expect(usersManager.updateAvatar(mkReq('image/png', okStream()) as any)).rejects.toThrow('Unable to create avatar')++ const mvSpy2 = jest.spyOn(filesUtilsModule, 'moveFiles').mockResolvedValue(undefined)+ await expect(usersManager.updateAvatar(mkReq('image/png', okStream()) as any)).resolves.toBeUndefined()+ const expectedSrc = path.join(userTest.tmpPath, 'avatar.png')+ const expectedDst = path.join(userTest.homePath, 'avatar.png')+ expect(mvSpy2).toHaveBeenCalledWith(expectedSrc, expectedDst, true)+ })++ it('setOnlineStatus + browseGroups + getGroup', async () => {+ usersQueriesService.setOnlineStatus = jest.fn().mockRejectedValue(new Error('boom'))+ expect(() => usersManager.setOnlineStatus({ id: 1 } as any, 1 as any)).not.toThrow()++ usersQueriesService.browseRootGroups = jest.fn().mockResolvedValue([{ id: 1 }])+ const root = await usersManager.browseGroups(userTest, '')+ expect(root.parentGroup).toBeUndefined()+ expect(root.members.length).toBe(1)+ usersQueriesService.groupFromName = jest.fn().mockResolvedValue(null)+ await expect(usersManager.browseGroups(userTest, 'unknown')).rejects.toThrow('Group not found')+ const group = { id: 42, name: 'Team' }+ usersQueriesService.groupFromName = jest.fn().mockResolvedValue(group)+ usersQueriesService.browseGroupMembers = jest.fn().mockResolvedValue([{ id: 7 }, { id: 8 }])+ const g2 = await usersManager.browseGroups(userTest, 'Team')+ expect(g2.parentGroup).toEqual(group)+ expect(g2.members).toEqual([{ id: 7 }, { id: 8 }])+ expect(usersQueriesService.browseGroupMembers).toHaveBeenCalledWith(42)++ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({ id: 1, members: [] })+ await expect(usersManager.getGroup(userTest, 1)).resolves.toEqual({ id: 1, members: [] })+ usersQueriesService.getGroup = jest.fn().mockResolvedValue({ id: 2 })+ await expect(usersManager.getGroup(userTest, 2, false)).resolves.toEqual({ id: 2 })+ usersQueriesService.getGroup = jest.fn().mockResolvedValue(null)+ await expect(usersManager.getGroup(userTest, 3, false)).rejects.toThrow('You are not allowed to do this action')+ })++ it('create/update personal group', async () => {+ await expect(usersManager.createPersonalGroup(userTest, { name: '' } as any)).rejects.toThrow('Group name is missing')+ usersQueriesService.checkGroupNameExists = jest.fn().mockResolvedValue(true)+ await expect(usersManager.createPersonalGroup(userTest, { name: 'A' })).rejects.toThrow('Name already used')+ usersQueriesService.checkGroupNameExists = jest.fn().mockResolvedValue(false)+ usersQueriesService.createPersonalGroup = jest.fn().mockResolvedValue(10)+ usersQueriesService.clearWhiteListCaches = jest.fn()+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 10 })+ const logSpy = jest.spyOn((usersManager as any)['logger'], 'log').mockImplementation(() => undefined as any)+ await expect(usersManager.createPersonalGroup(userTest, { name: 'OK' })).resolves.toEqual({ id: 10 })+ expect(logSpy).toHaveBeenCalled()+ usersQueriesService.createPersonalGroup = jest.fn().mockRejectedValue(new Error('db down'))+ await expect(usersManager.createPersonalGroup(userTest, { name: 'OK' })).rejects.toThrow('Unable to create group')++ await expect(usersManager.updatePersonalGroup(userTest, 1, {} as any)).rejects.toThrow('No changes to update')+ usersManager.getGroup = jest.fn().mockResolvedValueOnce({ id: 1, type: MEMBER_TYPE.GROUP })+ await expect(usersManager.updatePersonalGroup(userTest, 1, { name: 'x' })).rejects.toThrow('You are not allowed to do this action')+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP })+ usersQueriesService.checkGroupNameExists = jest.fn().mockResolvedValue(true)+ await expect(usersManager.updatePersonalGroup(userTest, 1, { name: 'dup' })).rejects.toThrow('Name already used')+ usersQueriesService.checkGroupNameExists = jest.fn().mockResolvedValue(false)+ usersQueriesService.updateGroup = jest.fn().mockRejectedValue(new Error('oops'))+ await expect(usersManager.updatePersonalGroup(userTest, 1, { name: 'ok' })).rejects.toThrow('oops')+ usersQueriesService.updateGroup = jest.fn().mockResolvedValue(true)+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP })+ await expect(usersManager.updatePersonalGroup(userTest, 1, { name: 'ok' })).resolves.not.toThrow()+ expect(usersManager.getGroup).toHaveBeenCalledWith(userTest, 1, false, userTest.isAdmin)+ })++ it('addUsersToGroup (GROUP/PGROUP)', async () => {+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.GROUP, members: [{ id: 2 }, { id: 3 }] })+ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([3, 4, 5])+ await expect(usersManager.addUsersToGroup(userTest, 1, [2, 3])).rejects.toThrow('No users to add to group')+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ await expect(usersManager.addUsersToGroup(userTest, 1, [3, 4, 5])).resolves.toBeUndefined()+ expect(usersQueriesService.updateGroupMembers).toHaveBeenCalledWith(1, {+ add: [+ { id: 4, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 5, groupRole: USER_GROUP_ROLE.MEMBER }+ ]+ })+ expect(usersQueriesService.usersWhitelist).toHaveBeenCalledWith(userTest.id, USER_ROLE.USER)++ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 2, type: MEMBER_TYPE.PGROUP, members: [] })+ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([10, 11])+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ await expect(usersManager.addUsersToGroup(userTest, 2, [10, 11])).resolves.toBeUndefined()+ expect(usersQueriesService.usersWhitelist).toHaveBeenCalledWith(userTest.id, undefined)+ expect(usersQueriesService.updateGroupMembers).toHaveBeenCalledWith(2, {+ add: [+ { id: 10, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 11, groupRole: USER_GROUP_ROLE.MEMBER }+ ]+ })+ })++ it('updateUserFromPersonalGroup', async () => {+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.GROUP, members: [] })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: 1 })).rejects.toThrow('You are not allowed to do this action')+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP, members: [] })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: 1 })).rejects.toThrow('User was not found')+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER },+ { id: 10, groupRole: USER_GROUP_ROLE.MEMBER }+ ]+ })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: USER_GROUP_ROLE.MEMBER })).rejects.toThrow(+ /group must have at least one manager/i+ )+ const spy = jest.spyOn(adminUsersManager, 'updateUserFromGroup').mockResolvedValue(undefined)+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 10, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 11, groupRole: USER_GROUP_ROLE.MEMBER }+ ]+ })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: USER_GROUP_ROLE.MANAGER })).resolves.toBeUndefined()+ expect(spy).toHaveBeenCalledWith(1, 9, { role: 1 })+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP, members: [{ id: 9, groupRole: USER_GROUP_ROLE.MEMBER }] })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: USER_GROUP_ROLE.MEMBER })).resolves.toBeUndefined()+ ;(spy as jest.Mock).mockClear()+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER },+ { id: 10, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: USER_GROUP_ROLE.MEMBER })).resolves.toBeUndefined()+ expect(spy).toHaveBeenCalledWith(1, 9, { role: USER_GROUP_ROLE.MEMBER })+ ;(spy as jest.Mock).mockClear()+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER },+ { id: 10, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ await expect(usersManager.updateUserFromPersonalGroup(userTest, 1, 9, { role: USER_GROUP_ROLE.MANAGER })).resolves.toBeUndefined()+ expect(spy).not.toHaveBeenCalled()+ })++ it('removeUserFromGroup', async () => {+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, members: [] })+ await expect(usersManager.removeUserFromGroup(userTest, 1, 9)).rejects.toThrow('User was not found')+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.GROUP, members: [{ id: 9, groupRole: USER_GROUP_ROLE.MANAGER }] })+ await expect(usersManager.removeUserFromGroup(userTest, 1, 9)).rejects.toThrow('You are not allowed to do this action')+ usersManager.getGroup = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP, members: [{ id: 9, groupRole: USER_GROUP_ROLE.MANAGER }] })+ await expect(usersManager.removeUserFromGroup(userTest, 1, 9)).rejects.toThrow('Group must have at least one manager')+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 10, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ await expect(usersManager.removeUserFromGroup(userTest, 1, 9)).resolves.toBeUndefined()+ expect(usersQueriesService.updateGroupMembers).toHaveBeenCalledWith(1, { remove: [9] })+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ usersManager.getGroup = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER },+ { id: 10, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ await expect(usersManager.removeUserFromGroup(userTest, 1, 9)).resolves.toBeUndefined()+ expect(usersQueriesService.updateGroupMembers).toHaveBeenCalledWith(1, { remove: [9] })+ })++ it('leave/delete personal group', async () => {+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue(null)+ await expect(usersManager.leavePersonalGroup(userTest, 1)).rejects.toThrow('You are not allowed to do this action')+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.GROUP, members: [{ id: userTest.id }] })+ await expect(usersManager.leavePersonalGroup(userTest, 1)).rejects.toThrow('You are not allowed to do this action')+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({ id: 1, type: MEMBER_TYPE.PGROUP, members: [] })+ await expect(usersManager.leavePersonalGroup(userTest, 1)).rejects.toThrow('User was not found')+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [{ id: userTest.id, groupRole: USER_GROUP_ROLE.MANAGER }]+ })+ await expect(usersManager.leavePersonalGroup(userTest, 1)).rejects.toThrow('Group must have at least one manager')+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({+ id: 1,+ type: 2,+ members: [+ { id: userTest.id, groupRole: USER_GROUP_ROLE.MEMBER },+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ const lSpy = jest.spyOn((usersManager as any)['logger'], 'log').mockImplementation(() => undefined as any)+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ await expect(usersManager.leavePersonalGroup(userTest, 1)).resolves.toBeUndefined()+ expect(lSpy).toHaveBeenCalledWith(expect.stringMatching(/has left group/))+ usersQueriesService.updateGroupMembers = jest.fn().mockRejectedValue(new Error('DB'))+ await expect(usersManager.leavePersonalGroup(userTest, 1)).rejects.toThrow('DB')+ usersQueriesService.getGroupWithMembers = jest.fn().mockResolvedValue({+ id: 1,+ type: MEMBER_TYPE.PGROUP,+ members: [+ { id: userTest.id, groupRole: USER_GROUP_ROLE.MANAGER },+ { id: 9, groupRole: USER_GROUP_ROLE.MANAGER }+ ]+ })+ usersQueriesService.updateGroupMembers = jest.fn().mockResolvedValue(undefined)+ await expect(usersManager.leavePersonalGroup(userTest, 1)).resolves.toBeUndefined()++ usersQueriesService.canDeletePersonalGroup = jest.fn().mockResolvedValue(false)+ await expect(usersManager.deletePersonalGroup(userTest, 7)).rejects.toThrow('You are not allowed to do this action')+ usersQueriesService.canDeletePersonalGroup = jest.fn().mockResolvedValue(true)+ const wSpy = jest.spyOn((usersManager as any)['logger'], 'warn').mockImplementation(() => undefined as any)+ usersQueriesService.deletePersonalGroup = jest.fn().mockResolvedValue(false)+ await expect(usersManager.deletePersonalGroup(userTest, 7)).rejects.toThrow('Unable to delete group')+ expect(wSpy).toHaveBeenCalledWith(expect.stringMatching(/does not exist/))+ const lgSpy = jest.spyOn((usersManager as any)['logger'], 'log').mockImplementation(() => undefined as any)+ usersQueriesService.deletePersonalGroup = jest.fn().mockResolvedValue(true)+ await expect(usersManager.deletePersonalGroup(userTest, 7)).resolves.toBeUndefined()+ expect(lgSpy).toHaveBeenCalledWith(expect.stringMatching(/was deleted/))+ })++ it('guests + proxies', async () => {+ usersQueriesService.listGuests = jest.fn().mockResolvedValue([{ id: 1 }])+ await expect(usersManager.listGuests(userTest)).resolves.toEqual([{ id: 1 }])+ const checkSpy = jest.spyOn(adminUsersManager, 'checkUser').mockImplementation(() => undefined)+ usersQueriesService.listGuests = jest.fn().mockResolvedValue({ id: 9 })+ await expect(usersManager.getGuest(userTest, 9)).resolves.toEqual({ id: 9 })+ expect(checkSpy).toHaveBeenCalled()++ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([userTest.id, 100])+ usersQueriesService.clearWhiteListCaches = jest.fn()+ const createSpy = jest.spyOn(adminUsersManager, 'createUserOrGuest').mockResolvedValue({ id: 55 } as any)+ const dto1: CreateUserDto = { ...userTest, managers: [100], password: 'x' }+ const r = await usersManager.createGuest(userTest, dto1)+ expect(createSpy).toHaveBeenCalled()+ expect(usersQueriesService.clearWhiteListCaches).toHaveBeenCalledWith([userTest.id])+ expect(r).toEqual({ id: 55 })+ const args1 = (createSpy as jest.Mock).mock.calls[0][0]+ expect(args1.managers).toEqual(expect.arrayContaining([userTest.id]))+ ;(createSpy as jest.Mock).mockClear()+ const dto2: CreateUserDto = { ...userTest, managers: [userTest.id, 100], password: 'y' }+ await usersManager.createGuest(userTest, dto2)+ const args2 = (createSpy as jest.Mock).mock.calls[0][0]+ expect((args2.managers as number[]).filter((m: number) => m === userTest.id)).toHaveLength(1)++ await expect(usersManager.updateGuest(userTest, 9, {} as any)).rejects.toThrow('No changes to update')+ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([1])+ await expect(usersManager.updateGuest(userTest, 9, { managers: [2] } as any)).rejects.toThrow('Guest must have at least one manager')+ usersQueriesService.isGuestManager = jest.fn().mockResolvedValue(false)+ await expect(usersManager.updateGuest(userTest, 9, { email: 'a' } as any)).rejects.toThrow('You are not allowed to do this action')+ usersQueriesService.isGuestManager = jest.fn().mockResolvedValue(true)+ jest.spyOn(adminUsersManager, 'updateUserOrGuest').mockResolvedValue({ managers: [{ id: 999 }] } as any)+ await expect(usersManager.updateGuest(userTest, 9, { email: 'a' } as any)).resolves.toBeNull()+ jest.spyOn(adminUsersManager, 'updateUserOrGuest').mockResolvedValue({ managers: [{ id: userTest.id }] } as any)+ await expect(usersManager.updateGuest(userTest, 9, { email: 'a' } as any)).resolves.toEqual({ managers: [{ id: userTest.id }] })+ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([userTest.id, 77])+ usersQueriesService.isGuestManager = jest.fn().mockResolvedValue(true)+ jest.spyOn(adminUsersManager, 'updateUserOrGuest').mockResolvedValue({ managers: [{ id: userTest.id }, { id: 77 }] } as any)+ await expect(usersManager.updateGuest(userTest, 9, { managers: [userTest.id, 77] } as any)).resolves.toEqual({+ managers: [{ id: userTest.id }, { id: 77 }]+ })++ usersQueriesService.isGuestManager = jest.fn().mockResolvedValue(null)+ await expect(usersManager.deleteGuest(userTest, 9)).rejects.toThrow('You are not allowed to do this action')+ usersQueriesService.isGuestManager = jest.fn().mockResolvedValue({ id: 9, login: 'guest' })+ const delSpy = jest.spyOn(adminUsersManager, 'deleteUserOrGuest').mockResolvedValue(undefined)+ await expect(usersManager.deleteGuest(userTest, 9)).resolves.toBeUndefined()+ expect(delSpy).toHaveBeenCalledWith(9, 'guest', { deleteSpace: true, isGuest: true })++ usersQueriesService.searchUsersOrGroups = jest.fn().mockResolvedValue([{ id: 1 }])+ await expect(usersManager.searchMembers(userTest, { search: '' } as any)).resolves.toEqual([{ id: 1 }])++ usersQueriesService.getOnlineUsers = jest.fn().mockResolvedValue([{ id: 123 }])+ await expect(usersManager.getOnlineUsers([123])).resolves.toEqual([{ id: 123 }])+ expect(usersQueriesService.getOnlineUsers).toHaveBeenCalledWith([123])+ usersQueriesService.usersWhitelist = jest.fn().mockResolvedValue([10, 11])+ await expect(usersManager.usersWhitelist(userTest.id)).resolves.toEqual([10, 11])+ expect(usersQueriesService.usersWhitelist).toHaveBeenCalledWith(userTest.id)+ })})diff --git a/backend/src/applications/users/services/users-manager.service.ts b/backend/src/applications/users/services/users-manager.service.tsindex 5fe17113..04e71daf 100755--- a/backend/src/applications/users/services/users-manager.service.ts+++ b/backend/src/applications/users/services/users-manager.service.ts@@ -321,7 +321,7 @@ export class UsersManager {async leavePersonalGroup(user: UserModel, groupId: number): Promise<void> {const currentGroup: GroupWithMembers = await this.usersQueries.getGroupWithMembers(user.id, groupId, true)- if (!currentGroup || currentGroup.type === MEMBER_TYPE.GROUP || !currentGroup.members.find((m) => m.id === user.id)) {+ if (!currentGroup || currentGroup.type === MEMBER_TYPE.GROUP) {throw new HttpException('You are not allowed to do this action', HttpStatus.FORBIDDEN)}const userWhoLeaves = currentGroup.members.find((m) => m.id === user.id)