Merge pull request #4 from Axel77g/improve-test-coverage-domain

Improve test coverage domain

Author: Axel77g

backend/jest.config.js

@@ -11,6 +11,7 @@ module.exports = {
     "^@application/(.*)$": "<rootDir>/src/application/$1",
     "^@shared/(.*)$": "<rootDir>/src/shared/$1",
     "^@expressApp/(.*)$": "<rootDir>/src/infrastructure/frameworks/express/$1",
+    "^@tests/(.*)$": "<rootDir>/src/tests/$1",
   },
   testPathIgnorePatterns: ["/node_modules/", "/dist/"],
 };

backend/package.json

@@ -40,6 +40,7 @@
     "@infrastructure": "dist/infrastructure",
     "@application": "dist/application",
     "@shared": "dist/shared",
-    "@infra_express": "dist/infrastructure/frameworks/express"
+    "@infra_express": "dist/infrastructure/frameworks/express",
+    "@tests": "dist/tests"
   }
 }

backend/src/domain/inventoryManagement/entities/Dealer.test.ts

@@ -0,0 +1,86 @@
+import {Dealer} from "@domain/inventoryManagement/entities/Dealer";
+import {ApplicationException} from "@shared/ApplicationException";
+import {assertError, generateAddressDTO, generateDealerDTO} from "@tests/Utils";
+import {Siret} from "@domain/shared/value-object/Siret";
+import {Address} from "@domain/shared/value-object/Address";
+import {RegisterDealerEvent} from "@domain/inventoryManagement/events/RegisterDealerEvent";
+import {UnregisterDealerEvent} from "@domain/inventoryManagement/events/UnregisterDealerEvent";
+
+describe('Dealer.fromObject', () => {
+    it('should return a Dealer when provided with a valid DealerDTO', () => {
+        const dto = generateDealerDTO();
+        const dealer = Dealer.fromObject(dto);
+        expect(dealer).toBeInstanceOf(Dealer);
+    });
+
+    it('should return an ApplicationException when SIRET is invalid', () => {
+        const dto = generateDealerDTO({ siret: "INVALID_SIRET" });
+        const dealer = Dealer.fromObject(dto) as ApplicationException;
+        expect(dealer).toBeInstanceOf(ApplicationException);
+        assertError(dealer, Siret.errors.SIRET_NOT_VALID);
+    });
+
+    it('should return an ApplicationException when Address is invalid', () => {
+        const dto = generateDealerDTO({
+            address: generateAddressDTO({ country :"France", postalCode: "INVALID_POSTAL_CODE" })
+        });
+        const dealer = Dealer.fromObject(dto) as ApplicationException;
+        expect(dealer).toBeInstanceOf(ApplicationException);
+        assertError(dealer, Address.errors.COUNTRY_CODE_NOT_VALID);
+    });
+});
+
+describe('Dealer.create', () => {
+    it('should create a Dealer when provided with valid inputs', () => {
+        const siret = Siret.create("12345678901234") as Siret;
+        const address = Address.create(generateAddressDTO()) as Address;
+        const dealer = Dealer.create({
+            siret,
+            name: "Valid Dealer",
+            address,
+            phoneNumber: "0123456789"
+        });
+
+        expect(dealer).toBeInstanceOf(Dealer);
+        expect(dealer.name).toBe("Valid Dealer");
+        expect(dealer.phoneNumber).toBe("0123456789");
+    });
+
+});
+
+describe('Dealer.registerEvent', () => {
+    it('should return a RegisterDealerEvent with the correct properties', () => {
+        const siret = Siret.create("12345678901234") as Siret;
+        const address = Address.create(generateAddressDTO()) as Address;
+        const dealer = Dealer.create({
+            siret,
+            name: "Dealer for Event",
+            address,
+            phoneNumber: "0123456789"
+        });
+
+        const event = dealer.registerEvent();
+        expect(event).toBeInstanceOf(RegisterDealerEvent);
+        expect(event.payload.siret).toBe(siret.getValue());
+        expect(event.payload.name).toBe("Dealer for Event");
+        expect(event.payload.address).toEqual(address);
+        expect(event.payload.phoneNumber).toBe("0123456789");
+    });
+});
+
+describe('Dealer.unregisterEvent', () => {
+    it('should return an UnregisterDealerEvent with the correct SIRET', () => {
+        const siret = Siret.create("12345678901234") as Siret;
+        const address = Address.create(generateAddressDTO()) as Address;
+        const dealer = Dealer.create({
+            siret,
+            name: "Dealer for Event",
+            address,
+            phoneNumber: "0123456789"
+        });
+
+        const event = dealer.unregisterEvent();
+        expect(event).toBeInstanceOf(UnregisterDealerEvent);
+        expect(event.payload.siret).toBe(siret.getValue());
+    });
+});

backend/src/domain/inventoryManagement/entities/InventorySparePart.test.ts

@@ -0,0 +1,64 @@
+import { InventorySparePart } from "./InventorySparePart";
+import { ApplicationException } from "@shared/ApplicationException";
+import {assertError, generateInventorySparePartDTO} from "@tests/Utils";
+
+describe("InventorySparePart", () => {
+    describe("create", () => {
+        it("should create an InventorySparePart when provided with valid data", () => {
+            const dto = generateInventorySparePartDTO();
+            const sparePart = InventorySparePart.create(dto) as InventorySparePart;
+            expect(sparePart).toBeInstanceOf(InventorySparePart);
+            expect(sparePart.reference).toBe(dto.reference);
+            expect(sparePart.name).toBe(dto.name);
+        });
+
+        it("should return an ApplicationException when name is too short", () => {
+            const dto = generateInventorySparePartDTO({ name: "A" }); // Nom trop court
+            const sparePart = InventorySparePart.create(dto) as ApplicationException;
+            expect(sparePart).toBeInstanceOf(ApplicationException);
+            assertError(sparePart, InventorySparePart.errors.NAME_TOO_SHORT)
+        });
+
+        it("should return an ApplicationException when reference is too short", () => {
+            const dto = generateInventorySparePartDTO({ reference: "ABC" }); // Référence trop courte
+            const sparePart = InventorySparePart.create(dto) as ApplicationException;
+            expect(sparePart).toBeInstanceOf(ApplicationException);
+            assertError(sparePart, InventorySparePart.errors.REFERENCE_TOO_SHORT)
+        });
+    });
+
+    describe("fromObject", () => {
+        it("should create an InventorySparePart from a valid DTO", () => {
+            const dto = generateInventorySparePartDTO();
+            const sparePart = InventorySparePart.fromObject(dto);
+            expect(sparePart).toBeInstanceOf(InventorySparePart);
+        });
+
+        it("should return an ApplicationException for an invalid DTO", () => {
+            const dto = generateInventorySparePartDTO({ reference: "123", name: "" }); // Référence et nom invalides
+            const sparePart = InventorySparePart.fromObject(dto);
+            expect(sparePart).toBeInstanceOf(ApplicationException);
+        });
+    });
+
+    describe("setName", () => {
+        it("should create a new InventorySparePart with an updated name", () => {
+            const dto = generateInventorySparePartDTO();
+            const sparePart = InventorySparePart.create(dto) as InventorySparePart;
+            const updatedSparePart = sparePart.setName("Updated Name");
+            expect(updatedSparePart).not.toBe(sparePart); // Nouvelle instance
+            expect(updatedSparePart.name).toBe("Updated Name");
+        });
+    });
+
+    describe("upsertEvent", () => {
+        it("should create an UpsertInventorySparePartEvent with the correct data", () => {
+            const dto = generateInventorySparePartDTO();
+            const sparePart = InventorySparePart.create(dto) as InventorySparePart;
+            const event = sparePart.upsertEvent();
+            expect(event).toBeDefined();
+            expect(event.payload.reference).toBe(sparePart.reference);
+            expect(event.payload.name).toBe(sparePart.name);
+        });
+    });
+});

backend/src/domain/inventoryManagement/entities/InventorySparePart.ts

@@ -9,6 +9,11 @@ export interface InventorySparePartDTO {
 export class InventorySparePart{
     public static readonly REFERENCE_MIN_LENGTH = 5;
     public static readonly NAME_MIN_LENGTH = 2;
+    static errors = {
+        REFERENCE_TOO_SHORT: new ApplicationException("InventorySparePart.ReferenceTooShort",`Reference must be at least ${InventorySparePart.REFERENCE_MIN_LENGTH} characters long`),
+        NAME_TOO_SHORT: new ApplicationException("InventorySparePart.NameTooShort",`Name must be at least ${InventorySparePart.NAME_MIN_LENGTH} characters long`),
+    }
+
 
     private constructor(
         public readonly reference: string,
@@ -25,8 +30,8 @@ export class InventorySparePart{
     }
 
     static create(sparePart: InventorySparePartDTO): InventorySparePart | ApplicationException {
-        if(sparePart.name.length < this.NAME_MIN_LENGTH) return new ApplicationException("InventorySparePart.NameTooShort",`Name must be at least ${InventorySparePart.NAME_MIN_LENGTH} characters long`);
-        if(sparePart.reference.length < this.REFERENCE_MIN_LENGTH) return new ApplicationException("InventorySparePart.ReferenceTooShort",`Reference must be at least ${InventorySparePart.REFERENCE_MIN_LENGTH} characters long`);
+        if(sparePart.name.length < this.NAME_MIN_LENGTH) return InventorySparePart.errors.NAME_TOO_SHORT
+        if(sparePart.reference.length < this.REFERENCE_MIN_LENGTH) return InventorySparePart.errors.REFERENCE_TOO_SHORT
         return new InventorySparePart(sparePart.reference, sparePart.name);
     }
 

backend/src/domain/inventoryManagement/entities/Order.test.ts

@@ -0,0 +1,120 @@
+import {assertError, generateOrderDTO, generateOrderLineDTOs, generateSiret} from "@tests/Utils";
+import {ApplicationException} from "@shared/ApplicationException";
+import {Order} from "@domain/inventoryManagement/entities/Order";
+import {OrderStatusEnum} from "@domain/inventoryManagement/enums/OrderStatusEnum";
+import {OrderLine} from "@domain/inventoryManagement/value-object/OrderLine";
+import {InventorySparePart} from "@domain/inventoryManagement/entities/InventorySparePart";
+
+describe("Order", () => {
+    describe("create", () => {
+        it("should create an Order with valid data", () => {
+            const dto = generateOrderDTO();
+            const order = Order.create({
+                ...dto,
+                siret: generateSiret(),
+                lines : [OrderLine.create({reference: "123", quantity: 1, unitPrice: 100}) as OrderLine]
+            });
+            expect(order).toBeInstanceOf(Order);
+        });
+
+        it("should return an ApplicationException when orderedAt is after deliveredAt", () => {
+            const dto = generateOrderDTO({
+                orderedAt: new Date("2023-01-03"),
+                deliveredAt: new Date("2023-01-01"),
+            });
+            const order = Order.create({
+                ...dto,
+                siret: generateSiret()
+            });
+            expect(order).toBeInstanceOf(ApplicationException);
+            assertError(order as ApplicationException, Order.errors.INVALID_DATE);
+        });
+
+        it("should return an ApplicationException when no order lines are provided", () => {
+            const dto = generateOrderDTO({ lines: [] });
+            const order = Order.create({
+                ...dto,
+                siret: generateSiret(),
+            });
+            expect(order).toBeInstanceOf(ApplicationException);
+            assertError(order as ApplicationException, Order.errors.NO_LINES);
+        });
+    });
+
+    describe("fromObject", () => {
+        it("should create an Order from a valid DTO", () => {
+            const dto = generateOrderDTO();
+            const order = Order.fromObject(dto);
+            expect(order).toBeInstanceOf(Order);
+        });
+
+        it("should return an ApplicationException for an invalid SIRET", () => {
+            const dto = generateOrderDTO({ siret: "INVALID_SIRET" });
+            const order = Order.fromObject(dto);
+            expect(order).toBeInstanceOf(ApplicationException);
+        });
+
+        it("should return an ApplicationException for an invalid OrderLine", () => {
+            const dto = generateOrderDTO({
+                lines: generateOrderLineDTOs(1, { reference: "" }), // Ligne invalide
+            });
+            const order = Order.fromObject(dto);
+            expect(order).toBeInstanceOf(ApplicationException);
+            assertError(order as ApplicationException, InventorySparePart.errors.REFERENCE_TOO_SHORT);
+        });
+    });
+
+    describe("applyStatus", () => {
+        it("should change the status to COMPLETED if applicable", () => {
+            const dto = generateOrderDTO();
+            const order = Order.fromObject(dto) as Order;
+            const updatedOrder = order.applyStatus(OrderStatusEnum.COMPLETED);
+            expect(updatedOrder).toBeInstanceOf(Order);
+            expect((updatedOrder as Order).status).toBe(OrderStatusEnum.COMPLETED);
+        });
+
+        it("should return an ApplicationException if trying to COMPLETE a CANCELED order", () => {
+            const dto = generateOrderDTO({ status: OrderStatusEnum.CANCELED });
+            const order = Order.fromObject(dto) as Order;
+            const result = order.applyStatus(OrderStatusEnum.COMPLETED);
+            expect(result).toBeInstanceOf(ApplicationException);
+            assertError(
+                result as ApplicationException,
+                Order.errors.CANNOT_COMPLETE_CANCELED_ORDER
+            );
+        });
+
+        it("should return an ApplicationException if trying to CANCEL a COMPLETED order", () => {
+            const dto = generateOrderDTO({ status: OrderStatusEnum.COMPLETED });
+            const order = Order.fromObject(dto) as Order;
+            const result = order.applyStatus(OrderStatusEnum.CANCELED);
+            expect(result).toBeInstanceOf(ApplicationException);
+            assertError(
+                result as ApplicationException,
+                Order.errors.CANNOT_CANCEL_COMPLETED_ORDER
+            );
+        });
+    });
+
+    describe("registerEvent", () => {
+        it("should create a RegisterOrderEvent with the correct data", () => {
+            const dto = generateOrderDTO();
+            const order = Order.fromObject(dto) as Order;
+            const event = order.registerEvent();
+            expect(event).toBeDefined();
+            expect(event.payload.orderId).toBe(order.orderId);
+            expect(event.payload.lines).toBe(order.lines);
+        });
+    });
+
+    describe("updateStatusEvent", () => {
+        it("should create an UpdateOrderStatusEvent with the correct data", () => {
+            const dto = generateOrderDTO();
+            const order = Order.fromObject(dto) as Order;
+            const event = order.updateStatusEvent();
+            expect(event).toBeDefined();
+            expect(event.payload.orderId).toBe(order.orderId);
+            expect(event.payload.status).toBe(order.status);
+        });
+    });
+});

backend/src/domain/inventoryManagement/entities/Order.ts

@@ -27,7 +27,9 @@ export class Order {
     static errors = {
         CANNOT_COMPLETE_CANCELED_ORDER: new ApplicationException("Order","Cannot complete a cancelled order"),
         CANNOT_CANCEL_COMPLETED_ORDER: new ApplicationException("Order","Cannot cancel a completed order"),
-        CANNOT_PROCESS_ORDER: new ApplicationException("Order","Cannot process a cancelled or a completed order")
+        CANNOT_PROCESS_ORDER: new ApplicationException("Order","Cannot process a cancelled or a completed order"),
+        INVALID_DATE : new ApplicationException("Order.InvalidDates","Ordered date must be before delivered date"),
+        NO_LINES :  new ApplicationException("Order.NoLines","Order must have at least one line")
     }
 
     private constructor(
@@ -129,9 +131,9 @@ export class Order {
         lines: OrderLine[],
         status ?: OrderStatusEnum,
         statusHistory ?: OrderStatusHistory[]
-    }){
-        if(order.orderedAt > order.deliveredAt) return new ApplicationException("Order.InvalidDates","Ordered date must be before delivered date");
-        if(order.lines.length === 0) return new ApplicationException("Order.NoLines","Order must have at least one line");
+    }) : Order | ApplicationException {
+        if(order.orderedAt > order.deliveredAt) return this.errors.INVALID_DATE;
+        if(order.lines.length === 0) return this.errors.NO_LINES;
         return new Order(
             order.orderId || Order.generateID(),
             order.orderedAt,

backend/src/domain/inventoryManagement/value-object/OrderLine.test.ts

@@ -0,0 +1,35 @@
+import {OrderLine, OrderLineDTO} from "@domain/inventoryManagement/value-object/OrderLine";
+import {assertError, generateOrderLineDTO} from "@tests/Utils";
+import {ApplicationException} from "@shared/ApplicationException";
+import {InventorySparePart} from "@domain/inventoryManagement/entities/InventorySparePart";
+
+describe("OrderLine", () => {
+    describe("create", () => {
+        it("should create an OrderLine with valid data", () => {
+            const dto: OrderLineDTO = generateOrderLineDTO();
+            const orderLine = OrderLine.create(dto);
+            expect(orderLine).toBeInstanceOf(OrderLine);
+            expect(orderLine).toEqual(
+                expect.objectContaining({
+                    reference: dto.reference,
+                    quantity: dto.quantity,
+                    unitPrice: dto.unitPrice,
+                })
+            );
+        });
+
+        it("should return an ApplicationException when the reference is invalid", () => {
+            const dto: OrderLineDTO = generateOrderLineDTO({ reference: "X" }); // Référence invalide
+            const orderLine = OrderLine.create(dto);
+            expect(orderLine).toBeInstanceOf(ApplicationException);
+            assertError(orderLine as ApplicationException, InventorySparePart.errors.REFERENCE_TOO_SHORT);
+        });
+
+        it("should return an ApplicationException when quantity is <= 0", () => {
+            const dto: OrderLineDTO = generateOrderLineDTO({ quantity: 0 }); // Quantité invalide
+            const orderLine = OrderLine.create(dto);
+            expect(orderLine).toBeInstanceOf(ApplicationException);
+            assertError(orderLine as ApplicationException, OrderLine.errors.INVALID_QUANTITY);
+        });
+    });
+});