deno.land / x / zod@v3.19.1 / __tests__ / async-parsing.test.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393// @ts-ignore TS6133import { expect } from "https://deno.land/x/expect@v0.2.6/mod.ts";const test = Deno.test;
import * as z from "../index.ts";
/// stringconst stringSchema = z.string();
test("string async parse", async () => { const goodData = "XXX"; const badData = 12;
const goodResult = await stringSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await stringSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// numberconst numberSchema = z.number();test("number async parse", async () => { const goodData = 1234.2353; const badData = "1234";
const goodResult = await numberSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await numberSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// bigIntconst bigIntSchema = z.bigint();test("bigInt async parse", async () => { const goodData = BigInt(145); const badData = 134;
const goodResult = await bigIntSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await bigIntSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// booleanconst booleanSchema = z.boolean();test("boolean async parse", async () => { const goodData = true; const badData = 1;
const goodResult = await booleanSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await booleanSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// dateconst dateSchema = z.date();test("date async parse", async () => { const goodData = new Date(); const badData = new Date().toISOString();
const goodResult = await dateSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await dateSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// undefinedconst undefinedSchema = z.undefined();test("undefined async parse", async () => { const goodData = undefined; const badData = "XXX";
const goodResult = await undefinedSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(undefined);
const badResult = await undefinedSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// nullconst nullSchema = z.null();test("null async parse", async () => { const goodData = null; const badData = undefined;
const goodResult = await nullSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await nullSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// anyconst anySchema = z.any();test("any async parse", async () => { const goodData = [{}]; // const badData = 'XXX';
const goodResult = await anySchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
// const badResult = await anySchema.safeParseAsync(badData); // expect(badResult.success).toBe(false); // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// unknownconst unknownSchema = z.unknown();test("unknown async parse", async () => { const goodData = ["asdf", 124, () => {}]; // const badData = 'XXX';
const goodResult = await unknownSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
// const badResult = await unknownSchema.safeParseAsync(badData); // expect(badResult.success).toBe(false); // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// voidconst voidSchema = z.void();test("void async parse", async () => { const goodData = undefined; const badData = 0;
const goodResult = await voidSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await voidSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// arrayconst arraySchema = z.array(z.string());test("array async parse", async () => { const goodData = ["XXX"]; const badData = "XXX";
const goodResult = await arraySchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await arraySchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// objectconst objectSchema = z.object({ string: z.string() });test("object async parse", async () => { const goodData = { string: "XXX" }; const badData = { string: 12 };
const goodResult = await objectSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await objectSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// unionconst unionSchema = z.union([z.string(), z.undefined()]);test("union async parse", async () => { const goodData = undefined; const badData = null;
const goodResult = await unionSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await unionSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// recordconst recordSchema = z.record(z.object({}));test("record async parse", async () => { const goodData = { adsf: {}, asdf: {} }; const badData = [{}];
const goodResult = await recordSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await recordSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// functionconst functionSchema = z.function();test("function async parse", async () => { const goodData = () => {}; const badData = "XXX";
const goodResult = await functionSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(typeof goodResult.data).toEqual("function");
const badResult = await functionSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// literalconst literalSchema = z.literal("asdf");test("literal async parse", async () => { const goodData = "asdf"; const badData = "asdff";
const goodResult = await literalSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await literalSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// enumconst enumSchema = z.enum(["fish", "whale"]);test("enum async parse", async () => { const goodData = "whale"; const badData = "leopard";
const goodResult = await enumSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await enumSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// nativeEnumenum nativeEnumTest { asdf = "qwer",}// @ts-ignoreconst nativeEnumSchema = z.nativeEnum(nativeEnumTest);test("nativeEnum async parse", async () => { const goodData = nativeEnumTest.asdf; const badData = "asdf";
const goodResult = await nativeEnumSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) expect(goodResult.data).toEqual(goodData);
const badResult = await nativeEnumSchema.safeParseAsync(badData); expect(badResult.success).toBe(false); if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);});
/// promiseconst promiseSchema = z.promise(z.number());test("promise async parse good", async () => { const goodData = Promise.resolve(123);
const goodResult = await promiseSchema.safeParseAsync(goodData); expect(goodResult.success).toBe(true); if (goodResult.success) { expect(goodResult.data).toBeInstanceOf(Promise); const data = await goodResult.data; expect(data).toEqual(123); // expect(goodResult.data).resolves.toEqual(124); // return goodResult.data; } else { throw new Error("success should be true"); }});
test("promise async parse bad", async () => { const badData = Promise.resolve("XXX"); const badResult = await promiseSchema.safeParseAsync(badData); expect(badResult.success).toBe(true); if (badResult.success) { await expect(badResult.data).rejects.toBeInstanceOf(z.ZodError); } else { throw new Error("success should be true"); }});
test("async validation non-empty strings", async () => { const base = z.object({ hello: z.string().refine((x) => x && x.length > 0), foo: z.string().refine((x) => x && x.length > 0), });
const testval = { hello: "", foo: "" }; const result1 = base.safeParse(testval); const result2 = base.safeParseAsync(testval);
const r1 = result1; await result2.then((r2) => { if (r1.success === false && r2.success === false) expect(r1.error.issues.length).toBe(r2.error.issues.length); // <--- r1 has length 2, r2 has length 1 });});
test("async validation multiple errors 1", async () => { const base = z.object({ hello: z.string(), foo: z.number(), });
const testval = { hello: 3, foo: "hello" }; const result1 = base.safeParse(testval); const result2 = base.safeParseAsync(testval);
const r1 = result1; await result2.then((r2) => { if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length); });});
test("async validation multiple errors 2", async () => { const base = (is_async?: boolean) => z.object({ hello: z.string(), foo: z.object({ bar: z.number().refine(is_async ? async () => false : () => false), }), });
const testval = { hello: 3, foo: { bar: 4 } }; const result1 = base().safeParse(testval); const result2 = base(true).safeParseAsync(testval);
const r1 = result1; await result2.then((r2) => { if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length); });});
test("ensure early async failure prevents follow-up refinement checks", async () => { let count = 0; const base = z.object({ hello: z.string(), foo: z .number() .refine(async () => { count++; return true; }) .refine(async () => { count++; return true; }, "Good"), });
const testval = { hello: "bye", foo: 3 }; const result = await base.safeParseAsync(testval); if (result.success === false) { expect(result.error.issues.length).toBe(1); expect(count).toBe(1); }
// await result.then((r) => { // if (r.success === false) expect(r.error.issues.length).toBe(1); // expect(count).toBe(2); // });});
zod
Version Info
a year ago
