@hy_ong/zod-kit 0.0.2 → 0.0.5

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: "TEST is required",
-      min: "TEST must be at least 5",
-      max: "TEST must be at most 10",
-    },
-  },
-  {
-    locale: "zh-TW",
-    messages: {
-      required: "請輸入 TEST",
-      min: "TEST 最小值 5",
-      max: "TEST 最大值 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({ label: "TEST" })
-    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({ label: "TEST" })
-    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({ label: "TEST", 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({ label: "TEST", 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({ label: "TEST", 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({ label: "TEST", 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({ label: "TEST", 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({ label: "TEST", 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)
+    })
   })
 })