feat(machine): support skeleton reconfiguration

test/app.e2e-spec.ts

@@ -3,17 +3,31 @@ import { INestApplication } from '@nestjs/common';
 import * as request from 'supertest';
 import { App } from 'supertest/types';
 import { AppModule } from './../src/app.module';
+import { PrismaService } from '../src/prisma/prisma.service';
 
 describe('AppController (e2e)', () => {
   let app: INestApplication<App>;
+  let prisma: PrismaService;
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     const moduleFixture: TestingModule = await Test.createTestingModule({
       imports: [AppModule],
     }).compile();
 
     app = moduleFixture.createNestApplication();
     await app.init();
+
+    prisma = app.get(PrismaService);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  beforeEach(async () => {
+    await prisma.$executeRawUnsafe(
+      'TRUNCATE TABLE custom_field_values, documents, pieces, composants, machines, composant_models, piece_models, type_machine_component_requirements, type_machine_piece_requirements, custom_fields, type_machines, type_composants, type_pieces, constructeurs, sites RESTART IDENTITY CASCADE',
+    );
   });
 
   it('/ (GET)', () => {
@@ -22,4 +36,256 @@ describe('AppController (e2e)', () => {
       .expect(200)
       .expect('Hello World!');
   });
+
+  describe('Machines skeleton reconfiguration', () => {
+    it('reconfigures machine skeleton according to updated requirements', async () => {
+      const site = await prisma.site.create({
+        data: {
+          name: 'Site principal',
+          contactName: 'Jane Doe',
+          contactPhone: '0102030405',
+          contactAddress: '1 rue Principale',
+          contactPostalCode: '75000',
+          contactCity: 'Paris',
+        },
+      });
+
+      const typeComposant = await prisma.typeComposant.create({
+        data: {
+          name: 'Module',
+          description: 'Module principal',
+        },
+      });
+
+      await prisma.customField.create({
+        data: {
+          name: 'Serial',
+          type: 'text',
+          required: false,
+          options: [],
+          typeComposantId: typeComposant.id,
+        },
+      });
+
+      const typePiece = await prisma.typePiece.create({
+        data: {
+          name: 'Pièce de rechange',
+          description: 'Pièce critique',
+        },
+      });
+
+      await prisma.customField.create({
+        data: {
+          name: 'Batch',
+          type: 'text',
+          required: false,
+          options: [],
+          typePieceId: typePiece.id,
+        },
+      });
+
+      const componentModelV1 = await prisma.composantModel.create({
+        data: {
+          name: 'Module V1',
+          typeComposantId: typeComposant.id,
+          structure: {
+            name: 'Module V1',
+            customFields: [{ name: 'Serial', defaultValue: 'SERIAL-V1' }],
+          },
+        },
+      });
+
+      const componentModelV2 = await prisma.composantModel.create({
+        data: {
+          name: 'Module V2',
+          typeComposantId: typeComposant.id,
+          structure: {
+            name: 'Module V2',
+            customFields: [{ name: 'Serial', defaultValue: 'SERIAL-V2' }],
+          },
+        },
+      });
+
+      const pieceModelV1 = await prisma.pieceModel.create({
+        data: {
+          name: 'Pièce V1',
+          typePieceId: typePiece.id,
+          structure: {
+            name: 'Pièce V1',
+            customFields: [{ name: 'Batch', defaultValue: 'BATCH-V1' }],
+          },
+        },
+      });
+
+      const pieceModelV2 = await prisma.pieceModel.create({
+        data: {
+          name: 'Pièce V2',
+          typePieceId: typePiece.id,
+          structure: {
+            name: 'Pièce V2',
+            customFields: [{ name: 'Batch', defaultValue: 'BATCH-V2' }],
+          },
+        },
+      });
+
+      const typeMachine = await prisma.typeMachine.create({
+        data: {
+          name: 'Type Machine A',
+          componentRequirements: {
+            create: [
+              {
+                label: 'Module initial',
+                minCount: 1,
+                maxCount: 1,
+                required: true,
+                allowNewModels: false,
+                typeComposantId: typeComposant.id,
+              },
+            ],
+          },
+          pieceRequirements: {
+            create: [
+              {
+                label: 'Pièce initiale',
+                minCount: 1,
+                maxCount: 1,
+                required: true,
+                allowNewModels: false,
+                typePieceId: typePiece.id,
+              },
+            ],
+          },
+        },
+        include: {
+          componentRequirements: true,
+          pieceRequirements: true,
+        },
+      });
+
+      const initialComponentRequirement = typeMachine.componentRequirements[0];
+      const initialPieceRequirement = typeMachine.pieceRequirements[0];
+
+      const createResponse = await request(app.getHttpServer())
+        .post('/machines')
+        .send({
+          name: 'Machine Alpha',
+          siteId: site.id,
+          typeMachineId: typeMachine.id,
+          componentSelections: [
+            {
+              requirementId: initialComponentRequirement.id,
+              componentModelId: componentModelV1.id,
+            },
+          ],
+          pieceSelections: [
+            {
+              requirementId: initialPieceRequirement.id,
+              pieceModelId: pieceModelV1.id,
+            },
+          ],
+        })
+        .expect(201);
+
+      const machineId = createResponse.body.id as string;
+
+      const initialComponents = await prisma.composant.findMany({ where: { machineId } });
+      expect(initialComponents).toHaveLength(1);
+      const initialComponentId = initialComponents[0].id;
+
+      const initialPieces = await prisma.piece.findMany({ where: { machineId } });
+      expect(initialPieces).toHaveLength(1);
+      const initialPieceId = initialPieces[0].id;
+
+      expect(
+        await prisma.customFieldValue.count({ where: { composantId: initialComponentId } }),
+      ).toBe(1);
+      expect(await prisma.customFieldValue.count({ where: { pieceId: initialPieceId } })).toBe(1);
+
+      await prisma.typeMachineComponentRequirement.deleteMany({
+        where: { typeMachineId: typeMachine.id },
+      });
+      await prisma.typeMachinePieceRequirement.deleteMany({
+        where: { typeMachineId: typeMachine.id },
+      });
+
+      const newComponentRequirement = await prisma.typeMachineComponentRequirement.create({
+        data: {
+          label: 'Modules mis à jour',
+          minCount: 2,
+          maxCount: 2,
+          required: true,
+          allowNewModels: true,
+          typeMachineId: typeMachine.id,
+          typeComposantId: typeComposant.id,
+        },
+      });
+
+      const newPieceRequirement = await prisma.typeMachinePieceRequirement.create({
+        data: {
+          label: 'Pièce mise à jour',
+          minCount: 1,
+          maxCount: 1,
+          required: true,
+          allowNewModels: false,
+          typeMachineId: typeMachine.id,
+          typePieceId: typePiece.id,
+        },
+      });
+
+      const reconfigureResponse = await request(app.getHttpServer())
+        .patch(`/machines/${machineId}/skeleton`)
+        .send({
+          componentSelections: [
+            {
+              requirementId: newComponentRequirement.id,
+              componentModelId: componentModelV2.id,
+            },
+            {
+              requirementId: newComponentRequirement.id,
+              definition: {
+                name: 'Module personnalisé',
+                customFields: [{ name: 'Serial', defaultValue: 'SERIAL-CUSTOM' }],
+              },
+            },
+          ],
+          pieceSelections: [
+            {
+              requirementId: newPieceRequirement.id,
+              pieceModelId: pieceModelV2.id,
+            },
+          ],
+        })
+        .expect(200);
+
+      expect(reconfigureResponse.body.composants).toHaveLength(2);
+      expect(reconfigureResponse.body.pieces).toHaveLength(1);
+
+      const componentsAfter = await prisma.composant.findMany({ where: { machineId } });
+      expect(componentsAfter).toHaveLength(2);
+      const componentIdsAfter = componentsAfter.map((component) => component.id);
+      expect(componentIdsAfter).not.toContain(initialComponentId);
+      componentsAfter.forEach((component) => {
+        expect(component.typeMachineComponentRequirementId).toBe(newComponentRequirement.id);
+      });
+
+      const componentValueCount = await prisma.customFieldValue.count({
+        where: { composantId: { in: componentIdsAfter } },
+      });
+      expect(componentValueCount).toBe(2);
+      expect(
+        await prisma.customFieldValue.count({ where: { composantId: initialComponentId } }),
+      ).toBe(0);
+
+      const piecesAfter = await prisma.piece.findMany({ where: { machineId } });
+      expect(piecesAfter).toHaveLength(1);
+      const [updatedPiece] = piecesAfter;
+      expect(updatedPiece.typeMachinePieceRequirementId).toBe(newPieceRequirement.id);
+      expect(updatedPiece.id).not.toBe(initialPieceId);
+
+      expect(
+        await prisma.customFieldValue.count({ where: { pieceId: updatedPiece.id } }),
+      ).toBe(1);
+      expect(await prisma.customFieldValue.count({ where: { pieceId: initialPieceId } })).toBe(0);
+    });
+  });
 });