Skip to content
Snippets Groups Projects
Select Git revision
  • 2a81e183b09dcf06f8117bb05d870344e6ead15f
  • master default protected
  • add-frequency-to-form
  • dev protected
  • ckan-2.11.0
  • add-package-custom-fields
  • fix-adding-datasets-for-users-and-editors
  • add-auth-subroute
  • 71-migrate-custom-fields-to-ckanext-scheming
  • add-author-maintainer-information
  • fix-inline-flex-btns
  • fix-known-spatial-uri-validation
  • py3
  • 47-aktuelle-resource-einer-collection-wird-nicht-mehr-gefunden
  • 10-eingabe-der-dct-accrualperiodicity-in-weboberflache
  • v1.3
  • 2.5.3
  • 2.5.2
  • 2.5.1
  • 2.5.0
  • 2.4.7
  • 2.4.6
  • 2.4.5
  • 2.4.4
  • 2.4.3
  • 2.4.2
  • 2.4.1
  • 2.4.0
  • 2.3.1
  • 2.3.0
  • 2.2.0
  • 2.1.0
  • 2.0.0
  • 1.4.3
  • 1.4.2
  • 1.4.1
36 results

test_search.py

Blame
  • keycloak.resource.service.spec.ts 8.49 KiB
    /*
     * 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);
    
      const dummyError: Error = new Error('Test error');
      const dummyErrorAction: Observable<Error> = new Observable((observer) => observer.error(dummyError));
    
      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 set loading', () => {
          service._handleLoading(dummyAction);
    
          expect(service.stateResource.value.loading).toBe(true);
        });
    
        it('should call refreshAfterFirstEmit', () => {
          service._refreshAfterEmit = jest.fn().mockReturnValue(dummyAction);
    
          service._handleLoading(dummyAction);
    
          expect(service._refreshAfterEmit).toHaveBeenCalled();
        });
    
        it('should call progress', () => {
          service._setLoadingInStateResource = jest.fn().mockReturnValue(dummyAction);
    
          service._handleLoading(dummyAction);
    
          expect(service._setLoadingInStateResource).toHaveBeenCalled();
        });
      });
    
      describe('refreshAfterEmit', () => {
        it('should call refresh after first emit', () => {
          service.refresh = jest.fn();
    
          service._refreshAfterEmit(dummyAction).subscribe();
    
          expect(service.refresh).toHaveBeenCalled();
        });
    
        it('should call refresh on error', () => {
          service.refresh = jest.fn();
    
          service._refreshAfterEmit(dummyErrorAction).subscribe();
    
          expect(service.refresh).toHaveBeenCalled();
        });
    
        it('should throw error refresh on error', () => {
          service.refresh = jest.fn();
    
          const result: Observable<unknown> = service._refreshAfterEmit(dummyErrorAction);
    
          expect(result).toBeObservable(cold('#', null, dummyError));
        });
      });
    
      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);
      }
    }