Validate component and piece requirements

src/pieces/pieces.service.spec.ts

@@ -1,19 +1,85 @@
+import { BadRequestException } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { PiecesService } from './pieces.service';
 import { PrismaService } from '../prisma/prisma.service';
+import { CreatePieceDto } from '../shared/dto/piece.dto';
 
 describe('PiecesService', () => {
   let service: PiecesService;
+  let prisma: any;
 
   beforeEach(async () => {
+    prisma = {
+      piece: {
+        create: jest.fn(),
+      },
+      machine: {
+        findUnique: jest.fn(),
+      },
+      composant: {
+        findUnique: jest.fn(),
+      },
+    };
+
     const module: TestingModule = await Test.createTestingModule({
-      providers: [PiecesService, PrismaService],
+      providers: [PiecesService, { provide: PrismaService, useValue: prisma }],
     }).compile();
 
     service = module.get<PiecesService>(PiecesService);
   });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create a piece when requirement matches the machine skeleton', async () => {
+    const dto: CreatePieceDto = {
+      name: 'Piece A',
+      machineId: 'machine-1',
+      typePieceId: 'type-piece-1',
+      typeMachinePieceRequirementId: 'req-1',
+    };
+
+    prisma.machine.findUnique.mockResolvedValue({
+      id: 'machine-1',
+      typeMachine: {
+        pieceRequirements: [
+          { id: 'req-1', typePieceId: 'type-piece-1' },
+        ],
+      },
+    });
+
+    const created = { id: 'piece-1' };
+    prisma.piece.create.mockResolvedValue(created);
+
+    await expect(service.create(dto)).resolves.toEqual(created);
+    expect(prisma.piece.create).toHaveBeenCalled();
+    expect(prisma.piece.create.mock.calls[0][0].data.machineId).toBe(
+      'machine-1',
+    );
+  });
+
+  it('should refuse creation when requirement does not belong to machine skeleton', async () => {
+    const dto: CreatePieceDto = {
+      name: 'Piece A',
+      machineId: 'machine-1',
+      typePieceId: 'type-piece-1',
+      typeMachinePieceRequirementId: 'req-2',
+    };
+
+    prisma.machine.findUnique.mockResolvedValue({
+      id: 'machine-1',
+      typeMachine: {
+        pieceRequirements: [
+          { id: 'req-1', typePieceId: 'type-piece-1' },
+        ],
+      },
+    });
+
+    await expect(service.create(dto)).rejects.toBeInstanceOf(
+      BadRequestException,
+    );
+
+    expect(prisma.piece.create).not.toHaveBeenCalled();
   });
 });