@tomei/sso 0.65.0 → 0.65.1-test.1

package/__tests__/unit/components/system/system.spec.ts

@@ -243,6 +243,7 @@ describe('System', () => {
       const result = await System.findAll(dbTransaction, loginUser);
 
       expect(findAllWithPaginationSpy).toHaveBeenCalledWith({
+        distinct: true,
         where: {},
         order: [['CreatedAt', 'DESC']],
         transaction: dbTransaction,

package/__tests__/unit/components/user-password-history/user-password-history.spec.ts

@@ -0,0 +1,165 @@
+import { UserPasswordHistory } from '../../../../src/components/user-password-history/user-password-history';
+import { UserPasswordHistoryRepository } from '../../../../src/components/user-password-history/user-password-history.repository';
+import { PasswordHashService } from '../../../../src/components/password-hash';
+import { ComponentConfig } from '@tomei/config';
+import { ClassError } from '@tomei/general';
+
+describe('UserPasswordHistory', () => {
+  const historyData = {
+    HistoryId: '1',
+    UserId: 1,
+    PasswordHash: '$argon2id$v=19$m=65536,t=3,p=4$hash1',
+    CreatedAt: new Date('2024-01-01'),
+    get: (opts?: any) => ({
+      HistoryId: '1',
+      UserId: 1,
+      PasswordHash: '$argon2id$v=19$m=65536,t=3,p=4$hash1',
+      CreatedAt: new Date('2024-01-01'),
+    }),
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('init', () => {
+    it('should return new instance when no historyId is provided', async () => {
+      const result = await UserPasswordHistory.init();
+      expect(result).toBeInstanceOf(UserPasswordHistory);
+      expect(result.HistoryId).toBeUndefined();
+    });
+
+    it('should initialize UserPasswordHistory with valid historyId', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(historyData as any);
+
+      const result = await UserPasswordHistory.init(1);
+
+      expect(result).toBeInstanceOf(UserPasswordHistory);
+      expect(result.UserId).toBe(1);
+    });
+
+    it('should throw ClassError when historyId is not found', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserPasswordHistory.init(999)).rejects.toThrow(
+        'UserPasswordHistory not found',
+      );
+    });
+  });
+
+  describe('validate', () => {
+    const passwordHashService = new PasswordHashService();
+
+    beforeEach(() => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockReturnValue(3 as any);
+    });
+
+    it('should return null when no password history exists', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce([] as any);
+
+      const result = await UserPasswordHistory.validate(
+        null,
+        1,
+        'NewPassword1!',
+        passwordHashService,
+      );
+
+      expect(result).toBeNull();
+    });
+
+    it('should throw ClassError when password matches history', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce([historyData] as any);
+      jest
+        .spyOn(passwordHashService, 'verify')
+        .mockResolvedValueOnce(true as any);
+
+      await expect(
+        UserPasswordHistory.validate(null, 1, 'OldPassword1!', passwordHashService),
+      ).rejects.toThrow(ClassError);
+    });
+
+    it('should not throw when password does not match any history', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce([historyData] as any);
+      jest
+        .spyOn(passwordHashService, 'verify')
+        .mockResolvedValueOnce(false as any);
+
+      await expect(
+        UserPasswordHistory.validate(null, 1, 'NewPassword1!', passwordHashService),
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('create', () => {
+    beforeEach(() => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockReturnValue(3 as any);
+    });
+
+    it('should create a new password history record', async () => {
+      const createSpy = jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'create')
+        .mockResolvedValueOnce(historyData as any);
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce([historyData] as any);
+
+      await UserPasswordHistory.create(null, 1, 'hashedPassword');
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should purge oldest records when history exceeds policy limit', async () => {
+      const oldRecords = [
+        { HistoryId: '1', CreatedAt: new Date('2024-01-01') },
+        { HistoryId: '2', CreatedAt: new Date('2024-02-01') },
+        { HistoryId: '3', CreatedAt: new Date('2024-03-01') },
+        { HistoryId: '4', CreatedAt: new Date('2024-04-01') },
+      ];
+
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'create')
+        .mockResolvedValueOnce(historyData as any);
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce(oldRecords as any);
+      const destroySpy = jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'destroyMultiple')
+        .mockResolvedValueOnce(undefined as any);
+
+      await UserPasswordHistory.create(null, 1, 'hashedPassword');
+
+      expect(destroySpy).toHaveBeenCalledTimes(1);
+      expect(destroySpy).toHaveBeenCalledWith(['4'], null);
+    });
+
+    it('should not purge when history is within policy limit', async () => {
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'create')
+        .mockResolvedValueOnce(historyData as any);
+      jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'findAll')
+        .mockResolvedValueOnce([historyData] as any);
+      const destroySpy = jest
+        .spyOn(UserPasswordHistoryRepository.prototype, 'destroyMultiple')
+        .mockResolvedValueOnce(undefined as any);
+
+      await UserPasswordHistory.create(null, 1, 'hashedPassword');
+
+      expect(destroySpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/__tests__/unit/components/user-reporting-hierarchy/user-reporting-hierarchy.spec.ts

@@ -0,0 +1,233 @@
+// LoginUser must be imported first to prime the module cache and avoid circular dependency
+// (user-reporting-hierarchy → user.ts → login-user.ts → user.ts circular)
+import { LoginUser } from '../../../../src/components/login-user/login-user';
+import { User } from '../../../../src/components/login-user/user';
+import { UserReportingHierarchy } from '../../../../src/components/user-reporting-hierarchy/user-reporting-hierarchy';
+import { UserReportingHierarchyRepository } from '../../../../src/components/user-reporting-hierarchy/user-reporting-hierarchy.repository';
+import { ApplicationConfig } from '@tomei/config';
+import { Activity } from '@tomei/activity-history';
+import { ClassError } from '@tomei/general';
+
+describe('UserReportingHierarchy', () => {
+  const loginUser = new (LoginUser.prototype as any).constructor();
+  loginUser.ObjectId = '1';
+  loginUser.UserId = 1;
+
+  const hierarchyData = {
+    UserReportingHierarchyId: 1,
+    ReportingUserId: 10,
+    UserId: 20,
+    Rank: 1,
+    Status: 'Active',
+    CreatedById: 1,
+    CreatedAt: new Date('2024-01-01'),
+    UpdatedById: 1,
+    UpdatedAt: new Date('2024-01-01'),
+    get: (opts?: any) => ({
+      UserReportingHierarchyId: 1,
+      ReportingUserId: 10,
+      UserId: 20,
+      Rank: 1,
+      Status: 'Active',
+      CreatedById: 1,
+      CreatedAt: new Date('2024-01-01'),
+      UpdatedById: 1,
+      UpdatedAt: new Date('2024-01-01'),
+    }),
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  beforeEach(() => {
+    jest
+      .spyOn(ApplicationConfig, 'getComponentConfigValue')
+      .mockReturnValue('TST' as any);
+    jest
+      .spyOn(Activity.prototype, 'create')
+      .mockResolvedValue(undefined as any);
+    jest
+      .spyOn(LoginUser.prototype, 'checkPrivileges')
+      .mockResolvedValue(true as any);
+  });
+
+  describe('init', () => {
+    it('should return a new instance when no id is provided', async () => {
+      const result = await UserReportingHierarchy.init();
+      expect(result).toBeInstanceOf(UserReportingHierarchy);
+      expect(result.UserReportingHierarchyId).toBeNaN();
+    });
+
+    it('should initialize with valid id', async () => {
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(hierarchyData as any);
+
+      const result = await UserReportingHierarchy.init(1);
+
+      expect(result).toBeInstanceOf(UserReportingHierarchy);
+      expect(result.ReportingUserId).toBe(10);
+      expect(result.UserId).toBe(20);
+      expect(result.Rank).toBe(1);
+    });
+
+    it('should throw ClassError when id is not found', async () => {
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserReportingHierarchy.init(999)).rejects.toThrow(
+        'UserReportingHierarchy not found',
+      );
+    });
+  });
+
+  describe('createUserReportingHierarchy', () => {
+    it('should throw when user lacks USER_REPORTING_HIERARCHY_CREATE privilege', async () => {
+      jest
+        .spyOn(LoginUser.prototype, 'checkPrivileges')
+        .mockResolvedValueOnce(false as any);
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+
+      const hierarchy = await UserReportingHierarchy.init();
+      await expect(
+        hierarchy.createUserReportingHierarchy(loginUser, null, 10, 20, 1, 'Active'),
+      ).rejects.toThrow('User does not have the required privileges');
+    });
+
+    it('should throw when relationship already exists', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(hierarchyData as any);
+
+      const hierarchy = await UserReportingHierarchy.init();
+      await expect(
+        hierarchy.createUserReportingHierarchy(loginUser, null, 10, 20, 1, 'Active'),
+      ).rejects.toThrow('Relationship already exists');
+    });
+
+    it('should throw when rank already exists', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null) // no existing relationship
+        .mockResolvedValueOnce(hierarchyData as any); // rank exists
+
+      const hierarchy = await UserReportingHierarchy.init();
+      await expect(
+        hierarchy.createUserReportingHierarchy(loginUser, null, 10, 20, 1, 'Active'),
+      ).rejects.toThrow('Rank already exists');
+    });
+
+    it('should throw when previous rank is not yet assigned (rank > 1)', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null) // no existing relationship
+        .mockResolvedValueOnce(null) // rank 2 not taken
+        .mockResolvedValueOnce(null); // rank 1 (predecessor) not found
+
+      const hierarchy = await UserReportingHierarchy.init();
+      await expect(
+        hierarchy.createUserReportingHierarchy(loginUser, null, 10, 20, 2, 'Active'),
+      ).rejects.toThrow('Rank before the new rank is not yet assigned to the user');
+    });
+
+    it('should create hierarchy successfully', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null) // no existing relationship
+        .mockResolvedValueOnce(null); // rank 1 not taken
+      const createSpy = jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'create')
+        .mockResolvedValueOnce(hierarchyData as any);
+
+      const hierarchy = await UserReportingHierarchy.init();
+      const result = await hierarchy.createUserReportingHierarchy(
+        loginUser,
+        null,
+        10,
+        20,
+        1,
+        'Active',
+      );
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+      expect(result).toBeInstanceOf(UserReportingHierarchy);
+    });
+  });
+
+  describe('updateUserReportingHierarchy', () => {
+    it('should throw when user lacks USER_REPORTING_HIERARCHY_UPDATE privilege', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(LoginUser.prototype, 'checkPrivileges')
+        .mockResolvedValueOnce(false as any);
+
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(hierarchyData as any);
+
+      const hierarchy = await UserReportingHierarchy.init(1);
+      await expect(
+        hierarchy.updateUserReportingHierarchy(loginUser, null, 10, 20, 1, 'Active'),
+      ).rejects.toThrow('User does not have the required privileges');
+    });
+
+    it('should update successfully', async () => {
+      jest.spyOn(User, 'init').mockResolvedValue(loginUser as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(hierarchyData as any);
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null) // no duplicate relationship
+        .mockResolvedValueOnce(null); // rank 1 not taken by other
+      const updateSpy = jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'update')
+        .mockResolvedValueOnce(undefined as any);
+
+      const hierarchy = await UserReportingHierarchy.init(1);
+      const result = await hierarchy.updateUserReportingHierarchy(
+        loginUser,
+        null,
+        10,
+        20,
+        1,
+        'Active',
+      );
+
+      expect(updateSpy).toHaveBeenCalledTimes(1);
+      expect(result).toBeInstanceOf(UserReportingHierarchy);
+    });
+  });
+
+  describe('removeUserReportingHierarchy', () => {
+    it('should throw when user lacks USER_REPORTING_HIERARCHY_REMOVE privilege', async () => {
+      jest
+        .spyOn(LoginUser.prototype, 'checkPrivileges')
+        .mockResolvedValueOnce(false as any);
+
+      await expect(
+        UserReportingHierarchy.removeUserReportingHierarchy(loginUser, null, 1),
+      ).rejects.toThrow('Insufficient privileges to remove reporting hierarchy');
+    });
+
+    it('should remove hierarchy successfully', async () => {
+      jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(hierarchyData as any);
+      const destroySpy = jest
+        .spyOn(UserReportingHierarchyRepository.prototype, 'destroy')
+        .mockResolvedValueOnce(undefined as any);
+
+      await UserReportingHierarchy.removeUserReportingHierarchy(loginUser, null, 1);
+
+      expect(destroySpy).toHaveBeenCalledTimes(1);
+      expect(destroySpy).toHaveBeenCalledWith(1, null);
+    });
+  });
+});