@hy_ong/zod-kit 0.0.2 → 0.0.5

package/tests/common/password.test.ts

@@ -5,25 +5,39 @@ const locales = [
   {
     locale: "en",
     messages: {
-      required: "TEST is required",
-      min: "TEST must be at least 5 characters",
-      max: "TEST must be at most 5 characters",
-      uppercase: "TEST must include at least one uppercase letter",
-      lowercase: "TEST must include at least one lowercase letter",
-      digits: "TEST must include at least one digit",
-      special: "TEST must include at least one special character",
+      required: "Required",
+      min: "Must be at least 8 characters",
+      max: "Must be at most 20 characters",
+      uppercase: "Must include at least one uppercase letter",
+      lowercase: "Must include at least one lowercase letter",
+      digits: "Must include at least one digit",
+      special: "Must include at least one special character",
+      noRepeating: "Must not contain repeating characters",
+      noSequential: "Must not contain sequential characters",
+      noCommonWords: "Must not contain common words or patterns",
+      minStrength: "Password strength must be at least strong",
+      excludes: "Must not contain test",
+      includes: "Must include @",
+      invalid: "Invalid password format",
     },
   },
   {
     locale: "zh-TW",
     messages: {
-      required: "請輸入 TEST",
-      min: "TEST 長度至少 5 字元",
-      max: "TEST 長度最多 5 字元",
-      uppercase: "TEST 必須包含至少一個大寫字母",
-      lowercase: "TEST 必須包含至少一個小寫字母",
-      digits: "TEST 必須包含至少一個數字",
-      special: "TEST 必須包含至少一個特殊符號",
+      required: "必填",
+      min: "長度至少 8 字元",
+      max: "長度最多 20 字元",
+      uppercase: "必須包含至少一個大寫字母",
+      lowercase: "必須包含至少一個小寫字母",
+      digits: "必須包含至少一個數字",
+      special: "必須包含至少一個特殊符號",
+      noRepeating: "不可包含重複字元",
+      noSequential: "不可包含連續字元",
+      noCommonWords: "不可包含常見密碼或模式",
+      minStrength: "密碼強度必須至少為 strong",
+      excludes: "不得包含「test」",
+      includes: "必須包含「@」",
+      invalid: "密碼格式錯誤",
     },
   },
 ] as const
@@ -31,59 +45,272 @@ const locales = [
 describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
   beforeEach(() => setLocale(locale as Locale))
 
-  it("should pass with valid string", () => {
-    const schema = password({ label: "TEST" })
-    expect(schema.parse("hello")).toBe("hello")
-  })
+  describe("basic functionality", () => {
+    it("should pass with valid string", () => {
+      const schema = password()
+      expect(schema.parse("hello")).toBe("hello")
+    })
+
+    it("should fail with empty string when required", () => {
+      const schema = password()
+      expect(() => schema.parse("")).toThrow(messages.required)
+      expect(() => schema.parse(null)).toThrow(messages.required)
+      expect(() => schema.parse(undefined)).toThrow(messages.required)
+    })
+
+    it("should pass with null when not required", () => {
+      const schema = password({ required: false })
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+    })
+
+    it("should handle default values", () => {
+      const schema = password({ required: false, defaultValue: "default123" })
+      expect(schema.parse("")).toBe("default123")
+      expect(schema.parse(null)).toBe("default123")
+      expect(schema.parse(undefined)).toBe("default123")
+      expect(schema.parse("actual")).toBe("actual")
+    })
 
-  it("should fail with empty string when required", () => {
-    const schema = password({ label: "TEST" })
-    expect(() => schema.parse("")).toThrow(messages.required)
-    expect(() => schema.parse(null)).toThrow(messages.required)
-    expect(() => schema.parse(undefined)).toThrow(messages.required)
+    it("should apply transform function", () => {
+      const schema = password({ transform: (val) => val.toLowerCase() })
+      expect(schema.parse("HELLO")).toBe("hello")
+    })
   })
 
-  it("should pass with null when not required", () => {
-    const schema = password({ label: "TEST", required: false })
-    expect(schema.parse("")).toBe(null)
-    expect(schema.parse(null)).toBe(null)
-    expect(schema.parse(undefined)).toBe(null)
+  describe("length validation", () => {
+    it("should fail with string shorter than min", () => {
+      const schema = password({ min: 8 })
+      expect(() => schema.parse("short")).toThrow(messages.min)
+    })
+
+    it("should fail with string longer than max", () => {
+      const schema = password({ max: 20 })
+      expect(() => schema.parse("this_is_a_very_long_password_that_exceeds_limit")).toThrow(messages.max)
+    })
+
+    it("should pass with valid length", () => {
+      const schema = password({ min: 5, max: 15 })
+      expect(schema.parse("validpassword")).toBe("validpassword")
+    })
   })
 
-  it("should fail with string shorter than min", () => {
-    const schema = password({ label: "TEST", min: 5 })
-    expect(() => schema.parse("hi")).toThrow(messages.min)
-    expect(() => schema.parse("")).toThrow(messages.min)
-    expect(() => schema.parse(null)).toThrow(messages.min)
-    expect(() => schema.parse(undefined)).toThrow(messages.min)
+  describe("character requirements", () => {
+    it("should enforce uppercase requirement", () => {
+      const schema = password({ uppercase: true })
+      expect(() => schema.parse("lowercase1!")).toThrow(messages.uppercase)
+      expect(schema.parse("Hello1!")).toBe("Hello1!")
+    })
+
+    it("should enforce lowercase requirement", () => {
+      const schema = password({ lowercase: true })
+      expect(() => schema.parse("UPPERCASE1!")).toThrow(messages.lowercase)
+      expect(schema.parse("Test1!")).toBe("Test1!")
+    })
+
+    it("should enforce digit requirement", () => {
+      const schema = password({ digits: true })
+      expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
+      expect(schema.parse("With1!")).toBe("With1!")
+    })
+
+    it("should enforce special character requirement", () => {
+      const schema = password({ special: true })
+      expect(() => schema.parse("NoSpecial1")).toThrow(messages.special)
+      expect(schema.parse("Valid1!")).toBe("Valid1!")
+    })
+
+    it("should enforce multiple requirements", () => {
+      const schema = password({ uppercase: true, lowercase: true, digits: true, special: true })
+      expect(() => schema.parse("nouppercase1!")).toThrow(messages.uppercase)
+      expect(() => schema.parse("NOLOWERCASE1!")).toThrow(messages.lowercase)
+      expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
+      expect(() => schema.parse("NoSpecial1")).toThrow(messages.special)
+      expect(schema.parse("Valid1!")).toBe("Valid1!")
+    })
   })
 
-  it("should fail with string longer than max", () => {
-    const schema = password({ label: "TEST", max: 5 })
-    expect(() => schema.parse("hello world")).toThrow(messages.max)
+  describe("advanced security features", () => {
+    it("should enforce no repeating characters", () => {
+      const schema = password({ noRepeating: true })
+      expect(() => schema.parse("password111")).toThrow(messages.noRepeating)
+      expect(() => schema.parse("helllo")).toThrow(messages.noRepeating)
+      expect(schema.parse("password")).toBe("password")
+    })
+
+    it("should enforce no sequential characters", () => {
+      const schema = password({ noSequential: true })
+      expect(() => schema.parse("abc123")).toThrow(messages.noSequential)
+      expect(() => schema.parse("xyz789")).toThrow(messages.noSequential)
+      expect(() => schema.parse("password456")).toThrow(messages.noSequential)
+      expect(schema.parse("random135")).toBe("random135")
+    })
+
+    it("should enforce no common words", () => {
+      const schema = password({ noCommonWords: true })
+      expect(() => schema.parse("password123")).toThrow(messages.noCommonWords)
+      expect(() => schema.parse("admin")).toThrow(messages.noCommonWords)
+      expect(() => schema.parse("qwerty")).toThrow(messages.noCommonWords)
+      expect(schema.parse("randomtext")).toBe("randomtext")
+    })
+
+    it("should enforce minimum strength", () => {
+      const schema = password({ minStrength: "strong" })
+      expect(() => schema.parse("weak")).toThrow(messages.minStrength)
+      expect(() => schema.parse("123456")).toThrow(messages.minStrength)
+      expect(schema.parse("StrongP@ssw0rd")).toBe("StrongP@ssw0rd")
+    })
   })
 
-  it("should enforce uppercase requirement", () => {
-    const schema = password({ label: "TEST", uppercase: true })
-    expect(() => schema.parse("lowercase1!")).toThrow(messages.uppercase)
-    expect(schema.parse("Hello1!")).toBe("Hello1!")
+  describe("content validation", () => {
+    it("should enforce includes requirement", () => {
+      const schema = password({ includes: "@" })
+      expect(() => schema.parse("password")).toThrow(messages.includes)
+      expect(schema.parse("user@pass")).toBe("user@pass")
+    })
+
+    it("should enforce excludes requirement with string", () => {
+      const schema = password({ excludes: "test" })
+      expect(() => schema.parse("testpassword")).toThrow(messages.excludes)
+      expect(schema.parse("password")).toBe("password")
+    })
+
+    it("should enforce excludes requirement with array", () => {
+      const schema = password({ excludes: ["test", "admin"] })
+      expect(() => schema.parse("testpassword")).toThrow()
+      expect(() => schema.parse("adminpass")).toThrow()
+      expect(schema.parse("password")).toBe("password")
+    })
+
+    it("should enforce regex requirement", () => {
+      const schema = password({ regex: /^[a-zA-Z0-9!@#$%^&*()]+$/ })
+      expect(() => schema.parse("invalid-password")).toThrow(messages.invalid)
+      expect(schema.parse("Valid123!")).toBe("Valid123!")
+    })
   })
 
-  it("should enforce lowercase requirement", () => {
-    const schema = password({ label: "TEST", lowercase: true })
-    expect(() => schema.parse("UPPERCASE1!")).toThrow(messages.lowercase)
-    expect(schema.parse("Test1!")).toBe("Test1!")
+  describe("custom i18n messages", () => {
+    it("should use custom i18n messages when provided", () => {
+      const customMessages = {
+        en: {
+          required: "Custom required message",
+          min: "Custom min ${min} message",
+          uppercase: "Custom uppercase message",
+        },
+        "zh-TW": {
+          required: "自訂必填訊息",
+          min: "自訂最小長度 ${min} 訊息",
+          uppercase: "自訂大寫字母訊息",
+        },
+      }
+
+      const schema = password({
+        min: 8,
+        uppercase: true,
+        i18n: customMessages,
+      })
+
+      if (locale === "en") {
+        expect(() => schema.parse("")).toThrow("Custom required message")
+        expect(() => schema.parse("short")).toThrow("Custom min 8 message")
+        expect(() => schema.parse("nouppercase")).toThrow("Custom uppercase message")
+      } else {
+        expect(() => schema.parse("")).toThrow("自訂必填訊息")
+        expect(() => schema.parse("short")).toThrow("自訂最小長度 8 訊息")
+        expect(() => schema.parse("nouppercase")).toThrow("自訂大寫字母訊息")
+      }
+    })
+
+    it("should fallback to default i18n when custom message not provided", () => {
+      const customMessages = {
+        en: { required: "Custom required message" },
+        "zh-TW": { required: "自訂必填訊息" },
+      }
+
+      const schema = password({
+        uppercase: true,
+        i18n: customMessages,
+      })
+
+      if (locale === "en") {
+        expect(() => schema.parse("")).toThrow("Custom required message")
+        expect(() => schema.parse("nouppercase")).toThrow(messages.uppercase)
+      } else {
+        expect(() => schema.parse("")).toThrow("自訂必填訊息")
+        expect(() => schema.parse("nouppercase")).toThrow(messages.uppercase)
+      }
+    })
   })
 
-  it("should enforce digit requirement", () => {
-    const schema = password({ label: "TEST", digits: true })
-    expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
-    expect(schema.parse("With1!")).toBe("With1!")
+  describe("complex scenarios", () => {
+    it("should handle all features combined", () => {
+      const schema = password({
+        min: 12,
+        max: 50,
+        uppercase: true,
+        lowercase: true,
+        digits: true,
+        special: true,
+        noRepeating: true,
+        noSequential: true,
+        noCommonWords: true,
+        minStrength: "strong",
+        includes: "@",
+        excludes: ["test", "admin"],
+      })
+
+      // Should fail for various reasons
+      expect(() => schema.parse("short")).toThrow()
+      expect(() => schema.parse("NoLowercase123!@")).toThrow()
+      expect(() => schema.parse("nouppercase123!@")).toThrow()
+      expect(() => schema.parse("NoDigits!@")).toThrow()
+      expect(() => schema.parse("NoSpecial123@")).toThrow()
+      expect(() => schema.parse("Repeating111!@")).toThrow()
+      expect(() => schema.parse("Sequential123!@")).toThrow()
+      expect(() => schema.parse("Password123!@")).toThrow()
+      expect(() => schema.parse("Complex123!")).toThrow() // Missing @
+      expect(() => schema.parse("TestComplex123!@")).toThrow() // Contains "test"
+
+      // Should pass
+      expect(schema.parse("C0mpl3x@P@ssw0rd")).toBe("C0mpl3x@P@ssw0rd")
+    })
+
+    it("should work with optional password and all features", () => {
+      const schema = password({
+        required: false,
+        min: 8,
+        uppercase: true,
+        lowercase: true,
+        digits: true,
+        special: true,
+      })
+
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse("")).toBe(null)
+      expect(() => schema.parse("weak")).toThrow()
+      expect(schema.parse("Strong1!")).toBe("Strong1!")
+    })
   })
 
-  it("should enforce special character requirement", () => {
-    const schema = password({ label: "TEST", special: true })
-    expect(() => schema.parse("NoSpecial1")).toThrow(messages.special)
-    expect(schema.parse("Valid1!")).toBe("Valid1!")
+  describe("password strength calculation", () => {
+    const testStrengthScenarios = [
+      { password: "weak", expectedToPass: false, minStrength: "medium" as const },
+      { password: "Medium1", expectedToPass: false, minStrength: "strong" as const },
+      { password: "Strong1!", expectedToPass: true, minStrength: "medium" as const },
+      { password: "VeryStrongP@ssw0rd123", expectedToPass: true, minStrength: "strong" as const },
+    ]
+
+    testStrengthScenarios.forEach(({ password: testPassword, expectedToPass, minStrength }) => {
+      it(`should ${expectedToPass ? "pass" : "fail"} for password "${testPassword}" with minStrength "${minStrength}"`, () => {
+        const schema = password({ minStrength })
+
+        if (expectedToPass) {
+          expect(schema.parse(testPassword)).toBe(testPassword)
+        } else {
+          expect(() => schema.parse(testPassword)).toThrow()
+        }
+      })
+    })
   })
-})
+})