@ieeesa-npm/tenants 0.4.2 → 0.4.4

package/src/lib/services/tenant-applications.service.spec.ts

@@ -0,0 +1,1245 @@
+import { TestBed } from '@angular/core/testing';
+import { TenantApplicationsService } from './tenant-applications.service';
+import { AlertsService, HttpService } from '@ieeesa-npm/utility';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import {
+  HttpClient,
+  HttpErrorResponse,
+  HttpHandler,
+} from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { TenantsMocks } from '../assets/tenants-mock';
+import { Features } from '../models/features.model';
+import { AppTypeConfig } from '../models/app-type-config.model';
+import { RoleTypeConfiguration } from '../models/role-type.model';
+import {
+  RolesAndPermissionsRequestPayload,
+  RolePermissionMappingRequestPayload,
+} from '../models/roles-and-permissions.model';
+
+describe('TenantApplicationsService', () => {
+  let service: TenantApplicationsService;
+  let httpService: HttpService;
+  const getFeaturesListMockResponse = TenantsMocks.mockFeatureResponse;
+  const getAppTypesMockResponse = TenantsMocks.mockAppTypesResponse;
+  const createTenantMockPayload = TenantsMocks.createTenantMockPayload;
+  const mockErrorResponse = {
+    error: 'Test error',
+    status: 500,
+    statusText: 'Internal server error',
+  };
+  const createTenantMockResponse = TenantsMocks.createTenantMockResponse;
+  const updateTenantStatusMockResponse =
+    TenantsMocks.updateTenantStatusMockResponse;
+  const updateTenantStatusMockPayload =
+    TenantsMocks.updateTenantStatusMockPayload;
+  const getRoleTypesMockResponse = TenantsMocks.mockRoleTypesResponse;
+  const getRoleTypeMockPayload = TenantsMocks.mockRoleTypePayload;
+  const createRoleMockResponse = TenantsMocks.createRoleMockResponse;
+  const createRoleMockPayload = TenantsMocks.createRoleMockPayload;
+  const editRoleMockResponse = TenantsMocks.editRoleMockResponse;
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [
+        HttpClient,
+        HttpHandler,
+        HttpService,
+        TenantApplicationsService,
+        AlertsService,
+      ],
+    });
+    service = TestBed.inject(TenantApplicationsService);
+    httpService = TestBed.inject(HttpService);
+    service.checkBoxOptions = TenantsMocks?.mockFeaturesFormattedResponse;
+  });
+  describe('#setAppConfig', () => {
+    it('should set app config', () => {
+      const spyOnSetAppConfig = spyOn(
+        service,
+        'setAppConfig'
+      ).and.callThrough();
+      service.setAppConfig(
+        TenantsMocks?.getApiBaseURL,
+        TenantsMocks?.mockUserPermissions
+      );
+      expect(spyOnSetAppConfig).toHaveBeenCalledWith(
+        TenantsMocks?.getApiBaseURL,
+        TenantsMocks?.mockUserPermissions
+      );
+    });
+  });
+  describe('#setUserTenantsPermissions', () => {
+    it('should call setUserTenantsPermissions method and set setUserTenantsPermissions', () => {
+      const setUserTenantsPermissionsSpy = spyOn(
+        service,
+        'setUserTenantsPermissions'
+      ).and.callThrough();
+      service.setUserTenantsPermissions(
+        TenantsMocks.mockGlobalTenantsPermissions
+      );
+      expect(setUserTenantsPermissionsSpy).toHaveBeenCalledWith(
+        TenantsMocks.mockGlobalTenantsPermissions
+      );
+    });
+  });
+  describe('#getUserTenantsPermissions', () => {
+    it('should return user tenants permissions', () => {
+      service.setUserTenantsPermissions(
+        TenantsMocks.mockGlobalTenantsPermissions
+      );
+      expect(service.getUserTenantsPermissions()).toEqual(
+        TenantsMocks.mockGlobalTenantsPermissions
+      );
+    });
+  });
+  describe('#getTenantsList', () => {
+    it('should call getTenantsList', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.getTenantsMockResponse)
+      );
+      service
+        .getTenantsList(TenantsMocks.getTenantsMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(TenantsMocks.getTenantsMockResponse);
+        });
+    });
+    it('should return error in retrieving tenants list', (done) => {
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(TenantsMocks.mockErrorResponse))
+      );
+      service.getTenantsList(TenantsMocks.getTenantsMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+
+  describe('#getRolesAndPermissions', () => {
+    it('should get roles and permissions mappings configured for the tenant', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.mockUserPermissionRoles)
+      );
+      service
+        .getRolesAndPermissionsMappings(
+          'SAAPS',
+          TenantsMocks.getRolesMockPayload
+        )
+        .subscribe((response) => {
+          expect(response).toEqual(TenantsMocks.mockUserPermissionRoles);
+        });
+    });
+    it('should return error in retrieving roles and permissions list', (done) => {
+      const mockRolesAndPermissionsMappingErrorResponse = {
+        error: {
+          status: false,
+          message: 'Unable to fetch Roles and Permissions Mapping.',
+          body: { errorCodes: ['3009'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(
+          () =>
+            new HttpErrorResponse(mockRolesAndPermissionsMappingErrorResponse)
+        )
+      );
+      service
+        .getRolesAndPermissionsMappings(
+          'SAAPS',
+          TenantsMocks.getRolesMockPayload
+        )
+        .subscribe({
+          next: () => {
+            done();
+          },
+          error: (error: HttpErrorResponse) => {
+            done();
+            expect(error).toBeTruthy();
+          },
+        });
+    });
+  });
+
+  describe('#getRoles', () => {
+    it('should get the roles configured for the tenant', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.mockUserRoles)
+      );
+      service.getRoles('SAAPS').subscribe((response) => {
+        expect(response).toEqual(TenantsMocks.mockUserRoles);
+      });
+    });
+    it('should return error in retrieving roles list', (done) => {
+      const mockRolesErrorResponse = {
+        error: {
+          status: false,
+          message: 'No Role(s) found.',
+          body: { errorCodes: ['3007'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockRolesErrorResponse))
+      );
+      service.getRoles('SAAPS').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+
+  describe('#getRosterType', () => {
+    it('should get the roster type configured for the tenant', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.mockRosterTypeResponse)
+      );
+      service.getRosterType().subscribe((response) => {
+        expect(response).toEqual(TenantsMocks.mockRosterTypeResponse);
+      });
+    });
+    it('should return error in retrieving roster types list', (done) => {
+      const mockRosterTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Resource not found.',
+          body: { errorCodes: ['2066'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockRosterTypesErrorResponse))
+      );
+      service.getRosterType().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getGroupTypeSettings', () => {
+    it('should get the settings configured for the tenant', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.mockGroupTypeSettingResponse)
+      );
+      service.getGroupTypeSettings().subscribe((response) => {
+        expect(response).toEqual(TenantsMocks.mockGroupTypeSettingResponse);
+      });
+    });
+    it('should return error in retrieving roster types list', (done) => {
+      const mocGroupTypeSettingsErrorResponse = {
+        error: {
+          status: false,
+          message: 'Resource not found.',
+          body: { errorCodes: ['2066'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(
+          () => new HttpErrorResponse(mocGroupTypeSettingsErrorResponse)
+        )
+      );
+      service.getGroupTypeSettings().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getFeaturesList', () => {
+    it('should return get features list success response', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(getFeaturesListMockResponse)
+      );
+      service.getFeatures().subscribe((response) => {
+        expect(response).toEqual(getFeaturesListMockResponse);
+      });
+    });
+    it('should throw features not found error in retrieving list of features', (done) => {
+      const mockGetFeaturesListErrorResponse = {
+        error: {
+          status: false,
+          message: 'List of features not found.',
+          body: { errorCodes: ['2026'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(
+          () => new HttpErrorResponse(mockGetFeaturesListErrorResponse)
+        )
+      );
+      service.getFeatures().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockGetFeaturesListErrorResponse)
+          );
+        },
+      });
+    });
+    it('should return Internal Server Error error while getting list of features', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => errorResponse)
+      );
+      service.getFeatures().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+
+  describe('#getApplicationTypes', () => {
+    it('should return application types success response', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(getAppTypesMockResponse)
+      );
+      service.getApplicationTypes().subscribe((response) => {
+        expect(response).toEqual(getAppTypesMockResponse);
+      });
+    });
+    it('should throw application types not found error in retrieving application types', (done) => {
+      const mockGetAppTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Application Type not found.',
+          body: { errorCodes: ['2003'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetAppTypesErrorResponse))
+      );
+      service.getApplicationTypes().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockGetAppTypesErrorResponse)
+          );
+        },
+      });
+    });
+    it('should return Internal Server Error error while getting application types', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => errorResponse)
+      );
+      service.getApplicationTypes().subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#createTenant', () => {
+    it('should create new tenant successfully', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(createTenantMockResponse)
+      );
+      service.createTenant(createTenantMockPayload).subscribe((response) => {
+        expect(response).toEqual(createTenantMockResponse);
+      });
+    });
+    it('should throw application title is required error while creating a tenant', (done) => {
+      const mockCreateTenantErrorResponse = {
+        error: {
+          status: false,
+          message: 'Application Title is required.',
+          body: { errorCodes: ['2028'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      const mockCreateTenantPayload =
+        TenantsMocks.mockCreateTenantPayloadMissingAppTitle;
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockCreateTenantErrorResponse))
+      );
+      service.createTenant(mockCreateTenantPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockCreateTenantErrorResponse)
+          );
+        },
+      });
+    });
+    it('should handle error while creating a tenant is failed', (done) => {
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.createTenant(createTenantMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#createGroupType', () => {
+    it('should create new group type successfully', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.mockCreateGroupTypeSuccessResponse)
+      );
+      service
+        .createGroupType(TenantsMocks.mockCreateGroupTypePayload)
+        .subscribe((response) => {
+          expect(response).toEqual(
+            TenantsMocks.mockCreateGroupTypeSuccessResponse
+          );
+        });
+    });
+    it('should throw group type name already exists while creating a tenant', (done) => {
+      const mockCreateTenantErrorResponse = {
+        error: {
+          status: false,
+          message: 'Resource Not Found',
+          body: { errorCodes: ['2067'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      const mockCreateGroupTypePayload =
+        TenantsMocks.mockCreateGroupTypePayload;
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockCreateTenantErrorResponse))
+      );
+      service.createGroupType(mockCreateGroupTypePayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockCreateTenantErrorResponse)
+          );
+        },
+      });
+    });
+  });
+  describe('#getFeatureOptions', () => {
+    it('should format the feature list to checkbox options.', () => {
+      const featureList = TenantsMocks.mockFeatureResponse?.body;
+      service.getFeatureOptions(featureList);
+      expect(service.checkBoxOptions).toEqual(
+        TenantsMocks.mockFeaturesFormattedDefaultResponse
+      );
+    });
+    it('should return the empty checkbox options.', () => {
+      const featureList: Features[] = [];
+      service.getFeatureOptions(featureList);
+      expect(service.checkBoxOptions).toEqual([]);
+    });
+  });
+  describe('#getApplicationTypeOptions', () => {
+    it('should format the app type list to radio options.', () => {
+      const appTypeList = TenantsMocks.mockAppTypesResponse?.body;
+      service.getApplicationTypeOptions(appTypeList);
+      expect(service.radioOptions).toEqual(
+        TenantsMocks.mockAppTypesFormattedResponse
+      );
+    });
+    it('should return the empty radio options.', () => {
+      const featureList: AppTypeConfig[] = [];
+      service.getApplicationTypeOptions(featureList);
+      expect(service.radioOptions).toEqual([]);
+    });
+  });
+  describe('#getFeatureIds', () => {
+    it('should return the list of feature ids from the selected features.', () => {
+      const featureIds = service.getFeatureIds(
+        TenantsMocks.mockFeaturesFormattedResponse
+      );
+      expect(featureIds).toEqual(
+        TenantsMocks?.createTenantMockPayload?.payload?.features
+      );
+    });
+  });
+  describe('#setTenantInfo', () => {
+    it('should set the tenant info.', () => {
+      service.newTenantInfo = TenantsMocks?.createTenantMockPayload?.payload;
+      expect(service.getNewTenantInfo).toEqual(
+        TenantsMocks?.createTenantMockPayload?.payload
+      );
+    });
+  });
+  describe('#getTenantDetails', () => {
+    it('should return tenant details success response', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.viewTenantDetailsMockResponse)
+      );
+      service.getTenantDetails('SAAPS').subscribe((response) => {
+        expect(response).toEqual(TenantsMocks?.viewTenantDetailsMockResponse);
+      });
+    });
+    it('should return custom error in retrieving tenant details', (done) => {
+      const mockGetViewTenantsErrorResponse = {
+        error: {
+          status: false,
+          message: 'Tenant Details not found.',
+          body: { errorCodes: ['2050'] },
+        },
+        status: 404,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetViewTenantsErrorResponse))
+      );
+      service.getTenantDetails('').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+    it('should return error in retrieving tenant details', (done) => {
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(
+          () => new HttpErrorResponse(TenantsMocks.viewTenantErrorResponse)
+        )
+      );
+      service.getTenantDetails('').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#updateTenantStatus', () => {
+    it('should update tenant status successfully', () => {
+      spyOn(httpService, 'putData').and.returnValue(
+        of(updateTenantStatusMockResponse)
+      );
+      service
+        .updateTenantStatus(updateTenantStatusMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(updateTenantStatusMockResponse);
+        });
+    });
+    it('should throw a custom error while updating the status is failed.', (done) => {
+      const mockUpdateTenantStatusErrorResponse = {
+        error: {
+          status: false,
+          message: 'Application Id does not exist.',
+          body: { errorCodes: ['2041'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(
+          () => new HttpErrorResponse(mockUpdateTenantStatusErrorResponse)
+        )
+      );
+      service
+        .updateTenantStatus(TenantsMocks.updateTenantStatusPayloadWithoutAppId)
+        .subscribe({
+          next: () => {
+            done();
+          },
+          error: (error: HttpErrorResponse) => {
+            done();
+            expect(error).toBeTruthy();
+          },
+        });
+    });
+    it('should handle error while updating the tenant status', (done) => {
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.updateTenantStatus(updateTenantStatusMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#editTenant', () => {
+    it('should edit tenant details successfully', () => {
+      spyOn(httpService, 'putData').and.returnValue(
+        of(TenantsMocks.editTenantMockResponse)
+      );
+      service
+        .editTenant(TenantsMocks.editTenantMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(TenantsMocks.editTenantMockResponse);
+        });
+    });
+    it('should throw application title is required error while editing a tenant', (done) => {
+      const mockEditTenantErrorResponse = {
+        error: {
+          status: false,
+          message: 'Application Title is required.',
+          body: { errorCodes: ['2028'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      const mockEditTenantPayload =
+        TenantsMocks.mockCreateTenantPayloadMissingAppTitle;
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockEditTenantErrorResponse))
+      );
+      service.editTenant(mockEditTenantPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockEditTenantErrorResponse)
+          );
+        },
+      });
+    });
+    it('should handle error while editing a tenant is failed', (done) => {
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.createTenant(TenantsMocks.editTenantMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getFeaturesList', () => {
+    it('should format the feature list from checkbox options.', () => {
+      const featureList = TenantsMocks?.mockFeaturesFormattedResponse;
+      service.getFeaturesList(featureList);
+      expect(service.checkBoxOptions).toEqual(
+        TenantsMocks.mockFeaturesFormattedResponse
+      );
+    });
+    it('should return the feature list.', () => {
+      const featureList = TenantsMocks?.mockFeaturesFormattedResponse;
+      service.getFeaturesList(TenantsMocks?.mockFeaturesFormattedResponse);
+      expect(service.checkBoxOptions).toEqual(featureList);
+    });
+  });
+  describe('#getRoleTypes', () => {
+    it('should return role types success response', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(getRoleTypesMockResponse)
+      );
+      service.getRoleTypes(getRoleTypeMockPayload).subscribe((response) => {
+        expect(response).toEqual(getRoleTypesMockResponse);
+      });
+    });
+    it('should throw custom error if role typed not found while retrieving role types from http service', (done) => {
+      const mockGetRoleTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Type not found.',
+          body: { errorCodes: ['3014'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetRoleTypesErrorResponse))
+      );
+      service.getRoleTypes(getRoleTypeMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockGetRoleTypesErrorResponse)
+          );
+        },
+      });
+    });
+    it('should throw custom error if role type is already exists', (done) => {
+      const mockGetRoleTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Type is already exists.',
+          body: { errorCodes: ['3012'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetRoleTypesErrorResponse))
+      );
+      service.getRoleTypes(getRoleTypeMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockGetRoleTypesErrorResponse)
+          );
+        },
+      });
+    });
+    it('should throw custom error when role name is empty', (done) => {
+      const mockGetRoleTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Name is required.',
+          body: { errorCodes: ['3016'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetRoleTypesErrorResponse))
+      );
+      service.getRoleTypes(getRoleTypeMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockGetRoleTypesErrorResponse)
+          );
+        },
+      });
+    });
+    it('should return Internal Server Error error while getting role types', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => errorResponse)
+      );
+      service.getRoleTypes(getRoleTypeMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getRoleTypeOptions', () => {
+    it('should format the role type list to select options.', () => {
+      const roleTypeList = TenantsMocks.mockRoleTypesResponse?.body;
+      service.getRoleTypeOptions(roleTypeList);
+      expect(service.roleTypeOptions).toEqual(
+        TenantsMocks.mockRoleTypesFormattedResponse
+      );
+    });
+    it('should return the empty role type options.', () => {
+      const roleTypeList: RoleTypeConfiguration[] = [];
+      service.getRoleTypeOptions(roleTypeList);
+      expect(service.roleTypeOptions).toEqual([]);
+    });
+  });
+
+  describe('#createRole', () => {
+    it('should create new role successfully', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(createRoleMockResponse)
+      );
+      service.createRole(createRoleMockPayload).subscribe((response) => {
+        expect(response).toEqual(createRoleMockResponse);
+      });
+    });
+    it('should throw custom error for creating a new role when role type is empty', (done) => {
+      const mockCreateRoleErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role type is required.',
+          body: { errorCodes: ['3014'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      const mockCreateRolePayload =
+        TenantsMocks.mockCreateRolePayloadMissingRoleType;
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockCreateRoleErrorResponse))
+      );
+      service.createRole(mockCreateRolePayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockCreateRoleErrorResponse)
+          );
+        },
+      });
+    });
+    it('should handle error while creating a role is failed', (done) => {
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.createRole(createRoleMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#setNewlyCreatedRoleInfo', () => {
+    it('should set the create role info.', () => {
+      service.newlyCreatedRole = TenantsMocks?.createRoleMockPayload?.payload;
+      expect(service.getNewlyCreatedRoleInfo()).toEqual(
+        TenantsMocks?.createRoleMockPayload?.payload
+      );
+    });
+  });
+  describe('#deleteRole', () => {
+    it('should delete the role successfully', () => {
+      spyOn(httpService, 'putData').and.returnValue(
+        of(TenantsMocks.deleteRoleMockResponse)
+      );
+      service
+        .deleteRole(TenantsMocks.deleteRoleMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(TenantsMocks.deleteRoleMockResponse);
+        });
+    });
+    it('should throw Role Id not found error while deleting the role', (done) => {
+      const mockDeleteRoleErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Id not found.',
+          body: { errorCodes: ['3010'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockDeleteRoleErrorResponse))
+      );
+      service.deleteRole(TenantsMocks.deleteRoleMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockDeleteRoleErrorResponse)
+          );
+        },
+      });
+    });
+    it('should handle error while deleting a role is failed', (done) => {
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.deleteRole(TenantsMocks.deleteRoleMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#editRole', () => {
+    it('should update the modified role successfully', () => {
+      spyOn(httpService, 'putData').and.returnValue(of(editRoleMockResponse));
+      service.editRole(createRoleMockPayload).subscribe((response) => {
+        expect(response).toEqual(editRoleMockResponse);
+      });
+    });
+    it('should throw custom error for updating a role when role name is empty', (done) => {
+      const mockEditRoleErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Name is required.',
+          body: { errorCodes: ['3016'] },
+        },
+        status: 400,
+        statusText: 'OK',
+      };
+      const mockEditRolePayload =
+        TenantsMocks.mockEditRolePayloadMissingRoleName;
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockEditRoleErrorResponse))
+      );
+      service.editRole(mockEditRolePayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toEqual(
+            new HttpErrorResponse(mockEditRoleErrorResponse)
+          );
+        },
+      });
+    });
+    it('should handle error while creating a role is failed', (done) => {
+      spyOn(httpService, 'putData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockErrorResponse))
+      );
+      service.editRole(createRoleMockPayload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#setRolesInfo', () => {
+    it('should set the role info list.', () => {
+      service.setRolesInfo(TenantsMocks?.mockUserRoles?.body);
+      expect(service.getRolesInfo()).toEqual(TenantsMocks?.mockUserRoles?.body);
+    });
+  });
+  describe('#setSelectedRoleInformation', () => {
+    it('should set the selected role information.', () => {
+      service.setSelectedRoleInformation(TenantsMocks?.mockRoleInfo);
+      expect(service.getSelectedRoleInformation()).toEqual(
+        TenantsMocks?.mockRoleInfo
+      );
+    });
+  });
+  describe('#setRoleTypeOption', () => {
+    it('should set the selected role type option.', () => {
+      service.setRoleTypeOption(TenantsMocks?.mockRoleTypesFormattedResponse);
+      expect(service.getRoleTypeOption()).toEqual(
+        TenantsMocks?.mockRoleTypesFormattedResponse
+      );
+    });
+  });
+  describe('#getPermissions', () => {
+    it('should get the permissions configured for the tenant', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.permissionsSuccessResponse)
+      );
+      service.getPermissions('SAAPS').subscribe((response) => {
+        expect(response).toEqual(TenantsMocks.permissionsSuccessResponse);
+      });
+    });
+    it('should return error in retrieving permissions list', (done) => {
+      const mockPermissionsErrorResponse =
+        TenantsMocks.permissionsFailureResponse;
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockPermissionsErrorResponse))
+      );
+      service.getPermissions('SAAPS').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getRolePermissionMapping', () => {
+    it('should get the permissions based on the role selection.', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.getPermissionsByRoleIdSuccessResponse)
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: null,
+          roleId: 'RT_NESC_6537b7bc-2006-4395-9d77-b2e31d1db522',
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe((response) => {
+        expect(response).toEqual(
+          TenantsMocks.getPermissionsByRoleIdSuccessResponse
+        );
+      });
+    });
+    it('should return error while retrieving permissions list based on role selection.', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(errorResponse))
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: null,
+          roleId: 'RT_NESC_6537b7bc-2006-4395-9d77-b2e31d1db522',
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+    it('should get the roles based on the permission selection.', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.getRolesByPermissionIdSuccessResponse)
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: 'PERM_NESC_68041ee9-3035-4136-9091-db42700a6204',
+          roleId: null,
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe((response) => {
+        expect(response).toEqual(
+          TenantsMocks.getRolesByPermissionIdSuccessResponse
+        );
+      });
+    });
+    it('should return error while retrieving roles based on permission selection.', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(errorResponse))
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: 'PERM_NESC_68041ee9-3035-4136-9091-db42700a6204',
+          roleId: null,
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+    it('should get the permissions based on the role and permission selection.', () => {
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.getPermissionsByRoleIdAndPermissionIdSuccessResponse)
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: 'PERM_NESC_68041ee9-3035-4136-9091-db42700a6204',
+          roleId: 'RT_NESC_6537b7bc-2006-4395-9d77-b2e31d1db522',
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe((response) => {
+        expect(response).toEqual(
+          TenantsMocks.getPermissionsByRoleIdAndPermissionIdSuccessResponse
+        );
+      });
+    });
+    it('should return error while retrieving permissions list based on role selection.', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(errorResponse))
+      );
+      const payload: RolePermissionMappingRequestPayload = {
+        payload: {
+          appId: 'NESC',
+          permissionId: null,
+          roleId: 'RT_NESC_6537b7bc-2006-4395-9d77-b2e31d1db522',
+        },
+      };
+      service.getRolePermissionMapping(payload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#saveRolePermissionMapping', () => {
+    it('should save the role and permissions mapping changes.', () => {
+      const payload: RolesAndPermissionsRequestPayload = {
+        payload: [
+          {
+            appId: 'NESC',
+            permissionId: 'PERM_NESC_c05ff592-7178-4614-b730-7a7a8828824e',
+            roleId: 'RT_NESC_44e33b17-053c-4e0f-9d01-71b5604cbc7f',
+            status: true,
+          },
+        ],
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        of(TenantsMocks.saveRolePermissionMappingSuccessResponse)
+      );
+      service.saveRolePermissionMapping(payload).subscribe((response) => {
+        expect(response).toEqual(
+          TenantsMocks.saveRolePermissionMappingSuccessResponse
+        );
+      });
+    });
+    it('should return error while saving roles and permissions.', (done) => {
+      const errorResponse = { status: 500, message: 'Internal Server Error' };
+      const payload: RolesAndPermissionsRequestPayload = {
+        payload: [
+          {
+            appId: 'NESC',
+            permissionId: 'PERM_NESC_c05ff592-7178-4614-b730-7a7a8828824e',
+            roleId: 'RT_NESC_44e33b17-053c-4e0f-9d01-71b5604cbc7f',
+            status: true,
+          },
+        ],
+      };
+      spyOn(httpService, 'postData').and.returnValue(
+        throwError(() => new HttpErrorResponse(errorResponse))
+      );
+      service.saveRolePermissionMapping(payload).subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+  describe('#getGroupTypes', () => {
+    it('should return group types success response', () => {
+      spyOn(httpService, 'getData').and.returnValue(
+        of(TenantsMocks.mockGroupTypeResponse)
+      );
+      service.getGroupTypes('testAppId').subscribe((response) => {
+        expect(response).toEqual(TenantsMocks?.mockGroupTypeResponse);
+      });
+    });
+    it('should return custom error in retrieving group types', (done) => {
+      const mockGetGroupTypesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Group Type(s) not found.',
+          body: { errorCodes: ['1010'] },
+        },
+        status: 404,
+        statusText: 'OK',
+      };
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(() => new HttpErrorResponse(mockGetGroupTypesErrorResponse))
+      );
+      service.getGroupTypes('').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+    it('should return error in retrieving group types', (done) => {
+      spyOn(httpService, 'getData').and.returnValue(
+        throwError(
+          () =>
+            new HttpErrorResponse({
+              error: 'Test error',
+              status: 500,
+              statusText: 'Internal server error',
+            })
+        )
+      );
+      service.getGroupTypes('').subscribe({
+        next: () => {
+          done();
+        },
+        error: (error: HttpErrorResponse) => {
+          done();
+          expect(error).toBeTruthy();
+        },
+      });
+    });
+  });
+
+  describe('#setGroupTypeDetails', () => {
+    it('should call setGroupTypeDetails method and set setGroupTypeDetails', () => {
+      const setGroupTypeDetailsSpy = spyOn(
+        service,
+        'setGroupTypeDetails'
+      ).and.callThrough();
+      service.setGroupTypeDetails(TenantsMocks.mockGroupTypeResponse);
+      expect(setGroupTypeDetailsSpy).toHaveBeenCalledWith(
+        TenantsMocks.mockGroupTypeResponse
+      );
+    });
+  });
+  describe('#getGroupTypeDetails', () => {
+    it('should return group type details', () => {
+      service.setGroupTypeDetails(TenantsMocks.mockGroupTypeResponse);
+      expect(service.getGroupTypeDetails()).toEqual(
+        TenantsMocks.mockGroupTypeResponse
+      );
+    });
+  });
+});