cat-documents-ng 1.0.4 → 1.0.6

package/src/lib/document/components/document-list/document-list.component.spec.ts

@@ -0,0 +1,486 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { DocumentListComponent } from './document-list.component';
+import { DocumentHttpService } from '../../services/document-http.service';
+import { DocumentListService } from '../../services/document-list.service';
+import { DocumentMenuService } from '../../services/document-menu.service';
+import { DocumentStore } from '../../state/document.store';
+import { DocumentScrollService } from '../../services/document-scroll.service';
+import { of } from 'rxjs';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { DocumentTypeModel } from '../../models/document-type.model';
+import { DocumentModel } from '../../models/document.model';
+import { DocumentListItem, DocumentListResponse } from '../../models/document-list-response.model';
+import { SHARED } from '../../../../Shared/constant/SHARED';
+
+describe('DocumentListComponent', () => {
+  let component: DocumentListComponent;
+  let fixture: ComponentFixture<DocumentListComponent>;
+  let documentHttpService: jasmine.SpyObj<DocumentHttpService>;
+  let documentListService: jasmine.SpyObj<DocumentListService>;
+  let documentMenuService: jasmine.SpyObj<DocumentMenuService>;
+  let documentStore: jasmine.SpyObj<DocumentStore>;
+  let documentScrollService: jasmine.SpyObj<DocumentScrollService>;
+
+  beforeEach(async () => {
+    // Mock services
+    documentHttpService = jasmine.createSpyObj('DocumentHttpService', ['getDocumentTypes', 'updateDocumentName']);
+    documentListService = jasmine.createSpyObj('DocumentListService', [
+      'setupDocumentListSubscription',
+      'buildDocumentCategories',
+      'refreshDocumentListForNewContext',
+      'handleTableRowClick',
+      'handleDeleteAction',
+      'refreshAllDataWithCurrentFilters',
+      'refreshDocumentList'
+    ]);
+    documentMenuService = jasmine.createSpyObj('DocumentMenuService', ['isMenuItemSectionVisible']);
+    documentStore = jasmine.createSpyObj('DocumentStore', ['setSelectedMenuItem']);
+    documentScrollService = jasmine.createSpyObj('DocumentScrollService', [
+      'setupScrollListeners',
+      'setScrolling',
+      'setupSectionObserver',
+      'resetScrollingAfterDelay',
+      'disconnectSectionObserver',
+      'cleanupScrollListeners'
+    ]);
+
+    // Mock service methods
+    documentListService.setupDocumentListSubscription.and.returnValue(of([]));
+    documentListService.buildDocumentCategories.and.returnValue({
+      documentCategories: [],
+      categoryTables: [],
+      categoryCompletionCounts: [],
+      categorySeverities: []
+    });
+    documentListService.handleTableRowClick.and.returnValue({} as DocumentListItem);
+    documentListService.handleDeleteAction.and.returnValue(of({}));
+    documentMenuService.isMenuItemSectionVisible.and.returnValue(true);
+
+    await TestBed.configureTestingModule({
+      declarations: [DocumentListComponent],
+      providers: [
+        { provide: DocumentHttpService, useValue: documentHttpService },
+        { provide: DocumentListService, useValue: documentListService },
+        { provide: DocumentMenuService, useValue: documentMenuService },
+        { provide: DocumentStore, useValue: documentStore },
+        { provide: DocumentScrollService, useValue: documentScrollService }
+      ],
+      schemas: [NO_ERRORS_SCHEMA] // To suppress schema-related errors
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(DocumentListComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges(); // Trigger lifecycle hooks and initial data binding
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should initialize with default values', () => {
+    expect(component.contextId).toBe(SHARED.EMPTY);
+    expect(component.documentListResponse).toBeNull();
+    expect(component.selectedMenuItemId).toBeNull();
+    expect(component.navigationInfo).toBeNull();
+    expect(component.isSidebarVisible).toBe(SHARED.FALSE);
+    expect(component.isdialogVisible).toBe(SHARED.FALSE);
+    expect(component.documentList).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.options).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.selectedOption).toBeNull();
+    expect(component.categoryTables).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.documentCategories).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.categoryCompletionCounts).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.categorySeverities).toEqual(SHARED.EMPTY_ARRAY);
+    expect(component.deleteMessage).toEqual(SHARED.EMPTY_ARRAY);
+  });
+
+  it('should setup document list subscription on init', () => {
+    expect(documentListService.setupDocumentListSubscription).toHaveBeenCalled();
+  });
+
+  it('should handle sidebar visibility', () => {
+    component.handleOpenSideBar(true);
+    expect(component.isSidebarVisible).toBeTrue();
+    
+    component.handleOpenSideBar(false);
+    expect(component.isSidebarVisible).toBeFalse();
+  });
+
+  it('should handle table row click', () => {
+    const mockRowData = { _id: '1', name: 'Test Document' };
+    component.handleTableRowClick(mockRowData);
+    
+    expect(component.isdialogVisible).toBe(SHARED.TRUE);
+    expect(documentListService.handleTableRowClick).toHaveBeenCalledWith(mockRowData);
+  });
+
+  it('should handle delete action', () => {
+    const mockRowData = { _id: '1', name: 'Test Document' };
+    component.contextId = 'test-context';
+    component.selectedDocument = { _id: '1' } as DocumentListItem;
+    
+    component.handleDeleteAction(mockRowData);
+    
+    expect(documentListService.handleDeleteAction).toHaveBeenCalledWith(mockRowData, 'test-context');
+  });
+
+  it('should handle dialog close and reset selected document', () => {
+    component.selectedDocument = { _id: "1" } as DocumentListItem;
+    component.fileName = 'test-file.pdf';
+    component.contextId = 'test-context';
+    
+    component.handleCloseModal();
+    
+    expect(component.isdialogVisible).toBe(SHARED.FALSE);
+    expect(component.selectedDocument).toEqual({} as DocumentListItem);
+    expect(component.fileName).toBe(SHARED.EMPTY);
+    expect(documentListService.refreshAllDataWithCurrentFilters).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should refresh document list', () => {
+    component.contextId = 'test-context';
+    component.refreshDocumentList();
+    
+    expect(documentListService.refreshDocumentList).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should refresh document list with delete action', () => {
+    component.contextId = 'test-context';
+    component.refreshDocumentList(true);
+    
+    expect(documentListService.refreshDocumentList).toHaveBeenCalledWith('test-context');
+    expect(component.deleteMessage).toEqual([{severity: SHARED.SUCCESS_SEVERITY, detail: SHARED.DOCUMENT_DELETED_SUCCESSFULLY}]);
+  });
+
+  it('should handle document status update', () => {
+    component.contextId = 'test-context';
+    
+    // Test name update action
+    component.handleDocumentStatusUpdate({ actionType: SHARED.NAME_UPDATE_ACTION });
+    expect(documentListService.refreshAllDataWithCurrentFilters).toHaveBeenCalledWith('test-context');
+    
+    // Test other actions
+    component.handleDocumentStatusUpdate({ actionType: 'other' });
+    expect(documentListService.refreshDocumentList).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should handle delete error', () => {
+    const mockError = { message: 'Delete failed' };
+    component.handleDeleteError(mockError);
+    
+    expect(component.deleteMessage).toEqual([{severity: 'error', detail: 'Delete failed'}]);
+  });
+
+  it('should handle delete success', () => {
+    component.contextId = 'test-context';
+    component.handleDeleteSuccess();
+    
+    expect(documentListService.refreshDocumentList).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should handle document name update', () => {
+    component.contextId = 'test-context';
+    component.handleDocumentNameUpdate();
+    
+    expect(documentListService.refreshAllDataWithCurrentFilters).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should handle viewer destroyed', () => {
+    component.contextId = 'test-context';
+    component.handleViewerDestroyed();
+    
+    expect(documentListService.refreshDocumentList).toHaveBeenCalledWith('test-context');
+  });
+
+  it('should build document categories', () => {
+    const mockResponse: DocumentListResponse[] = [{ 
+      label: 'Category 1', 
+      categoryDescription: 'Test category',
+      totalDocs: 0,
+      acceptedDocs: 0,
+      list: [],
+      completed: '0%'
+    }];
+    component.documentListResponse = mockResponse;
+    
+    component.buildDocumentCategories();
+    
+    expect(documentListService.buildDocumentCategories).toHaveBeenCalledWith(mockResponse);
+  });
+
+  it('should cleanup on destroy', () => {
+    spyOn(component['documentListSubscription'], 'unsubscribe');
+    
+    component.ngOnDestroy();
+    
+    expect(component['documentListSubscription'].unsubscribe).toHaveBeenCalled();
+    expect(documentScrollService.disconnectSectionObserver).toHaveBeenCalled();
+  });
+
+  describe('ngOnChanges', () => {
+    it('should handle contextId changes', () => {
+      const changes = {
+        contextId: {
+          currentValue: 'new-context',
+          previousValue: 'old-context',
+          firstChange: false,
+          isFirstChange: () => false
+        }
+      } as any;
+      
+      component.ngOnChanges(changes);
+      
+      expect(documentListService.refreshDocumentListForNewContext).toHaveBeenCalledWith('new-context');
+    });
+
+    it('should handle selectedMenuItemId changes', () => {
+      component.selectedMenuItemId = 'test-menu-item';
+      const changes = {
+        selectedMenuItemId: {
+          currentValue: 'test-menu-item',
+          previousValue: null,
+          firstChange: false,
+          isFirstChange: () => false
+        }
+      } as any;
+      
+      spyOn(component, 'scrollToCategorySection');
+      
+      component.ngOnChanges(changes);
+      
+      expect(component.scrollToCategorySection).toHaveBeenCalledWith('test-menu-item');
+    });
+
+    it('should handle navigationInfo changes', () => {
+      const navigationInfo = {
+        menuItemId: 'test-menu',
+        menuItemLabel: 'Test Menu',
+        categoryLabel: 'Test Category',
+        categoryIndex: 0
+      };
+      component.navigationInfo = navigationInfo;
+      
+      const changes = {
+        navigationInfo: {
+          currentValue: navigationInfo,
+          previousValue: null,
+          firstChange: false,
+          isFirstChange: () => false
+        }
+      } as any;
+      
+      spyOn(component, 'scrollToCategorySectionWithNavigationInfo');
+      
+      component.ngOnChanges(changes);
+      
+      expect(component.scrollToCategorySectionWithNavigationInfo).toHaveBeenCalledWith(navigationInfo);
+    });
+
+    it('should handle documentListResponse changes', () => {
+      const mockResponse: DocumentListResponse[] = [{ 
+        label: 'Category 1', 
+        categoryDescription: 'Test category',
+        totalDocs: 0,
+        acceptedDocs: 0,
+        list: [],
+        completed: '0%'
+      }];
+      
+      const changes = {
+        documentListResponse: {
+          currentValue: mockResponse,
+          previousValue: null,
+          firstChange: false,
+          isFirstChange: () => false
+        }
+      } as any;
+      
+      component.ngOnChanges(changes);
+      
+      // Since handleDocumentListFilteringChange is private, we can't spy on it directly
+      // Instead, we verify the component state changes appropriately
+      expect(component.documentListResponse).toBe(mockResponse);
+    });
+  });
+
+  describe('ngAfterViewInit', () => {
+    it('should setup scroll listeners and scroll to selected menu item', () => {
+      component.selectedMenuItemId = 'test-menu-item';
+      component.documentCategoriesContainer = { nativeElement: {} } as any;
+      
+      spyOn(component, 'scrollToCategorySection');
+      
+      component.ngAfterViewInit();
+      
+      expect(documentScrollService.setupScrollListeners).toHaveBeenCalled();
+      expect(component.scrollToCategorySection).toHaveBeenCalledWith('test-menu-item');
+    });
+  });
+
+  describe('scrollToCategorySection', () => {
+    beforeEach(() => {
+      component.documentCategories = [
+        { label: 'Application', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' },
+        { label: 'Applicant', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' },
+        { label: 'Affordability Calculators', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' },
+        { label: 'Affordability', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' }
+      ];
+      component.documentCategoriesContainer = {
+        nativeElement: {
+          querySelectorAll: jasmine.createSpy('querySelectorAll').and.returnValue([
+            { scrollIntoView: jasmine.createSpy('scrollIntoView') }
+          ])
+        }
+      } as any;
+    });
+
+    it('should scroll to exact match category when menu item matches exactly', () => {
+      component.scrollToCategorySection('affordability-calculators');
+      
+      expect(documentScrollService.setScrolling).toHaveBeenCalled();
+    });
+
+    it('should not match partial strings (affordability should not match affordability-calculators)', () => {
+      component.scrollToCategorySection('affordability');
+      
+      expect(documentScrollService.setScrolling).toHaveBeenCalled();
+      // Should match the exact "Affordability" category, not "Affordability Calculators"
+    });
+
+    it('should use legacy matching for application category', () => {
+      component.scrollToCategorySection('application-menu-item');
+      
+      expect(documentScrollService.setScrolling).toHaveBeenCalled();
+    });
+
+    it('should use legacy matching for applicant category', () => {
+      component.scrollToCategorySection('applicant-menu-item');
+      
+      expect(documentScrollService.setScrolling).toHaveBeenCalled();
+    });
+
+    it('should fall back to first category when no match found', () => {
+      component.scrollToCategorySection('nonexistent-category');
+      
+      expect(documentScrollService.setScrolling).toHaveBeenCalled();
+    });
+  });
+
+  describe('private helper methods', () => {
+    it('should convert menuItemId to readable label format', () => {
+      const result = component['convertMenuItemIdToReadableLabel']('affordability-calculators');
+      expect(result).toBe('Affordability Calculators');
+    });
+
+    it('should convert snake_case menuItemId to readable label format', () => {
+      const result = component['convertMenuItemIdToReadableLabel']('affordability_calculators');
+      expect(result).toBe('Affordability Calculators');
+    });
+
+    it('should detect substring relationships correctly', () => {
+      const isSubstring = component['isSubstringOfLongerCategory']('affordability', 'affordability calculators');
+      expect(isSubstring).toBeTrue();
+    });
+
+    it('should not detect substring when lengths are similar', () => {
+      const isSubstring = component['isSubstringOfLongerCategory']('affordability', 'affordability');
+      expect(isSubstring).toBeFalse();
+    });
+  });
+
+  describe('highlightCategory', () => {
+    it('should add and remove highlight class', (done) => {
+      const mockElement = {
+        classList: {
+          add: jasmine.createSpy('add'),
+          remove: jasmine.createSpy('remove')
+        }
+      } as any;
+      
+      component.highlightCategory(mockElement);
+      
+      expect(mockElement.classList.add).toHaveBeenCalledWith('category-highlight');
+      
+      setTimeout(() => {
+        expect(mockElement.classList.remove).toHaveBeenCalledWith('category-highlight');
+        done();
+      }, 2100);
+    });
+  });
+
+  describe('getters', () => {
+    beforeEach(() => {
+      component.documentCategories = [
+        { label: 'Category 1', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' },
+        { label: 'Category 2', categoryDescription: '', totalDocs: 0, acceptedDocs: 0, list: [], completed: '0%' }
+      ];
+    });
+
+    it('should return formatted category labels', () => {
+      expect(component.formattedCategoryLabels).toEqual(['Category 1', 'Category 2']);
+    });
+
+    it('should return safe category IDs', () => {
+      expect(component.categoryIds).toEqual(['section-category-1', 'section-category-2']);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should show delete error message with custom message', () => {
+      const error = { error: { message: 'Custom error message' } };
+      component.handleDeleteError(error);
+      
+      expect(component.deleteMessage).toEqual([{severity: 'error', detail: 'Custom error message'}]);
+    });
+
+    it('should show delete error message with fallback message', () => {
+      const error = { message: 'Fallback error message' };
+      component.handleDeleteError(error);
+      
+      expect(component.deleteMessage).toEqual([{severity: 'error', detail: 'Fallback error message'}]);
+    });
+
+    it('should show default error message when no specific message', () => {
+      const error = {};
+      component.handleDeleteError(error);
+      
+      expect(component.deleteMessage).toEqual([{severity: 'error', detail: 'Failed to delete document. Please try again.'}]);
+    });
+  });
+
+  describe('menu visibility logic', () => {
+    it('should check menu item visibility correctly', () => {
+      const mockResponse: DocumentListResponse[] = [
+        { 
+          label: 'Affordability Calculators', 
+          categoryDescription: 'Test category',
+          totalDocs: 1,
+          acceptedDocs: 0,
+          list: [{ _id: '1', fileName: 'test.pdf', docName: 'Test', fileSize: '1MB', documentUrl: 'url', status: 'pending', isUploaded: true, uploadedOn: '2023-01-01', ownerName: 'User', contentType: 'pdf' }],
+          completed: '0%'
+        }
+      ];
+      
+      component.documentListResponse = mockResponse;
+      component.selectedMenuItemId = 'affordability';
+      
+      // Mock the menu service to return false for affordability (should not match affordability calculators)
+      documentMenuService.isMenuItemSectionVisible.and.returnValue(false);
+      
+      // Trigger the filtering change
+      const changes = {
+        documentListResponse: {
+          currentValue: mockResponse,
+          previousValue: null,
+          firstChange: false,
+          isFirstChange: () => false
+        }
+      } as any;
+      
+      component.ngOnChanges(changes);
+      
+      expect(documentMenuService.isMenuItemSectionVisible).toHaveBeenCalledWith('affordability', mockResponse);
+    });
+  });
+  
+});