Ajout de la gestion des erreurs HTTP, implémentation de la validation des comptes, et mise à jour des dépendances. Création de tests pour les entités et services de compte, ainsi que l'ajout d'un système de limitation de taux.

tests/AccountValidation.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from "vitest";
+import {
+  emailSchema,
+  passwordSchema,
+  loginSchema,
+  registerSchema,
+  EMAIL_REGEX,
+  MIN_PASSWORD_LENGTH,
+} from "../src/domain/account/validation/AccountValidation";
+import { AccountEntity } from "../src/domain/account/entity/AccountEntity";
+import {
+  InvalidEmailFormatError,
+  WeakPasswordError,
+} from "../src/domain/account/errors/AccountErrors";
+
+describe("AccountValidation", () => {
+  describe("Email validation consistency", () => {
+    const validEmails = [
+      "test@example.com",
+      "user.name@domain.co.uk",
+      "firstname+lastname@example.org",
+    ];
+
+    const invalidEmails = [
+      "invalid-email",
+      "@example.com",
+      "test@",
+      "test",
+      "test@domain",
+      "",
+    ];
+
+    it("should validate same emails in Zod and Entity", () => {
+      validEmails.forEach((email) => {
+        expect(emailSchema.safeParse(email).success).toBe(true);
+        expect(() => AccountEntity.create(email, "password123")).not.toThrow(
+          InvalidEmailFormatError,
+        );
+      });
+
+      invalidEmails.forEach((email) => {
+        expect(emailSchema.safeParse(email).success).toBe(false);
+        expect(() => AccountEntity.create(email, "password123")).toThrow(
+          InvalidEmailFormatError,
+        );
+      });
+    });
+
+    it("should use same regex pattern", () => {
+      validEmails.forEach((email) => {
+        expect(EMAIL_REGEX.test(email)).toBe(true);
+      });
+
+      invalidEmails.forEach((email) => {
+        expect(EMAIL_REGEX.test(email)).toBe(false);
+      });
+    });
+  });
+
+  describe("Password validation consistency", () => {
+    const validPasswords = ["password123", "abcdefgh", "12345678", "P@ssw0rd!"];
+
+    const invalidPasswords = ["1234567", "short", "", "abc"];
+
+    it("should validate same passwords in Zod and Entity", () => {
+      validPasswords.forEach((password) => {
+        expect(passwordSchema.safeParse(password).success).toBe(true);
+        expect(() =>
+          AccountEntity.create("test@example.com", password),
+        ).not.toThrow(WeakPasswordError);
+      });
+
+      invalidPasswords.forEach((password) => {
+        expect(passwordSchema.safeParse(password).success).toBe(false);
+        expect(() =>
+          AccountEntity.create("test@example.com", password),
+        ).toThrow(WeakPasswordError);
+      });
+    });
+
+    it("should use same minimum length", () => {
+      validPasswords.forEach((password) => {
+        expect(password.length >= MIN_PASSWORD_LENGTH).toBe(true);
+      });
+
+      invalidPasswords.forEach((password) => {
+        expect(password.length >= MIN_PASSWORD_LENGTH).toBe(false);
+      });
+    });
+  });
+
+  describe("Complete schemas", () => {
+    it("should validate login schema correctly", () => {
+      const validLogin = { email: "test@example.com", password: "password123" };
+      const invalidLogin = { email: "invalid", password: "123" };
+
+      expect(loginSchema.safeParse(validLogin).success).toBe(true);
+      expect(loginSchema.safeParse(invalidLogin).success).toBe(false);
+    });
+
+    it("should validate register schema correctly", () => {
+      const validRegister = {
+        email: "test@example.com",
+        password: "password123",
+      };
+      const invalidRegister = { email: "invalid", password: "123" };
+
+      expect(registerSchema.safeParse(validRegister).success).toBe(true);
+      expect(registerSchema.safeParse(invalidRegister).success).toBe(false);
+    });
+  });
+
+  describe("Error messages consistency", () => {
+    it("should return consistent password error message", () => {
+      const result = passwordSchema.safeParse("123");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0]?.message).toContain(
+          `${MIN_PASSWORD_LENGTH} caractères`,
+        );
+      }
+    });
+
+    it("should return consistent email error message", () => {
+      const result = emailSchema.safeParse("invalid-email");
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0]?.message).toBe("Format d'email invalide");
+      }
+    });
+  });
+});