Test/760 moderation pages (#475)

* test(moderation-pages): added tests * test(moderation-pages): added use of mocks

Author: dinlvkdn

src/app/features/moderation/pages/collection-moderation/collection-moderation.component.spec.ts

@@ -1,44 +1,45 @@
-import { MockProvider } from 'ng-mocks';
+import { MockComponents, MockProvider } from 'ng-mocks';
 
 import { BehaviorSubject } from 'rxjs';
 
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { ActivatedRoute, Router } from '@angular/router';
 
 import { IS_MEDIUM } from '@osf/shared/helpers';
+import { SelectComponent, SubHeaderComponent } from '@shared/components';
+
+import { CollectionModerationTab } from '../../enums';
 
 import { CollectionModerationComponent } from './collection-moderation.component';
 
 import { OSFTestingStoreModule } from '@testing/osf.testing.module';
+import { ActivatedRouteMockBuilder } from '@testing/providers/route-provider.mock';
+import { RouterMockBuilder } from '@testing/providers/router-provider.mock';
 
 describe('Component: Collection Moderation', () => {
  let component: CollectionModerationComponent;
  let fixture: ComponentFixture<CollectionModerationComponent>;
  let isMediumSubject: BehaviorSubject<boolean>;
-
- const mockActivatedRoute = {
- snapshot: {
- firstChild: {
- data: {
- tab: null,
- },
- },
- params: { providerId: 'osf' },
- },
- };
-
- const mockRouter = {
- navigate: jest.fn(),
- };
+ let mockRouter: ReturnType<RouterMockBuilder['build']>;
+ let mockActivatedRoute: ReturnType<ActivatedRouteMockBuilder['build']>;
 
  beforeEach(async () => {
  isMediumSubject = new BehaviorSubject<boolean>(true);
+ mockRouter = RouterMockBuilder.create().build();
+ mockActivatedRoute = ActivatedRouteMockBuilder.create()
+ .withParams({ providerId: 'test-provider-id' })
+ .withData({ tab: CollectionModerationTab.AllItems })
+ .build();
 
  await TestBed.configureTestingModule({
- imports: [CollectionModerationComponent, OSFTestingStoreModule],
+ imports: [
+ CollectionModerationComponent,
+ OSFTestingStoreModule,
+ ...MockComponents(SubHeaderComponent, SelectComponent),
+ ],
  providers: [
- { provide: ActivatedRoute, useValue: mockActivatedRoute },
- { provide: Router, useValue: mockRouter },
+ MockProvider(ActivatedRoute, mockActivatedRoute),
+ MockProvider(Router, mockRouter),
  MockProvider(IS_MEDIUM, isMediumSubject),
  ],
  }).compileComponents();
@@ -51,4 +52,144 @@ describe('Component: Collection Moderation', () => {
  it('should create', () => {
  expect(component).toBeTruthy();
  });
+
+ it('should initialize with default values', () => {
+ expect(component.selectedTab).toBeUndefined();
+ expect(component.tabOptions).toBeDefined();
+ expect(component.isMedium).toBeDefined();
+ });
+
+ it('should initialize selected tab from route data', async () => {
+ const mockFirstChild = {
+ data: { tab: CollectionModerationTab.Moderators },
+ };
+
+ const routeWithFirstChild = ActivatedRouteMockBuilder.create()
+ .withParams({ providerId: 'test-provider-id' })
+ .build();
+
+ Object.defineProperty(routeWithFirstChild.snapshot, 'firstChild', {
+ value: mockFirstChild,
+ writable: true,
+ });
+
+ await TestBed.configureTestingModule({
+ imports: [
+ CollectionModerationComponent,
+ OSFTestingStoreModule,
+ ...MockComponents(SubHeaderComponent, SelectComponent),
+ ],
+ providers: [
+ MockProvider(ActivatedRoute, routeWithFirstChild),
+ MockProvider(Router, mockRouter),
+ MockProvider(IS_MEDIUM, isMediumSubject),
+ ],
+ }).compileComponents();
+
+ const testFixture = TestBed.createComponent(CollectionModerationComponent);
+ const testComponent = testFixture.componentInstance;
+
+ testComponent.ngOnInit();
+
+ expect(testComponent.selectedTab).toBe(CollectionModerationTab.Moderators);
+ });
+
+ it('should navigate to not-found when providerId is missing', async () => {
+ const routeWithoutProviderId = ActivatedRouteMockBuilder.create().withParams({}).build();
+
+ await TestBed.configureTestingModule({
+ imports: [
+ CollectionModerationComponent,
+ OSFTestingStoreModule,
+ ...MockComponents(SubHeaderComponent, SelectComponent),
+ ],
+ providers: [
+ MockProvider(ActivatedRoute, routeWithoutProviderId),
+ MockProvider(Router, mockRouter),
+ MockProvider(IS_MEDIUM, isMediumSubject),
+ ],
+ }).compileComponents();
+
+ const testFixture = TestBed.createComponent(CollectionModerationComponent);
+ const testComponent = testFixture.componentInstance;
+
+ testComponent.ngOnInit();
+
+ expect(mockRouter.navigate).toHaveBeenCalledWith(['/not-found']);
+ });
+
+ it('should call getCollectionProvider action on init when providerId exists', () => {
+ const getCollectionProviderSpy = jest.fn();
+ component.actions = {
+ ...component.actions,
+ getCollectionProvider: getCollectionProviderSpy,
+ };
+
+ component.ngOnInit();
+
+ expect(getCollectionProviderSpy).toHaveBeenCalledWith('test-provider-id');
+ });
+
+ it('should handle tab change and navigate to new tab', () => {
+ const newTab = CollectionModerationTab.Moderators;
+
+ component.onTabChange(newTab);
+
+ expect(component.selectedTab).toBe(newTab);
+ expect(mockRouter.navigate).toHaveBeenCalledWith([newTab], { relativeTo: expect.any(Object) });
+ });
+
+ it('should call clearCurrentProvider on destroy', () => {
+ const clearCurrentProviderSpy = jest.fn();
+ component.actions = {
+ ...component.actions,
+ clearCurrentProvider: clearCurrentProviderSpy,
+ };
+
+ component.ngOnDestroy();
+
+ expect(clearCurrentProviderSpy).toHaveBeenCalled();
+ });
+
+ it('should have actions defined', () => {
+ expect(component.actions).toBeDefined();
+ expect(component.actions.getCollectionProvider).toBeDefined();
+ expect(component.actions.clearCurrentProvider).toBeDefined();
+ });
+
+ it('should have tab options defined', () => {
+ expect(component.tabOptions).toBeDefined();
+ expect(component.tabOptions.length).toBeGreaterThan(0);
+ });
+
+ it('should handle isMedium observable', () => {
+ expect(component.isMedium()).toBe(true);
+
+ isMediumSubject.next(false);
+ fixture.detectChanges();
+
+ expect(component.isMedium()).toBe(false);
+ });
+
+ it('should handle tab change with different tab values', () => {
+ const tabs = [
+ CollectionModerationTab.AllItems,
+ CollectionModerationTab.Moderators,
+ CollectionModerationTab.Settings,
+ ];
+
+ tabs.forEach((tab) => {
+ component.onTabChange(tab);
+ expect(component.selectedTab).toBe(tab);
+ expect(mockRouter.navigate).toHaveBeenCalledWith([tab], { relativeTo: expect.any(Object) });
+ });
+ });
+
+ it('should not navigate when providerId is present', () => {
+ mockActivatedRoute = ActivatedRouteMockBuilder.create().withParams({ providerId: 'valid-id' }).build();
+
+ component.ngOnInit();
+
+ expect(mockRouter.navigate).not.toHaveBeenCalledWith(['/not-found']);
+ });
 });

src/app/features/moderation/pages/my-preprint-reviewing/my-preprint-reviewing.component.spec.ts

@@ -1,39 +1,47 @@
-import { Store } from '@ngxs/store';
-
-import { TranslatePipe } from '@ngx-translate/core';
-import { MockComponents, MockPipe, MockProvider } from 'ng-mocks';
+import { MockComponents } from 'ng-mocks';
 
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 
+import {
+ MyReviewingNavigationComponent,
+ PreprintRecentActivityListComponent,
+} from '@osf/features/moderation/components';
 import { SubHeaderComponent } from '@osf/shared/components';
-import { MOCK_STORE } from '@shared/mocks';
 
-import { MyReviewingNavigationComponent, PreprintRecentActivityListComponent } from '../../components';
 import { PreprintModerationSelectors } from '../../store/preprint-moderation';
 
 import { MyPreprintReviewingComponent } from './my-preprint-reviewing.component';
 
+import { MOCK_PREPRINT_PROVIDER_MODERATION_INFO } from '@testing/mocks/preprint-provider-moderation-info.mock';
+import { MOCK_PREPRINT_REVIEW_ACTIONS } from '@testing/mocks/preprint-review-action.mock';
+import { OSFTestingStoreModule } from '@testing/osf.testing.module';
+import { provideMockStore } from '@testing/providers/store-provider.mock';
+
 describe('MyPreprintReviewingComponent', () => {
  let component: MyPreprintReviewingComponent;
  let fixture: ComponentFixture<MyPreprintReviewingComponent>;
 
- beforeEach(async () => {
- (MOCK_STORE.selectSignal as jest.Mock).mockImplementation((selector) => {
- if (selector === PreprintModerationSelectors.getPreprintProviders) return () => [];
- if (selector === PreprintModerationSelectors.arePreprintProviderLoading) return () => false;
- if (selector === PreprintModerationSelectors.getPreprintReviews) return () => [];
- if (selector === PreprintModerationSelectors.arePreprintReviewsLoading) return () => false;
- if (selector === PreprintModerationSelectors.getPreprintReviewsTotalCount) return () => 0;
- return () => null;
- });
+ const mockPreprintProviders = [MOCK_PREPRINT_PROVIDER_MODERATION_INFO];
+ const mockPreprintReviews = MOCK_PREPRINT_REVIEW_ACTIONS;
 
+ beforeEach(async () => {
  await TestBed.configureTestingModule({
  imports: [
  MyPreprintReviewingComponent,
- ...MockComponents(SubHeaderComponent, MyReviewingNavigationComponent, PreprintRecentActivityListComponent),
- MockPipe(TranslatePipe),
+ OSFTestingStoreModule,
+ ...MockComponents(SubHeaderComponent, PreprintRecentActivityListComponent, MyReviewingNavigationComponent),
+ ],
+ providers: [
+ provideMockStore({
+ signals: [
+ { selector: PreprintModerationSelectors.getPreprintProviders, value: mockPreprintProviders },
+ { selector: PreprintModerationSelectors.arePreprintProviderLoading, value: false },
+ { selector: PreprintModerationSelectors.getPreprintReviews, value: mockPreprintReviews },
+ { selector: PreprintModerationSelectors.arePreprintReviewsLoading, value: false },
+ { selector: PreprintModerationSelectors.getPreprintReviewsTotalCount, value: 2 },
+ ],
+ }),
  ],
- providers: [MockProvider(Store, MOCK_STORE)],
  }).compileComponents();
 
  fixture = TestBed.createComponent(MyPreprintReviewingComponent);
@@ -44,4 +52,24 @@ describe('MyPreprintReviewingComponent', () => {
  it('should create', () => {
  expect(component).toBeTruthy();
  });
+
+ it('should initialize with default values', () => {
+ expect(component.preprintProviders()).toEqual(mockPreprintProviders);
+ expect(component.isPreprintProvidersLoading()).toBe(false);
+ expect(component.preprintReviews()).toEqual(mockPreprintReviews);
+ expect(component.isReviewsLoading()).toBe(false);
+ expect(component.preprintReviewsTotalCount()).toBe(2);
+ });
+
+ it('should handle page change', () => {
+ expect(() => component.pageChanged(2)).not.toThrow();
+ });
+
+ it('should handle page change with different page numbers', () => {
+ const pages = [1, 2, 3, 5, 10];
+
+ pages.forEach((page) => {
+ expect(() => component.pageChanged(page)).not.toThrow();
+ });
+ });
 });