create test for service-prodiver.repo

src/modules/rolle/api/provider.controller.spec.ts

@@ -0,0 +1,57 @@
+import {Test, TestingModule} from "@nestjs/testing";
+import { ProviderController } from "./provider.controller";
+import {createMock, DeepMocked} from "@golevelup/ts-jest";
+import {RolleService} from "../domain/rolle.service";
+import {ServiceProviderByPersonIdBodyParams} from "./service-provider-by-person-id.body.params";
+import {faker} from "@faker-js/faker";
+import {ServiceProviderDo} from "../domain/service-provider.do";
+
+describe('ProviderController', () => {
+    let module: TestingModule;
+    let providerController: ProviderController;
+    let rolleServiceMock: DeepMocked<RolleService>;
+    let serviceProviderDo: DeepMocked<ServiceProviderDo<true>[]>;
+
+    beforeAll(async () => {
+        module = await Test.createTestingModule({
+            imports: [],
+            providers: [
+                ProviderController,
+                {
+                    provide: RolleService,
+                    useValue: createMock<RolleService>(),
+                },
+                {
+                    provide: ServiceProviderDo,
+                    useValue: createMock<ServiceProviderDo<true>[]>(),
+                },
+            ],
+        }).compile();
+        providerController = module.get(ProviderController);
+        rolleServiceMock = module.get(RolleService);
+        serviceProviderDo = module.get(ServiceProviderDo);
+    });
+
+    afterAll(async () => {
+        await module.close();
+    });
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    it('should be defined', () => {
+        expect(providerController).toBeDefined();
+    });
+
+    describe('when getting result from service', () => {
+        it('should not throw', async () => {
+            const persondId: ServiceProviderByPersonIdBodyParams = {
+                personId: faker.string.alpha(),
+            };
+            rolleServiceMock.getAvailableServiceProviders.mockResolvedValue(serviceProviderDo);
+            await expect(providerController.getServiceProvidersByPersonId(persondId)).resolves.not.toThrow();
+            expect(rolleServiceMock.getAvailableServiceProviders).toHaveBeenCalledTimes(1);
+        });
+    });
+});

src/modules/rolle/domain/service-provider.do.ts

@@ -22,4 +22,7 @@ export class ServiceProviderDo<WasPersisted extends boolean> implements DoBase<W
 
     @AutoMap()
     public url!: string;
+
+    @AutoMap()
+    public providedOnSchulstrukturknoten!: string;
 }

src/modules/rolle/persistence/service-provider.repo.spec.ts

@@ -0,0 +1,87 @@
+import {Test, TestingModule} from "@nestjs/testing";
+import {EntityManager, MikroORM} from "@mikro-orm/core";
+import {Mapper} from "@automapper/core";
+import {ConfigTestModule, DatabaseTestModule, DoFactory, MapperTestModule} from "../../../../test/utils";
+import {getMapperToken} from "@automapper/nestjs";
+import {ServiceProviderRepo} from "./service-provider.repo";
+import {ServiceProviderMapperProfile} from "./service-provider.mapper.profile";
+import {ServiceProviderZugriffDo} from "../domain/service-provider-zugriff.do";
+import {ServiceProviderDo} from "../domain/service-provider.do";
+import {ServiceProviderEntity} from "./service-provider.entity";
+import {ServiceProviderZugriffEntity} from "./service-provider-zugriff.entity";
+import {ServiceProviderZugriffMapperProfile} from "./service-provider-zugriff.mapper.profile";
+
+describe('ServiceProviderRepo', () => {
+    let module: TestingModule;
+    let sut: ServiceProviderRepo;
+    let orm: MikroORM;
+    let em: EntityManager;
+    let mapper: Mapper;
+
+    beforeAll(async () => {
+        module = await Test.createTestingModule({
+            imports: [ConfigTestModule, DatabaseTestModule.forRoot({isDatabaseRequired: true}), MapperTestModule],
+            providers: [ServiceProviderMapperProfile, ServiceProviderZugriffMapperProfile, ServiceProviderRepo],
+        }).compile();
+        sut = module.get(ServiceProviderRepo);
+        orm = module.get(MikroORM);
+        em = module.get(EntityManager);
+        mapper = module.get(getMapperToken());
+        await DatabaseTestModule.setupDatabase(orm);
+    }, 30 * 1_000);
+
+    afterAll(async () => {
+        await module.close();
+    }, 30 * 1_000);
+
+    beforeEach(async () => {
+        await DatabaseTestModule.clearDatabase(orm);
+    });
+
+    it('should be defined', () => {
+        expect(sut).toBeDefined();
+    });
+
+    describe('findById provided by ServiceProviderZugriffDo', () => {
+        describe('when found by id', () => {
+            it('should return found serviceProvider', async () => {
+                const props: Partial<ServiceProviderDo<false>> = {
+                    id: '1'
+                };
+                const serviceProviderDo: ServiceProviderDo<false> = DoFactory.createServiceProvider(false, props);
+                const serviceProviderZugriffDo: ServiceProviderZugriffDo<false> = DoFactory.createServiceProviderZugriff(false, {serviceProvider: '123'});
+                await em.persistAndFlush(mapper.map(serviceProviderDo, ServiceProviderDo, ServiceProviderEntity));
+                await em.persistAndFlush(mapper.map(serviceProviderZugriffDo, ServiceProviderZugriffDo, ServiceProviderZugriffEntity));
+
+                const serviceProvider: ServiceProviderEntity[] = await em.find(ServiceProviderEntity, {});
+                expect(serviceProvider).not.toBeNull();
+                expect(serviceProvider).toHaveLength(1);
+                console.log(serviceProvider[0]);
+
+                const serviceProviderZugriff: ServiceProviderZugriffEntity[] = await em.find(ServiceProviderZugriffEntity, {});
+                expect(serviceProviderZugriff).not.toBeNull();
+                expect(serviceProviderZugriff).toHaveLength(1);
+                console.log(serviceProviderZugriff[0]);
+
+                const foundServiceProvider: ServiceProviderDo<true>[] = await sut.findAll(serviceProviderZugriffDo);
+                expect(foundServiceProvider).not.toBeNull();
+                expect(foundServiceProvider).toHaveLength(1);
+
+             /*   const personDo: PersonDo<false> = DoFactory.createPerson(false, {referrer: faker.string.uuid()});
+                await em.persistAndFlush(mapper.map(personDo, PersonDo, PersonEntity));
+                const [person]: PersonEntity[] = await em.find(PersonEntity, {});
+                expect(person).toBeInstanceOf(PersonEntity);
+                const foundPerson: Option<PersonDo<true>> = await sut.findAll((person as PersonEntity).id);
+                expect(foundPerson).toBeInstanceOf(PersonDo);*/
+            });
+        });
+
+        describe('when not found by id provided by ServiceProviderZugriffDo', () => {
+            it('should return null', async () => {
+                const serviceProviderZugriffDo: ServiceProviderZugriffDo<true> = DoFactory.createServiceProviderZugriff(true);
+                const foundServiceProvider: Option<ServiceProviderDo<true>[]> = await sut.findAll(serviceProviderZugriffDo);
+                expect(foundServiceProvider).toHaveLength(0);
+            });
+        });
+    });
+});

src/modules/rolle/persistence/service-provider.repo.ts

@@ -10,7 +10,7 @@ import { ServiceProviderEntity } from './service-provider.entity.js';
 export class ServiceProviderRepo {
     public constructor(private readonly em: EntityManager, @Inject(getMapperToken()) private readonly mapper: Mapper) {}
 
-    public async findAll(serviceProviderZugriff: ServiceProviderZugriffDo<true>): Promise<ServiceProviderDo<true>[]> {
+    public async findAll(serviceProviderZugriff: ServiceProviderZugriffDo<boolean>): Promise<ServiceProviderDo<true>[]> {
         const query: Record<string, unknown> = {};
         if (serviceProviderZugriff.serviceProvider) {
             query['id'] = { $ilike: serviceProviderZugriff.serviceProvider };

test/utils/do-factory.ts

@@ -5,6 +5,8 @@ import { OrganisationsTyp } from '../../src/modules/organisation/domain/organisa
 import { UserDo } from '../../src/modules/keycloak-administration/domain/user.do.js';
 import { PersonenkontextDo } from '../../src/modules/person/domain/personenkontext.do.js';
 import { Rolle, Jahrgangsstufe, Personenstatus } from '../../src/modules/person/domain/personenkontext.enums.js';
+import {ServiceProviderZugriffDo} from "../../src/modules/rolle/domain/service-provider-zugriff.do";
+import {ServiceProviderDo} from "../../src/modules/rolle/domain/service-provider.do";
 
 export class DoFactory {
     public static createPerson<WasPersisted extends boolean>(
@@ -76,4 +78,32 @@ export class DoFactory {
 
         return Object.assign(new PersonenkontextDo<WasPersisted>(), user, props);
     }
+
+    public static createServiceProvider<WasPersisted extends boolean>(
+        withId: WasPersisted,
+        props?: Partial<ServiceProviderDo<WasPersisted>>,
+    ): ServiceProviderDo<WasPersisted> {
+        const serviceProvider: ServiceProviderDo<false> = {
+            name: faker.internet.domainWord(),
+            url: faker.internet.url(),
+            providedOnSchulstrukturknoten: faker.string.numeric(),
+            id: '1',
+            createdAt: withId ? faker.date.past() : undefined,
+            updatedAt: withId ? faker.date.recent() : undefined,
+        };
+        return Object.assign(new ServiceProviderDo<WasPersisted>(), serviceProvider, props);
+    }
+
+    public static createServiceProviderZugriff<WasPersisted extends boolean>(
+        withId: WasPersisted,
+        props?: Partial<ServiceProviderZugriffDo<WasPersisted>>,
+    ): ServiceProviderZugriffDo<WasPersisted> {
+        const serviceProviderZugriff: ServiceProviderZugriffDo<false> = {
+            serviceProvider: faker.string.numeric(),
+            id: withId ? faker.string.uuid() : undefined,
+            createdAt: withId ? faker.date.past() : undefined,
+            updatedAt: withId ? faker.date.recent() : undefined,
+        };
+        return Object.assign(new ServiceProviderZugriffDo<WasPersisted>(), serviceProviderZugriff, props);
+    }
 }