openstapps/frontend/app/src/app/modules/profile/id-cards.spec.ts

import {ConfigProvider} from '../config/config.provider';
import {IdCardsProvider} from './id-cards.provider';
import {HttpClient} from '@angular/common/http';
import {AuthHelperService} from '../auth/auth-helper.service';
import {AuthProvider} from '../auth/auth.provider';
import {BehaviorSubject, firstValueFrom, of} from 'rxjs';
import {EncryptedStorageProvider} from '../storage/encrypted-storage.provider';
import {TestBed} from '@angular/core/testing';
import {TranslateService} from '@ngx-translate/core';
import {LoggerTestingModule} from 'ngx-logger/testing';

class FakeAuth {
  isLoggedIn$ = new BehaviorSubject(false);

  user$ = new BehaviorSubject<unknown>(undefined);

  // eslint-disable-next-line @typescript-eslint/no-empty-function
  getValidToken() {}
}

describe('IdCards', () => {
  let configProviderSpy: ConfigProvider;
  let httpClient: HttpClient;
  let encryptedStorageProvider: EncryptedStorageProvider;
  let fakeAuth: FakeAuth;

  const authHelperServiceMock = jasmine.createSpyObj('AuthHelperService', ['getUserFromUserInfo']);
  const translateServiceSpy = jasmine.createSpyObj('TranslateService', ['setDefaultLang', 'use']);

  beforeEach(() => {
    fakeAuth = new FakeAuth();
    configProviderSpy = jasmine.createSpyObj('ConfigProvider', ['config', 'getAnyValue']);
    configProviderSpy.config = {
      app: {features: {extern: {idCards: {url: 'http://id-cards.local', authProvider: 'default'}}}},
    } as never;
    configProviderSpy.getAnyValue = () =>
      ({
        default: {
          endpoints: {
            mapping: {
              id: '$.id',
              email: '$.attributes.mailPrimaryAddress',
              givenName: '$.attributes.givenName',
              familyName: '$.attributes.sn',
              name: '$.attributes.sn',
              role: '$.attributes.eduPersonPrimaryAffiliation',
              studentId: '$.attributes.employeeNumber',
            },
          },
        },
      }) as never;
    encryptedStorageProvider = jasmine.createSpyObj('EncryptedStorageProvider', ['get', 'set', 'delete']);
    encryptedStorageProvider.get = jasmine.createSpy().and.resolveTo();
    encryptedStorageProvider.set = jasmine.createSpy().and.resolveTo();
    encryptedStorageProvider.delete = jasmine.createSpy().and.resolveTo();
    httpClient = jasmine.createSpyObj('HttpClient', ['get']);

    TestBed.configureTestingModule({
      imports: [LoggerTestingModule],
      providers: [
        IdCardsProvider,
        {
          provide: TranslateService,
          useValue: translateServiceSpy,
        },
        {
          provide: EncryptedStorageProvider,
          useValue: encryptedStorageProvider,
        },
        {
          provide: ConfigProvider,
          useValue: configProviderSpy,
        },
        {
          provide: AuthHelperService,
          useValue: authHelperServiceMock,
        },
        {
          provide: AuthProvider,
          useValue: fakeAuth,
        },
        {
          provide: HttpClient,
          useValue: httpClient,
        },
      ],
    });
  });

  it('should emit undefined if not logged in', async () => {
    const provider = TestBed.inject(IdCardsProvider);
    expect(await firstValueFrom(provider.getIdCards())).toEqual([]);
  });

  it('should emit network result when logged in', async () => {
    fakeAuth.isLoggedIn$.next(true);
    httpClient.get = jasmine.createSpy().and.returnValue(of(['abc']));
    fakeAuth.getValidToken = jasmine.createSpy().and.resolveTo({accessToken: 'fake-token'});
    const provider = TestBed.inject(IdCardsProvider);
    expect(await firstValueFrom(provider.getIdCards())).toEqual(['abc' as never]);
    // eslint-disable-next-line unicorn/no-null
    expect(httpClient.get).toHaveBeenCalledOnceWith('http://id-cards.local', {
      headers: {
        Authorization: 'Bearer fake-token',
      },
      responseType: 'json',
    });
  });

  it('should react to logins', async () => {
    const provider = TestBed.inject(IdCardsProvider);
    const observable = provider.getIdCards();
    expect(await firstValueFrom(observable)).toEqual([]);
    httpClient.get = jasmine.createSpy().and.returnValue(of(['abc']));
    fakeAuth.getValidToken = jasmine.createSpy().and.resolveTo({accessToken: 'fake-token'});
    fakeAuth.isLoggedIn$.next(true);
    // this is counter-intuitive, but because we unsubscribed above the first value
    // will now contain the network result.
    expect(await firstValueFrom(observable)).toEqual(['abc' as never]);
  });
});