FM / tests

/home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v4/classic/tests/

/home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v4/classic/tests

Name	Size	Mode	Actions
anyunknown.test.ts	639	0666	edit dl rm
array.test.ts	7284	0666	edit dl rm
assignability.test.ts	6790	0666	edit dl rm
async-parsing.test.ts	12311	0666	edit dl rm
async-refinements.test.ts	1867	0666	edit dl rm
base.test.ts	179	0666	edit dl rm
bigint.test.ts	1956	0666	edit dl rm
brand.test.ts	2206	0666	edit dl rm
catch.test.ts	7224	0666	edit dl rm
coalesce.test.ts	743	0666	edit dl rm
coerce.test.ts	7736	0666	edit dl rm
continuability.test.ts	7478	0666	edit dl rm
custom.test.ts	1215	0666	edit dl rm
date.test.ts	962	0666	edit dl rm
datetime.test.ts	11511	0666	edit dl rm
default.test.ts	7717	0666	edit dl rm
description.test.ts	1294	0666	edit dl rm
discriminated-unions.test.ts	16810	0666	edit dl rm
enum.test.ts	8488	0666	edit dl rm
error-utils.test.ts	12572	0666	edit dl rm
error.test.ts	19502	0666	edit dl rm
file.test.ts	2460	0666	edit dl rm
firstparty.test.ts	2977	0666	edit dl rm
function.test.ts	6299	0666	edit dl rm
generics.test.ts	2162	0666	edit dl rm
index.test.ts	27562	0666	edit dl rm
instanceof.test.ts	1052	0666	edit dl rm
intersection.test.ts	4763	0666	edit dl rm
json.test.ts	3309	0666	edit dl rm
lazy.test.ts	4756	0666	edit dl rm
literal.test.ts	2478	0666	edit dl rm
map.test.ts	4817	0666	edit dl rm
nan.test.ts	645	0666	edit dl rm
nested-refine.test.ts	3623	0666	edit dl rm
nonoptional.test.ts	2405	0666	edit dl rm
nullable.test.ts	591	0666	edit dl rm
number.test.ts	7827	0666	edit dl rm
object.test.ts	15999	0666	edit dl rm
optional.test.ts	4130	0666	edit dl rm
partial.test.ts	4835	0666	edit dl rm
pickomit.test.ts	4422	0666	edit dl rm
pipe.test.ts	1848	0666	edit dl rm
prefault.test.ts	1007	0666	edit dl rm
preprocess.test.ts	6959	0666	edit dl rm
primitive.test.ts	7649	0666	edit dl rm
promise.test.ts	2315	0666	edit dl rm
prototypes.test.ts	498	0666	edit dl rm
readonly.test.ts	11777	0666	edit dl rm
record.test.ts	8118	0666	edit dl rm
recursive-types.test.ts	7335	0666	edit dl rm
refine.test.ts	14774	0666	edit dl rm
registries.test.ts	5999	0666	edit dl rm
set.test.ts	5572	0666	edit dl rm
standard-schema.test.ts	1369	0666	edit dl rm
string-formats.test.ts	3068	0666	edit dl rm
string.test.ts	64124	0666	edit dl rm
stringbool.test.ts	2333	0666	edit dl rm
template-literal.test.ts	34836	0666	edit dl rm
to-json-schema.test.ts	59276	0666	edit dl rm
transform.test.ts	6000	0666	edit dl rm
tuple.test.ts	4702	0666	edit dl rm
union.test.ts	2497	0666	edit dl rm
validations.test.ts	6736	0666	edit dl rm
void.test.ts	306	0666	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v4/classic/tests/array.test.ts (7284B)

import { expect, expectTypeOf, test } from "vitest";
import * as z from "zod/v4";

test("type inference", () => {
  const schema = z.string().array();
  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string[]>();
});

test("array min/max", async () => {
  const schema = z.array(z.string()).min(2).max(2);
  const r1 = await schema.safeParse(["asdf"]);
  expect(r1.success).toEqual(false);
  expect(r1.error!.issues).toMatchInlineSnapshot(`
    [
      {
        "code": "too_small",
        "inclusive": true,
        "message": "Too small: expected array to have >=2 items",
        "minimum": 2,
        "origin": "array",
        "path": [],
      },
    ]
  `);

const r2 = await schema.safeParse(["asdf", "asdf", "asdf"]);
  expect(r2.success).toEqual(false);
  expect(r2.error!.issues).toMatchInlineSnapshot(`
    [
      {
        "code": "too_big",
        "inclusive": true,
        "maximum": 2,
        "message": "Too big: expected array to have <=2 items",
        "origin": "array",
        "path": [],
      },
    ]
  `);
});

test("array length", async () => {
  const schema = z.array(z.string()).length(2);
  schema.parse(["asdf", "asdf"]);

const r1 = await schema.safeParse(["asdf"]);
  expect(r1.success).toEqual(false);
  expect(r1.error!.issues).toMatchInlineSnapshot(`
    [
      {
        "code": "too_small",
        "exact": true,
        "inclusive": true,
        "message": "Too small: expected array to have >=2 items",
        "minimum": 2,
        "origin": "array",
        "path": [],
      },
    ]
  `);

const r2 = await schema.safeParse(["asdf", "asdf", "asdf"]);
  expect(r2.success).toEqual(false);
  expect(r2.error!.issues).toMatchInlineSnapshot(`
    [
      {
        "code": "too_big",
        "exact": true,
        "inclusive": true,
        "maximum": 2,
        "message": "Too big: expected array to have <=2 items",
        "origin": "array",
        "path": [],
      },
    ]
  `);
});

test("array.nonempty()", () => {
  const schema = z.string().array().nonempty();
  schema.parse(["a"]);
  expect(() => schema.parse([])).toThrow();
});

test("array.nonempty().max()", () => {
  const schema = z.string().array().nonempty().max(2);
  schema.parse(["a"]);
  expect(() => schema.parse([])).toThrow();
  expect(() => schema.parse(["a", "a", "a"])).toThrow();
});

test("parse empty array in nonempty", () => {
  expect(() =>
    z
      .array(z.string())
      .nonempty()
      .parse([] as any)
  ).toThrow();
});

test("get element", () => {
  const schema = z.string().array();
  schema.element.parse("asdf");
  expect(() => schema.element.parse(12)).toThrow();
});

test("continue parsing despite array size error", () => {
  const schema = z.object({
    people: z.string().array().min(2),
  });

test("parse should fail given sparse array", () => {
  const schema = z.array(z.string()).nonempty().min(1).max(3);
  const result = schema.safeParse(new Array(3));
  expect(result.success).toEqual(false);
  expect(result).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "expected": "string",
        "code": "invalid_type",
        "path": [
          0
        ],
        "message": "Invalid input: expected string, received undefined"
      },
      {
        "expected": "string",
        "code": "invalid_type",
        "path": [
          1
        ],
        "message": "Invalid input: expected string, received undefined"
      },
      {
        "expected": "string",
        "code": "invalid_type",
        "path": [
          2
        ],
        "message": "Invalid input: expected string, received undefined"
      }
    ]],
      "success": false,
    }
  `);
});

// const unique = z.string().array().unique();
// const uniqueArrayOfObjects = z.array(z.object({ name: z.string() })).unique({ identifier: (item) => item.name });

// test("passing unique validation", () => {
//   unique.parse(["a", "b", "c"]);
//   uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Joe" }]);
// });

// test("failing unique validation", () => {
//   expect(() => unique.parse(["a", "a", "b"])).toThrow();
//   expect(() => uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Leo" }])).toThrow();
// });

// test("continue parsing despite array of primitives uniqueness error", () => {
//   const schema = z.number().array().unique();

//   const result = schema.safeParse([1, 1, 2, 2, 3]);

//   expect(result.success).toEqual(false);
//   if (!result.success) {
//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
//     expect(issue?.message).toEqual("Values must be unique");
//   }
// });

// test("continue parsing despite array of objects not_unique error", () => {
//   const schema = z.array(z.object({ name: z.string() })).unique({
//     identifier: (item) => item.name,
//     showDuplicates: true,
//   });

//   const result = schema.safeParse([
//     { name: "Leo" },
//     { name: "Joe" },
//     { name: "Leo" },
//   ]);

// test("returns custom error message without duplicate elements", () => {
//   const schema = z.number().array().unique({ message: "Custom message" });

//   const result = schema.safeParse([1, 1, 2, 2, 3]);

// test("returns error message with duplicate elements", () => {
//   const schema = z.number().array().unique({ showDuplicates: true });

//   const result = schema.safeParse([1, 1, 2, 2, 3]);

// test("returns custom error message with duplicate elements", () => {
//   const schema = z
//     .number()
//     .array()
//     .unique({
//       message: (item) => `Custom message: '${item}' are not unique`,
//       showDuplicates: true,
//     });

//   const result = schema.safeParse([1, 1, 2, 2, 3]);

import { expect, expectTypeOf, test } from "vitest"; import * as z from "zod/v4"; test("type inference", () => { const schema = z.string().array(); expectTypeOf>().toEqualTypeOf(); }); test("array min/max", async () => { const schema = z.array(z.string()).min(2).max(2); const r1 = await schema.safeParse(["asdf"]); expect(r1.success).toEqual(false); expect(r1.error!.issues).toMatchInlineSnapshot(` [ { "code": "too_small", "inclusive": true, "message": "Too small: expected array to have >=2 items", "minimum": 2, "origin": "array", "path": [], }, ] `); const r2 = await schema.safeParse(["asdf", "asdf", "asdf"]); expect(r2.success).toEqual(false); expect(r2.error!.issues).toMatchInlineSnapshot(` [ { "code": "too_big", "inclusive": true, "maximum": 2, "message": "Too big: expected array to have <=2 items", "origin": "array", "path": [], }, ] `); }); test("array length", async () => { const schema = z.array(z.string()).length(2); schema.parse(["asdf", "asdf"]); const r1 = await schema.safeParse(["asdf"]); expect(r1.success).toEqual(false); expect(r1.error!.issues).toMatchInlineSnapshot(` [ { "code": "too_small", "exact": true, "inclusive": true, "message": "Too small: expected array to have >=2 items", "minimum": 2, "origin": "array", "path": [], }, ] `); const r2 = await schema.safeParse(["asdf", "asdf", "asdf"]); expect(r2.success).toEqual(false); expect(r2.error!.issues).toMatchInlineSnapshot(` [ { "code": "too_big", "exact": true, "inclusive": true, "maximum": 2, "message": "Too big: expected array to have <=2 items", "origin": "array", "path": [], }, ] `); }); test("array.nonempty()", () => { const schema = z.string().array().nonempty(); schema.parse(["a"]); expect(() => schema.parse([])).toThrow(); }); test("array.nonempty().max()", () => { const schema = z.string().array().nonempty().max(2); schema.parse(["a"]); expect(() => schema.parse([])).toThrow(); expect(() => schema.parse(["a", "a", "a"])).toThrow(); }); test("parse empty array in nonempty", () => { expect(() => z .array(z.string()) .nonempty() .parse([] as any) ).toThrow(); }); test("get element", () => { const schema = z.string().array(); schema.element.parse("asdf"); expect(() => schema.element.parse(12)).toThrow(); }); test("continue parsing despite array size error", () => { const schema = z.object({ people: z.string().array().min(2), }); const result = schema.safeParse({ people: [123], }); expect(result).toMatchInlineSnapshot(` { "error": [ZodError: [ { "expected": "string", "code": "invalid_type", "path": [ "people", 0 ], "message": "Invalid input: expected string, received number" }, { "origin": "array", "code": "too_small", "minimum": 2, "inclusive": true, "path": [ "people" ], "message": "Too small: expected array to have >=2 items" } ]], "success": false, } `); }); test("parse should fail given sparse array", () => { const schema = z.array(z.string()).nonempty().min(1).max(3); const result = schema.safeParse(new Array(3)); expect(result.success).toEqual(false); expect(result).toMatchInlineSnapshot(` { "error": [ZodError: [ { "expected": "string", "code": "invalid_type", "path": [ 0 ], "message": "Invalid input: expected string, received undefined" }, { "expected": "string", "code": "invalid_type", "path": [ 1 ], "message": "Invalid input: expected string, received undefined" }, { "expected": "string", "code": "invalid_type", "path": [ 2 ], "message": "Invalid input: expected string, received undefined" } ]], "success": false, } `); }); // const unique = z.string().array().unique(); // const uniqueArrayOfObjects = z.array(z.object({ name: z.string() })).unique({ identifier: (item) => item.name }); // test("passing unique validation", () => { // unique.parse(["a", "b", "c"]); // uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Joe" }]); // }); // test("failing unique validation", () => { // expect(() => unique.parse(["a", "a", "b"])).toThrow(); // expect(() => uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Leo" }])).toThrow(); // }); // test("continue parsing despite array of primitives uniqueness error", () => { // const schema = z.number().array().unique(); // const result = schema.safeParse([1, 1, 2, 2, 3]); // expect(result.success).toEqual(false); // if (!result.success) { // const issue = result.error.issues.find(({ code }) => code === "not_unique"); // expect(issue?.message).toEqual("Values must be unique"); // } // }); // test("continue parsing despite array of objects not_unique error", () => { // const schema = z.array(z.object({ name: z.string() })).unique({ // identifier: (item) => item.name, // showDuplicates: true, // }); // const result = schema.safeParse([ // { name: "Leo" }, // { name: "Joe" }, // { name: "Leo" }, // ]); // expect(result.success).toEqual(false); // if (!result.success) { // const issue = result.error.issues.find(({ code }) => code === "not_unique"); // expect(issue?.message).toEqual("Element(s): 'Leo' not unique"); // } // }); // test("returns custom error message without duplicate elements", () => { // const schema = z.number().array().unique({ message: "Custom message" }); // const result = schema.safeParse([1, 1, 2, 2, 3]); // expect(result.success).toEqual(false); // if (!result.success) { // const issue = result.error.issues.find(({ code }) => code === "not_unique"); // expect(issue?.message).toEqual("Custom message"); // } // }); // test("returns error message with duplicate elements", () => { // const schema = z.number().array().unique({ showDuplicates: true }); // const result = schema.safeParse([1, 1, 2, 2, 3]); // expect(result.success).toEqual(false); // if (!result.success) { // const issue = result.error.issues.find(({ code }) => code === "not_unique"); // expect(issue?.message).toEqual("Element(s): '1,2' not unique"); // } // }); // test("returns custom error message with duplicate elements", () => { // const schema = z // .number() // .array() // .unique({ // message: (item) => `Custom message: '${item}' are not unique`, // showDuplicates: true, // }); // const result = schema.safeParse([1, 1, 2, 2, 3]); // expect(result.success).toEqual(false); // if (!result.success) { // const issue = result.error.issues.find(({ code }) => code === "not_unique"); // expect(issue?.message).toEqual("Custom message: '1,2' are not unique"); // } // });