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);  // });});