zod 3.26.0-canary.20250703T011142 → 3.26.0-canary.20250703T025502

package/src/v4/classic/tests/set.test.ts

@@ -0,0 +1,179 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const stringSet = z.set(z.string());
+type stringSet = z.infer<typeof stringSet>;
+
+const minTwo = z.set(z.string()).min(2);
+const maxTwo = z.set(z.string()).max(2);
+const justTwo = z.set(z.string()).size(2);
+const nonEmpty = z.set(z.string()).nonempty();
+const nonEmptyMax = z.set(z.string()).nonempty().max(2);
+
+test("type inference", () => {
+  expectTypeOf<stringSet>().toEqualTypeOf<Set<string>>();
+});
+
+test("valid parse", () => {
+  const result = stringSet.safeParse(new Set(["first", "second"]));
+  expect(result.success).toEqual(true);
+  expect(result.data!.has("first")).toEqual(true);
+  expect(result.data!.has("second")).toEqual(true);
+  expect(result.data!.has("third")).toEqual(false);
+
+  expect(() => {
+    minTwo.parse(new Set(["a", "b"]));
+    minTwo.parse(new Set(["a", "b", "c"]));
+    maxTwo.parse(new Set(["a", "b"]));
+    maxTwo.parse(new Set(["a"]));
+    justTwo.parse(new Set(["a", "b"]));
+    nonEmpty.parse(new Set(["a"]));
+    nonEmptyMax.parse(new Set(["a"]));
+  }).not.toThrow();
+});
+
+test("valid parse async", async () => {
+  const result = await stringSet.spa(new Set(["first", "second"]));
+  expect(result.success).toEqual(true);
+  expect(result.data!.has("first")).toEqual(true);
+  expect(result.data!.has("second")).toEqual(true);
+  expect(result.data!.has("third")).toEqual(false);
+
+  const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
+  expect(asyncResult.success).toEqual(true);
+  expect(asyncResult.data!.has("first")).toEqual(true);
+  expect(asyncResult.data!.has("second")).toEqual(true);
+  expect(asyncResult.data!.has("third")).toEqual(false);
+});
+
+test("valid parse: size-related methods", () => {
+  expect(() => {
+    minTwo.parse(new Set(["a", "b"]));
+    minTwo.parse(new Set(["a", "b", "c"]));
+    maxTwo.parse(new Set(["a", "b"]));
+    maxTwo.parse(new Set(["a"]));
+    justTwo.parse(new Set(["a", "b"]));
+    nonEmpty.parse(new Set(["a"]));
+    nonEmptyMax.parse(new Set(["a"]));
+  }).not.toThrow();
+
+  const sizeZeroResult = stringSet.parse(new Set());
+  expect(sizeZeroResult.size).toBe(0);
+
+  const sizeTwoResult = minTwo.parse(new Set(["a", "b"]));
+  expect(sizeTwoResult.size).toBe(2);
+});
+
+test("failing when parsing empty set in nonempty ", () => {
+  const result = nonEmpty.safeParse(new Set());
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_small");
+});
+
+test("failing when set is smaller than min() ", () => {
+  const result = minTwo.safeParse(new Set(["just_one"]));
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_small");
+});
+
+test("failing when set is bigger than max() ", () => {
+  const result = maxTwo.safeParse(new Set(["one", "two", "three"]));
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_big");
+});
+
+test("doesn’t throw when an empty set is given", () => {
+  const result = stringSet.safeParse(new Set([]));
+  expect(result.success).toEqual(true);
+});
+
+test("throws when a Map is given", () => {
+  const result = stringSet.safeParse(new Map([]));
+  expect(result.success).toEqual(false);
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "set",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected set, received Map"
+      }
+    ]]
+  `);
+});
+
+test("throws when the given set has invalid input", () => {
+  const result = stringSet.safeParse(new Set([Symbol()]));
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received symbol"
+      }
+    ]]
+  `);
+});
+
+test("throws when the given set has multiple invalid entries", () => {
+  const result = stringSet.safeParse(new Set([1, 2] as any[]));
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(2);
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]]
+  `);
+});
+
+test("min/max", async () => {
+  const schema = z.set(z.string()).min(4).max(5);
+
+  const r1 = schema.safeParse(new Set(["a", "b", "c", "d"]));
+  expect(r1.success).toEqual(true);
+
+  const r2 = schema.safeParse(new Set(["a", "b", "c"]));
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "message": "Too small: expected set to have >4 items",
+        "minimum": 4,
+        "origin": "set",
+        "path": [],
+      },
+    ]
+  `);
+
+  const r3 = schema.safeParse(new Set(["a", "b", "c", "d", "e", "f"]));
+  expect(r3.success).toEqual(false);
+  expect(r3.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "maximum": 5,
+        "message": "Too big: expected set to have <5 items",
+        "origin": "set",
+        "path": [],
+      },
+    ]
+  `);
+});

package/src/v4/classic/tests/standard-schema.test.ts

@@ -0,0 +1,57 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("length checks", async () => {
+  const schema = z.string();
+  const result = await schema["~standard"].validate(12);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "issues": [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [],
+        },
+      ],
+    }
+  `);
+});
+
+test("length checks", async () => {
+  const schema = z.string();
+  const result = await schema["~standard"].validate("asdf");
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "value": "asdf",
+    }
+  `);
+});
+
+test("length checks", async () => {
+  const schema = z.string().refine(async (val) => val.length > 5);
+  const result = await schema["~standard"].validate(12);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "issues": [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [],
+        },
+      ],
+    }
+  `);
+});
+
+test("length checks", async () => {
+  const schema = z.string().refine(async (val) => val.length > 5);
+  const result = await schema["~standard"].validate("234134134");
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "value": "234134134",
+    }
+  `);
+});

package/src/v4/classic/tests/string-formats.test.ts

@@ -0,0 +1,109 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("string format methods", () => {
+  const a = z.email().min(10);
+  const b = z.email().max(10);
+  const c = z.email().length(10);
+  const d = z.email().uppercase();
+  const e = z.email().lowercase();
+
+  // Positive and negative cases for `a`
+  expect(a.safeParse("longemail@example.com").success).toBe(true); // Positive
+  expect(a.safeParse("ort@e.co").success).toBe(false); // Negative
+
+  // Positive and negative cases for `b`
+  expect(b.safeParse("sho@e.co").success).toBe(true); // Positive
+  expect(b.safeParse("longemail@example.com").success).toBe(false); // Negative
+
+  // Positive and negative cases for `c`
+  expect(c.safeParse("56780@e.co").success).toBe(true); // Positive
+  expect(c.safeParse("shoasdfasdfrt@e.co").success).toBe(false); // Negative
+
+  // Positive and negative cases for `d`
+  expect(d.safeParse("EMAIL@EXAMPLE.COM").success).toBe(true); // Positive
+  expect(d.safeParse("email@example.com").success).toBe(false); // Negative
+
+  // Positive and negative cases for `e`
+  expect(e.safeParse("email@example.com").success).toBe(true); // Positive
+  expect(e.safeParse("EMAIL@EXAMPLE.COM").success).toBe(false); // Negative
+});
+
+test("z.stringFormat", () => {
+  const ccRegex = /^(?:\d{14,19}|\d{4}(?: \d{3,6}){2,4}|\d{4}(?:-\d{3,6}){2,4})$/u;
+
+  const a = z
+    .stringFormat("creditCard", (val) => ccRegex.test(val), {
+      error: `Invalid credit card number`,
+    })
+    .refine((_) => false, "Also bad");
+
+  expect(a.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "creditCard",
+        "path": [],
+        "message": "Invalid credit card number"
+      },
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Also bad"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+  expect(a.safeParse("1234-5678-9012-3456")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Also bad"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+  expect(a.def.pattern).toMatchInlineSnapshot(`undefined`);
+
+  const b = z
+    .stringFormat("creditCard", ccRegex, {
+      abort: true,
+      error: `Invalid credit card number`,
+    })
+    .refine((_) => false, "Also bad");
+
+  expect(b.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "creditCard",
+        "path": [],
+        "message": "Invalid credit card number"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+  expect(b.safeParse("1234-5678-9012-3456")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Also bad"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+  expect(b.def.pattern).toMatchInlineSnapshot(
+    `/\\^\\(\\?:\\\\d\\{14,19\\}\\|\\\\d\\{4\\}\\(\\?: \\\\d\\{3,6\\}\\)\\{2,4\\}\\|\\\\d\\{4\\}\\(\\?:-\\\\d\\{3,6\\}\\)\\{2,4\\}\\)\\$/u`
+  );
+});