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
import { HttpException } from '@nestjs/common'
import { Test, TestingModule } from '@nestjs/testing'
import { AuthManager } from '../../../authentication/auth.service.js'
import { GROUP_TYPE } from '../constants/group.js'
import { USER_GROUP_ROLE, USER_ROLE } from '../constants/user.js'
import type { CreateOrUpdateGroupDto } from '../dto/create-or-update-group.dto.js'
import type { CreateUserDto, UpdateUserDto, UpdateUserFromGroupDto } from '../dto/create-or-update-user.dto.js'
import { searchMembersSchema, type ValidatedSearchMembersDto } from '../dto/search-members.dto.js'
import { UserModel } from '../models/user.model.js'
import { AdminUsersManager } from './admin-users-manager.service.js'
import { AdminUsersQueries } from './admin-users-queries.service.js'
import { FilesQuotaManager } from '../../files/services/files-quota-manager.service.js'
import { Mock } from 'vitest'
import * as _fs from '../../files/utils/files.js'
// mock file utils used by the service (delete/rename user space)
vi.mock('../../files/utils/files.js', async (importOriginal) => {
const actual = await importOriginal<typeof import('../../files/utils/files.js')>()
return {
...actual,
isPathInside: vi.fn(() => true),
isPathExists: vi.fn(),
moveFiles: vi.fn(),
removeFiles: vi.fn()
}
})
// mock hash/anonymize utilities (preserve other module exports)
vi.mock('../../../common/functions.js', async (importOriginal) => {
const actual = await importOriginal<typeof import('../../../common/functions.js')>()
return {
...actual,
hashPassword: vi.fn(async (pwd: string) => `hashed:${pwd}`),
anonymizePassword: vi.fn((dto: any) => ({ ...dto, password: '***' }))
}
})
// Alias FS mocks (avoid repetitions)
const fs = vi.mocked(_fs)
// Helper utilities
const expectHttp = async (p: Promise<any>) => expect(p).rejects.toBeInstanceOf(HttpException)
const spyMakePaths = () => vi.spyOn(UserModel.prototype, 'makePaths').mockResolvedValueOnce(undefined)
describe(AdminUsersManager.name, () => {
let service: AdminUsersManager
// deep mocks
let authManagerMock: { setCookies: Mock }
let adminQueriesMock: {
listUsers: Mock
usersQueries: {
listGuests: Mock
from: Mock
createUserOrGuest: Mock
updateUserOrGuest: Mock
deleteUser: Mock
compareUserPassword: Mock
checkGroupNameExists: Mock
checkUserExists: Mock
searchUsersOrGroups: Mock
clearWhiteListCaches: Mock
clearWebDAVAuthCache: Mock
allUserIdsFromGroupsAndSubGroups: Mock
}
updateUserGroups: Mock
updateGuestManagers: Mock
deleteUser: Mock
groupFromName: Mock
browseGroupMembers: Mock
browseRootGroupMembers: Mock
groupFromId: Mock
createGroup: Mock
updateGroup: Mock
deleteGroup: Mock
addUsersToGroup: Mock
updateUserFromGroup: Mock
removeUserFromGroup: 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: vi.fn() }
adminQueriesMock = {
listUsers: vi.fn(),
usersQueries: {
listGuests: vi.fn(),
from: vi.fn(),
createUserOrGuest: vi.fn(),
updateUserOrGuest: vi.fn(),
deleteUser: vi.fn(),
compareUserPassword: vi.fn(),
checkGroupNameExists: vi.fn(),
checkUserExists: vi.fn(),
searchUsersOrGroups: vi.fn(),
clearWhiteListCaches: vi.fn(),
clearWebDAVAuthCache: vi.fn(),
allUserIdsFromGroupsAndSubGroups: vi.fn().mockResolvedValue([])
},
updateUserGroups: vi.fn(),
updateGuestManagers: vi.fn(),
deleteUser: vi.fn(),
groupFromName: vi.fn(),
browseGroupMembers: vi.fn(),
browseRootGroupMembers: vi.fn(),
groupFromId: vi.fn(),
createGroup: vi.fn(),
updateGroup: vi.fn(),
deleteGroup: vi.fn(),
addUsersToGroup: vi.fn(),
updateUserFromGroup: vi.fn(),
removeUserFromGroup: vi.fn()
}
const module: TestingModule = await Test.createTestingModule({
providers: [
AdminUsersManager,
{ provide: AuthManager, useValue: authManagerMock },
{
provide: FilesQuotaManager,
useValue: { updateStorageQuota: () => vi.fn() }
},
{ provide: AdminUsersQueries, useValue: adminQueriesMock }
]
}).compile()
module.useLogger(['fatal'])
service = module.get<AdminUsersManager>(AdminUsersManager)
})
beforeEach(() => {
vi.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))
})
it('rejects a login that would escape the user directory', async () => {
await expectHttp(service.createUserOrGuest({ login: '..', email: 'bad@x', password: 'p', managers: [] } as any, USER_ROLE.USER, false))
expect(adminQueriesMock.usersQueries.checkUserExists).not.toHaveBeenCalled()
expect(adminQueriesMock.usersQueries.createUserOrGuest).not.toHaveBeenCalled()
})
})
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('rejects a login that would escape the user directory before rename', async () => {
setUser({ ...baseUser })
await expectHttp(service.updateUserOrGuest(baseUser.id, { login: '../outside' } as any))
expect(adminQueriesMock.usersQueries.checkUserExists).not.toHaveBeenCalled()
expect(fs.moveFiles).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('update guest + groups diff', async () => {
const guest = {
id: 33,
login: 'g',
email: 'g@x',
managers: [{ id: 2 }],
groups: [{ id: 1 }, { id: 3 }],
role: USER_ROLE.GUEST
}
setGuest(guest as any)
const updatedGuest = { ...guest, groups: [{ id: 3 }, { id: 5 }] }
setGuest(updatedGuest as any)
adminQueriesMock.updateUserGroups.mockResolvedValueOnce(undefined)
const res = await service.updateUserOrGuest(guest.id, { groups: [3, 5] } as UpdateUserDto, USER_ROLE.GUEST)
expect(adminQueriesMock.usersQueries.updateUserOrGuest).not.toHaveBeenCalled()
expect(adminQueriesMock.updateUserGroups).toHaveBeenCalledWith(guest.id, { add: [5], delete: [1] })
expect(adminQueriesMock.updateGuestManagers).not.toHaveBeenCalled()
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('updateUserGroups échoue pour guest', async () => {
const guest = { id: 33, login: 'g', email: 'g@x', managers: [{ id: 2 }], groups: [{ id: 1 }], role: USER_ROLE.GUEST }
setGuest(guest as any)
adminQueriesMock.updateUserGroups.mockRejectedValueOnce(new Error('group error'))
await expect(service.updateUserOrGuest(guest.id, { groups: [2] } as any, USER_ROLE.GUEST)).rejects.toThrow('Unable to update user groups')
expect(adminQueriesMock.updateGuestManagers).not.toHaveBeenCalled()
})
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 })).resolves.toBeUndefined()
expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(10, 'john')
expect(adminQueriesMock.usersQueries.clearWebDAVAuthCache).toHaveBeenCalledWith(10)
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))
})
})
describe('deleteUserFromAdmin / deleteGuestFromAdmin', () => {
it('deletes a user from the user endpoint', async () => {
adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 10, login: 'to-del', role: USER_ROLE.USER } as any)
adminQueriesMock.deleteUser.mockResolvedValueOnce(true)
await service.deleteUserFromAdmin(10, { deleteSpace: true })
expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(10, 'to-del')
})
it.each([USER_ROLE.GUEST, USER_ROLE.LINK])('rejects role %s from the user endpoint', async (role) => {
adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 10, login: 'mismatch', role } as any)
await expectHttp(service.deleteUserFromAdmin(10, { deleteSpace: false }))
expect(adminQueriesMock.deleteUser).not.toHaveBeenCalled()
})
it('deletes a guest and always removes its home', async () => {
adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 11, login: 'guest', role: USER_ROLE.GUEST } as any)
adminQueriesMock.deleteUser.mockResolvedValueOnce(true)
fs.isPathExists.mockResolvedValueOnce(false)
await service.deleteGuestFromAdmin(11)
expect(adminQueriesMock.deleteUser).toHaveBeenCalledWith(11, 'guest')
expect(fs.isPathExists).toHaveBeenCalled()
})
it('rejects a regular user from the guest endpoint', async () => {
adminQueriesMock.usersQueries.from.mockResolvedValueOnce({ id: 10, login: 'user', role: USER_ROLE.USER } as any)
await expectHttp(service.deleteGuestFromAdmin(10))
expect(adminQueriesMock.deleteUser).not.toHaveBeenCalled()
})
})
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(undefined)
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(undefined)
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('clears WebDAV authentication for users affected by a group permission change', async () => {
adminQueriesMock.usersQueries.allUserIdsFromGroupsAndSubGroups.mockResolvedValueOnce([10, 11])
adminQueriesMock.updateGroup.mockResolvedValueOnce(true)
adminQueriesMock.groupFromId.mockResolvedValueOnce({ id: 5, permissions: '' })
await service.updateGroup(5, { permissions: '' } as any)
expect(adminQueriesMock.usersQueries.clearWebDAVAuthCache).toHaveBeenCalledWith([10, 11])
})
it('deleteGroup success / fail', async () => {
adminQueriesMock.usersQueries.allUserIdsFromGroupsAndSubGroups.mockResolvedValueOnce([10, 11])
adminQueriesMock.deleteGroup.mockResolvedValueOnce(true)
await expect(service.deleteGroup(5)).resolves.toBeUndefined()
expect(adminQueriesMock.usersQueries.clearWebDAVAuthCache).toHaveBeenCalledWith([10, 11])
adminQueriesMock.deleteGroup.mockResolvedValueOnce(false)
await expectHttp(service.deleteGroup(6))
})
it('addUsersToGroup: NOT_FOUND + error', async () => {
adminQueriesMock.groupFromId.mockResolvedValueOnce(undefined)
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 = searchMembersSchema.parse({ search: 'jo' }) as ValidatedSearchMembersDto
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, res))
adminQueriesMock.usersQueries.compareUserPassword.mockResolvedValueOnce(false)
await expectHttp(service.impersonateUser(admin, 6, 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, 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 as never, 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()
})
})
})