Merge branch 'dspace-cris-2023_02_x' into gdpr-metrics_2023_02_x_DSC-1413

Author: FrancescoMolinaro

src/app/collection-page/collection-page.component.spec.ts

@@ -0,0 +1,144 @@
+import { ComponentFixture, TestBed, fakeAsync } from '@angular/core/testing';
+import { CollectionPageComponent } from './collection-page.component';
+import { ActivatedRoute, Router } from '@angular/router';
+import { of } from 'rxjs';
+import { CollectionDataService } from '../core/data/collection-data.service';
+import { AuthService } from '../core/auth/auth.service';
+import { PaginationService } from '../core/pagination/pagination.service';
+import { AuthorizationDataService } from '../core/data/feature-authorization/authorization-data.service';
+import { DSONameService } from '../core/breadcrumbs/dso-name.service';
+import { APP_CONFIG } from '../../../src/config/app-config.interface';
+import { PLATFORM_ID } from '@angular/core';
+import { ActivatedRouteStub } from '../shared/testing/active-router.stub';
+import { RouterStub } from '../shared/testing/router.stub';
+import { environment } from 'src/environments/environment.test';
+import { createSuccessfulRemoteDataObject$ } from '../shared/remote-data.utils';
+import { Collection } from '../core/shared/collection.model';
+import { SearchService } from '../core/shared/search/search.service';
+import { By } from '@angular/platform-browser';
+import { FormsModule } from '@angular/forms';
+import { RouterTestingModule } from '@angular/router/testing';
+import { TranslateModule } from '@ngx-translate/core';
+import { VarDirective } from '../shared/utils/var.directive';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { Bitstream } from '../core/shared/bitstream.model';
+
+describe('CollectionPageComponent', () => {
+  let component: CollectionPageComponent;
+  let compAsAny: any;
+  let fixture: ComponentFixture<CollectionPageComponent>;
+
+  let collectionDataServiceSpy: jasmine.SpyObj<CollectionDataService>;
+  let authServiceSpy: jasmine.SpyObj<AuthService>;
+  let paginationServiceSpy: jasmine.SpyObj<PaginationService>;
+  let authorizationDataServiceSpy: jasmine.SpyObj<AuthorizationDataService>;
+  let dsoNameServiceSpy: jasmine.SpyObj<DSONameService>;
+  let searchServiceSpy: jasmine.SpyObj<SearchService>;
+  let aroute = new ActivatedRouteStub();
+  let router = new RouterStub();
+
+  const collection = Object.assign(new Collection(), {});
+
+  beforeEach(async () => {
+    authServiceSpy = jasmine.createSpyObj('AuthService', ['isAuthenticated']);
+    paginationServiceSpy = jasmine.createSpyObj('PaginationService', ['getCurrentPagination', 'getCurrentSort', 'clearPagination']);
+    authorizationDataServiceSpy = jasmine.createSpyObj('AuthorizationDataService', ['isAuthorized']);
+    collectionDataServiceSpy = jasmine.createSpyObj('CollectionDataService', ['findById', 'getAuthorizedCollection']);
+    searchServiceSpy = jasmine.createSpyObj('SearchService', ['search']);
+    dsoNameServiceSpy = jasmine.createSpyObj('DSONameService', ['getName']);
+
+    await TestBed.configureTestingModule({
+      imports: [RouterTestingModule, FormsModule, TranslateModule.forRoot(), BrowserAnimationsModule],
+      declarations: [CollectionPageComponent, VarDirective],
+      providers: [
+        { provide: ActivatedRoute, useValue: aroute },
+        { provide: Router, useValue: router },
+        { provide: CollectionDataService, useValue: collectionDataServiceSpy },
+        { provide: AuthService, useValue: authServiceSpy },
+        { provide: PaginationService, useValue: paginationServiceSpy },
+        { provide: AuthorizationDataService, useValue: authorizationDataServiceSpy },
+        { provide: DSONameService, useValue: dsoNameServiceSpy },
+        { provide: SearchService, useValue: searchServiceSpy },
+        { provide: APP_CONFIG, useValue: environment },
+        { provide: PLATFORM_ID, useValue: 'browser' },
+      ]
+    })
+      .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CollectionPageComponent);
+    component = fixture.componentInstance;
+    compAsAny = component as any;
+    component.collectionRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Collection(), {
+      name: 'Test Collection',
+    }));
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should initialize the component', () => {
+    const routeData = {
+      dso: createSuccessfulRemoteDataObject$(collection),
+    };
+    Object.defineProperty(TestBed.inject(ActivatedRoute), 'data', {
+      get: () => of(routeData),
+    });
+    authorizationDataServiceSpy.isAuthorized.and.returnValue(of(true));
+    component.ngOnInit();
+
+    expect(component.collectionRD$).toBeDefined();
+    expect(component.logoRD$).toBeDefined();
+    expect(component.isCollectionAdmin$).toBeDefined();
+    expect(compAsAny.paginationChanges$).toBeDefined();
+    expect(component.itemRD$).toBeDefined();
+    expect(component.collectionPageRoute$).toBeDefined();
+  });
+
+  it('should display collection name', fakeAsync(() => {
+    component.collectionRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Collection(), {
+      name: 'Test Collection',
+    }));
+    fixture.detectChanges();
+    fixture.whenStable().then(() => {
+      const collectionNameElement = fixture.debugElement.query(By.css('ds-comcol-page-header')).nativeElement;
+      expect(collectionNameElement.textContent.trim()).toBe('Test Collection');
+    });
+  }));
+
+  it('should display collection logo if available', () => {
+    component.collectionRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Collection(), {
+      name: 'Test Collection',
+    }));
+    component.logoRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Bitstream(), {
+      name: 'Test Logo',
+    }));
+    fixture.detectChanges();
+
+    fixture.whenStable().then(() => {
+      const logoElement = fixture.debugElement.query(By.css('ds-comcol-page-logo')).nativeElement;
+      expect(logoElement).toBeTruthy();
+    });
+  });
+
+  it('should not display collection logo if not available', () => {
+    component.collectionRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Collection(), {
+      name: 'Test Collection',
+    }));
+    component.logoRD$ = of({ hasSucceeded: false, payload: null }) as any;
+    fixture.detectChanges();
+
+    fixture.whenStable().then(() => {
+      const logoElement = fixture.debugElement.query(By.css('ds-comcol-page-logo'));
+      expect(logoElement).toBeNull();
+    });
+  });
+
+  it('should clear pagination on ngOnDestroy', () => {
+    component.ngOnDestroy();
+    expect(paginationServiceSpy.clearPagination).toHaveBeenCalledWith(component.paginationConfig.id);
+  });
+});

src/app/community-page/community-page.component.spec.ts

@@ -0,0 +1,123 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { ActivatedRoute, Router } from '@angular/router';
+import { CommunityPageComponent } from './community-page.component';
+import { AuthService } from '../core/auth/auth.service';
+import { AuthorizationDataService } from '../core/data/feature-authorization/authorization-data.service';
+import { DSONameService } from '../core/breadcrumbs/dso-name.service';
+import { ActivatedRouteStub } from '../shared/testing/active-router.stub';
+import { RouterStub } from '../shared/testing/router.stub';
+import { RouterTestingModule } from '@angular/router/testing';
+import { FormsModule } from '@angular/forms';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { TranslateModule } from '@ngx-translate/core';
+import { VarDirective } from '../shared/utils/var.directive';
+import { createSuccessfulRemoteDataObject$ } from '../shared/remote-data.utils';
+import { Community } from '../core/shared/community.model';
+import { of } from 'rxjs';
+import { CommunityDataService } from '../core/data/community-data.service';
+import { MetadataService } from '../core/metadata/metadata.service';
+import { Bitstream } from '../core/shared/bitstream.model';
+import { By } from '@angular/platform-browser';
+
+describe('CommunityPageComponent', () => {
+  let component: CommunityPageComponent;
+  let fixture: ComponentFixture<CommunityPageComponent>;
+
+  let authServiceSpy: jasmine.SpyObj<AuthService>;
+  let authorizationDataServiceSpy: jasmine.SpyObj<AuthorizationDataService>;
+  let dsoNameServiceSpy: jasmine.SpyObj<DSONameService>;
+  let aroute = new ActivatedRouteStub();
+  let router = new RouterStub();
+
+  const community = Object.assign(new Community(), {
+    id: 'test-community',
+    uuid: 'test-community',
+    metadata: [
+      {
+        key: 'dc.title',
+        language: 'en_US',
+        value: 'test community'
+      }
+    ],
+    logo: createSuccessfulRemoteDataObject$(new Bitstream()),
+  });
+
+  beforeEach(async () => {
+    authServiceSpy = jasmine.createSpyObj('AuthService', ['isAuthenticated']);
+    authorizationDataServiceSpy = jasmine.createSpyObj('AuthorizationDataService', ['isAuthorized']);
+    dsoNameServiceSpy = jasmine.createSpyObj('DSONameService', ['getName']);
+    await TestBed.configureTestingModule({
+      imports: [RouterTestingModule, FormsModule, TranslateModule.forRoot(), BrowserAnimationsModule],
+      declarations: [CommunityPageComponent, VarDirective],
+      providers: [
+        { provide: ActivatedRoute, useValue: aroute },
+        { provide: Router, useValue: router },
+        { provide: AuthService, useValue: authServiceSpy },
+        { provide: AuthorizationDataService, useValue: authorizationDataServiceSpy },
+        { provide: DSONameService, useValue: dsoNameServiceSpy },
+        { provide: CommunityDataService, useValue: {} },
+        { provide: MetadataService, useValue: {} }
+      ]
+    }).compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(CommunityPageComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should initialize the component', () => {
+    const routeData = {
+      data: of({ dso: createSuccessfulRemoteDataObject$(community) }),
+    };
+    authorizationDataServiceSpy.isAuthorized.and.returnValue(of(true));
+
+    Object.defineProperty(TestBed.inject(ActivatedRoute), 'data', {
+      get: () => of(routeData),
+    });
+
+    component.ngOnInit();
+    expect(component.communityRD$).toBeDefined();
+    expect(component.logoRD$).toBeDefined();
+    expect(component.communityPageRoute$).toBeDefined();
+    expect(component.isCommunityAdmin$).toBeDefined();
+  });
+
+  it('should display community logo if available', () => {
+    component.communityRD$ = createSuccessfulRemoteDataObject$(community);
+    fixture.detectChanges();
+
+    fixture.whenStable().then(() => {
+      const logoElement = fixture.debugElement.query(By.css('ds-comcol-page-logo')).nativeElement;
+      expect(logoElement).toBeTruthy();
+    });
+  });
+
+
+  it('should not display community logo if not available', () => {
+    component.communityRD$ = createSuccessfulRemoteDataObject$(Object.assign(new Community(), {
+      name: 'Test',
+      logo: createSuccessfulRemoteDataObject$(null),
+    }));
+    fixture.detectChanges();
+
+    fixture.whenStable().then(() => {
+      const logoElement = fixture.debugElement.query(By.css('ds-comcol-page-logo'));
+      expect(logoElement).toBeNull();
+    });
+  });
+
+  it('should display collection name', () => {
+    component.communityRD$ = createSuccessfulRemoteDataObject$(Object.assign(community));
+    fixture.detectChanges();
+    fixture.whenStable().then(() => {
+      const collectionNameElement = fixture.debugElement.query(By.css('ds-comcol-page-header')).nativeElement;
+      expect(collectionNameElement.textContent.trim()).toBe('Test Collection');
+    });
+  });
+});

src/app/core/services/internal-link.service.spec.ts

@@ -0,0 +1,70 @@
+import { TestBed, waitForAsync } from '@angular/core/testing';
+import { InternalLinkService } from './internal-link.service';
+import { NativeWindowService } from './window.service';
+
+describe('InternalLinkService', () => {
+  let service: InternalLinkService;
+
+  beforeEach(waitForAsync(() => {
+    return TestBed.configureTestingModule({
+      providers: [
+        InternalLinkService,
+        { provide: NativeWindowService, useValue: { nativeWindow: { location: { origin: 'https://currentdomain' } } } },
+    ],
+    }).compileComponents();
+  }));
+
+  beforeEach(() => {
+    service = TestBed.inject(InternalLinkService);
+  });
+
+  describe('isLinkInternal', () => {
+    it('should return true for internal link starting with "/"', () => {
+      const result = service.isLinkInternal('/my-link');
+      expect(result).toBe(true);
+    });
+
+    it('should return true for internal link starting with currentURL', () => {
+      const result = service.isLinkInternal('https://currentdomain/my-link');
+      expect(result).toBe(true);
+    });
+
+    it('should return true for internal link starting with "currentdomain"', () => {
+      const result = service.isLinkInternal('currentdomain/my-link');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for external link', () => {
+      const result = service.isLinkInternal('https://externaldomain/my-link');
+      expect(result).toBe(false);
+    });
+
+    it('should return true for internal link without leading "/"', () => {
+      const result = service.isLinkInternal('my-link');
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('transformInternalLink', () => {
+    it('should transform internal link by removing currentURL', () => {
+      const result = service.getRelativePath('https://currentdomain/my-link');
+      expect(result).toBe('/my-link');
+    });
+
+    it('should transform internal link by adding leading "/" if missing', () => {
+      const result = service.getRelativePath('currentdomain/my-link');
+      expect(result).toBe('/my-link');
+    });
+
+    it('should return unchanged link for external link', () => {
+      const result = service.getRelativePath('https://externalDomain/my-link');
+      expect(result).toBe('https://externalDomain/my-link');
+    });
+
+    it('should return unchanged link for internal link with leading "/"', () => {
+      const result = service.getRelativePath('/my-link');
+      expect(result).toBe('/my-link');
+    });
+  });
+
+});

src/app/core/services/internal-link.service.ts

@@ -0,0 +1,57 @@
+import { Inject, Injectable } from '@angular/core';
+import { NativeWindowRef, NativeWindowService } from './window.service';
+
+/**
+ * LinkService provides utility functions for working with links, such as checking if a link is internal
+ * and transforming internal links based on the current URL.
+ */
+@Injectable()
+export class InternalLinkService {
+  currentURL = this._window.nativeWindow.location.origin;
+
+  constructor(
+    @Inject(NativeWindowService) protected _window: NativeWindowRef,
+  ) {
+
+  }
+
+  /**
+   * Check if the provided link is internal, i.e., it starts with a '/' or matches the current URL.
+   *
+   * @param link The link to be checked.
+   * @returns A boolean indicating whether the link is internal.
+   */
+  public isLinkInternal(link: string): boolean {
+    // Create a Domain object for the provided link
+    const currentDomain = new URL(this.currentURL).hostname;
+
+    return link.startsWith('/')
+      || link.startsWith(this.currentURL)
+      || link.startsWith(currentDomain)
+      || link === currentDomain
+      || !link.includes('://');
+  }
+
+  /**
+   * Get the relative path for an internal link based on the current URL.
+   *
+   * @param link The internal link to be transformed.
+   * @returns The relative path for the given internal link.
+   */
+  public getRelativePath(link: string): string {
+    // Create a Domain object for the provided link
+    const currentDomain = new URL(this.currentURL).hostname;
+
+    if (link.startsWith(this.currentURL)) {
+      const currentSegments = link.substring(this.currentURL.length);
+      return currentSegments.startsWith('/') ? currentSegments : `/${currentSegments}`;
+    }
+
+    if (link.startsWith(currentDomain)) {
+      const currentSegments = link.substring(currentDomain.length);
+      return currentSegments.startsWith('/') ? currentSegments : `/${currentSegments}`;
+    }
+
+    return link;
+  }
+}