Add a generic ItemPageLicenseFieldComponent

src/app/item-page/simple/field-components/specific-field/license/item-page-license-field.component.html

@@ -0,0 +1,31 @@
+@if (licenses.length > 0 || uris.length > 0) {
+  <div class="item-page-field">
+    @if ((hasCcLicenseName$ | async) && (hasCcLicenseUri$ | async)) {
+      <ds-item-page-cc-license-field [item]="item" [variant]="'full'"></ds-item-page-cc-license-field>
+    } @else {
+      <ds-metadata-field-wrapper [label]="'item.page.license.title' | translate">
+        @if (licenses.length === uris.length) {
+          @for (license of licenses; track license; let last=$last; let i=$index) {
+            <a [href]="uris[i]" target="_blank" class="license-link"><span class="license-text">{{ license }}</span></a>
+            @if (!last) {
+              <span class="separator" [innerHTML]="separator"></span>
+            }
+          }
+        } @else {
+          @for (license of licenses; track license; let last=$last) {
+            <span class="license-text">{{ license }}</span>
+            @if (!last || uris.length > 0) {
+              <span class="separator" [innerHTML]="separator"></span>
+            }
+          }
+          @for (uri of uris; track uri; let last=$last) {
+            <a [href]="uri" target="_blank" class="license-link"><span class="license-text">{{ uri }}</span></a>
+            @if (!last) {
+              <span class="separator" [innerHTML]="separator"></span>
+            }
+          }
+        }
+      </ds-metadata-field-wrapper>
+    }
+  </div>
+}

src/app/item-page/simple/field-components/specific-field/license/item-page-license-field.component.spec.ts

@@ -0,0 +1,299 @@
+import {
+  ChangeDetectionStrategy,
+  NO_ERRORS_SCHEMA,
+} from '@angular/core';
+import {
+  ComponentFixture,
+  TestBed,
+  waitForAsync,
+} from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { APP_CONFIG } from '@dspace/config/app-config.interface';
+import { ConfigurationDataService } from '@dspace/core/data/configuration-data.service';
+import { ConfigurationProperty } from '@dspace/core/shared/configuration-property.model';
+import { Item } from '@dspace/core/shared/item.model';
+import {
+  MetadataMap,
+  MetadataValue,
+} from '@dspace/core/shared/metadata.models';
+import { ConfigurationDataServiceStub } from '@dspace/core/testing/configuration-data.service.stub';
+import { TranslateLoaderMock } from '@dspace/core/testing/translate-loader.mock';
+import { createPaginatedList } from '@dspace/core/testing/utils.test';
+import { createSuccessfulRemoteDataObject$ } from '@dspace/core/utilities/remote-data.utils';
+import {
+  TranslateLoader,
+  TranslateModule,
+} from '@ngx-translate/core';
+
+import { environment } from '../../../../../../environments/environment';
+import { ItemPageLicenseFieldComponent } from './item-page-license-field.component';
+
+
+interface TestInstance {
+  metadata: any;
+}
+
+
+interface TestCase {
+  testInstance: TestInstance;
+  expected: {
+    render: boolean,
+    textElements: string[],
+    linkElements: string[],
+  };
+}
+
+
+const licenseNameMock = 'LICENSE NAME';
+const exampleUriMock = 'http://example.com';
+const ccUriMock = 'https://creativecommons.org/licenses/by/4.0';
+
+
+const testCases: TestCase[] = [
+  {
+    testInstance: {
+      metadata: { 'dc.rights': undefined, 'dc.rights.uri': undefined },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': [ undefined, undefined ], 'dc.rights.uri': undefined },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights.license': undefined, 'dc.rights.uri': undefined },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': undefined, 'dc.rights.license': undefined, 'dc.rights.uri': [ undefined, undefined ] },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': null, 'dc.rights.license': null, 'dc.rights.uri': null },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': null, 'dc.rights.license': null, 'dc.rights.uri': [ null, null ] },
+    },
+    expected: {
+      render: false,
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights.uri': exampleUriMock },
+    },
+    expected: {
+      render: true,
+      textElements: [exampleUriMock],
+      linkElements: [exampleUriMock],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': null, 'dc.rights.license': null, 'dc.rights.uri': exampleUriMock },
+    },
+    expected: {
+      render: true,
+      textElements: [exampleUriMock],
+      linkElements: [exampleUriMock],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights.uri': ccUriMock },
+    },
+    expected: {
+      render: true,
+      textElements: [ccUriMock],
+      linkElements: [ccUriMock],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': null, 'dc.rights.license': licenseNameMock, 'dc.rights.uri': null },
+    },
+    expected: {
+      render: true,
+      textElements: [licenseNameMock],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': licenseNameMock, 'dc.rights.uri': ccUriMock },
+    },
+    expected: {
+      render: true,
+      // This test case is delegated to ItemPageCcLicenseFieldComponent
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': licenseNameMock, 'dc.rights.license': licenseNameMock, 'dc.rights.uri': ccUriMock  },
+    },
+    expected: {
+      render: true,
+      // This test case meets the CC criteria too (since it has 'dc.rights', and 'dc.rights.uri'
+      // points to a CC license). Thus, it is delegated to ItemPageCcLicenseFieldComponent.
+      textElements: [],
+      linkElements: [],
+    },
+  },
+  {
+    testInstance: {
+      metadata: { 'dc.rights': licenseNameMock, 'dc.rights.license': licenseNameMock, 'dc.rights.uri': exampleUriMock  },
+    },
+    expected: {
+      render: true,
+      textElements: [licenseNameMock, licenseNameMock, exampleUriMock],
+      linkElements: [exampleUriMock],
+    },
+  },
+];
+
+
+// Updates the component fixture with parameters from the test instance
+function configureFixture(
+  fixture: ComponentFixture<ItemPageLicenseFieldComponent>,
+  testInstance: TestInstance,
+) {
+  const item = Object.assign(new Item(), {
+    bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+    metadata: new MetadataMap(),
+  });
+
+  for (const [key, values] of Object.entries(testInstance.metadata)) {
+    for (const value of values instanceof Array ? values : [values]) {
+      item.metadata[key] = [
+        {
+          language: 'en_US',
+          value: value,
+        },
+      ] as MetadataValue[];
+    }
+  }
+
+  let component: ItemPageLicenseFieldComponent = fixture.componentInstance;
+  component.item = item;
+
+  fixture.detectChanges();
+}
+
+
+describe('ItemPageLicenseFieldComponent', () => {
+  let fixture: ComponentFixture<ItemPageLicenseFieldComponent>;
+  let configurationDataService = new ConfigurationDataServiceStub();
+
+  beforeEach(waitForAsync(() => {
+    configurationDataService.findByPropertyName = jasmine.createSpy()
+      .withArgs('cc.license.name').and.returnValue(createSuccessfulRemoteDataObject$({
+        ... new ConfigurationProperty(),
+        name: 'cc.license.name',
+        values: [ 'dc.rights' ],
+      },
+      ))
+      .withArgs('cc.license.uri').and.returnValue(createSuccessfulRemoteDataObject$({
+        ... new ConfigurationProperty(),
+        name: 'cc.license.uri',
+        values: [ 'dc.rights.uri' ],
+      },
+      ));
+    void TestBed.configureTestingModule({
+      imports: [
+        TranslateModule.forRoot({
+          loader: {
+            provide: TranslateLoader,
+            useClass: TranslateLoaderMock,
+          },
+        }),
+        ItemPageLicenseFieldComponent,
+      ],
+      providers: [
+        { provide: APP_CONFIG, useValue: environment },
+        { provide: ConfigurationDataService, useValue: configurationDataService },
+      ],
+      schemas: [NO_ERRORS_SCHEMA],
+    })
+      .overrideComponent(ItemPageLicenseFieldComponent, {
+        set: { changeDetection: ChangeDetectionStrategy.Default },
+      })
+      .compileComponents();
+  }));
+
+  beforeEach(waitForAsync(() => {
+    fixture = TestBed.createComponent(ItemPageLicenseFieldComponent);
+  }));
+
+  testCases.forEach((testCase) => {
+    describe('', () => {
+      beforeEach(async () => {
+        configureFixture(fixture, testCase.testInstance);
+      });
+
+      it('should render or not the component',
+        () => {
+          const componentEl = fixture.debugElement.query(By.css('.item-page-field'));
+          expect(Boolean(componentEl)).toBe(testCase.expected.render);
+        },
+      );
+
+      it('should show/hide license as plain text',
+        () => {
+          const textEl = fixture.debugElement.queryAll(By.css('.license-text'));
+          expect(textEl.length).toBe(testCase.expected.textElements.length);
+          if (textEl && testCase.expected.textElements.length > 0) {
+            textEl.forEach((elt, idx) =>
+              expect(elt.nativeElement.innerHTML).toContain(testCase.expected.textElements[idx]),
+            );
+          }
+        },
+      );
+
+      it('should show/hide the license as link',
+        () => {
+          const linkEl = fixture.debugElement.queryAll(By.css('.license-link'));
+          expect(linkEl.length).toBe(testCase.expected.linkElements.length);
+          if (linkEl && testCase.expected.linkElements.length > 0) {
+            linkEl.forEach((elt, idx) =>
+              expect(elt.query(By.css('.license-text')).nativeElement.innerHTML).toContain(testCase.expected.linkElements[idx]),
+            );
+          }
+        },
+      );
+    });
+  });
+});