Task/Quote form assessment

backend/apps/bff/src/app/app.module.ts

@@ -1,11 +1,8 @@
 import { Module } from '@nestjs/common';
 
-import { AppController } from './app.controller';
-import { QuoteService } from './services/quote/quote.service';
+import { QuoteModule } from '../quote/quote.module';
 
 @Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [QuoteService],
+  imports: [QuoteModule],
 })
 export class AppModule {}

backend/apps/bff/src/common/common.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { LongStringGeneratorService } from './services/long-string-generator/long-string-generator.service';
+import { TimingService } from './services/timing/timing.service';
+
+@Module({
+  providers: [LongStringGeneratorService, TimingService],
+  exports: [LongStringGeneratorService, TimingService],
+})
+export class CommonModule {}

backend/apps/bff/src/common/services/long-string-generator/long-string-generator.service.spec.ts

@@ -0,0 +1,21 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { LongStringGeneratorService } from './long-string-generator.service';
+
+describe('LongStringGeneratorService', () => {
+  let service: LongStringGeneratorService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [LongStringGeneratorService],
+    }).compile();
+
+    service = module.get<LongStringGeneratorService>(
+      LongStringGeneratorService
+    );
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/apps/bff/src/common/services/long-string-generator/long-string-generator.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@nestjs/common';
+import { randomBytes } from 'crypto';
+
+@Injectable()
+export class LongStringGeneratorService {
+  generate(size = 10) {
+    return randomBytes(size).toString('hex');
+  }
+}

backend/apps/bff/src/common/services/timing/timing.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { TimingService } from './timing.service';
+
+describe('TimingService', () => {
+  let service: TimingService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [TimingService],
+    }).compile();
+
+    service = module.get<TimingService>(TimingService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/apps/bff/src/common/services/timing/timing.service.ts

@@ -0,0 +1,5 @@
+export class TimingService {
+  static async sleep(ms: number = 4000): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

backend/apps/bff/src/quote/controllers/__tests__/quote.controller.spec.ts

@@ -0,0 +1,91 @@
+import { fakerEN } from '@faker-js/faker';
+import { Test, TestingModule } from '@nestjs/testing';
+import { QuoteRequestDto } from '@target/interfaces';
+
+import { QuoteSchema } from '../../data/schema/quote.schema';
+import { QuoteService } from '../../services/quote/quote.service';
+import { QuoteController } from '../quoteController';
+
+describe('QuotaController', () => {
+  let appController: QuoteController;
+  let quoteService: jest.Mocked<QuoteService>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [QuoteController],
+      providers: [
+        {
+          provide: QuoteService,
+          useValue: { calculateQuote: jest.fn(), createQuote: jest.fn() },
+        },
+      ],
+    }).compile();
+
+    appController = module.get<QuoteController>(QuoteController);
+    quoteService = module.get(QuoteService);
+  });
+
+  it('should be defined', () => {
+    expect(appController).toBeDefined();
+    expect(quoteService).toBeDefined();
+  });
+
+  describe('getQuote', () => {
+    it('should call process quote with a valid birthday', async () => {
+      const mockQuoteDto: QuoteRequestDto = {
+        geburtsdatum: '2020-01-01',
+        leistungsVorgabe: 'Beitrag',
+        beitrag: 1000,
+        berechnungDerLaufzeit: 'Alter bei Rentenbeginn',
+        laufzeit: 10,
+        beitragszahlungsweise: 'Einmalbeitrag',
+        rentenzahlungsweise: 'Monatliche Renten',
+      };
+
+      const calculatedQuote: Omit<QuoteSchema, 'id'> = {
+        basisdaten: {
+          geburtsdatum: '2020-01-01',
+          versicherungsbeginn: '2024-01-01',
+          garantieniveau: '100%',
+          alterBeiRentenbeginn: 67,
+          aufschubdauer: 30,
+          beitragszahlungsdauer: 30,
+        },
+        leistungsmerkmale: {
+          garantierteMindestrente: 1000,
+          einmaligesGarantiekapital: 50000,
+          todesfallleistungAbAltersrentenbezug: 40000,
+        },
+        beitrag: {
+          einmalbeitrag: 50000,
+          beitragsdynamik: '3%',
+        },
+      };
+
+      const expectedQuote = {
+        ...calculatedQuote,
+        id: fakerEN.string.alpha({ length: 15 }),
+      };
+
+      jest
+        .spyOn(quoteService, 'calculateQuote')
+        .mockReturnValueOnce(calculatedQuote);
+      jest
+        .spyOn(quoteService, 'createQuote')
+        .mockResolvedValueOnce(expectedQuote);
+
+      const result = await appController.post(mockQuoteDto);
+
+      expect(quoteService.calculateQuote).toHaveBeenCalledWith({
+        beitrag: mockQuoteDto.beitrag,
+        geburtsdatum: mockQuoteDto.geburtsdatum,
+      });
+      expect(quoteService.calculateQuote).toHaveBeenCalledTimes(1);
+
+      expect(quoteService.createQuote).toHaveBeenCalledWith(calculatedQuote);
+      expect(quoteService.createQuote).toHaveBeenCalledTimes(1);
+
+      expect(result).toBe(expectedQuote);
+    });
+  });
+});

backend/apps/bff/src/quote/controllers/quoteController.ts

@@ -0,0 +1,29 @@
+import { Body, Controller, Get, Param, Post } from '@nestjs/common';
+import { QuoteRequestDto, QuoteResponseDto } from '@target/interfaces';
+import { InputDtoSchema } from '@target/validations';
+
+import { QuoteSchema } from '../data/schema/quote.schema';
+import { ValidationPipe } from '../pipes/validation.pipe';
+import { QuoteService } from '../services/quote/quote.service';
+
+@Controller('/quote')
+export class QuoteController {
+  constructor(private readonly quoteService: QuoteService) {}
+
+  @Post()
+  async post(
+    @Body(new ValidationPipe(InputDtoSchema)) quoteDto: QuoteRequestDto
+  ): Promise<QuoteResponseDto> {
+    const quote = this.quoteService.calculateQuote({
+      beitrag: quoteDto.beitrag,
+      geburtsdatum: quoteDto.geburtsdatum,
+    });
+
+    return await this.quoteService.createQuote(quote);
+  }
+
+  @Get('/:id')
+  async get(@Param('id') id: string): Promise<QuoteSchema> {
+    return await this.quoteService.findOnById(id);
+  }
+}