@hy_ong/zod-kit 0.0.4 → 0.0.6

package/tests/common/number.test.ts

@@ -1,77 +1,247 @@
 import { describe, it, expect, beforeEach } from "vitest"
-import { setLocale, number, Locale } from "../../src"
-
-const locales = [
-  {
-    locale: "en",
-    messages: {
-      required: "Required",
-      min: "Must be at least 5",
-      max: "Must be at most 10",
-    },
-  },
-  {
-    locale: "zh-TW",
-    messages: {
-      required: "必填",
-      min: "最小值 5",
-      max: "最大值 10",
-    },
-  },
-] as const
-
-describe.each(locales)("number() locale: $locale", ({ locale, messages }) => {
-  beforeEach(() => setLocale(locale as Locale))
-
-  it("should pass with valid number", () => {
-    const schema = number()
-    expect(schema.parse(42)).toBe(42)
+import { number, setLocale } from "../../src"
+
+describe("number() features", () => {
+  beforeEach(() => setLocale("en"))
+
+  describe("type validation", () => {
+    it("should accept integers when type='integer'", () => {
+      const schema = number({ type: "integer" })
+      expect(schema.parse(42)).toBe(42)
+      expect(schema.parse("123")).toBe(123)
+    })
+
+    it("should reject floats when type='integer'", () => {
+      const schema = number({ type: "integer" })
+      expect(() => schema.parse(3.14)).toThrow("Must be an integer")
+      expect(() => schema.parse("3.14")).toThrow("Must be an integer")
+    })
+
+    it("should accept floats when type='float'", () => {
+      const schema = number({ type: "float" })
+      expect(schema.parse(3.14)).toBe(3.14)
+      expect(schema.parse("3.14")).toBe(3.14)
+    })
+
+    it("should reject integers when type='float'", () => {
+      const schema = number({ type: "float" })
+      expect(() => schema.parse(42)).toThrow("Must be a decimal number")
+      expect(() => schema.parse("42")).toThrow("Must be a decimal number")
+    })
+
+    it("should accept both when type='both' (default)", () => {
+      const schema = number({ type: "both" })
+      expect(schema.parse(42)).toBe(42)
+      expect(schema.parse(3.14)).toBe(3.14)
+    })
   })
 
-  it("should parse string number", () => {
-    const schema = number()
-    expect(schema.parse("123")).toBe(123)
+  describe("sign validation", () => {
+    it("should enforce positive numbers", () => {
+      const schema = number({ positive: true })
+      expect(schema.parse(5)).toBe(5)
+      expect(() => schema.parse(0)).toThrow("Must be positive")
+      expect(() => schema.parse(-5)).toThrow("Must be positive")
+    })
+
+    it("should enforce negative numbers", () => {
+      const schema = number({ negative: true })
+      expect(schema.parse(-5)).toBe(-5)
+      expect(() => schema.parse(0)).toThrow("Must be negative")
+      expect(() => schema.parse(5)).toThrow("Must be negative")
+    })
+
+    it("should enforce non-negative numbers", () => {
+      const schema = number({ nonNegative: true })
+      expect(schema.parse(0)).toBe(0)
+      expect(schema.parse(5)).toBe(5)
+      expect(() => schema.parse(-5)).toThrow("Must be non-negative")
+    })
+
+    it("should enforce non-positive numbers", () => {
+      const schema = number({ nonPositive: true })
+      expect(schema.parse(0)).toBe(0)
+      expect(schema.parse(-5)).toBe(-5)
+      expect(() => schema.parse(5)).toThrow("Must be non-positive")
+    })
   })
 
-  it("should fail for empty string when required", () => {
-    const schema = number({ required: true })
-    expect(() => schema.parse("")).toThrow(messages.required)
-    expect(() => schema.parse(null)).toThrow(messages.required)
-    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  describe("multipleOf validation", () => {
+    it("should enforce multiple of constraint", () => {
+      const schema = number({ multipleOf: 5 })
+      expect(schema.parse(0)).toBe(0)
+      expect(schema.parse(5)).toBe(5)
+      expect(schema.parse(10)).toBe(10)
+      expect(schema.parse(-5)).toBe(-5)
+      expect(() => schema.parse(3)).toThrow("Must be a multiple of 5")
+      expect(() => schema.parse(7)).toThrow("Must be a multiple of 5")
+    })
   })
 
-  it("should allow null if not required", () => {
-    const schema = number({ required: false })
-    expect(schema.parse("")).toBe(null)
-    expect(schema.parse(null)).toBe(null)
-    expect(schema.parse(undefined)).toBe(null)
+  describe("precision validation", () => {
+    it("should enforce decimal precision", () => {
+      const schema = number({ precision: 2 })
+      expect(schema.parse(3.14)).toBe(3.14)
+      expect(schema.parse(3.1)).toBe(3.1)
+      expect(schema.parse(3)).toBe(3)
+      expect(() => schema.parse(3.141)).toThrow("Must have at most 2 decimal places")
+      expect(() => schema.parse(3.1234)).toThrow("Must have at most 2 decimal places")
+    })
+  })
+
+  describe("finite validation", () => {
+    it("should reject infinite values by default", () => {
+      const schema = number()
+      expect(() => schema.parse(Infinity)).toThrow("Must be a finite number")
+      expect(() => schema.parse(-Infinity)).toThrow("Must be a finite number")
+    })
+
+    it("should allow infinite values when finite=false", () => {
+      const schema = number({ finite: false })
+      expect(schema.parse(Infinity)).toBe(Infinity)
+      expect(schema.parse(-Infinity)).toBe(-Infinity)
+    })
   })
 
-  it("should apply default value with not required", () => {
-    const schema = number({ required: false, defaultValue: 42 })
-    expect(schema.parse("")).toBe(42)
-    expect(schema.parse(null)).toBe(42)
-    expect(schema.parse(undefined)).toBe(42)
+  describe("parseCommas functionality", () => {
+    it("should parse comma-separated numbers", () => {
+      const schema = number({ parseCommas: true })
+      expect(schema.parse("1,234")).toBe(1234)
+      expect(schema.parse("1,234.56")).toBe(1234.56)
+      expect(schema.parse("12,345,678")).toBe(12345678)
+    })
+
+    it("should not parse commas by default", () => {
+      const schema = number()
+      expect(() => schema.parse("1,234")).toThrow("Must be a valid number")
+    })
   })
 
-  it("should apply default value with required", () => {
-    const schema = number({ required: true, defaultValue: 42 })
-    expect(schema.parse("")).toBe(42)
-    expect(schema.parse(null)).toBe(42)
-    expect(schema.parse(undefined)).toBe(42)
+  describe("transform functionality", () => {
+    it("should apply transform function", () => {
+      const schema = number({
+        transform: (val) => Math.round(val * 100) / 100, // Round to 2 decimals
+      })
+      expect(schema.parse(3.14159)).toBe(3.14)
+      expect(schema.parse("2.71828")).toBe(2.72)
+    })
   })
 
-  it("should enforce min", () => {
-    const schema = number({ min: 5 })
-    expect(schema.parse(5)).toBe(5)
-    expect(() => schema.parse(2)).toThrow(messages.min)
-    expect(() => schema.parse("2")).toThrow(messages.min)
+  describe("custom i18n messages", () => {
+    it("should use custom messages when provided", () => {
+      const schema = number({
+        type: "integer",
+        min: 0,
+        i18n: {
+          en: {
+            required: "Custom required message",
+            integer: "Custom integer message",
+            min: "Custom min: at least ${min}",
+          },
+          "zh-TW": {
+            required: "客製化必填訊息",
+            integer: "客製化整數訊息",
+            min: "客製化最小值: 至少 ${min}",
+          },
+        },
+      })
+
+      expect(() => schema.parse("")).toThrow("Custom required message")
+      expect(() => schema.parse(3.14)).toThrow("Custom integer message")
+      expect(() => schema.parse(-1)).toThrow("Custom min: at least 0")
+    })
+
+    it("should fallback to default messages when custom not provided", () => {
+      const schema = number({
+        type: "integer",
+        max: 10,
+        i18n: {
+          en: {
+            required: "Custom required message",
+          },
+          "zh-TW": {
+            required: "客製化必填訊息",
+          },
+        },
+      })
+
+      expect(() => schema.parse("")).toThrow("Custom required message")
+      expect(() => schema.parse(3.14)).toThrow("Must be an integer")
+      expect(() => schema.parse(15)).toThrow("Must be at most 10")
+    })
+
+    it("should use correct locale for custom messages", () => {
+      setLocale("en")
+      const schemaEn = number({
+        type: "integer",
+        i18n: {
+          en: {
+            integer: "English integer message",
+          },
+          "zh-TW": {
+            integer: "繁體中文整數訊息",
+          },
+        },
+      })
+      expect(() => schemaEn.parse(3.14)).toThrow("English integer message")
+
+      setLocale("zh-TW")
+      const schemaZh = number({
+        type: "integer",
+        i18n: {
+          en: {
+            integer: "English integer message",
+          },
+          "zh-TW": {
+            integer: "繁體中文整數訊息",
+          },
+        },
+      })
+      expect(() => schemaZh.parse(3.14)).toThrow("繁體中文整數訊息")
+    })
   })
 
-  it("should enforce max", () => {
-    const schema = number({ max: 10 })
-    expect(schema.parse(10)).toBe(10)
-    expect(() => schema.parse(11)).toThrow(messages.max)
-    expect(() => schema.parse("11")).toThrow(messages.max)
+  describe("complex scenarios", () => {
+    it("should work with multiple validations", () => {
+      const schema = number({
+        type: "integer",
+        min: 1,
+        max: 100,
+        multipleOf: 5,
+        positive: true,
+      })
+
+      expect(schema.parse(5)).toBe(5)
+      expect(schema.parse(10)).toBe(10)
+      expect(schema.parse(95)).toBe(95)
+
+      expect(() => schema.parse(0)).toThrow("Must be positive")
+      expect(() => schema.parse(3)).toThrow("Must be a multiple of 5")
+      expect(() => schema.parse(105)).toThrow("Must be at most 100")
+      expect(() => schema.parse(5.5)).toThrow("Must be an integer")
+    })
+
+    it("should handle null values correctly when not required", () => {
+      const schema = number({
+        required: false,
+        type: "integer",
+        min: 0,
+      })
+
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+      expect(schema.parse(5)).toBe(5)
+    })
+
+    it("should work with parseCommas and transform together", () => {
+      const schema = number({
+        parseCommas: true,
+        transform: (val) => Math.floor(val / 100) * 100, // Round down to nearest 100
+      })
+
+      expect(schema.parse("1,234")).toBe(1200)
+      expect(schema.parse("5,678.90")).toBe(5600)
+    })
   })
 })

package/tests/common/password.test.ts

@@ -6,24 +6,38 @@ const locales = [
     locale: "en",
     messages: {
       required: "Required",
-      min: "Must be at least 5 characters",
-      max: "Must be at most 5 characters",
+      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: "必填",
-      min: "長度至少 5 字元",
-      max: "長度最多 5 字元",
+      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()
-    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()
-    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({ 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({ 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({ 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({ 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({ 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({ 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({ 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()
+        }
+      })
+    })
   })
-})
+})