Test/1088 improvement (#662)

* fix(tests): fixed skipped tests

* fix(tests): added tests for skipped files

* fix(tests): fixed tests for registry and token-add-edit-form

* fix(tests): fixed tests preprint-withdrawal-submissions

* test(registry-components): added new tests

Author: dinlvkdn

jest.config.js

@@ -64,13 +64,13 @@ module.exports = {
     '<rootDir>/src/environments',
     '<rootDir>/src/app/app.config.ts',
     '<rootDir>/src/app/app.routes.ts',
-    '<rootDir>/src/app/features/files/components',
     '<rootDir>/src/app/features/files/pages/file-detail',
     '<rootDir>/src/app/features/project/addons/',
     '<rootDir>/src/app/features/project/overview/',
     '<rootDir>/src/app/features/project/registrations',
     '<rootDir>/src/app/features/project/wiki',
-    '<rootDir>/src/app/features/registry/',
+    '<rootDir>/src/app/features/registry/components',
+    '<rootDir>/src/app/features/registry/pages/registry-wiki/registry-wiki',
     '<rootDir>/src/app/features/settings/addons/',
     '<rootDir>/src/app/features/settings/tokens/store/',
     '<rootDir>/src/app/shared/components/file-menu/',

src/app/core/components/nav-menu/nav-menu.component.spec.ts

@@ -1,20 +1,66 @@
-import { TranslatePipe, TranslateService } from '@ngx-translate/core';
-import { MockPipe, MockProvider } from 'ng-mocks';
+import { MockProvider } from 'ng-mocks';
 
+import { NO_ERRORS_SCHEMA, signal } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { provideNoopAnimations } from '@angular/platform-browser/animations';
-import { ActivatedRoute } from '@angular/router';
+import { ActivatedRoute, Router } from '@angular/router';
+
+import { CustomMenuItem } from '@osf/core/models';
+import { AuthService } from '@osf/core/services';
+import { ProviderSelectors } from '@osf/core/store/provider/provider.selectors';
+import { UserSelectors } from '@osf/core/store/user/user.selectors';
+import { CurrentResourceSelectors } from '@osf/shared/stores';
 
 import { NavMenuComponent } from './nav-menu.component';
 
-describe.skip('NavMenuComponent', () => {
+import { MOCK_USER } from '@testing/mocks';
+import { OSFTestingModule } from '@testing/osf.testing.module';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
+import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
+import { provideMockStore } from '@testing/providers/store-provider.mock';
+
+describe('NavMenuComponent', () => {
   let component: NavMenuComponent;
   let fixture: ComponentFixture<NavMenuComponent>;
+  let mockAuthService: any;
 
   beforeEach(async () => {
+    Object.defineProperty(window, 'open', {
+      writable: true,
+      value: jest.fn(),
+    });
+    mockAuthService = {
+      navigateToSignIn: jest.fn(),
+      logout: jest.fn(),
+    };
+
     await TestBed.configureTestingModule({
-      imports: [NavMenuComponent, MockPipe(TranslatePipe)],
-      providers: [MockProvider(ActivatedRoute), MockProvider(TranslateService), provideNoopAnimations()],
+      imports: [NavMenuComponent, OSFTestingModule],
+      providers: [
+        provideMockStore({
+          signals: [
+            { selector: UserSelectors.isAuthenticated, value: signal(false) },
+            { selector: UserSelectors.getCurrentUser, value: signal(MOCK_USER) },
+            { selector: UserSelectors.getCanViewReviews, value: signal(false) },
+            { selector: ProviderSelectors.getCurrentProvider, value: signal(null) },
+            { selector: CurrentResourceSelectors.getCurrentResource, value: signal(null) },
+          ],
+        }),
+        {
+          provide: Router,
+          useValue: {
+            ...RouterMockBuilder.create().withUrl('/test').build(),
+            serializeUrl: jest.fn(() => '/test'),
+            parseUrl: jest.fn(() => ({})),
+            isActive: jest.fn(() => false),
+          },
+        },
+        {
+          provide: ActivatedRoute,
+          useValue: ActivatedRouteMockBuilder.create().build(),
+        },
+        MockProvider(AuthService, mockAuthService),
+      ],
+      schemas: [NO_ERRORS_SCHEMA],
     }).compileComponents();
 
     fixture = TestBed.createComponent(NavMenuComponent);
@@ -25,4 +71,121 @@ describe.skip('NavMenuComponent', () => {
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  it('should open external links in new tab for support and donate items', () => {
+    const openSpy = jest.spyOn(window, 'open');
+    const supportItem: CustomMenuItem = { id: 'support', url: 'https://support.example.com' };
+    const donateItem: CustomMenuItem = { id: 'donate', url: 'https://donate.example.com' };
+
+    component.goToLink(supportItem);
+    expect(openSpy).toHaveBeenCalledWith('https://support.example.com', '_blank');
+
+    component.goToLink(donateItem);
+    expect(openSpy).toHaveBeenCalledWith('https://donate.example.com', '_blank');
+  });
+
+  it('should navigate to sign in for sign-in item', () => {
+    const signInItem: CustomMenuItem = { id: 'sign-in' };
+
+    component.goToLink(signInItem);
+    expect(mockAuthService.navigateToSignIn).toHaveBeenCalled();
+  });
+
+  it('should logout for log-out item', () => {
+    const logOutItem: CustomMenuItem = { id: 'log-out' };
+
+    component.goToLink(logOutItem);
+    expect(mockAuthService.logout).toHaveBeenCalled();
+  });
+
+  it('should emit closeMenu for items without children', () => {
+    const emitSpy = jest.spyOn(component.closeMenu, 'emit');
+    const menuItem: CustomMenuItem = { id: 'test-item' };
+
+    component.goToLink(menuItem);
+    expect(emitSpy).toHaveBeenCalled();
+  });
+
+  it('should not emit closeMenu for items with children', () => {
+    const emitSpy = jest.spyOn(component.closeMenu, 'emit');
+    const menuItemWithChildren: CustomMenuItem = {
+      id: 'test-item',
+      items: [{ id: 'child-item' }],
+    };
+
+    component.goToLink(menuItemWithChildren);
+    expect(emitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should return false for items without items array', () => {
+    const menuItem: CustomMenuItem = { id: 'test-item' };
+    expect(component.hasVisibleChildren(menuItem)).toBe(false);
+  });
+
+  it('should return false for items with empty items array', () => {
+    const menuItem: CustomMenuItem = { id: 'test-item', items: [] };
+    expect(component.hasVisibleChildren(menuItem)).toBe(false);
+  });
+
+  it('should return false for items with all invisible children', () => {
+    const menuItem: CustomMenuItem = {
+      id: 'test-item',
+      items: [
+        { id: 'child1', visible: false },
+        { id: 'child2', visible: false },
+      ],
+    };
+    expect(component.hasVisibleChildren(menuItem)).toBe(false);
+  });
+
+  it('should return true for items with at least one visible child', () => {
+    const menuItem: CustomMenuItem = {
+      id: 'test-item',
+      items: [
+        { id: 'child1', visible: false },
+        { id: 'child2', visible: true },
+      ],
+    };
+    expect(component.hasVisibleChildren(menuItem)).toBe(true);
+  });
+
+  it('should return false for items with children that have visible property undefined', () => {
+    const menuItem: CustomMenuItem = {
+      id: 'test-item',
+      items: [{ id: 'child1' }],
+    };
+    expect(component.hasVisibleChildren(menuItem)).toBe(false);
+  });
+
+  it('should have mainMenuItems computed property', () => {
+    expect(component.mainMenuItems).toBeDefined();
+    expect(typeof component.mainMenuItems).toBe('function');
+  });
+
+  it('should have currentRoute computed property', () => {
+    expect(component.currentRoute).toBeDefined();
+  });
+
+  it('should have currentResourceId computed property', () => {
+    expect(component.currentResourceId).toBeDefined();
+    expect(typeof component.currentResourceId).toBe('function');
+  });
+
+  it('should have isCollectionsRoute computed property', () => {
+    expect(component.isCollectionsRoute).toBeDefined();
+    expect(typeof component.isCollectionsRoute).toBe('function');
+  });
+
+  it('should have isPreprintRoute computed property', () => {
+    expect(component.isPreprintRoute).toBeDefined();
+    expect(typeof component.isPreprintRoute).toBe('function');
+  });
+
+  it('should emit closeMenu event', () => {
+    const emitSpy = jest.spyOn(component.closeMenu, 'emit');
+
+    component.closeMenu.emit();
+
+    expect(emitSpy).toHaveBeenCalled();
+  });
 });

src/app/core/components/osf-banners/services/maintenance.service.spec.ts

@@ -38,7 +38,9 @@ describe('MaintenanceService', () => {
     httpMock = TestBed.inject(HttpTestingController);
   });
 
-  afterEach(() => {});
+  afterEach(() => {
+    httpMock.verify();
+  });
 
   it('should return maintenance when within window and map severity correctly', (done) => {
     service.fetchMaintenanceStatus().subscribe((result) => {

src/app/features/admin-institutions/components/admin-table/admin-table.component.spec.ts

@@ -1,43 +1,129 @@
-import { TranslatePipe, TranslateService } from '@ngx-translate/core';
-import { MockComponent, MockPipe, MockProvider } from 'ng-mocks';
+import { MockComponent, MockDirective, MockPipe } from 'ng-mocks';
 
 import { DatePipe } from '@angular/common';
 import { ComponentRef } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 
-import { TableCellData, TableColumn } from '@osf/features/admin-institutions/models';
+import { TableCellLink } from '@osf/features/admin-institutions/models';
 import { CustomPaginatorComponent } from '@shared/components';
+import { StopPropagationDirective } from '@shared/directives';
 
 import { AdminTableComponent } from './admin-table.component';
 
+import { OSFTestingModule } from '@testing/osf.testing.module';
+
 describe('AdminTableComponent', () => {
   let component: AdminTableComponent;
   let componentRef: ComponentRef<AdminTableComponent>;
   let fixture: ComponentFixture<AdminTableComponent>;
-  const mockColumns: TableColumn[] = [];
-  const mockData: TableCellData[] = [];
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       imports: [
         AdminTableComponent,
         MockComponent(CustomPaginatorComponent),
-        MockPipe(TranslatePipe),
+        OSFTestingModule,
         MockPipe(DatePipe),
+        MockComponent(CustomPaginatorComponent),
+        MockDirective(StopPropagationDirective),
       ],
-      providers: [MockProvider(TranslateService)],
     }).compileComponents();
 
     fixture = TestBed.createComponent(AdminTableComponent);
     component = fixture.componentInstance;
     componentRef = fixture.componentRef;
 
-    componentRef.setInput('tableColumns', mockColumns);
-    componentRef.setInput('tableData', mockData);
+    componentRef.setInput('tableColumns', []);
+    componentRef.setInput('tableData', []);
     fixture.detectChanges();
   });
 
   it('should create', () => {
     expect(component).toBeTruthy();
   });
+
+  it('should identify TableCellLink objects correctly', () => {
+    const link: TableCellLink = { text: 'Test', url: '/test' };
+    const stringValue = 'test string';
+    const numberValue = 123;
+
+    expect(component.isLink(link)).toBe(true);
+    expect(component.isLink(stringValue)).toBe(false);
+    expect(component.isLink(numberValue)).toBe(false);
+    expect(component.isLink(undefined)).toBe(false);
+  });
+
+  it('should identify TableCellLink arrays correctly', () => {
+    const linkArray: TableCellLink[] = [
+      { text: 'Test1', url: '/test1' },
+      { text: 'Test2', url: '/test2' },
+    ];
+    const stringArray = ['test1', 'test2'];
+    const emptyArray: any[] = [];
+
+    expect(component.isLinkArray(linkArray)).toBe(true);
+    expect(component.isLinkArray(stringArray)).toBe(false);
+    expect(component.isLinkArray(emptyArray)).toBe(true);
+    expect(component.isLinkArray(undefined)).toBe(false);
+  });
+
+  it('should get cell value for TableCellLink', () => {
+    const link: TableCellLink = { text: 'Test Link', url: '/test' };
+    const result = component.getCellValue(link);
+
+    expect(result).toBe('Test Link');
+  });
+
+  it('should compute first link correctly', () => {
+    const paginationLinks = {
+      first: { href: '/api/users?page=1' },
+      prev: { href: '/api/users?page=1' },
+      next: { href: '/api/users?page=3' },
+    };
+
+    componentRef.setInput('paginationLinks', paginationLinks);
+    fixture.detectChanges();
+
+    expect(component.firstLink()).toBe('/api/users?page=1');
+  });
+
+  it('should compute prev link correctly', () => {
+    const paginationLinks = {
+      first: { href: '/api/users?page=1' },
+      prev: { href: '/api/users?page=1' },
+      next: { href: '/api/users?page=3' },
+    };
+
+    componentRef.setInput('paginationLinks', paginationLinks);
+    fixture.detectChanges();
+
+    expect(component.prevLink()).toBe('/api/users?page=1');
+  });
+
+  it('should compute next link correctly', () => {
+    const paginationLinks = {
+      first: { href: '/api/users?page=1' },
+      prev: { href: '/api/users?page=1' },
+      next: { href: '/api/users?page=3' },
+    };
+
+    componentRef.setInput('paginationLinks', paginationLinks);
+    fixture.detectChanges();
+
+    expect(component.nextLink()).toBe('/api/users?page=3');
+  });
+
+  it('should return empty string when pagination links are undefined', () => {
+    componentRef.setInput('paginationLinks', undefined);
+    fixture.detectChanges();
+
+    expect(component.firstLink()).toBe('');
+    expect(component.prevLink()).toBe('');
+    expect(component.nextLink()).toBe('');
+  });
+
+  it('should have download menu items', () => {
+    expect(component.downloadMenuItems).toBeDefined();
+    expect(Array.isArray(component.downloadMenuItems)).toBe(true);
+  });
 });