@ieeesa-npm/tenants 0.4.2 → 0.4.4

package/src/lib/components/view-tenant-details/view-tenant-details.component.spec.ts

@@ -0,0 +1,1221 @@
+import {
+  ComponentFixture,
+  TestBed,
+  fakeAsync,
+  flush,
+  tick,
+} from '@angular/core/testing';
+import { ViewTenantDetailsComponent } from './view-tenant-details.component';
+import { TenantApplicationsService } from '../../services/tenant-applications.service';
+import {
+  AlertType,
+  AlertsService,
+  GlobalErrorHandlerService,
+} from '@ieeesa-npm/utility';
+import { Observable } from 'rxjs';
+import { TenantsMocks } from '../../assets/tenants-mock';
+import {
+  HttpBackend,
+  HttpClient,
+  HttpErrorResponse,
+  HttpHandler,
+} from '@angular/common/http';
+import { RouterTestingModule } from '@angular/router/testing';
+import { CommonModule } from '@angular/common';
+import { MatDialogModule, MatDialogRef } from '@angular/material/dialog';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { SharedService } from '@ieeesa-npm/shared';
+import { AccordionInfo } from '@presentation/models/accordion-info.model';
+import {
+  ModalComponent,
+  ModalConfirmationComponent,
+  RadioOption,
+  TableColumnType,
+} from '@ieeesa-npm/presentation';
+import { CreateTenantApplicationComponent } from '../create-tenant-application/create-tenant-application.component';
+import { RolesAndPermissions } from '../../models/roles-and-permissions.model';
+import { TableColumnSchema } from '@presentation/models/table-schema.model';
+import { TenantPermissionsService } from '../../services/tenant-permissions.service';
+import { PermissionType } from '../../models/permission-type.model';
+import { TenantFunctionType } from '../../models/tenant-function-type.model';
+import { RolesAndPermissionsMappingComponent } from '../roles-and-permissions-mapping/roles-and-permissions-mapping.component';
+
+describe('ViewTenantDetailsComponent', () => {
+  let component: ViewTenantDetailsComponent;
+  let fixture: ComponentFixture<ViewTenantDetailsComponent>;
+  let tenantsService: TenantApplicationsService;
+  let sharedService: SharedService;
+  let globalErrorHandlerService: GlobalErrorHandlerService;
+  let userPermissionService: TenantPermissionsService;
+  let alertsService: AlertsService;
+  const dialogOptions = {
+    heading: 'Tenant A',
+    isCloseNeeded: true,
+    componentReference: CreateTenantApplicationComponent,
+    modalType: 1,
+  };
+  const mapRolesAndPermissionsDialogOptions = {
+    heading: 'Map Permissions & Roles',
+    isCloseNeeded: true,
+    componentReference: RolesAndPermissionsMappingComponent,
+    modalType: 1,
+  };
+  const mockRoutePath = {
+    viewTenants: 'tenants/view-tenants-list',
+    viewTenantDetails: 'tenants/view-tenant-details',
+    createTenant: 'tenants/create-tenant',
+  };
+  const mockServerErrorResponse = new HttpErrorResponse({
+    error: 'test',
+  });
+  const mockPayload = {
+    payload: {
+      offset: 0,
+      pageSize: 10,
+    },
+  };
+  const mockUserPermissionRoles = {
+    status: true,
+    message: 'SUCCESS',
+    body: {
+      totalRecords: 174,
+      rolePermissionDetails: [
+        {
+          permissionId: 'PERM_f85ac7b1-cd9e-4ca9-88c9-fac048c4de3b',
+          permissionName:
+            'Create, View, Edit Delete Meeting Agenda Template(s)',
+          roleList: [
+            {
+              roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+              roleName: 'Admin',
+            },
+            {
+              roleId: 'ROLE_NESC_68041ee9-3035-4136-9091-db42700a6204',
+              roleName: 'NESC Secretary',
+            },
+          ],
+        },
+        {
+          permissionId: 'PERM_4239b766-c491-44a8-bc9e-38b46354a5b7',
+          permissionName: 'View Events, Meetings & Export Meetings',
+          roleList: [
+            {
+              roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+              roleName: 'Admin',
+            },
+            {
+              roleId: 'ROLE_NESC_68041ee9-3035-4136-9091-db42700a6204',
+              roleName: 'NESC Secretary',
+            },
+            {
+              roleId: 'ROLE_NESC_ec0ec0cb-94a6-482e-8c84-31c3eb2a1526',
+              roleName: 'Editor',
+            },
+          ],
+        },
+      ],
+    },
+  };
+  const mockUserRoles = {
+    status: true,
+    message: 'SUCCESS',
+    body: [
+      {
+        roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+        roleName: 'Admin',
+        roleTypeName: 'System',
+        roleType: '11',
+        viewOrder: 1,
+      },
+      {
+        roleId: 'ROLE_NESC_ec0ec0cb-94a6-482e-8c84-31c3eb2a1526',
+        roleName: 'Editor',
+        roleTypeName: 'Officer',
+        roleType: '22',
+        viewOrder: 2,
+      },
+    ],
+  };
+  const tableData = [
+    {
+      permission: 'Create, View, Edit Delete Meeting Agenda Template(s)',
+      roleIdsList: [
+        'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+        'ROLE_NESC_68041ee9-3035-4136-9091-db42700a6204',
+      ],
+    },
+    {
+      permission: 'View Events, Meetings & Export Meetings',
+      roleIdsList: [
+        'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+        'ROLE_NESC_68041ee9-3035-4136-9091-db42700a6204',
+        'ROLE_NESC_ec0ec0cb-94a6-482e-8c84-31c3eb2a1526',
+      ],
+    },
+  ];
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [
+        RouterTestingModule,
+        ViewTenantDetailsComponent,
+        CommonModule,
+        BrowserAnimationsModule,
+        MatDialogModule,
+      ],
+      providers: [
+        SharedService,
+        HttpClient,
+        HttpHandler,
+        TenantApplicationsService,
+        GlobalErrorHandlerService,
+        HttpBackend,
+        AlertsService,
+      ],
+    });
+
+    fixture = TestBed.createComponent(ViewTenantDetailsComponent);
+    component = fixture.componentInstance;
+    tenantsService = TestBed.inject(TenantApplicationsService);
+    globalErrorHandlerService = TestBed.inject(GlobalErrorHandlerService);
+    sharedService = TestBed.inject(SharedService);
+    userPermissionService = TestBed.inject(TenantPermissionsService);
+    alertsService = TestBed.inject(AlertsService);
+    component.routePaths = mockRoutePath;
+    fixture.detectChanges();
+  });
+
+  it('should create the component', () => {
+    expect(component).toBeTruthy();
+  });
+  describe('#ngOnInit', () => {
+    it('should initialize routePaths', () => {
+      component.routePaths = mockRoutePath;
+      component.ngOnInit();
+      expect(component.routePaths).toEqual(mockRoutePath);
+    });
+  });
+  describe('#showTenantDetails', () => {
+    it('should set visibility for roles and permissions if accordion id is 2', () => {
+      const getRolesSpy = spyOn(component, 'getRolesAndInitializeTableSchema');
+      const accordionInfo: AccordionInfo = {
+        id: 2,
+        title: 'Roles and Permissions',
+        isDisabled: false,
+      };
+      component.showTenantDetails(accordionInfo, true);
+      expect(component.isRolesAndPermissionsExpanded).toBe(true);
+      expect(component.columnSchema).toEqual([]);
+      expect(getRolesSpy).toHaveBeenCalled();
+    });
+    it('should not set visibility for roles and permissions if accordion id is not 2', () => {
+      const accordionInfo: AccordionInfo = {
+        id: 1,
+        title: 'Basic Details',
+        isDisabled: false,
+      };
+      component.showTenantDetails(accordionInfo, true);
+      expect(component.isRolesAndPermissionsExpanded).toBe(false);
+    });
+    it('should set visibility for group types if accordion id is 3', () => {
+      const accordionInfo: AccordionInfo = {
+        id: 3,
+        title: 'Group Types',
+        isDisabled: false,
+      };
+      component.showTenantDetails(accordionInfo, true);
+      expect(component.isGroupTypesExpanded).toEqual(true);
+    });
+  });
+  describe('#getRoles', () => {
+    it('should call get roles', () => {
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUserRoles);
+        })
+      );
+      component.getRolesAndInitializeTableSchema();
+      const columnSchema: TableColumnSchema[] = [
+        {
+          id: 0,
+          columnDef: 'permissions',
+          heading: 'PERMISSIONS',
+          columnType: TableColumnType.TEXT,
+          cellData: (element: RolesAndPermissions) => element.permission,
+          isStickyColumn: true,
+        },
+        {
+          id: 1,
+          columnDef: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+          heading: 'Admin',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: () => {
+            return;
+          },
+        },
+        {
+          id: 2,
+          columnDef: 'ROLE_NESC_ec0ec0cb-94a6-482e-8c84-31c3eb2a1526',
+          heading: 'Editor',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: () => {
+            return;
+          },
+        },
+      ];
+      expect(component.columnSchema.length).toEqual(columnSchema.length);
+      expect(component.columnSchema[0].columnDef).toEqual(
+        columnSchema[0].columnDef
+      );
+      expect(component.columnSchema[1].columnDef).toEqual(
+        columnSchema[1].columnDef
+      );
+    });
+    it('should call get roles and sortRolesByRoleType on subscription and map correct data on columnSchema ', () => {
+      const unsortedMockUserRoles = {
+        status: true,
+        message: 'SUCCESS',
+        body: [
+          {
+            roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+            roleName: 'Admin',
+            roleTypeName: 'System',
+            roleType: '11',
+            viewOrder: 1,
+          },
+          {
+            roleId: 'ROLE_NESC_3a805b6b-963e-432f-96bf-7797ec7d6eb6',
+            roleName: 'Vice Chair',
+            roleTypeName: 'Member Level',
+            roleType: '33',
+            viewOrder: 3,
+          },
+          {
+            roleId: 'ROLE_NESC_46ea2d1a-8004-485f-b0bc-9237a5ae1eb2',
+            roleName: 'Non-Voter',
+            roleTypeName: 'Officer',
+            roleType: '22',
+            viewOrder: 2,
+          },
+        ],
+      };
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(unsortedMockUserRoles);
+        })
+      );
+      const columnSchema: TableColumnSchema[] = [
+        {
+          id: 0,
+          columnDef: 'permissions',
+          heading: 'PERMISSIONS',
+          columnType: TableColumnType.TEXT,
+          cellData: (element: RolesAndPermissions) => element.permission,
+          isStickyColumn: true,
+        },
+        {
+          id: 1,
+          columnDef: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+          heading: 'Admin',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: () => {
+            return;
+          },
+        },
+        {
+          id: 2,
+          columnDef: 'ROLE_NESC_46ea2d1a-8004-485f-b0bc-9237a5ae1eb2',
+          heading: 'Editor',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: () => {
+            return;
+          },
+        },
+        {
+          id: 3,
+          columnDef: 'ROLE_NESC_3a805b6b-963e-432f-96bf-7797ec7d6eb6',
+          heading: 'Vice Chair',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: () => {
+            return;
+          },
+        },
+      ];
+      component.getRolesAndInitializeTableSchema();
+      expect(component.columnSchema.length).toEqual(columnSchema.length);
+      expect(component.columnSchema[0].columnDef).toEqual(
+        columnSchema[0].columnDef
+      );
+      expect(component.columnSchema[1].columnDef).toEqual(
+        columnSchema[1].columnDef
+      );
+      expect(component.columnSchema[2].columnDef).toEqual(
+        columnSchema[2].columnDef
+      );
+    });
+    it('should set permissions value', () => {
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUserRoles);
+        })
+      );
+      component.getRolesAndInitializeTableSchema();
+      component.columnSchema[0].cellData(tableData[0]);
+      expect(component.columnSchema[0].cellData(tableData[0])).toEqual(
+        'Create, View, Edit Delete Meeting Agenda Template(s)'
+      );
+    });
+    it('should set yes value if role id presents in roleIdsList array', () => {
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUserRoles);
+        })
+      );
+      component.getRolesAndInitializeTableSchema();
+      component.columnSchema[2].cellData(tableData[0]);
+      expect(component.columnSchema[2].cellData(tableData[0])).toEqual('No');
+    });
+    it('should set no value if role id is not presents in roleIdsList array', () => {
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUserRoles);
+        })
+      );
+      component.getRolesAndInitializeTableSchema();
+      expect(component.columnSchema[2].cellData(tableData[1])).toEqual('Yes');
+    });
+    it('should throw custom error in retrieving getRoles', () => {
+      const mockGetViewTenantsErrorResponse = {
+        error: {
+          status: false,
+          message: 'No Role(s) found.',
+          body: { errorCodes: ['3007'] },
+        },
+        status: 404,
+        statusText: 'OK',
+      };
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockGetViewTenantsErrorResponse);
+        })
+      );
+      spyOn(sharedService, 'handleErrors').and.callThrough();
+      component.getRolesAndInitializeTableSchema();
+      expect(tenantsService.getRoles).toHaveBeenCalled();
+      expect(sharedService.handleErrors).toHaveBeenCalled();
+    });
+    it('should throw and handle global error in retrieving getRoles', () => {
+      const mockServerErrorResponse = new HttpErrorResponse({
+        error: 'test',
+      });
+      spyOn(tenantsService, 'getRoles').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      spyOn(globalErrorHandlerService, 'handleError');
+      component.getRolesAndInitializeTableSchema();
+      expect(globalErrorHandlerService.handleError).toHaveBeenCalledWith(
+        mockServerErrorResponse
+      );
+    });
+  });
+  describe('#getRolesAndPermissions', () => {
+    it('should call get rolesAndPermissions', () => {
+      spyOn(tenantsService, 'getRolesAndPermissionsMappings').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUserPermissionRoles);
+        })
+      );
+      component.getRolesAndPermissionsAndInitializeTableView(mockPayload);
+      expect(component.tableData).toEqual(tableData);
+    });
+    it('should throw custom error in retrieving rolesAndPermissions', () => {
+      const mockGetViewTenantsErrorResponse = {
+        error: {
+          status: false,
+          message: 'Unable to fetch Roles and Permissions Mapping.',
+          body: { errorCodes: ['3009'] },
+        },
+        status: 404,
+        statusText: 'OK',
+      };
+      spyOn(tenantsService, 'getRolesAndPermissionsMappings').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockGetViewTenantsErrorResponse);
+        })
+      );
+      spyOn(sharedService, 'handleErrors').and.callThrough();
+      component.getRolesAndPermissionsAndInitializeTableView(mockPayload);
+      expect(tenantsService.getRolesAndPermissionsMappings).toHaveBeenCalled();
+      expect(sharedService.handleErrors).toHaveBeenCalled();
+    });
+    it('should throw and handle global error in retrieving rolesAndPermissions', () => {
+      const mockServerErrorResponse = new HttpErrorResponse({
+        error: 'test',
+      });
+      spyOn(tenantsService, 'getRolesAndPermissionsMappings').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      spyOn(globalErrorHandlerService, 'handleError');
+      component.getRolesAndPermissionsAndInitializeTableView(mockPayload);
+      expect(globalErrorHandlerService.handleError).toHaveBeenCalledWith(
+        mockServerErrorResponse
+      );
+    });
+  });
+  describe('#onTablePaginationChange', () => {
+    it('should call getRolesAndPermissionsAndInitializeTableView with updated offset or page index', () => {
+      const pageEvent = {
+        pageIndex: 1,
+        pageSize: 10,
+        length: 100,
+      };
+      const getRolesAndPermissionsAndInitializeTableViewSpy = spyOn(
+        component,
+        'getRolesAndPermissionsAndInitializeTableView'
+      );
+      component.onTablePaginationChange(pageEvent);
+      expect(
+        getRolesAndPermissionsAndInitializeTableViewSpy
+      ).toHaveBeenCalledWith({
+        payload: {
+          pageSize: 10,
+          offset: 1,
+        },
+      });
+    });
+  });
+  describe('#trackByAccordionFn', () => {
+    it('should call trackByAccordionFn method', () => {
+      const accordionId = component.trackByAccordionFn(
+        0,
+        TenantsMocks.MockTenantAccordionInfo[0] as AccordionInfo
+      );
+      expect(accordionId).toBe(1);
+    });
+  });
+  describe('#getTenantDetails', () => {
+    it('should call get view tenant details', () => {
+      const appId = 'SAAPPS';
+      spyOn(tenantsService, 'getTenantDetails').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(TenantsMocks.viewTenantDetailsMockResponse);
+        })
+      );
+      component.getTenantDetails(appId);
+      expect(component.tenantDetails).toEqual(
+        TenantsMocks.viewTenantDetailsMockResponse.body
+      );
+    });
+    it('should call get view tenant details for inactive tenant', () => {
+      const appId = 'SAAPPS';
+      const viewTenantDetailsMockResponse = JSON.parse(
+        JSON.stringify(TenantsMocks.viewTenantDetailsMockResponse)
+      );
+      viewTenantDetailsMockResponse.body.status = false;
+      spyOn(tenantsService, 'getTenantDetails').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(viewTenantDetailsMockResponse);
+        })
+      );
+      component.getTenantDetails(appId);
+      expect(component.tenantDetails).toEqual(
+        viewTenantDetailsMockResponse.body
+      );
+    });
+    it('should throw custom error in retrieving getTenantDetails', () => {
+      const mockGetViewTenantsErrorResponse = {
+        error: {
+          status: false,
+          message: 'Tenant Details not found.',
+          body: { errorCodes: ['2050'] },
+        },
+        status: 404,
+        statusText: 'OK',
+      };
+      spyOn(tenantsService, 'getTenantDetails').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockGetViewTenantsErrorResponse);
+        })
+      );
+      spyOn(sharedService, 'handleErrors').and.callThrough();
+      component.getTenantDetails('');
+      expect(tenantsService.getTenantDetails).toHaveBeenCalled();
+      expect(sharedService.handleErrors).toHaveBeenCalled();
+    });
+    it('should throw and handle global error in retrieving getTenantDetails', () => {
+      spyOn(tenantsService, 'getTenantDetails').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      spyOn(globalErrorHandlerService, 'handleError');
+      component.getTenantDetails('');
+      expect(globalErrorHandlerService.handleError).toHaveBeenCalledWith(
+        mockServerErrorResponse
+      );
+    });
+  });
+  describe('#openEditTenantForm', () => {
+    it('should call openEditTenantForm method and open modal', () => {
+      const spyOpenModal = spyOn(component, 'openModal');
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.openEditTenantForm();
+      expect(spyOpenModal).toHaveBeenCalled();
+      fixture.detectChanges();
+      component.dialog.open(ModalComponent, {
+        data: dialogOptions,
+        width: 'auto',
+        panelClass: ['ieeesa-modal-dialog'],
+        ariaModal: true,
+      });
+      expect(component.dialog.open).toHaveBeenCalledWith(ModalComponent, {
+        data: dialogOptions,
+        width: 'auto',
+        panelClass: ['ieeesa-modal-dialog'],
+        ariaModal: true,
+      });
+    });
+  });
+  describe('#getRoleTypes', () => {
+    it('should call getRoleTypes and set select options', () => {
+      const mockRoleTypes = TenantsMocks.mockRoleTypesFormattedResponse;
+      spyOn(tenantsService, 'getRoleTypes').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(TenantsMocks.mockRoleTypesResponse);
+        })
+      );
+      component.getRoleTypes();
+      expect(component.roleTypeOptions).toEqual(mockRoleTypes);
+    });
+    it('should throw error in retrieving getRoleTypes', () => {
+      const getRoleTypesSpy = spyOn(
+        tenantsService,
+        'getRoleTypes'
+      ).and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      spyOn(globalErrorHandlerService, 'handleError');
+      component.getRoleTypes();
+      expect(getRoleTypesSpy).toHaveBeenCalled();
+      expect(globalErrorHandlerService.handleError).toHaveBeenCalledWith(
+        mockServerErrorResponse
+      );
+    });
+    it('should call openCreateRoleForm method and open modal after getting roleTypeOptions from http server', () => {
+      component.functionType = TenantFunctionType.CREATE_ROLE;
+      tenantsService.setTenantFunctionType(TenantFunctionType.CREATE_ROLE);
+      const openCreateRoleFormSpy = spyOn(
+        component,
+        'openCreateRoleForm'
+      ).and.callThrough();
+      spyOn(tenantsService, 'getRoleTypes').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(TenantsMocks.mockRoleTypesResponse);
+        })
+      );
+      component.getRoleTypes();
+      expect(openCreateRoleFormSpy).toHaveBeenCalled();
+    });
+  });
+  describe('#openCreateRoleForm', () => {
+    it('should call openCreateRoleForm method and open modal', () => {
+      const spyOpenModal = spyOn(component, 'openModal');
+      const spySetFunction = spyOn(tenantsService, 'setTenantFunctionType');
+      spyOn(component.dialog, 'open').and.callThrough();
+      tenantsService.setTenantFunctionType(TenantFunctionType.CREATE_ROLE);
+      const functionType = TenantFunctionType.CREATE_ROLE;
+      component.roleTypeOptions = TenantsMocks.mockRoleTypesFormattedResponse;
+      component.openCreateRoleForm();
+      expect(spyOpenModal).toHaveBeenCalled();
+      expect(spySetFunction).toHaveBeenCalled();
+      expect(component.functionType).toEqual(functionType);
+    });
+    it('should call openCreateRoleForm method and open modal', () => {
+      const spyGetRoleTypes = spyOn(component, 'getRoleTypes');
+      component.roleTypeOptions = [];
+      component.openCreateRoleForm();
+      fixture.detectChanges();
+      expect(spyGetRoleTypes).toHaveBeenCalled();
+    });
+  });
+  describe('#openEditRoleForm', () => {
+    it('should call openEditRoleForm() and getRoleTypes() when roleTypeOptions is empty', () => {
+      const spyOpenModal = spyOn(component, 'openModal');
+      const spySetFunction = spyOn(tenantsService, 'setTenantFunctionType');
+      spyOn(component.dialog, 'open').and.callThrough();
+      const functionType = TenantFunctionType.EDIT_ROLE;
+      component.openEditRoleForm();
+      expect(spyOpenModal).toHaveBeenCalled();
+      fixture.detectChanges();
+      expect(spySetFunction).toHaveBeenCalled();
+      expect(component.functionType).toEqual(functionType);
+    });
+  });
+  describe('#openModal', () => {
+    it('should open create tenant modal with the provided className', () => {
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.openModal(dialogOptions);
+      fixture.detectChanges();
+      component.dialog.open(ModalComponent, {
+        data: dialogOptions,
+        width: 'auto',
+        panelClass: ['ieeesa-modal-dialog'],
+        ariaModal: true,
+      });
+      expect(component.dialog.open).toHaveBeenCalledWith(ModalComponent, {
+        data: dialogOptions,
+        width: 'auto',
+        panelClass: ['ieeesa-modal-dialog'],
+        ariaModal: true,
+      });
+    });
+    it('should edit the tenant successfully', () => {
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      spyOn(alertsService, 'showMessage').and.callThrough();
+      const showAlertMessageSpy = spyOn(sharedService, 'showAlertMessage');
+      component.functionType = TenantFunctionType.EDIT;
+      component.openModal(dialogOptions, 'ieeesa-modal-dialog');
+      component.dialogRef.componentInstance.submitFormResponse.next(
+        TenantsMocks.editTenantMockResponse
+      );
+      fixture.detectChanges();
+      expect(showAlertMessageSpy).toHaveBeenCalledOnceWith(
+        AlertType.SUCCESS,
+        'IEEE SA Collaboration Portal has been updated successfully.'
+      );
+    });
+    it('should handle edit tenant form submission cancel', fakeAsync(() => {
+      component.openModal(dialogOptions, 'ieeesa-modal-dialog');
+      component.dialogRef.componentInstance.formCancel.next();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const dialogRefSpy = jasmine.createSpyObj<MatDialogRef<any>>(
+        'MatDialogRef',
+        ['close']
+      );
+      expect(dialogRefSpy.close).toBeTruthy();
+      tick();
+      flush();
+    }));
+    it('should handle successful role creation and call getRolesAndPermissionsAndInitializeTableView with roleAndPermissionInfo', () => {
+      component.functionType = TenantFunctionType.CREATE_ROLE;
+      component.tenantDetails = TenantsMocks.tenantInfoMock;
+      tenantsService.setNewlyCreatedRoleInfo(TenantsMocks.mockCreateRoleInfo);
+      const getRolesAndInitializeTableSchemaSpy = spyOn(
+        component,
+        'getRolesAndInitializeTableSchema'
+      );
+      const showAlertMessageSpy = spyOn(
+        sharedService,
+        'showAlertMessage'
+      ).and.callThrough();
+      component.openModal(dialogOptions, 'ieeesa-create-role');
+      component.dialogRef.componentInstance.submitFormResponse.next(
+        TenantsMocks.createRoleMockResponse
+      );
+      fixture.detectChanges();
+      expect(showAlertMessageSpy).toHaveBeenCalledOnceWith(
+        AlertType.SUCCESS,
+        'New Secretary has been successfully added to the SA Collaboration portal. You can map the permissions for the newly added role.'
+      );
+      expect(getRolesAndInitializeTableSchemaSpy).toHaveBeenCalled();
+    });
+    it('should handle successful role modification and call getRolesAndPermissionsAndInitializeTableView with roleAndPermissionInfo', () => {
+      component.functionType = TenantFunctionType.EDIT_ROLE;
+      component.tenantDetails = TenantsMocks.tenantInfoMock;
+      tenantsService.setNewlyCreatedRoleInfo(TenantsMocks.mockCreateRoleInfo);
+      const getRolesAndInitializeTableSchemaSpy = spyOn(
+        component,
+        'getRolesAndInitializeTableSchema'
+      );
+      const showAlertMessageSpy = spyOn(
+        sharedService,
+        'showAlertMessage'
+      ).and.callThrough();
+      component.openModal(dialogOptions, 'ieeesa-edit-role');
+      component.dialogRef.componentInstance.submitFormResponse.next(
+        TenantsMocks.editRoleMockResponse
+      );
+      fixture.detectChanges();
+      expect(showAlertMessageSpy).toHaveBeenCalledOnceWith(
+        AlertType.SUCCESS,
+        'Secretary has been successfully edited for the SA Collaboration portal.'
+      );
+      expect(getRolesAndInitializeTableSchemaSpy).toHaveBeenCalled();
+    });
+    it('should call the getRolesAndInitializeTableSchema method to update the data table on formCancel event.', () => {
+      const functionTypeSpy = spyOn(
+        tenantsService,
+        'getTenantFunctionType'
+      ).and.returnValue(TenantFunctionType.MAP_PERMISSION_AND_ROLE);
+      const getRolesAndInitializeTableSchemaSpy = spyOn(
+        component,
+        'getRolesAndInitializeTableSchema'
+      );
+      component.openModal(
+        mapRolesAndPermissionsDialogOptions,
+        'map-permissions-roles'
+      );
+      component.dialogRef.componentInstance.formCancel.next(false);
+      fixture.detectChanges();
+      expect(getRolesAndInitializeTableSchemaSpy).toHaveBeenCalled();
+      expect(functionTypeSpy).toHaveBeenCalled();
+    });
+    it('should call the getRolesAndInitializeTableSchema method to update the data table on modalConfirm event.', () => {
+      const functionTypeSpy = spyOn(
+        tenantsService,
+        'getTenantFunctionType'
+      ).and.returnValue(TenantFunctionType.MAP_PERMISSION_AND_ROLE);
+      const getRolesAndInitializeTableSchemaSpy = spyOn(
+        component,
+        'getRolesAndInitializeTableSchema'
+      );
+      component.openModal(
+        mapRolesAndPermissionsDialogOptions,
+        'map-permissions-roles'
+      );
+      component.dialogRef.componentInstance.modalConfirm.next(false);
+      fixture.detectChanges();
+      expect(getRolesAndInitializeTableSchemaSpy).toHaveBeenCalled();
+      expect(functionTypeSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('#onSlideToggleChange', () => {
+    it('should open the tenant status confirmation modal when slide toggle event changes', () => {
+      const slideToggleOption = {
+        id: 1,
+        label: 'Active',
+        checked: true,
+      };
+      const openTenantStatusSpy = spyOn(
+        component,
+        'openTenantStatusConfirmationModal'
+      ).and.callThrough();
+      component.onSlideToggleChange(slideToggleOption);
+      expect(openTenantStatusSpy).toHaveBeenCalledWith(
+        slideToggleOption?.checked
+      );
+    });
+  });
+  describe('#openTenantStatusConfirmationModal', () => {
+    it('should open the tenant confirmation modal to prompt the reactivate message', fakeAsync(() => {
+      const tenantStatus = true;
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      const modalOptions = Object.assign(
+        {},
+        TenantsMocks?.openUpdateTenantStatusConfirmationModalOptions
+      );
+      const promptMessage = modalOptions?.promptMessage;
+      const status = tenantStatus ? 'reactivate' : 'inactivate';
+      modalOptions.promptMessage = `${promptMessage} ${status} ${component?.tenantDetails?.appTitle}?`;
+      spyOn(tenantsService, 'updateTenantStatus').and.callThrough();
+      component.openTenantStatusConfirmationModal(tenantStatus);
+      fixture.detectChanges();
+      expect(component.dialog.open).toHaveBeenCalledWith(
+        ModalConfirmationComponent,
+        {
+          data: modalOptions,
+          width: 'auto',
+          autoFocus: 'dialog',
+          ariaLabel: 'Alert',
+        }
+      );
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const dialogRefSpy = jasmine.createSpyObj<MatDialogRef<any>>(
+        'MatDialogRef',
+        ['close']
+      );
+      component.dialogRef.afterClosed().next(true);
+      expect(tenantsService.updateTenantStatus).toHaveBeenCalled();
+      expect(dialogRefSpy).toBeDefined();
+      expect(component.dialogRef).toBeDefined();
+      tick();
+      flush();
+    }));
+    it('should open the tenant confirmation modal to prompt the inactivate message', fakeAsync(() => {
+      const tenantStatus = false;
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      const modalOptions = Object.assign(
+        {},
+        TenantsMocks?.openUpdateTenantStatusConfirmationModalOptions
+      );
+      const promptMessage = modalOptions?.promptMessage;
+      const status = tenantStatus ? 'reactivate' : 'inactivate';
+      modalOptions.promptMessage = `${promptMessage} ${status} ${component?.tenantDetails?.appTitle}?`;
+      spyOn(tenantsService, 'updateTenantStatus').and.callThrough();
+      component.openTenantStatusConfirmationModal(tenantStatus);
+      fixture.detectChanges();
+      expect(component.dialog.open).toHaveBeenCalledWith(
+        ModalConfirmationComponent,
+        {
+          data: modalOptions,
+          width: 'auto',
+          autoFocus: 'dialog',
+          ariaLabel: 'Alert',
+        }
+      );
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const dialogRefSpy = jasmine.createSpyObj<MatDialogRef<any>>(
+        'MatDialogRef',
+        ['close']
+      );
+      component.dialogRef.afterClosed().next(false);
+      expect(tenantsService.updateTenantStatus).not.toHaveBeenCalled();
+      expect(dialogRefSpy).toBeDefined();
+      expect(component.dialogRef).toBeDefined();
+      tick();
+      flush();
+    }));
+  });
+
+  describe('#updateTenantStatus', () => {
+    it('should update the tenant status successfully.', () => {
+      const mockUpdateTenantStatusResponse =
+        TenantsMocks.updateTenantStatusMockResponse;
+      spyOn(tenantsService, 'updateTenantStatus').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUpdateTenantStatusResponse);
+        })
+      );
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      component.updateTenantStatus(true);
+      tenantsService
+        .updateTenantStatus(TenantsMocks.updateTenantStatusMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(mockUpdateTenantStatusResponse);
+        });
+    });
+    it('should update the tenant status successfully when slide toggle changed to inactive state', () => {
+      const mockUpdateTenantStatusResponse =
+        TenantsMocks.updateTenantStatusMockResponse;
+      spyOn(tenantsService, 'updateTenantStatus').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(mockUpdateTenantStatusResponse);
+        })
+      );
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      component.updateTenantStatus(false);
+      tenantsService
+        .updateTenantStatus(TenantsMocks.updateTenantStatusMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(mockUpdateTenantStatusResponse);
+        });
+    });
+    it('should show a custom error while appId is missing in the payload', () => {
+      const mockUpdateTenantsErrorResponse = {
+        error: {
+          status: false,
+          message: 'Tenant Details not found.',
+          body: { errorCodes: ['2050'] },
+        },
+        status: false,
+        statusText: 'OK',
+      };
+      spyOn(tenantsService, 'updateTenantStatus').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockUpdateTenantsErrorResponse);
+        })
+      );
+      spyOn(sharedService, 'handleErrors').and.callThrough();
+      component.updateTenantStatus(true);
+      expect(tenantsService.updateTenantStatus).toHaveBeenCalled();
+      expect(sharedService.handleErrors).toHaveBeenCalled();
+    });
+    it('should throw HttpErrorResponse while updating tenant status.', () => {
+      const mockServerErrorResponse = new HttpErrorResponse({
+        error: 'test',
+      });
+      spyOn(component, 'setSlideToggleStatus');
+      spyOn(tenantsService, 'updateTenantStatus').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      const handleErrorSpy = spyOn(sharedService, 'handleErrors');
+      component.updateTenantStatus(true);
+      expect(handleErrorSpy).toHaveBeenCalled();
+      expect(component.setSlideToggleStatus).toHaveBeenCalledWith(true);
+    });
+  });
+
+  describe('#getApplicationTypes', () => {
+    it('should call getApplicationTypes and set application types', () => {
+      const mockAppTypes: RadioOption[] =
+        TenantsMocks.mockAppTypesFormattedResponse;
+      spyOn(tenantsService, 'getApplicationTypes').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(TenantsMocks.mockAppTypesResponse);
+        })
+      );
+      component.getApplicationTypes();
+      expect(component.appTypeOptions).toEqual(mockAppTypes);
+    });
+    it('should throw error in retrieving getApplicationTypes', () => {
+      spyOn(tenantsService, 'getApplicationTypes').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      spyOn(globalErrorHandlerService, 'handleError');
+      component.getApplicationTypes();
+      expect(globalErrorHandlerService.handleError).toHaveBeenCalledWith(
+        mockServerErrorResponse
+      );
+    });
+  });
+
+  describe('#validateAccess', () => {
+    it('should call validateAccess method with MANAGE_TENANT permission type and return true', () => {
+      component.userTenantsPermissions =
+        TenantsMocks.mockGlobalTenantsPermissions;
+      const validateAccessPermissionSpy = spyOn(
+        userPermissionService,
+        'validateAccessPermission'
+      ).and.callThrough();
+      const isPermissionAccessAllowed = component.validateAccess(
+        PermissionType.MANAGE_TENANT
+      );
+      expect(validateAccessPermissionSpy).toHaveBeenCalled();
+      expect(isPermissionAccessAllowed).toBeTrue();
+    });
+  });
+
+  describe('#openDeleteRoleModal', () => {
+    it('should open the delete role confirmation modal to prompt the confirmation message', fakeAsync(() => {
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      component.selectedRoleInfo = {
+        roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+        roleName: 'Admin',
+      };
+      const modalOptions = {
+        ...TenantsMocks?.openUpdateTenantStatusConfirmationModalOptions,
+      };
+      modalOptions.promptMessage = `Are you sure you want to delete the ${component?.selectedRoleInfo?.roleName}? Deleting this role will remove all current assignments in the ${component?.tenantDetails?.appTitle}.`;
+      spyOn(tenantsService, 'deleteRole').and.callThrough();
+      component.openDeleteRoleModal();
+      fixture.detectChanges();
+      expect(component.dialog.open).toHaveBeenCalledWith(
+        ModalConfirmationComponent,
+        {
+          data: modalOptions,
+          width: '25%',
+          panelClass: [
+            'ieeesa-modal-confirm-dialog',
+            'ieeesa-delete-role-confirm-dialog',
+          ],
+          autoFocus: 'dialog',
+          ariaLabel: 'Alert',
+        }
+      );
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const dialogRefSpy = jasmine.createSpyObj<MatDialogRef<any>>(
+        'MatDialogRef',
+        ['close']
+      );
+      component.dialogRef.afterClosed().next(true);
+      expect(tenantsService.deleteRole).toHaveBeenCalled();
+      expect(dialogRefSpy).toBeDefined();
+      expect(component.dialogRef).toBeDefined();
+      tick();
+      flush();
+    }));
+    it('should set the focus to menu element if confirmation modal result is false', fakeAsync(() => {
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.tenantDetails = TenantsMocks.viewTenantDetailsMockResponse.body;
+      component.selectedRoleInfo = {
+        roleId: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+        roleName: 'Admin',
+      };
+      spyOn(component, 'deleteRole').and.callThrough();
+      const element = document.createElement('button');
+      component.roleMenuElement = element;
+      spyOn(component.roleMenuElement, 'focus').and.callThrough();
+      component.openDeleteRoleModal();
+      fixture.detectChanges();
+      component.dialogRef.afterClosed().next(false);
+      expect(component.roleMenuElement.focus).toHaveBeenCalled();
+      expect(component.deleteRole).not.toHaveBeenCalled();
+      tick();
+      flush();
+    }));
+  });
+
+  describe('#deleteRole', () => {
+    it('should delete the role successfully.', () => {
+      spyOn(tenantsService, 'deleteRole').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.next(TenantsMocks.deleteRoleMockResponse);
+        })
+      );
+      component.deleteRole();
+      tenantsService
+        .deleteRole(TenantsMocks.deleteRoleMockPayload)
+        .subscribe((response) => {
+          expect(response).toEqual(TenantsMocks.deleteRoleMockResponse);
+        });
+    });
+    it('should show a custom error while role Id is missing in the payload', () => {
+      const mockDeleteRolesErrorResponse = {
+        error: {
+          status: false,
+          message: 'Role Id not found.',
+          body: { errorCodes: ['3010'] },
+        },
+        status: false,
+        statusText: 'OK',
+      };
+      spyOn(tenantsService, 'deleteRole').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockDeleteRolesErrorResponse);
+        })
+      );
+      spyOn(sharedService, 'handleErrors').and.callThrough();
+      component.deleteRole();
+      expect(tenantsService.deleteRole).toHaveBeenCalled();
+      expect(sharedService.handleErrors).toHaveBeenCalled();
+    });
+    it('should throw HttpErrorResponse while deleting a role.', () => {
+      const mockServerErrorResponse = new HttpErrorResponse({
+        error: 'test',
+      });
+      spyOn(tenantsService, 'deleteRole').and.returnValue(
+        new Observable((subscriber) => {
+          subscriber.error(mockServerErrorResponse);
+        })
+      );
+      const handleErrorSpy = spyOn(sharedService, 'handleErrors');
+      component.deleteRole();
+      expect(handleErrorSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('#onRoleMenuClick', () => {
+    it('should invoke openDeleteRoleModal when Delete Role is clicked from the roles and permissions table menu', () => {
+      spyOn(component, 'openDeleteRoleModal');
+      const mockRoleMenuClickEvent = {
+        tableColumnInfo: {
+          id: 1,
+          columnDef: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+          heading: 'Admin',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: {},
+        },
+        menuActionInfo: {
+          id: 2,
+          label: 'Delete Role',
+          ariaLabel: 'Delete Role',
+          iconURL: '',
+          toolTip: '',
+          isToolTipNeeded: false,
+        },
+      };
+      component.onRoleMenuClick(mockRoleMenuClickEvent);
+      expect(component.selectedRoleInfo).toEqual(TenantsMocks.mockRoleInfo);
+      expect(component.openDeleteRoleModal).toHaveBeenCalled();
+    });
+    it('should invoke openEditRoleForm when Edit Role is clicked from the roles and permissions table menu', () => {
+      spyOn(component, 'openEditRoleForm');
+      const mockRoleMenuClickEvent = {
+        tableColumnInfo: {
+          id: 1,
+          columnDef: 'ROLE_NESC_edaf1dcc-229f-4d4c-9635-7ac732b4dfd8',
+          heading: 'Admin',
+          columnType: TableColumnType.TEXT,
+          hasColumnActions: true,
+          cellData: {},
+        },
+        menuActionInfo: {
+          id: 1,
+          label: 'Edit Role',
+          ariaLabel: 'Edit Role',
+          iconURL: '',
+          toolTip: '',
+          isToolTipNeeded: false,
+        },
+      };
+      component.onRoleMenuClick(mockRoleMenuClickEvent);
+      expect(component.selectedRoleInfo).toEqual(TenantsMocks.mockRoleInfo);
+      expect(component.openEditRoleForm).toHaveBeenCalled();
+    });
+  });
+  describe('#roleMenuHtmlElement', () => {
+    it('should set the role menu HTML element', () => {
+      const element = document.createElement('div');
+      component.selectedRoleMenuElement(element);
+      expect(component.roleMenuElement).toEqual(element);
+    });
+  });
+  describe('#openMapRolesAndPermissions', () => {
+    it('should call openMapRolesAndPermissionsForm method and open modal', () => {
+      spyOn(component.dialog, 'open').and.callThrough();
+      component.openMapRolesAndPermissionsForm();
+      expect(component.dialog.open).toHaveBeenCalledWith(ModalComponent, {
+        data: mapRolesAndPermissionsDialogOptions,
+        width: '',
+        panelClass: ['ieeesa-modal-dialog', 'ieeesa-map-permissions-and-roles'],
+        ariaModal: true,
+      });
+      expect(component.dialogRef).toBeDefined();
+    });
+  });
+  describe('#openCreateGroupTypeForm', () => {
+    it('should call openCreateGroupForm method and open modal', () => {
+      const spyOpenModal = spyOn(component, 'openModal');
+      const spySetFunction = spyOn(tenantsService, 'setTenantFunctionType');
+      spyOn(component.dialog, 'open').and.callThrough();
+      tenantsService.setTenantFunctionType(
+        TenantFunctionType.CREATE_GROUP_TYPE
+      );
+      const functionType = TenantFunctionType.CREATE_GROUP_TYPE;
+      component.openCreateGroupTypeForm();
+      component['tenantAppService'].setNewlyCreatedGroupTypeInfo(
+        TenantsMocks.mockCreateGroupType
+      );
+      expect(spyOpenModal).toHaveBeenCalled();
+      expect(spySetFunction).toHaveBeenCalled();
+      expect(component.functionType).toEqual(functionType);
+    });
+    it('should handle successful group type creation and emit isGroupTypeAddedOrModified', () => {
+      component.functionType = TenantFunctionType.CREATE_GROUP_TYPE;
+      const showAlertMessageSpy = spyOn(sharedService, 'showAlertMessage');
+      const groupTypeTableUpdatedSpyOn = spyOn(
+        component['tenantAppService'].isGroupTypeAddedOrModified,
+        'next'
+      );
+      component['tenantAppService'].setNewlyCreatedGroupTypeInfo(
+        TenantsMocks.mockCreateGroupType
+      );
+      component.openModal(dialogOptions, 'ieeesa-create-group-type');
+      component.dialogRef.componentInstance.submitFormResponse.next(
+        TenantsMocks.mockCreateGroupTypeSuccessResponse
+      );
+      fixture.detectChanges();
+      expect(showAlertMessageSpy).toHaveBeenCalled();
+      expect(groupTypeTableUpdatedSpyOn).toHaveBeenCalledWith(true);
+    });
+  });
+  describe('#ngOnDestroy', () => {
+    it('should perform necessary cleanup tasks on ngOnDestroy', () => {
+      component.roleTypeOptions = [];
+      spyOn(component.destroy$, 'unsubscribe');
+      component.ngOnDestroy();
+      expect(component.roleTypeOptions.length).toBe(0);
+      expect(component.destroy$.unsubscribe).toHaveBeenCalled();
+      expect(component.destroy$.next).toBeTruthy();
+    });
+  });
+});