@flusys/nestjs-auth 7.1.0 → 8.0.0

package/fesm/services/user.service.spec.js

@@ -1,673 +0,0 @@
-import { BadRequestException, ForbiddenException, NotFoundException } from '@nestjs/common';
-import { ApiService } from '@flusys/nestjs-shared/classes';
-import * as bcrypt from 'bcrypt';
-import { createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { UserService } from './user.service';
-import { AppUser } from '../entities/app-user.entity';
-import { PermissionType, UserCompanyPermission } from '../entities/user-company-permission.entity';
-jest.mock('bcrypt', ()=>({
-        hash: jest.fn().mockResolvedValue('hashed-password'),
-        compare: jest.fn().mockResolvedValue(true)
-    }));
-function buildAppUser(overrides = {}) {
-    return {
-        id: 'user-1',
-        name: 'Test User',
-        email: 'user@example.com',
-        phone: null,
-        password: 'old-hashed',
-        isActive: true,
-        emailVerified: false,
-        phoneVerified: false,
-        profilePictureId: null,
-        lastLoginAt: null,
-        additionalFields: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('UserService', ()=>{
-    let service;
-    let userRepo;
-    let permissionRepo;
-    let mockUtilsService;
-    let mockAuthConfig;
-    let mockDataSourceProvider;
-    let mockUserEnricher;
-    let companyFeatureEnabled;
-    let mockDataSource;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        bcrypt.compare.mockResolvedValue(true);
-        bcrypt.hash.mockResolvedValue('hashed-password');
-        userRepo = createMockRepository();
-        permissionRepo = createMockRepository();
-        companyFeatureEnabled = false;
-        mockUtilsService = {
-            clearCache: jest.fn()
-        };
-        mockAuthConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockImplementation(()=>companyFeatureEnabled),
-            isPermissionModeFound: jest.fn().mockReturnValue(false)
-        };
-        mockDataSource = {
-            createQueryRunner: jest.fn()
-        };
-        mockDataSourceProvider = {
-            getRepository: jest.fn().mockImplementation(async (entity)=>{
-                if (entity === AppUser) return userRepo;
-                if (entity === UserCompanyPermission) return permissionRepo;
-                throw new Error('unexpected entity');
-            }),
-            getDataSource: jest.fn().mockResolvedValue(mockDataSource)
-        };
-        mockUserEnricher = {
-            enrichListItems: jest.fn(),
-            getProfileExtras: jest.fn(),
-            getProfileSections: jest.fn(),
-            getProfileSectionData: jest.fn(),
-            updateProfileSection: jest.fn(),
-            calculateProfileCompletion: jest.fn(),
-            validateProfileExtras: jest.fn(),
-            updateProfileExtras: jest.fn()
-        };
-        service = new UserService({}, mockUtilsService, mockDataSourceProvider, mockAuthConfig, mockUserEnricher);
-    });
-    /**
-   * Every write path has to drop both the list cache and the row's own cache, or a
-   * stale user keeps being served from `get-all`.
-   */ function expectCacheCleared(id) {
-        expect(mockUtilsService.clearCache).toHaveBeenCalledWith('appuser', expect.anything());
-        expect(mockUtilsService.clearCache).toHaveBeenCalledWith('appuser', expect.anything(), id);
-    }
-    describe('ensureDataSourceRepository', ()=>{
-        it('does not load the permission repository when the company feature is disabled', async ()=>{
-            await service.ensureDataSourceRepository();
-            expect(mockDataSourceProvider.getRepository).toHaveBeenCalledWith(AppUser);
-            expect(mockDataSourceProvider.getRepository).not.toHaveBeenCalledWith(UserCompanyPermission);
-        });
-        it('loads the permission repository when the company feature is enabled', async ()=>{
-            companyFeatureEnabled = true;
-            await service.ensureDataSourceRepository();
-            expect(mockDataSourceProvider.getRepository).toHaveBeenCalledWith(UserCompanyPermission);
-        });
-    });
-    describe('verifyEmail / verifyPhone', ()=>{
-        it('marks the email as verified and clears the cache', async ()=>{
-            await service.verifyEmail('user-1');
-            expect(userRepo.update).toHaveBeenCalledWith('user-1', {
-                emailVerified: true
-            });
-            expectCacheCleared('user-1');
-        });
-        it('marks the phone as verified and clears the cache', async ()=>{
-            await service.verifyPhone('user-1');
-            expect(userRepo.update).toHaveBeenCalledWith('user-1', {
-                phoneVerified: true
-            });
-            expectCacheCleared('user-1');
-        });
-    });
-    describe('updateStatus', ()=>{
-        it('updates the user directly when the company feature is disabled', async ()=>{
-            await service.updateStatus('user-1', false, null);
-            expect(userRepo.update).toHaveBeenCalledWith('user-1', {
-                isActive: false
-            });
-            expectCacheCleared('user-1');
-        });
-        it('throws NotFoundException when the company permission is missing', async ()=>{
-            companyFeatureEnabled = true;
-            permissionRepo.findOne.mockResolvedValue(null);
-            await expect(service.updateStatus('user-1', false, buildMockUser({
-                companyId: 'company-1'
-            }))).rejects.toThrow(NotFoundException);
-        });
-        it('updates the company permission status when the company feature is enabled', async ()=>{
-            companyFeatureEnabled = true;
-            const permission = {
-                isActive: true
-            };
-            permissionRepo.findOne.mockResolvedValue(permission);
-            permissionRepo.save.mockResolvedValue(permission);
-            await service.updateStatus('user-1', false, buildMockUser({
-                companyId: 'company-1'
-            }));
-            expect(permissionRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                isActive: false
-            }));
-            expect(userRepo.update).not.toHaveBeenCalled();
-            expectCacheCleared('user-1');
-        });
-    });
-    describe('convertSingleDtoToEntity', ()=>{
-        it('hashes the password when present in the DTO', async ()=>{
-            service.repository = userRepo;
-            userRepo.create.mockReturnValue({
-                password: null
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'New User',
-                email: 'new@example.com',
-                password: 'Password1!'
-            }, null);
-            expect(bcrypt.hash).toHaveBeenCalledWith('Password1!', 12);
-            expect(entity.password).toBe('hashed-password');
-        });
-        it('does not touch the password field when absent from the DTO', async ()=>{
-            service.repository = userRepo;
-            userRepo.create.mockReturnValue({
-                password: null
-            });
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'New User',
-                email: 'new@example.com'
-            }, null);
-            expect(bcrypt.hash).not.toHaveBeenCalled();
-            expect(entity.password).toBeNull();
-        });
-    });
-    describe('convertEntityToResponseDto', ()=>{
-        it('maps a plain entity when isRaw is false', ()=>{
-            const user = buildAppUser();
-            const dto = service.convertEntityToResponseDto(user, false);
-            expect(dto).toEqual(expect.objectContaining({
-                id: 'user-1',
-                email: 'user@example.com'
-            }));
-        });
-        it('maps a raw query result and derives isActive from the company permission when present', ()=>{
-            const raw = {
-                appuser_id: 'user-1',
-                appuser_name: 'Test User',
-                appuser_phone: null,
-                appuser_email: 'user@example.com',
-                appuser_profile_picture_id: null,
-                appuser_is_active: true,
-                appuser_companyIsActive: false,
-                appuser_email_verified: false,
-                appuser_phone_verified: false,
-                appuser_last_login_at: null,
-                appuser_additional_fields: null,
-                appuser_created_at: new Date(),
-                appuser_updated_at: new Date(),
-                appuser_deleted_at: null,
-                appuser_created_by_id: null,
-                appuser_updated_by_id: null,
-                appuser_deleted_by_id: null
-            };
-            const dto = service.convertEntityToResponseDto(raw, true);
-            expect(dto.isActive).toBe(false);
-        });
-        it('falls back to the base isActive column when no company permission flag is present in the raw row', ()=>{
-            const raw = {
-                appuser_id: 'user-1',
-                appuser_name: 'Test User',
-                appuser_phone: null,
-                appuser_email: 'user@example.com',
-                appuser_profile_picture_id: null,
-                appuser_is_active: true,
-                appuser_email_verified: false,
-                appuser_phone_verified: false,
-                appuser_last_login_at: null,
-                appuser_additional_fields: null,
-                appuser_created_at: new Date(),
-                appuser_updated_at: new Date(),
-                appuser_deleted_at: null,
-                appuser_created_by_id: null,
-                appuser_updated_by_id: null,
-                appuser_deleted_by_id: null
-            };
-            const dto = service.convertEntityToResponseDto(raw, true);
-            expect(dto.isActive).toBe(true);
-        });
-    });
-    describe('getFilterQuery', ()=>{
-        it('skips actionCode and isActive keys but applies other filters', async ()=>{
-            const qb = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getFilterQuery(qb, {
-                actionCode: 'x',
-                isActive: true,
-                name: 'John'
-            }, null);
-            expect(qb.andWhere).toHaveBeenCalledTimes(1);
-            expect(qb.andWhere).toHaveBeenCalledWith('appuser.name = :value', {
-                value: 'John'
-            });
-        });
-    });
-    describe('getGlobalSearchQuery', ()=>{
-        it('adds a LIKE search clause across name/email/phone', async ()=>{
-            const qb = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getGlobalSearchQuery(qb, 'john', null);
-            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('appuser.name LIKE'), {
-                search: '%john%'
-            });
-        });
-    });
-    describe('getExtraManipulateQuery', ()=>{
-        function buildQb() {
-            return {
-                andWhere: jest.fn().mockReturnThis(),
-                addSelect: jest.fn().mockReturnThis(),
-                setParameter: jest.fn().mockReturnThis()
-            };
-        }
-        it('short-circuits with 1=0 when company feature is enabled but the user has no companyId', async ()=>{
-            companyFeatureEnabled = true;
-            const qb = buildQb();
-            const { isRaw } = await service.getExtraManipulateQuery(qb, {
-                filter: {
-                    actionCode: 'user.read'
-                }
-            }, buildMockUser({
-                companyId: undefined
-            }));
-            expect(qb.andWhere).toHaveBeenCalledWith('1 = 0');
-            expect(isRaw).toBe(true);
-        });
-        it('applies isActive filter directly on the non-company path', async ()=>{
-            const qb = buildQb();
-            await service.getExtraManipulateQuery(qb, {
-                filter: {
-                    isActive: true
-                }
-            }, null);
-            expect(qb.andWhere).toHaveBeenCalledWith('appuser.isActive = :value', {
-                value: true
-            });
-        });
-        it('restricts results to the current company when the company feature is enabled', async ()=>{
-            companyFeatureEnabled = true;
-            const qb = buildQb();
-            service.permissionRepository = permissionRepo;
-            const { isRaw } = await service.getExtraManipulateQuery(qb, {
-                filter: {}
-            }, buildMockUser({
-                companyId: 'company-1'
-            }));
-            expect(qb.addSelect).toHaveBeenCalled();
-            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('user_company_permissions'), expect.objectContaining({
-                permissionType: PermissionType.COMPANY,
-                companyId: 'company-1'
-            }));
-            expect(isRaw).toBe(true);
-        });
-    });
-    describe('insert', ()=>{
-        it('delegates to the base insert when the company feature is disabled', async ()=>{
-            const baseInsertSpy = jest.spyOn(ApiService.prototype, 'insert').mockResolvedValue({
-                id: 'user-1'
-            });
-            const result = await service.insert({
-                name: 'A',
-                email: 'a@example.com',
-                password: 'Password1!'
-            }, null);
-            expect(baseInsertSpy).toHaveBeenCalled();
-            expect(result).toEqual({
-                id: 'user-1'
-            });
-            baseInsertSpy.mockRestore();
-        });
-        it('creates the user and company/branch permissions transactionally when the company feature is enabled', async ()=>{
-            companyFeatureEnabled = true;
-            service.dataSource = mockDataSource;
-            service.permissionRepository = permissionRepo;
-            service.repository = userRepo;
-            userRepo.create.mockReturnValue({});
-            const savedUser = buildAppUser();
-            const queryRunner = {
-                connect: jest.fn(),
-                startTransaction: jest.fn(),
-                commitTransaction: jest.fn(),
-                rollbackTransaction: jest.fn(),
-                release: jest.fn(),
-                manager: {
-                    save: jest.fn().mockResolvedValue(savedUser),
-                    findOne: jest.fn().mockResolvedValue(null),
-                    create: jest.fn().mockImplementation((_target, data)=>data)
-                }
-            };
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            const result = await service.insert({
-                name: 'A',
-                email: 'a@example.com',
-                password: 'Password1!',
-                isActive: true
-            }, buildMockUser({
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            }));
-            expect(queryRunner.manager.save).toHaveBeenCalled();
-            expect(queryRunner.commitTransaction).toHaveBeenCalled();
-            expect(result).toEqual(expect.objectContaining({
-                id: 'user-1'
-            }));
-            expectCacheCleared(savedUser.id);
-        });
-        it('rolls back the transaction if permission assignment fails', async ()=>{
-            companyFeatureEnabled = true;
-            service.dataSource = mockDataSource;
-            service.permissionRepository = permissionRepo;
-            service.repository = userRepo;
-            userRepo.create.mockReturnValue({});
-            const queryRunner = {
-                connect: jest.fn(),
-                startTransaction: jest.fn(),
-                commitTransaction: jest.fn(),
-                rollbackTransaction: jest.fn(),
-                release: jest.fn(),
-                manager: {
-                    save: jest.fn().mockResolvedValue(buildAppUser()),
-                    findOne: jest.fn().mockRejectedValue(new Error('db failure')),
-                    create: jest.fn()
-                }
-            };
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await expect(service.insert({
-                name: 'A',
-                email: 'a@example.com',
-                password: 'Password1!'
-            }, buildMockUser({
-                companyId: 'company-1'
-            }))).rejects.toThrow('db failure');
-            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
-        });
-    });
-    describe('getProfileWithExtras', ()=>{
-        it('throws ForbiddenException when requesting another user profile', async ()=>{
-            await expect(service.getProfileWithExtras('other-user', buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(ForbiddenException);
-        });
-        it('throws NotFoundException when the user does not exist', async ()=>{
-            userRepo.findOne.mockResolvedValue(null);
-            await expect(service.getProfileWithExtras('user-1', buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(NotFoundException);
-        });
-        it('returns the profile with enricher-provided extras', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            mockUserEnricher.getProfileExtras.mockResolvedValue({
-                completionPercentage: 80
-            });
-            const result = await service.getProfileWithExtras('user-1', buildMockUser({
-                id: 'user-1'
-            }));
-            expect(result.user).toEqual(expect.objectContaining({
-                id: 'user-1'
-            }));
-            expect(result.extras).toEqual({
-                completionPercentage: 80
-            });
-        });
-    });
-    describe('getAll (enriched)', ()=>{
-        it('enriches the list returned by the base getAll', async ()=>{
-            jest.spyOn(ApiService.prototype, 'getAll').mockResolvedValue({
-                data: [
-                    {
-                        id: 'user-1'
-                    }
-                ],
-                total: 1
-            });
-            mockUserEnricher.enrichListItems.mockResolvedValue([
-                {
-                    id: 'user-1',
-                    completionPercentage: 50
-                }
-            ]);
-            const result = await service.getAll('', {}, null);
-            expect(result.data).toEqual([
-                {
-                    id: 'user-1',
-                    completionPercentage: 50
-                }
-            ]);
-            expect(result.total).toBe(1);
-            jest.restoreAllMocks();
-        });
-    });
-    describe('getEnrichedList', ()=>{
-        it('returns users unchanged when no enricher is configured', async ()=>{
-            service = new UserService({}, mockUtilsService, mockDataSourceProvider, mockAuthConfig, undefined);
-            const users = [
-                {
-                    id: 'user-1'
-                }
-            ];
-            const result = await service.getEnrichedList(users, null);
-            expect(result).toBe(users);
-        });
-    });
-    describe('getProfileSections / getProfileSectionData / getProfileCompletion', ()=>{
-        it('returns sections from the enricher', async ()=>{
-            mockUserEnricher.getProfileSections.mockReturnValue([
-                {
-                    id: 's1',
-                    name: 'Basic',
-                    order: 1
-                }
-            ]);
-            const result = await service.getProfileSections();
-            expect(result).toEqual([
-                {
-                    id: 's1',
-                    name: 'Basic',
-                    order: 1
-                }
-            ]);
-        });
-        it('returns an empty array when no enricher is configured', async ()=>{
-            service = new UserService({}, mockUtilsService, mockDataSourceProvider, mockAuthConfig, undefined);
-            expect(await service.getProfileSections()).toEqual([]);
-        });
-        it('returns section data via the enricher after verifying profile ownership', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            mockUserEnricher.getProfileSectionData.mockResolvedValue({
-                sectionId: 's1',
-                data: {},
-                isComplete: true
-            });
-            const result = await service.getProfileSectionData('user-1', 's1', buildMockUser({
-                id: 'user-1'
-            }));
-            expect(result).toEqual(expect.objectContaining({
-                sectionId: 's1'
-            }));
-        });
-        it('returns the default 100% completion when no enricher is configured', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            service = new UserService({}, mockUtilsService, mockDataSourceProvider, mockAuthConfig, undefined);
-            const result = await service.getProfileCompletion('user-1', buildMockUser({
-                id: 'user-1'
-            }));
-            expect(result).toBe(100);
-        });
-        it('delegates completion calculation to the enricher when configured', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            mockUserEnricher.calculateProfileCompletion.mockResolvedValue(65);
-            const result = await service.getProfileCompletion('user-1', buildMockUser({
-                id: 'user-1'
-            }));
-            expect(result).toBe(65);
-        });
-    });
-    describe('updateProfileSection', ()=>{
-        it('throws BadRequestException when the data source is unavailable', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            service.dataSource = undefined;
-            mockDataSourceProvider.getDataSource.mockResolvedValue(undefined);
-            await expect(service.updateProfileSection('user-1', 's1', {}, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('throws BadRequestException when profile sections are not supported', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            service.dataSource = mockDataSource;
-            service = new UserService({}, mockUtilsService, mockDataSourceProvider, mockAuthConfig, undefined);
-            service.dataSource = mockDataSource;
-            await expect(service.updateProfileSection('user-1', 's1', {}, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('updates the section within a transaction and commits on success', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            service.dataSource = mockDataSource;
-            const queryRunner = {
-                connect: jest.fn(),
-                startTransaction: jest.fn(),
-                commitTransaction: jest.fn(),
-                rollbackTransaction: jest.fn(),
-                release: jest.fn()
-            };
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await service.updateProfileSection('user-1', 's1', {
-                foo: 'bar'
-            }, buildMockUser({
-                id: 'user-1'
-            }));
-            expect(mockUserEnricher.updateProfileSection).toHaveBeenCalledWith('user-1', 's1', {
-                foo: 'bar'
-            }, queryRunner);
-            expect(queryRunner.commitTransaction).toHaveBeenCalled();
-            expectCacheCleared('user-1');
-        });
-        it('rolls back the transaction when the enricher throws', async ()=>{
-            userRepo.findOne.mockResolvedValue(buildAppUser());
-            service.dataSource = mockDataSource;
-            const queryRunner = {
-                connect: jest.fn(),
-                startTransaction: jest.fn(),
-                commitTransaction: jest.fn(),
-                rollbackTransaction: jest.fn(),
-                release: jest.fn()
-            };
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            mockUserEnricher.updateProfileSection.mockRejectedValue(new Error('enrich failed'));
-            await expect(service.updateProfileSection('user-1', 's1', {}, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow('enrich failed');
-            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
-        });
-    });
-    describe('profile', ()=>{
-        function buildQueryRunner(findUser) {
-            return {
-                connect: jest.fn(),
-                startTransaction: jest.fn(),
-                commitTransaction: jest.fn(),
-                rollbackTransaction: jest.fn(),
-                release: jest.fn(),
-                manager: {
-                    findOne: jest.fn().mockResolvedValue(findUser),
-                    save: jest.fn().mockResolvedValue(findUser)
-                }
-            };
-        }
-        it('throws BadRequestException when the data source is unavailable', async ()=>{
-            service.dataSource = undefined;
-            mockDataSourceProvider.getDataSource.mockResolvedValue(undefined);
-            await expect(service.profile({
-                id: 'user-1'
-            }, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('throws NotFoundException when the target user does not exist', async ()=>{
-            service.dataSource = mockDataSource;
-            const queryRunner = buildQueryRunner(null);
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await expect(service.profile({
-                id: 'user-1'
-            }, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(NotFoundException);
-            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
-        });
-        it('requires the current password when changing your own password', async ()=>{
-            service.dataSource = mockDataSource;
-            const queryRunner = buildQueryRunner(buildAppUser());
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await expect(service.profile({
-                id: 'user-1',
-                password: 'NewPassword1!'
-            }, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('rejects an incorrect current password when changing your own password', async ()=>{
-            service.dataSource = mockDataSource;
-            const queryRunner = buildQueryRunner(buildAppUser());
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            bcrypt.compare.mockResolvedValue(false);
-            await expect(service.profile({
-                id: 'user-1',
-                password: 'NewPassword1!',
-                oldPassword: 'wrong'
-            }, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow(BadRequestException);
-        });
-        it('updates the profile and hashes the new password on success', async ()=>{
-            service.dataSource = mockDataSource;
-            const queryRunner = buildQueryRunner(buildAppUser());
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            const result = await service.profile({
-                id: 'user-1',
-                name: 'Updated Name',
-                password: 'NewPassword1!',
-                oldPassword: 'old-password'
-            }, buildMockUser({
-                id: 'user-1'
-            }));
-            expect(bcrypt.hash).toHaveBeenCalledWith('NewPassword1!', 12);
-            expect(queryRunner.manager.save).toHaveBeenCalled();
-            expect(queryRunner.commitTransaction).toHaveBeenCalled();
-            expect(result).toBe('user-1');
-            expectCacheCleared('user-1');
-        });
-        it('does not require the current password when an admin updates another user profile', async ()=>{
-            service.dataSource = mockDataSource;
-            const targetUser = buildAppUser({
-                id: 'other-user'
-            });
-            const queryRunner = buildQueryRunner(targetUser);
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await service.profile({
-                id: 'other-user',
-                password: 'NewPassword1!'
-            }, buildMockUser({
-                id: 'admin-1'
-            }));
-            expect(queryRunner.manager.save).toHaveBeenCalled();
-            expect(queryRunner.commitTransaction).toHaveBeenCalled();
-            expectCacheCleared('other-user');
-        });
-        it('rolls back the transaction when save fails', async ()=>{
-            service.dataSource = mockDataSource;
-            const queryRunner = buildQueryRunner(buildAppUser());
-            queryRunner.manager.save.mockRejectedValue(new Error('save failed'));
-            mockDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            await expect(service.profile({
-                id: 'user-1',
-                name: 'X'
-            }, buildMockUser({
-                id: 'user-1'
-            }))).rejects.toThrow('save failed');
-            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
-        });
-    });
-});