@tomei/sso 0.64.0-staging.2 → 0.64.0

package/.commitlintrc.json

@@ -1,22 +1,22 @@
-{
-  "extends": [
-    "@commitlint/config-conventional"
-  ],
-  "rules": {
-    "header-max-length": [ 2, "always", 120 ],
-    "type-enum": [
-      2,
-      "always",
-      [
-        "breaking",
-        "feat",
-        "fix",
-        "refactor",
-        "config",
-        "test",
-        "docs",
-        "chore"
-      ]
-    ]
-  }
-}
+{
+  "extends": [
+    "@commitlint/config-conventional"
+  ],
+  "rules": {
+    "header-max-length": [ 2, "always", 120 ],
+    "type-enum": [
+      2,
+      "always",
+      [
+        "breaking",
+        "feat",
+        "fix",
+        "refactor",
+        "config",
+        "test",
+        "docs",
+        "chore"
+      ]
+    ]
+  }
+}

package/.gitlab-ci.yml

@@ -1,16 +1,16 @@
-variables:
-  SONAR_USER_HOME: "${CI_PROJECT_DIR}/.sonar"  # Defines the location of the analysis task cache
-  GIT_DEPTH: "0"  # Tells git to fetch all the branches of the project, required by the analysis task
-sonarcloud-check:
-  image:
-    name: sonarsource/sonar-scanner-cli:latest
-    entrypoint: [""]
-  cache:
-    key: "${CI_JOB_NAME}"
-    paths:
-      - .sonar/cache
-  script:
-    - sonar-scanner
-  only:
-    - merge_requests
-    - main
+variables:
+  SONAR_USER_HOME: "${CI_PROJECT_DIR}/.sonar"  # Defines the location of the analysis task cache
+  GIT_DEPTH: "0"  # Tells git to fetch all the branches of the project, required by the analysis task
+sonarcloud-check:
+  image:
+    name: sonarsource/sonar-scanner-cli:latest
+    entrypoint: [""]
+  cache:
+    key: "${CI_JOB_NAME}"
+    paths:
+      - .sonar/cache
+  script:
+    - sonar-scanner
+  only:
+    - merge_requests
+    - main

package/.husky/commit-msg

@@ -1,10 +1,16 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npx commitlint --edit $1
-message="$(cat $1)"
-echo "$message"
-a=($(echo "$message" | tr ':' '\n'))
-echo "${a[0]}"
-git add .
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx commitlint --edit $1
+message="$(cat $1)"
+echo "$message"
+a=($(echo "$message" | tr ':' '\n'))
+echo "${a[0]}"
+# if [ "${a[0]}" = "feat" ];
+# then
+#     npm version --commit-hooks false --no-git-tag-version minor
+# else
+#     npm version --commit-hooks false --no-git-tag-version patch
+# fi
+git add .
 git commit -m "$message" --no-verify

package/.husky/pre-commit

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npm run lint
-npm run format
-npm run build
-git add .
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run lint
+npm run format
+npm run build
+git add .

package/.prettierrc

@@ -1,4 +1,4 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all"
-}
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/Jenkinsfile

@@ -1,57 +1,57 @@
-pipeline {
-    agent {
-        kubernetes {
-            label 'jenkins-agent'
-            namespace 'devops-tools'
-        }
-    }
-    tools {nodejs "node18"}
-    stages {
-        stage('Install') {
-            steps {
-                echo 'Install Dependencies..'
-                sh 'npm install'
-            }
-        }
-        stage('Test') {
-            steps {
-                echo 'Testing..'
-                sh 'npm run test'
-            }
-        }
-        stage('Build') {
-            steps {
-                echo 'Building..'
-                sh 'npm run build'
-            }
-        }
-        stage('Publish') {
-            steps {
-                echo 'Publish..'
-                withCredentials([
-                    usernamePassword(credentialsId: 'npm-auth-token', usernameVariable: 'NPM_USERNAME', passwordVariable: 'AUTH_TOKEN')
-                ]) {
-                sh "npm set //registry.npmjs.org/:_authToken=$AUTH_TOKEN"
-                sh "npm publish"
-            }
-        }
-}
-    }
-
-    post {
-        success {
-            script {
-                def gitAuthor = sh(returnStdout: true, script: 'git log -1 --pretty=format:%an').trim()
-                discordSend description: "Git Commit: ${env.GIT_COMMIT}\nGit Branch: ${env.GIT_BRANCH}\nGit URL: ${env.GIT_URL}\nGit Author: ${gitAuthor}", footer: '', image: '', link: env.BUILD_URL, result: 'SUCCESS', scmWebUrl: '', thumbnail: '', title: "${env.JOB_NAME} Build #${env.BUILD_NUMBER} Success", webhookURL: 'https://discord.com/api/webhooks/1117705705466642434/UWgw32kQerM5HOr-fcCYD2aQxE1koeN_4CSCEzDZz1EAI3vNaysAw0YU7YUrb4TozOw0'
-            }
-        }
-
-        failure {
-            script {
-                def gitAuthor = sh(returnStdout: true, script: 'git log -1 --pretty=format:%an').trim()
-                discordSend description: "Git Commit: ${env.GIT_COMMIT}\nGit Branch: ${env.GIT_BRANCH}\nGit URL: ${env.GIT_URL}\nGit Author: ${gitAuthor}", footer: '', image: '', link: env.BUILD_URL, result: 'FAILURE', scmWebUrl: '', thumbnail: '', title: "${env.JOB_NAME} Build #${env.BUILD_NUMBER} Failed", webhookURL: 'https://discord.com/api/webhooks/1117705705466642434/UWgw32kQerM5HOr-fcCYD2aQxE1koeN_4CSCEzDZz1EAI3vNaysAw0YU7YUrb4TozOw0'
-            }
-        }
-    } 
-
-}
+pipeline {
+    agent {
+        kubernetes {
+            label 'jenkins-agent'
+            namespace 'devops-tools'
+        }
+    }
+    tools {nodejs "node18"}
+    stages {
+        stage('Install') {
+            steps {
+                echo 'Install Dependencies..'
+                sh 'npm install'
+            }
+        }
+        stage('Test') {
+            steps {
+                echo 'Testing..'
+                sh 'npm run test'
+            }
+        }
+        stage('Build') {
+            steps {
+                echo 'Building..'
+                sh 'npm run build'
+            }
+        }
+        stage('Publish') {
+            steps {
+                echo 'Publish..'
+                withCredentials([
+                    usernamePassword(credentialsId: 'npm-auth-token', usernameVariable: 'NPM_USERNAME', passwordVariable: 'AUTH_TOKEN')
+                ]) {
+                sh "npm set //registry.npmjs.org/:_authToken=$AUTH_TOKEN"
+                sh "npm publish"
+            }
+        }
+}
+    }
+
+    post {
+        success {
+            script {
+                def gitAuthor = sh(returnStdout: true, script: 'git log -1 --pretty=format:%an').trim()
+                discordSend description: "Git Commit: ${env.GIT_COMMIT}\nGit Branch: ${env.GIT_BRANCH}\nGit URL: ${env.GIT_URL}\nGit Author: ${gitAuthor}", footer: '', image: '', link: env.BUILD_URL, result: 'SUCCESS', scmWebUrl: '', thumbnail: '', title: "${env.JOB_NAME} Build #${env.BUILD_NUMBER} Success", webhookURL: 'https://discord.com/api/webhooks/1117705705466642434/UWgw32kQerM5HOr-fcCYD2aQxE1koeN_4CSCEzDZz1EAI3vNaysAw0YU7YUrb4TozOw0'
+            }
+        }
+
+        failure {
+            script {
+                def gitAuthor = sh(returnStdout: true, script: 'git log -1 --pretty=format:%an').trim()
+                discordSend description: "Git Commit: ${env.GIT_COMMIT}\nGit Branch: ${env.GIT_BRANCH}\nGit URL: ${env.GIT_URL}\nGit Author: ${gitAuthor}", footer: '', image: '', link: env.BUILD_URL, result: 'FAILURE', scmWebUrl: '', thumbnail: '', title: "${env.JOB_NAME} Build #${env.BUILD_NUMBER} Failed", webhookURL: 'https://discord.com/api/webhooks/1117705705466642434/UWgw32kQerM5HOr-fcCYD2aQxE1koeN_4CSCEzDZz1EAI3vNaysAw0YU7YUrb4TozOw0'
+            }
+        }
+    } 
+
+}

package/README.md

@@ -1,23 +1,23 @@
-## SSO Package
-
-### How to use
-- run `npm i`
-- Make sure you set the environment in .sampledotenv in your project `.env` file
-- run `npm run start:dev`
-
-### How create a new migration
-- Make sure you have `DATABASE_URL` and `SHADOW_DATABASE_URL` in your project `.env` file
-- create a new empty database. dont do migration on it and set the `SHADOW_DATABASE_URL` to it
-- Create a database user 
-- Grant the above user privileges to alter sso tables and shadow database. The user should have access to the sso table and shadow database only. Use `create-sso-user.sql` as an example to create the user and grant privileges
-- Make changes to the `schema.prisma` file 
-- Run `npx prisma migrate dev --name <migration-name> --preview-feature --create-only` to create the migration. The migration will be created in the `migrations` folder.
-- open the newly created migration. review the migration and make changes if necessary.
-
-notes:
-- if you create a new table, after migration has been created, change the default character set to `latin1` from `utf8mb4` and remove COLLATE phrase.please also add it to the `create-sso-user.sql` file for references
-
-### How to run migration
-- run `npx prisma migrate deploy` to run the migration
-- run `npx prisma generate` to generate the prisma client
-
+## SSO Package
+
+### How to use
+- run `npm i`
+- Make sure you set the environment in .sampledotenv in your project `.env` file
+- run `npm run start:dev`
+
+### How create a new migration
+- Make sure you have `DATABASE_URL` and `SHADOW_DATABASE_URL` in your project `.env` file
+- create a new empty database. dont do migration on it and set the `SHADOW_DATABASE_URL` to it
+- Create a database user 
+- Grant the above user privileges to alter sso tables and shadow database. The user should have access to the sso table and shadow database only. Use `create-sso-user.sql` as an example to create the user and grant privileges
+- Make changes to the `schema.prisma` file 
+- Run `npx prisma migrate dev --name <migration-name> --preview-feature --create-only` to create the migration. The migration will be created in the `migrations` folder.
+- open the newly created migration. review the migration and make changes if necessary.
+
+notes:
+- if you create a new table, after migration has been created, change the default character set to `latin1` from `utf8mb4` and remove COLLATE phrase.please also add it to the `create-sso-user.sql` file for references
+
+### How to run migration
+- run `npx prisma migrate deploy` to run the migration
+- run `npx prisma generate` to generate the prisma client
+

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

@@ -1,80 +1,80 @@
-import { Group } from '../../../../src/components/group/group';
-import { GroupRepository } from '../../../../src/components/group/group.repository';
-import { ClassError } from '@tomei/general';
-import { GroupTypeEnum } from '../../../../src/enum/group-type.enum';
-
-
-describe('Group', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should initialize a group with valid GroupCode', async () => {
-    const groupAttr = {
-      GroupCode: 'group1',
-      Name: 'Group 1',
-      Description: 'This is Group 1',
-      Type: GroupTypeEnum.ROLE,
-      ParentGroupCode: 'parentGroup1',
-      InheritParentPrivilegeYN: 'Y',
-      InheritParentSystemAccessYN: 'N',
-      Status: 'Active',
-      CreatedById: 1,
-      CreatedAt: new Date(),
-      UpdatedById: 2,
-      UpdatedAt: new Date(),
-    };
-
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce({
-      ...groupAttr,
-      get: () => groupAttr,
-    } as any);
-
-    const result = await Group.init(null, 'group1');
-
-    expect(result).toBeInstanceOf(Group);
-    expect(result.GroupCode).toBe(groupAttr.GroupCode);
-    expect(result.Name).toBe(groupAttr.Name);
-    expect(result.Description).toBe(groupAttr.Description);
-    expect(result.Type).toBe(groupAttr.Type);
-    expect(result.ParentGroupCode).toBe(groupAttr.ParentGroupCode);
-    expect(result.InheritParentPrivilegeYN).toBe(groupAttr.InheritParentPrivilegeYN);
-    expect(result.InheritParentSystemAccessYN).toBe(groupAttr.InheritParentSystemAccessYN);
-    expect(result.Status).toBe(groupAttr.Status);
-    expect(result.CreatedById).toBe(groupAttr.CreatedById);
-    expect(result.CreatedAt).toBe(groupAttr.CreatedAt);
-    expect(result.UpdatedById).toBe(groupAttr.UpdatedById);
-    expect(result.UpdatedAt).toBe(groupAttr.UpdatedAt);
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
-      transaction: null,
-    });
-  });
-
-  it('should throw an error when initializing a group with invalid GroupCode', async () => {
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
-
-    await expect(Group.init(null, 'invalidGroupCode')).rejects.toThrow(
-      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
-    );
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('invalidGroupCode', {
-      transaction: null,
-    });
-  });
-
-  it('should throw an error when initializing a group with an error', async () => {
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
-
-    await expect(Group.init(null, 'group1')).rejects.toThrow(
-      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
-    );
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
-      transaction: null,
-    });
-  });
+import { Group } from '../../../../src/components/group/group';
+import { GroupRepository } from '../../../../src/components/group/group.repository';
+import { ClassError } from '@tomei/general';
+import { GroupTypeEnum } from '../../../../src/enum/group-type.enum';
+
+
+describe('Group', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should initialize a group with valid GroupCode', async () => {
+    const groupAttr = {
+      GroupCode: 'group1',
+      Name: 'Group 1',
+      Description: 'This is Group 1',
+      Type: GroupTypeEnum.ROLE,
+      ParentGroupCode: 'parentGroup1',
+      InheritParentPrivilegeYN: 'Y',
+      InheritParentSystemAccessYN: 'N',
+      Status: 'Active',
+      CreatedById: 1,
+      CreatedAt: new Date(),
+      UpdatedById: 2,
+      UpdatedAt: new Date(),
+    };
+
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce({
+      ...groupAttr,
+      get: () => groupAttr,
+    } as any);
+
+    const result = await Group.init(null, 'group1');
+
+    expect(result).toBeInstanceOf(Group);
+    expect(result.GroupCode).toBe(groupAttr.GroupCode);
+    expect(result.Name).toBe(groupAttr.Name);
+    expect(result.Description).toBe(groupAttr.Description);
+    expect(result.Type).toBe(groupAttr.Type);
+    expect(result.ParentGroupCode).toBe(groupAttr.ParentGroupCode);
+    expect(result.InheritParentPrivilegeYN).toBe(groupAttr.InheritParentPrivilegeYN);
+    expect(result.InheritParentSystemAccessYN).toBe(groupAttr.InheritParentSystemAccessYN);
+    expect(result.Status).toBe(groupAttr.Status);
+    expect(result.CreatedById).toBe(groupAttr.CreatedById);
+    expect(result.CreatedAt).toBe(groupAttr.CreatedAt);
+    expect(result.UpdatedById).toBe(groupAttr.UpdatedById);
+    expect(result.UpdatedAt).toBe(groupAttr.UpdatedAt);
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
+      transaction: null,
+    });
+  });
+
+  it('should throw an error when initializing a group with invalid GroupCode', async () => {
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
+
+    await expect(Group.init(null, 'invalidGroupCode')).rejects.toThrow(
+      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
+    );
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('invalidGroupCode', {
+      transaction: null,
+    });
+  });
+
+  it('should throw an error when initializing a group with an error', async () => {
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(Group.init(null, 'group1')).rejects.toThrow(
+      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
+    );
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
+      transaction: null,
+    });
+  });
 });

package/__tests__/unit/components/group-object-privilege/group-object-privilege.spec.ts

@@ -1,89 +1,89 @@
-import { GroupObjectPrivilegeRepository } from '../../../../src/components/group-object-privilege/group-object-privilege.repository';
-import { GroupObjectPrivilege } from '../../../../src/components/group-object-privilege/group-object-privilege';
-
-describe('GroupObjectPrivilege', () => {
-  let groupObjectPrivilege: GroupObjectPrivilege;
-
-  beforeEach(() => {
-    groupObjectPrivilege = new GroupObjectPrivilege();
-  });
-
-  it('should create an instance of GroupObjectPrivilege', () => {
-    expect(groupObjectPrivilege).toBeInstanceOf(GroupObjectPrivilege);
-  });
-
-  it('should have the correct TableName', () => {
-    expect(groupObjectPrivilege.TableName).toBe('sso_GroupObjectPrivilege');
-  });
-
-  it('should have the correct properties', () => {
-    expect(groupObjectPrivilege.ObjectName).toBeUndefined();
-    expect(groupObjectPrivilege.GroupObjectPrivilegeId).toBeUndefined();
-    expect(groupObjectPrivilege.GroupCode).toBeUndefined();
-    expect(groupObjectPrivilege.SystemPrivilegeId).toBeUndefined();
-    expect(groupObjectPrivilege.ObjectId).toBeUndefined();
-    expect(groupObjectPrivilege.ObjectType).toBeUndefined();
-    expect(groupObjectPrivilege.CreatedAt).toBeUndefined();
-    expect(groupObjectPrivilege.UpdatedAt).toBeUndefined();
-    expect(groupObjectPrivilege.CreatedById).toBeUndefined();
-    expect(groupObjectPrivilege.UpdatedById).toBeUndefined();
-  });
-
-  describe('init', () => {
-    it('should return an instance of GroupObjectPrivilege when GroupObjectPrivilegeId is provided', async () => {
-      const GroupObjectPrivilegeId = 1;
-      const mockGroupObjectPrivilegeAttr = {
-        GroupObjectPrivilegeId,
-        GroupCode: 'groupCode',
-        SystemPrivilegeId: 'SystemPrivilegeId',
-        ObjectId: 'objectId',
-        ObjectType: 'objectType',
-        CreatedAt: new Date(),
-        UpdatedAt: new Date(),
-        CreatedById: 1,
-        UpdatedById: 2,
-      };
-
-      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
-        get: () => mockGroupObjectPrivilegeAttr,
-      } as any);
-
-      const result = await GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
-
-      expect(result).toBeInstanceOf(GroupObjectPrivilege);
-      expect(result.GroupObjectPrivilegeId).toBe(GroupObjectPrivilegeId);
-      expect(result.GroupCode).toBe(mockGroupObjectPrivilegeAttr.GroupCode);
-      expect(result.SystemPrivilegeId).toBe(mockGroupObjectPrivilegeAttr.SystemPrivilegeId);
-      expect(result.ObjectId).toBe(mockGroupObjectPrivilegeAttr.ObjectId);
-      expect(result.ObjectType).toBe(mockGroupObjectPrivilegeAttr.ObjectType);
-      expect(result.CreatedAt).toBe(mockGroupObjectPrivilegeAttr.CreatedAt);
-      expect(result.UpdatedAt).toBe(mockGroupObjectPrivilegeAttr.UpdatedAt);
-      expect(result.CreatedById).toBe(mockGroupObjectPrivilegeAttr.CreatedById);
-      expect(result.UpdatedById).toBe(mockGroupObjectPrivilegeAttr.UpdatedById);
-    });
-
-    it('should throw an error when GroupObjectPrivilegeId is provided but no GroupObjectPrivilege is found', async () => {
-      const GroupObjectPrivilegeId = 1;
-      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
-
-      await expect(GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrow(
-        'GroupObjectPrivilege not found',
-      );
-    });
-
-    it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', async () => {
-      const result = await GroupObjectPrivilege.init();
-
-      expect(result).toBeInstanceOf(GroupObjectPrivilege);
-      expect(result.GroupObjectPrivilegeId).toBeUndefined();
-      expect(result.GroupCode).toBeUndefined();
-      expect(result.SystemPrivilegeId).toBeUndefined();
-      expect(result.ObjectId).toBeUndefined();
-      expect(result.ObjectType).toBeUndefined();
-      expect(result.CreatedAt).toBeUndefined();
-      expect(result.UpdatedAt).toBeUndefined();
-      expect(result.CreatedById).toBeUndefined();
-      expect(result.UpdatedById).toBeUndefined();
-    });
-  });
+import { GroupObjectPrivilegeRepository } from '../../../../src/components/group-object-privilege/group-object-privilege.repository';
+import { GroupObjectPrivilege } from '../../../../src/components/group-object-privilege/group-object-privilege';
+
+describe('GroupObjectPrivilege', () => {
+  let groupObjectPrivilege: GroupObjectPrivilege;
+
+  beforeEach(() => {
+    groupObjectPrivilege = new GroupObjectPrivilege();
+  });
+
+  it('should create an instance of GroupObjectPrivilege', () => {
+    expect(groupObjectPrivilege).toBeInstanceOf(GroupObjectPrivilege);
+  });
+
+  it('should have the correct TableName', () => {
+    expect(groupObjectPrivilege.TableName).toBe('sso_GroupObjectPrivilege');
+  });
+
+  it('should have the correct properties', () => {
+    expect(groupObjectPrivilege.ObjectName).toBeUndefined();
+    expect(groupObjectPrivilege.GroupObjectPrivilegeId).toBeUndefined();
+    expect(groupObjectPrivilege.GroupCode).toBeUndefined();
+    expect(groupObjectPrivilege.SystemPrivilegeId).toBeUndefined();
+    expect(groupObjectPrivilege.ObjectId).toBeUndefined();
+    expect(groupObjectPrivilege.ObjectType).toBeUndefined();
+    expect(groupObjectPrivilege.CreatedAt).toBeUndefined();
+    expect(groupObjectPrivilege.UpdatedAt).toBeUndefined();
+    expect(groupObjectPrivilege.CreatedById).toBeUndefined();
+    expect(groupObjectPrivilege.UpdatedById).toBeUndefined();
+  });
+
+  describe('init', () => {
+    it('should return an instance of GroupObjectPrivilege when GroupObjectPrivilegeId is provided', async () => {
+      const GroupObjectPrivilegeId = 1;
+      const mockGroupObjectPrivilegeAttr = {
+        GroupObjectPrivilegeId,
+        GroupCode: 'groupCode',
+        SystemPrivilegeId: 'SystemPrivilegeId',
+        ObjectId: 'objectId',
+        ObjectType: 'objectType',
+        CreatedAt: new Date(),
+        UpdatedAt: new Date(),
+        CreatedById: 1,
+        UpdatedById: 2,
+      };
+
+      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
+        get: () => mockGroupObjectPrivilegeAttr,
+      } as any);
+
+      const result = await GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
+
+      expect(result).toBeInstanceOf(GroupObjectPrivilege);
+      expect(result.GroupObjectPrivilegeId).toBe(GroupObjectPrivilegeId);
+      expect(result.GroupCode).toBe(mockGroupObjectPrivilegeAttr.GroupCode);
+      expect(result.SystemPrivilegeId).toBe(mockGroupObjectPrivilegeAttr.SystemPrivilegeId);
+      expect(result.ObjectId).toBe(mockGroupObjectPrivilegeAttr.ObjectId);
+      expect(result.ObjectType).toBe(mockGroupObjectPrivilegeAttr.ObjectType);
+      expect(result.CreatedAt).toBe(mockGroupObjectPrivilegeAttr.CreatedAt);
+      expect(result.UpdatedAt).toBe(mockGroupObjectPrivilegeAttr.UpdatedAt);
+      expect(result.CreatedById).toBe(mockGroupObjectPrivilegeAttr.CreatedById);
+      expect(result.UpdatedById).toBe(mockGroupObjectPrivilegeAttr.UpdatedById);
+    });
+
+    it('should throw an error when GroupObjectPrivilegeId is provided but no GroupObjectPrivilege is found', async () => {
+      const GroupObjectPrivilegeId = 1;
+      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
+
+      await expect(GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrow(
+        'GroupObjectPrivilege not found',
+      );
+    });
+
+    it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', async () => {
+      const result = await GroupObjectPrivilege.init();
+
+      expect(result).toBeInstanceOf(GroupObjectPrivilege);
+      expect(result.GroupObjectPrivilegeId).toBeUndefined();
+      expect(result.GroupCode).toBeUndefined();
+      expect(result.SystemPrivilegeId).toBeUndefined();
+      expect(result.ObjectId).toBeUndefined();
+      expect(result.ObjectType).toBeUndefined();
+      expect(result.CreatedAt).toBeUndefined();
+      expect(result.UpdatedAt).toBeUndefined();
+      expect(result.CreatedById).toBeUndefined();
+      expect(result.UpdatedById).toBeUndefined();
+    });
+  });
 });