keycloak.resource.service.spec.ts

/*
 * Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
 * Ministerpräsidenten des Landes Schleswig-Holstein
 * Staatskanzlei
 * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
 *
 * Lizenziert unter der EUPL, Version 1.2 oder - sobald
 * diese von der Europäischen Kommission genehmigt wurden -
 * Folgeversionen der EUPL ("Lizenz");
 * Sie dürfen dieses Werk ausschließlich gemäß
 * dieser Lizenz nutzen.
 * Eine Kopie der Lizenz finden Sie hier:
 *
 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
 *
 * Sofern nicht durch anwendbare Rechtsvorschriften
 * gefordert oder in schriftlicher Form vereinbart, wird
 * die unter der Lizenz verbreitete Software "so wie sie
 * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
 * ausdrücklich oder stillschweigend - verbreitet.
 * Die sprachspezifischen Genehmigungen und Beschränkungen
 * unter der Lizenz sind dem Lizenztext zu entnehmen.
 */
import { TestBed, fakeAsync, tick } from '@angular/core/testing';
import { faker } from '@faker-js/faker';
import { cold } from 'jest-marbles';
import { StateResource, createEmptyStateResource, createStateResource } from 'libs/tech-shared/src/lib/resource/resource.util';
import { Dummy, createDummy } from 'libs/tech-shared/test/dummy';
import { singleCold } from 'libs/tech-shared/test/marbles';
import { Observable, of } from 'rxjs';
import { KeycloakResourceService } from './keycloak.resource.service';

import * as ResourceUtil from 'libs/tech-shared/src/lib/resource/resource.util';

describe('KeycloakResourceService', () => {
  let service: KeycloakResourceService<unknown>;

  const id: string = faker.word.sample();
  const emptyStateResource: StateResource<unknown[]> = createEmptyStateResource<unknown[]>();
  const dummyObject: Dummy = createDummy();
  const dummyAction: Observable<Dummy> = of(dummyObject);

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [TestResourceService],
    });

    service = TestBed.inject(TestResourceService);
  });

  describe('getAll', () => {
    const stateResource: StateResource<unknown> = createStateResource([]);

    beforeEach(() => {
      service.handleChanges = jest.fn().mockReturnValue(singleCold(stateResource));
    });

    it('should return stateResource', () => {
      const stateResource$: Observable<StateResource<unknown[]>> = service.getAll();

      expect(stateResource$).toBeObservable(singleCold(stateResource));
    });

    it('should call handleChanges ', fakeAsync(() => {
      service.getAll().subscribe();

      expect(service.handleChanges).toHaveBeenCalled();
    }));
  });

  describe('handleChanges', () => {
    let doIfLoadingRequiredSpy: jest.SpyInstance<boolean>;

    beforeEach(() => {
      doIfLoadingRequiredSpy = jest.spyOn(ResourceUtil, 'doIfLoadingRequired').mockImplementation();
    });

    it('should call doIfLoadingRequired', () => {
      service.handleChanges(emptyStateResource);

      expect(doIfLoadingRequiredSpy).toHaveBeenCalled();
    });

    it('should return stateResource', (done) => {
      service.stateResource.next(createStateResource([]));

      service.handleChanges(emptyStateResource).subscribe((stateResource: StateResource<[]>) => {
        expect(stateResource).toEqual(createStateResource([]));
        done();
      });
    });
  });

  describe('loadResource', () => {
    it('should call set loading', () => {
      service.setLoading = jest.fn();

      service.loadResource();

      expect(service.setLoading).toHaveBeenCalled();
    });

    it('should update Resource', fakeAsync(() => {
      const dummyItems = [createDummy(), createDummy()];
      jest.spyOn(service, '_getItemsFromKeycloak' as any).mockReturnValue(of(dummyItems));

      service.loadResource();
      tick();

      expect(service.stateResource.value.resource).toEqual(dummyItems);
    }));
  });

  describe('create', () => {
    const saveObject: Dummy = createDummy();

    it('should call handleLoading', () => {
      service.handleLoading = jest.fn();

      service.create(saveObject);

      expect(service.handleLoading).toHaveBeenCalled();
    });

    it('should call createInKeycloak', () => {
      const createInKeycloakSpy: jest.SpyInstance = jest.spyOn(service, '_createInKeycloak' as any).mockReturnValue(of({}));

      service.create(saveObject);

      expect(createInKeycloakSpy).toHaveBeenCalled();
    });
  });

  describe('save', () => {
    it('should call handleLoading', () => {
      service.handleLoading = jest.fn();

      service.save(dummyObject);

      expect(service.handleLoading).toHaveBeenCalled();
    });

    it('should call createInKeycloak', () => {
      const saveInKeycloakSpy: jest.SpyInstance = jest.spyOn(service, '_saveInKeycloak' as any).mockReturnValue(of({}));

      service.save(dummyObject);

      expect(saveInKeycloakSpy).toHaveBeenCalled();
    });
  });

  describe('delete', () => {
    it('should call handleLoading', () => {
      service.handleLoading = jest.fn();

      service.delete(id);

      expect(service.handleLoading).toHaveBeenCalled();
    });

    it('should call createInKeycloak', () => {
      const saveInKeycloakSpy: jest.SpyInstance = jest.spyOn(service, '_saveInKeycloak' as any).mockReturnValue(of({}));

      service.save(id);

      expect(saveInKeycloakSpy).toHaveBeenCalled();
    });
  });

  describe('handleLoading', () => {
    it('should call refreshAfterFirstEmit', () => {
      service.refreshAfterFirstEmit = jest.fn().mockReturnValue(dummyAction);

      service.handleLoading(dummyAction);

      expect(service.refreshAfterFirstEmit).toHaveBeenCalled();
    });

    it('should call progress', () => {
      service.setLoadingInStateResource = jest.fn().mockReturnValue(dummyAction);

      service.handleLoading(dummyAction);

      expect(service.setLoadingInStateResource).toHaveBeenCalled();
    });
  });

  describe('refreshAfterFirstEmit', () => {
    it('should call refresh after first emit', fakeAsync(() => {
      service.refresh = jest.fn();

      service.refreshAfterFirstEmit(dummyAction).subscribe();
      tick();

      expect(service.refresh).toHaveBeenCalled();
    }));
  });

  describe('setLoadingInStateResource', () => {
    it('should emit emptyState first with loading and then state without loading', () => {
      const result: Observable<StateResource<Dummy>> = service.setLoadingInStateResource<Dummy>(cold('--x', { x: dummyObject }));

      expect(result).toBeObservable(cold('a-b', { a: createEmptyStateResource(true), b: createStateResource(dummyObject) }));
    });
  });

  describe('setLoading', () => {
    it('should set loading in state to true without parameter', () => {
      service.stateResource.value.loading = false;

      service.setLoading();

      expect(service.stateResource.value.loading).toEqual(true);
    });
  });

  describe('refresh', () => {
    it('should set reload in state to true', () => {
      service.refresh();

      expect(service.stateResource.value.reload).toBe(true);
    });

    it('should clear resource in state', () => {
      service.refresh();

      expect(service.stateResource.value.resource).toEqual([]);
    });
  });

  describe('select resource', () => {
    it('should return state resource', () => {
      const stateResource = createEmptyStateResource<unknown[]>();
      service.stateResource.next(stateResource);

      const resource$: Observable<StateResource<unknown[]>> = service.selectResource();

      expect(resource$).toBeObservable(singleCold(stateResource));
    });
  });
});

class TestResourceService extends KeycloakResourceService<unknown> {
  _getItemsFromKeycloak(): Observable<unknown[]> {
    return of(null);
  }

  _saveInKeycloak(): Observable<void> {
    return of(null);
  }

  _createInKeycloak(): Observable<void> {
    return of(null);
  }

  _deleteInKeycloak(): Observable<void> {
    return of(null);
  }
}