@tomei/sso 0.64.1 → 0.65.1-test.1

package/__tests__/unit/components/user-privilege/user-privilege.spec.ts

@@ -1,73 +1,73 @@
-import { UserPrivilege } from '../../../../src/components/user-privilege/user-privilege';
-import { UserPrivilegeRepository } from '../../../../src/components/user-privilege/user-privilege.repository';
-import { ClassError } from '@tomei/general';
-
-describe('UserPrivilege', () => {
-  let userPrivilege: UserPrivilege;
-  const userPrivilegeAttr = {
-    UserPrivilegeId: 1,
-    UserId: 1,
-    SystemPrivilegeId: 'privilege1',
-    Status: 'active',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    userPrivilege = new (UserPrivilege as any)(userPrivilegeAttr);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new UserPrivilege instance', () => {
-      expect(userPrivilege).toBeDefined();
-      expect(userPrivilege).toBeInstanceOf(UserPrivilege);
-      expect(userPrivilege.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
-      expect(userPrivilege.UserId).toBe(userPrivilegeAttr.UserId);
-      expect(userPrivilege.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
-      expect(userPrivilege.Status).toBe(userPrivilegeAttr.Status);
-      expect(userPrivilege.CreatedById).toBe(userPrivilegeAttr.CreatedById);
-      expect(userPrivilege.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
-      expect(userPrivilege.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
-      expect(userPrivilege.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize UserPrivilege with valid UserPrivilegeId', async () => {
-      const findOneMock = jest
-        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(userPrivilegeAttr as any);
-
-      const result = await UserPrivilege.init(null, 1);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: { UserPrivilegeId: 1 },
-        transaction: null,
-      });
-      expect(result).toBeInstanceOf(UserPrivilege);
-      expect(result.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
-      expect(result.UserId).toBe(userPrivilegeAttr.UserId);
-      expect(result.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
-      expect(result.Status).toBe(userPrivilegeAttr.Status);
-      expect(result.CreatedById).toBe(userPrivilegeAttr.CreatedById);
-      expect(result.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
-      expect(result.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
-      expect(result.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
-    });
-
-    it('should throw ClassError when UserPrivilegeId is not found', async () => {
-      jest
-        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      await expect(UserPrivilege.init(null, 1)).rejects.toThrow(ClassError);
-    });
-  });
+import { UserPrivilege } from '../../../../src/components/user-privilege/user-privilege';
+import { UserPrivilegeRepository } from '../../../../src/components/user-privilege/user-privilege.repository';
+import { ClassError } from '@tomei/general';
+
+describe('UserPrivilege', () => {
+  let userPrivilege: UserPrivilege;
+  const userPrivilegeAttr = {
+    UserPrivilegeId: 1,
+    UserId: 1,
+    SystemPrivilegeId: 'privilege1',
+    Status: 'active',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    userPrivilege = new (UserPrivilege as any)(userPrivilegeAttr);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new UserPrivilege instance', () => {
+      expect(userPrivilege).toBeDefined();
+      expect(userPrivilege).toBeInstanceOf(UserPrivilege);
+      expect(userPrivilege.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
+      expect(userPrivilege.UserId).toBe(userPrivilegeAttr.UserId);
+      expect(userPrivilege.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
+      expect(userPrivilege.Status).toBe(userPrivilegeAttr.Status);
+      expect(userPrivilege.CreatedById).toBe(userPrivilegeAttr.CreatedById);
+      expect(userPrivilege.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
+      expect(userPrivilege.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
+      expect(userPrivilege.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize UserPrivilege with valid UserPrivilegeId', async () => {
+      const findOneMock = jest
+        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(userPrivilegeAttr as any);
+
+      const result = await UserPrivilege.init(null, 1);
+
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { UserPrivilegeId: 1 },
+        transaction: null,
+      });
+      expect(result).toBeInstanceOf(UserPrivilege);
+      expect(result.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
+      expect(result.UserId).toBe(userPrivilegeAttr.UserId);
+      expect(result.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
+      expect(result.Status).toBe(userPrivilegeAttr.Status);
+      expect(result.CreatedById).toBe(userPrivilegeAttr.CreatedById);
+      expect(result.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
+      expect(result.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
+      expect(result.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
+    });
+
+    it('should throw ClassError when UserPrivilegeId is not found', async () => {
+      jest
+        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserPrivilege.init(null, 1)).rejects.toThrow(ClassError);
+    });
+  });
 });

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);
+    });
+  });
+});

package/__tests__/unit/components/user-system-access/user-system-access.spec.ts

@@ -1,90 +1,90 @@
-import { UserSystemAccess } from '../../../../src/components/user-system-access/user-system-access';
-import { UserSystemAccessRepository } from '../../../../src/components/user-system-access/user-system-access.repository';
-import { ClassError } from '@tomei/general';
-
-describe('UserSystemAccess', () => {
-  let userSystemAccess: UserSystemAccess;
-  const userSystemAccessAttr = {
-    UserSystemAccessId: 1,
-    UserId: 1,
-    SystemCode: 'system1',
-    Status: 'active',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    userSystemAccess = new (UserSystemAccess as any)(userSystemAccessAttr);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new UserSystemAccess instance', () => {
-      expect(userSystemAccess).toBeDefined();
-      expect(userSystemAccess).toBeInstanceOf(UserSystemAccess);
-      expect(userSystemAccess.UserSystemAccessId).toBe(
-        userSystemAccessAttr.UserSystemAccessId
-      );
-      expect(userSystemAccess.UserId).toBe(userSystemAccessAttr.UserId);
-      expect(userSystemAccess.SystemCode).toBe(userSystemAccessAttr.SystemCode);
-      expect(userSystemAccess.Status).toBe(userSystemAccessAttr.Status);
-      expect(userSystemAccess.CreatedById).toBe(
-        userSystemAccessAttr.CreatedById
-      );
-      expect(userSystemAccess.CreatedAt).toBe(userSystemAccessAttr.CreatedAt);
-      expect(userSystemAccess.UpdatedById).toBe(
-        userSystemAccessAttr.UpdatedById
-      );
-      expect(userSystemAccess.UpdatedAt).toBe(userSystemAccessAttr.UpdatedAt);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize UserSystemAccess with valid UserSystemAccessId', async () => {
-      const findOneMock = jest
-        .spyOn(UserSystemAccessRepository.prototype, 'findOne')
-        .mockResolvedValueOnce({
-          ...userSystemAccessAttr,
-          get: () => userSystemAccessAttr,
-        } as any);
-
-      const result = await UserSystemAccess.init(null, 1);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: { UserSystemAccessId: 1 },
-        transaction: null,
-      });
-      expect(result).toBeInstanceOf(UserSystemAccess);
-      expect(result.UserSystemAccessId).toBe(
-        userSystemAccessAttr.UserSystemAccessId
-      );
-      expect(result.UserId).toBe(userSystemAccessAttr.UserId);
-      expect(result.SystemCode).toBe(userSystemAccessAttr.SystemCode);
-      expect(result.Status).toBe(userSystemAccessAttr.Status);
-      expect(result.CreatedById).toBe(userSystemAccessAttr.CreatedById);
-      expect(result.CreatedAt).toBe(userSystemAccessAttr.CreatedAt);
-      expect(result.UpdatedById).toBe(userSystemAccessAttr.UpdatedById);
-      expect(result.UpdatedAt).toBe(userSystemAccessAttr.UpdatedAt);
-    });
-
-    it('should throw ClassError when UserSystemAccessId is not found', async () => {
-      jest
-        .spyOn(UserSystemAccessRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      try {
-        await UserSystemAccess.init(null, 1)
-        expect(false).toBe(true);
-      } catch (error) {
-        expect(error).toBeInstanceOf(ClassError);
-        expect(error.message).toBe('UserSystemAccess not found');
-      }
-    });
-  });
+import { UserSystemAccess } from '../../../../src/components/user-system-access/user-system-access';
+import { UserSystemAccessRepository } from '../../../../src/components/user-system-access/user-system-access.repository';
+import { ClassError } from '@tomei/general';
+
+describe('UserSystemAccess', () => {
+  let userSystemAccess: UserSystemAccess;
+  const userSystemAccessAttr = {
+    UserSystemAccessId: 1,
+    UserId: 1,
+    SystemCode: 'system1',
+    Status: 'active',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    userSystemAccess = new (UserSystemAccess as any)(userSystemAccessAttr);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new UserSystemAccess instance', () => {
+      expect(userSystemAccess).toBeDefined();
+      expect(userSystemAccess).toBeInstanceOf(UserSystemAccess);
+      expect(userSystemAccess.UserSystemAccessId).toBe(
+        userSystemAccessAttr.UserSystemAccessId
+      );
+      expect(userSystemAccess.UserId).toBe(userSystemAccessAttr.UserId);
+      expect(userSystemAccess.SystemCode).toBe(userSystemAccessAttr.SystemCode);
+      expect(userSystemAccess.Status).toBe(userSystemAccessAttr.Status);
+      expect(userSystemAccess.CreatedById).toBe(
+        userSystemAccessAttr.CreatedById
+      );
+      expect(userSystemAccess.CreatedAt).toBe(userSystemAccessAttr.CreatedAt);
+      expect(userSystemAccess.UpdatedById).toBe(
+        userSystemAccessAttr.UpdatedById
+      );
+      expect(userSystemAccess.UpdatedAt).toBe(userSystemAccessAttr.UpdatedAt);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize UserSystemAccess with valid UserSystemAccessId', async () => {
+      const findOneMock = jest
+        .spyOn(UserSystemAccessRepository.prototype, 'findOne')
+        .mockResolvedValueOnce({
+          ...userSystemAccessAttr,
+          get: () => userSystemAccessAttr,
+        } as any);
+
+      const result = await UserSystemAccess.init(null, 1);
+
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { UserSystemAccessId: 1 },
+        transaction: null,
+      });
+      expect(result).toBeInstanceOf(UserSystemAccess);
+      expect(result.UserSystemAccessId).toBe(
+        userSystemAccessAttr.UserSystemAccessId
+      );
+      expect(result.UserId).toBe(userSystemAccessAttr.UserId);
+      expect(result.SystemCode).toBe(userSystemAccessAttr.SystemCode);
+      expect(result.Status).toBe(userSystemAccessAttr.Status);
+      expect(result.CreatedById).toBe(userSystemAccessAttr.CreatedById);
+      expect(result.CreatedAt).toBe(userSystemAccessAttr.CreatedAt);
+      expect(result.UpdatedById).toBe(userSystemAccessAttr.UpdatedById);
+      expect(result.UpdatedAt).toBe(userSystemAccessAttr.UpdatedAt);
+    });
+
+    it('should throw ClassError when UserSystemAccessId is not found', async () => {
+      jest
+        .spyOn(UserSystemAccessRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      try {
+        await UserSystemAccess.init(null, 1)
+        expect(false).toBe(true);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ClassError);
+        expect(error.message).toBe('UserSystemAccess not found');
+      }
+    });
+  });
 });

package/__tests__/unit/redis-client/redis.service.spec.ts

@@ -1,24 +1,24 @@
-import { RedisService } from "../../../src/redis-client/redis.service";
-require('dotenv').config()
-// nneed to figure out how to mock redis
-describe('redis.service', () => {
-
-    afterEach(() => {
-        jest.restoreAllMocks()
-    })
-
-    it('should return redis service when instansiated', async () => {
-        const redisService = await RedisService.init();
-        expect(redisService).toBeDefined();
-    });
-
-    it('should able to write and read redis', async () => {
-        const data = {
-            test: 'test'
-        }
-        const redisService = await RedisService.init();
-        await redisService.set("test", data, 60 * 60 * 24 * 1)
-        const result = await redisService.get("test");
-        expect(result).toEqual(JSON.stringify(data));
-    });
+import { RedisService } from "../../../src/redis-client/redis.service";
+require('dotenv').config()
+// nneed to figure out how to mock redis
+describe('redis.service', () => {
+
+    afterEach(() => {
+        jest.restoreAllMocks()
+    })
+
+    it('should return redis service when instansiated', async () => {
+        const redisService = await RedisService.init();
+        expect(redisService).toBeDefined();
+    });
+
+    it('should able to write and read redis', async () => {
+        const data = {
+            test: 'test'
+        }
+        const redisService = await RedisService.init();
+        await redisService.set("test", data, 60 * 60 * 24 * 1)
+        const result = await redisService.get("test");
+        expect(result).toEqual(JSON.stringify(data));
+    });
 });