Skip to content

Sync-in · Sovereign platform for file storage, sharing, synchronization, and collaboration.

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.ts
index 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.ts
index 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): void
checkUser(user: User | AdminUser | GuestUser, checkOnly?: false): UserModel
checkUser(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.ts
index 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: UsersManager
let adminUsersManager: AdminUsersManager
@@ -27,6 +48,27 @@ describe(UsersManager.name, () => {
let usersQueriesService: UsersQueries
let userTest: UserModel
let 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 path
await 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.ts
index 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)