PD-5538

Author: cryptalith

src/app/core/record-header-state/record-header-state.service.spec.ts

@@ -0,0 +1,50 @@
+import { TestBed } from '@angular/core/testing'
+import { take } from 'rxjs/operators'
+import { getUserRecord } from '../record/record.service.spec'
+import { RecordHeaderStateService } from './record-header-state.service'
+
+describe('RecordHeaderStateService', () => {
+  let service: RecordHeaderStateService
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({})
+    service = TestBed.inject(RecordHeaderStateService)
+    service.reset()
+  })
+
+  it('should emit header loading separately from full record loading', (done) => {
+    service.setLoadingUserRecord(true)
+    service.setLoadingRecordHeader(false)
+
+    service.loadingRecordHeader$.pipe(take(1)).subscribe((loading) => {
+      expect(loading).toBeFalse()
+      done()
+    })
+  })
+
+  it('should share the latest user record with header consumers', (done) => {
+    const userRecord = getUserRecord()
+
+    service.setUserRecord(userRecord)
+
+    service.userRecord$.pipe(take(1)).subscribe((value) => {
+      expect(value).toBe(userRecord)
+      done()
+    })
+  })
+
+  it('should reset header-specific state', (done) => {
+    service.setLoadingRecordHeader(false)
+    service.setUserRecord(getUserRecord())
+
+    service.reset()
+
+    service.loadingRecordHeader$.pipe(take(1)).subscribe((loading) => {
+      expect(loading).toBeTrue()
+      service.userRecord$.pipe(take(1)).subscribe((userRecord) => {
+        expect(userRecord).toBeNull()
+        done()
+      })
+    })
+  })
+})

src/app/core/record-header-state/record-header-state.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core'
 import { BehaviorSubject } from 'rxjs'
+import { UserRecord } from 'src/app/types/record.local'
 
 /**
  * Shares state required by the Record Header between My ORCID and the Header.
@@ -8,7 +9,9 @@ import { BehaviorSubject } from 'rxjs'
 @Injectable({ providedIn: 'root' })
 export class RecordHeaderStateService {
   private readonly _loadingUserRecord = new BehaviorSubject<boolean>(true)
+  private readonly _loadingRecordHeader = new BehaviorSubject<boolean>(true)
   private readonly _isPublicRecord = new BehaviorSubject<string | null>(null)
+  private readonly _userRecord = new BehaviorSubject<UserRecord | null>(null)
   private readonly _affiliations = new BehaviorSubject<number>(0)
   private readonly _displaySideBar = new BehaviorSubject<boolean>(false)
   private readonly _displayBiography = new BehaviorSubject<boolean>(false)
@@ -17,7 +20,9 @@ export class RecordHeaderStateService {
   private readonly _hasCreditOrOtherNames = new BehaviorSubject<boolean>(false)
 
   readonly loadingUserRecord$ = this._loadingUserRecord.asObservable()
+  readonly loadingRecordHeader$ = this._loadingRecordHeader.asObservable()
   readonly isPublicRecord$ = this._isPublicRecord.asObservable()
+  readonly userRecord$ = this._userRecord.asObservable()
   readonly affiliations$ = this._affiliations.asObservable()
   readonly displaySideBar$ = this._displaySideBar.asObservable()
   readonly displayBiography$ = this._displayBiography.asObservable()
@@ -29,9 +34,15 @@ export class RecordHeaderStateService {
   setLoadingUserRecord(val: boolean) {
     this._loadingUserRecord.next(val)
   }
+  setLoadingRecordHeader(val: boolean) {
+    this._loadingRecordHeader.next(val)
+  }
   setIsPublicRecord(val: string | null) {
     this._isPublicRecord.next(val)
   }
+  setUserRecord(val: UserRecord | null) {
+    this._userRecord.next(val)
+  }
   setAffiliations(val: number) {
     this._affiliations.next(val)
   }
@@ -53,7 +64,9 @@ export class RecordHeaderStateService {
 
   reset() {
     this._loadingUserRecord.next(true)
+    this._loadingRecordHeader.next(true)
     this._isPublicRecord.next(null)
+    this._userRecord.next(null)
     this._affiliations.next(0)
     this._displaySideBar.next(false)
     this._displayBiography.next(false)

src/app/record/components/record-header/record-header.component.spec.ts

@@ -1,47 +1,72 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing'
 
 import { RecordHeaderComponent } from './record-header.component'
-import { HttpClientTestingModule } from '@angular/common/http/testing'
 import { WINDOW_PROVIDERS } from 'src/app/cdk/window'
 import { PlatformInfoService } from 'src/app/cdk/platform-info'
-import { ErrorHandlerService } from 'src/app/core/error-handler/error-handler.service'
-import { SnackbarService } from 'src/app/cdk/snackbar/snackbar.service'
-import { MatSnackBar } from '@angular/material/snack-bar'
-import { MatDialog } from '@angular/material/dialog'
-import { Overlay } from '@angular/cdk/overlay'
 import { RouterTestingModule } from '@angular/router/testing'
 import { RecordService } from 'src/app/core/record/record.service'
-
-import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core'
 import { MatTooltipModule } from '@angular/material/tooltip'
+import { of } from 'rxjs'
+import { HeaderCompactService } from 'src/app/core/header-compact/header-compact.service'
+import { RecordHeaderStateService } from 'src/app/core/record-header-state/record-header-state.service'
+import { TogglzService } from 'src/app/core/togglz/togglz.service'
+import { UserService } from 'src/app/core'
+import { getUserRecord } from 'src/app/core/record/record.service.spec'
+import { getUserSession } from 'src/app/core/user/user.service.spec'
+import { NoopAnimationsModule } from '@angular/platform-browser/animations'
+import { RumJourneyEventService } from 'src/app/rum/service/customEvent.service'
 
 describe('RecordHeaderComponent', () => {
   let component: RecordHeaderComponent
   let fixture: ComponentFixture<RecordHeaderComponent>
+  let state: RecordHeaderStateService
+  let recordService: jasmine.SpyObj<RecordService>
 
   beforeEach(async () => {
+    recordService = jasmine.createSpyObj<RecordService>('RecordService', [
+      'getRecord',
+    ])
+
     await TestBed.configureTestingModule({
       imports: [
-        HttpClientTestingModule,
         RouterTestingModule,
+        NoopAnimationsModule,
         MatTooltipModule,
         RecordHeaderComponent,
       ],
       providers: [
         WINDOW_PROVIDERS,
-        RecordService,
-        PlatformInfoService,
-        ErrorHandlerService,
-        SnackbarService,
-        MatSnackBar,
-        MatDialog,
-        Overlay,
+        RecordHeaderStateService,
+        { provide: RecordService, useValue: recordService },
+        {
+          provide: PlatformInfoService,
+          useValue: { get: () => of({ columns12: true }) },
+        },
+        {
+          provide: HeaderCompactService,
+          useValue: { compactActive$: of(false) },
+        },
+        {
+          provide: TogglzService,
+          useValue: { getStateOf: () => of(false) },
+        },
+        {
+          provide: UserService,
+          useValue: { getUserSession: () => of(getUserSession()) },
+        },
+        {
+          provide: RumJourneyEventService,
+          useValue: {
+            recordSimpleEvent: jasmine.createSpy('recordSimpleEvent'),
+          },
+        },
       ],
-      schemas: [CUSTOM_ELEMENTS_SCHEMA],
     }).compileComponents()
   })
 
   beforeEach(() => {
+    state = TestBed.inject(RecordHeaderStateService)
+    state.reset()
     fixture = TestBed.createComponent(RecordHeaderComponent)
     component = fixture.componentInstance
     fixture.detectChanges()
@@ -50,4 +75,41 @@ describe('RecordHeaderComponent', () => {
   it('should create', () => {
     expect(component).toBeTruthy()
   })
+
+  it('should render header data from shared record state', () => {
+    const userRecord = getUserRecord()
+    const orcid = userRecord.userInfo.REAL_USER_ORCID
+
+    state.setIsPublicRecord(orcid)
+    state.setLoadingRecordHeader(false)
+    state.setUserRecord(userRecord)
+    fixture.detectChanges()
+
+    const text = fixture.nativeElement.textContent
+    expect(component.bannerTitle).toBe('Published Name')
+    expect(text).toContain('Published Name')
+    expect(text).toContain(`https:${runtimeEnvironment.BASE_URL}${orcid}`)
+  })
+
+  it('should not ask RecordService to load record data for the header', () => {
+    state.setIsPublicRecord(getUserRecord().userInfo.REAL_USER_ORCID)
+    state.setLoadingRecordHeader(false)
+    state.setUserRecord(getUserRecord())
+    fixture.detectChanges()
+
+    expect(recordService.getRecord).not.toHaveBeenCalled()
+  })
+
+  it('should keep featured employment caption non-blocking', () => {
+    const userRecord = getUserRecord()
+
+    state.setIsPublicRecord(userRecord.userInfo.REAL_USER_ORCID)
+    state.setLoadingRecordHeader(false)
+    state.setUserRecord({ ...userRecord, affiliations: undefined })
+    fixture.detectChanges()
+
+    expect(component.loadingUserRecord).toBeFalse()
+    expect(component.bannerTitle).toBe('Published Name')
+    expect(component.bannerCaption).toBe('')
+  })
 })