Brunobkr/llama.cpp_AlgMor24_github

1// @ts-ignore TS61332import { expect, test } from "vitest";3 4import * as z from "zod/v3";5 6/// string7const stringSchema = z.string();8 9test("string async parse", async () => {10  const goodData = "XXX";11  const badData = 12;12 13  const goodResult = await stringSchema.safeParseAsync(goodData);14  expect(goodResult.success).toBe(true);15  if (goodResult.success) expect(goodResult.data).toEqual(goodData);16 17  const badResult = await stringSchema.safeParseAsync(badData);18  expect(badResult.success).toBe(false);19  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);20});21 22/// number23const numberSchema = z.number();24test("number async parse", async () => {25  const goodData = 1234.2353;26  const badData = "1234";27 28  const goodResult = await numberSchema.safeParseAsync(goodData);29  expect(goodResult.success).toBe(true);30  if (goodResult.success) expect(goodResult.data).toEqual(goodData);31 32  const badResult = await numberSchema.safeParseAsync(badData);33  expect(badResult.success).toBe(false);34  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);35});36 37/// bigInt38const bigIntSchema = z.bigint();39test("bigInt async parse", async () => {40  const goodData = BigInt(145);41  const badData = 134;42 43  const goodResult = await bigIntSchema.safeParseAsync(goodData);44  expect(goodResult.success).toBe(true);45  if (goodResult.success) expect(goodResult.data).toEqual(goodData);46 47  const badResult = await bigIntSchema.safeParseAsync(badData);48  expect(badResult.success).toBe(false);49  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);50});51 52/// boolean53const booleanSchema = z.boolean();54test("boolean async parse", async () => {55  const goodData = true;56  const badData = 1;57 58  const goodResult = await booleanSchema.safeParseAsync(goodData);59  expect(goodResult.success).toBe(true);60  if (goodResult.success) expect(goodResult.data).toEqual(goodData);61 62  const badResult = await booleanSchema.safeParseAsync(badData);63  expect(badResult.success).toBe(false);64  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);65});66 67/// date68const dateSchema = z.date();69test("date async parse", async () => {70  const goodData = new Date();71  const badData = new Date().toISOString();72 73  const goodResult = await dateSchema.safeParseAsync(goodData);74  expect(goodResult.success).toBe(true);75  if (goodResult.success) expect(goodResult.data).toEqual(goodData);76 77  const badResult = await dateSchema.safeParseAsync(badData);78  expect(badResult.success).toBe(false);79  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);80});81 82/// undefined83const undefinedSchema = z.undefined();84test("undefined async parse", async () => {85  const goodData = undefined;86  const badData = "XXX";87 88  const goodResult = await undefinedSchema.safeParseAsync(goodData);89  expect(goodResult.success).toBe(true);90  if (goodResult.success) expect(goodResult.data).toEqual(undefined);91 92  const badResult = await undefinedSchema.safeParseAsync(badData);93  expect(badResult.success).toBe(false);94  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);95});96 97/// null98const nullSchema = z.null();99test("null async parse", async () => {100  const goodData = null;101  const badData = undefined;102 103  const goodResult = await nullSchema.safeParseAsync(goodData);104  expect(goodResult.success).toBe(true);105  if (goodResult.success) expect(goodResult.data).toEqual(goodData);106 107  const badResult = await nullSchema.safeParseAsync(badData);108  expect(badResult.success).toBe(false);109  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);110});111 112/// any113const anySchema = z.any();114test("any async parse", async () => {115  const goodData = [{}];116  // const badData = 'XXX';117 118  const goodResult = await anySchema.safeParseAsync(goodData);119  expect(goodResult.success).toBe(true);120  if (goodResult.success) expect(goodResult.data).toEqual(goodData);121 122  // const badResult = await anySchema.safeParseAsync(badData);123  // expect(badResult.success).toBe(false);124  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);125});126 127/// unknown128const unknownSchema = z.unknown();129test("unknown async parse", async () => {130  const goodData = ["asdf", 124, () => {}];131  // const badData = 'XXX';132 133  const goodResult = await unknownSchema.safeParseAsync(goodData);134  expect(goodResult.success).toBe(true);135  if (goodResult.success) expect(goodResult.data).toEqual(goodData);136 137  // const badResult = await unknownSchema.safeParseAsync(badData);138  // expect(badResult.success).toBe(false);139  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);140});141 142/// void143const voidSchema = z.void();144test("void async parse", async () => {145  const goodData = undefined;146  const badData = 0;147 148  const goodResult = await voidSchema.safeParseAsync(goodData);149  expect(goodResult.success).toBe(true);150  if (goodResult.success) expect(goodResult.data).toEqual(goodData);151 152  const badResult = await voidSchema.safeParseAsync(badData);153  expect(badResult.success).toBe(false);154  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);155});156 157/// array158const arraySchema = z.array(z.string());159test("array async parse", async () => {160  const goodData = ["XXX"];161  const badData = "XXX";162 163  const goodResult = await arraySchema.safeParseAsync(goodData);164  expect(goodResult.success).toBe(true);165  if (goodResult.success) expect(goodResult.data).toEqual(goodData);166 167  const badResult = await arraySchema.safeParseAsync(badData);168  expect(badResult.success).toBe(false);169  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);170});171 172/// object173const objectSchema = z.object({ string: z.string() });174test("object async parse", async () => {175  const goodData = { string: "XXX" };176  const badData = { string: 12 };177 178  const goodResult = await objectSchema.safeParseAsync(goodData);179  expect(goodResult.success).toBe(true);180  if (goodResult.success) expect(goodResult.data).toEqual(goodData);181 182  const badResult = await objectSchema.safeParseAsync(badData);183  expect(badResult.success).toBe(false);184  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);185});186 187/// union188const unionSchema = z.union([z.string(), z.undefined()]);189test("union async parse", async () => {190  const goodData = undefined;191  const badData = null;192 193  const goodResult = await unionSchema.safeParseAsync(goodData);194  expect(goodResult.success).toBe(true);195  if (goodResult.success) expect(goodResult.data).toEqual(goodData);196 197  const badResult = await unionSchema.safeParseAsync(badData);198  expect(badResult.success).toBe(false);199  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);200});201 202/// record203const recordSchema = z.record(z.object({}));204test("record async parse", async () => {205  const goodData = { adsf: {}, asdf: {} };206  const badData = [{}];207 208  const goodResult = await recordSchema.safeParseAsync(goodData);209  expect(goodResult.success).toBe(true);210  if (goodResult.success) expect(goodResult.data).toEqual(goodData);211 212  const badResult = await recordSchema.safeParseAsync(badData);213  expect(badResult.success).toBe(false);214  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);215});216 217/// function218const functionSchema = z.function();219test("function async parse", async () => {220  const goodData = () => {};221  const badData = "XXX";222 223  const goodResult = await functionSchema.safeParseAsync(goodData);224  expect(goodResult.success).toBe(true);225  if (goodResult.success) expect(typeof goodResult.data).toEqual("function");226 227  const badResult = await functionSchema.safeParseAsync(badData);228  expect(badResult.success).toBe(false);229  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);230});231 232/// literal233const literalSchema = z.literal("asdf");234test("literal async parse", async () => {235  const goodData = "asdf";236  const badData = "asdff";237 238  const goodResult = await literalSchema.safeParseAsync(goodData);239  expect(goodResult.success).toBe(true);240  if (goodResult.success) expect(goodResult.data).toEqual(goodData);241 242  const badResult = await literalSchema.safeParseAsync(badData);243  expect(badResult.success).toBe(false);244  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);245});246 247/// enum248const enumSchema = z.enum(["fish", "whale"]);249test("enum async parse", async () => {250  const goodData = "whale";251  const badData = "leopard";252 253  const goodResult = await enumSchema.safeParseAsync(goodData);254  expect(goodResult.success).toBe(true);255  if (goodResult.success) expect(goodResult.data).toEqual(goodData);256 257  const badResult = await enumSchema.safeParseAsync(badData);258  expect(badResult.success).toBe(false);259  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);260});261 262/// nativeEnum263enum nativeEnumTest {264  asdf = "qwer",265}266// @ts-ignore267const nativeEnumSchema = z.nativeEnum(nativeEnumTest);268test("nativeEnum async parse", async () => {269  const goodData = nativeEnumTest.asdf;270  const badData = "asdf";271 272  const goodResult = await nativeEnumSchema.safeParseAsync(goodData);273  expect(goodResult.success).toBe(true);274  if (goodResult.success) expect(goodResult.data).toEqual(goodData);275 276  const badResult = await nativeEnumSchema.safeParseAsync(badData);277  expect(badResult.success).toBe(false);278  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);279});280 281/// promise282const promiseSchema = z.promise(z.number());283test("promise async parse good", async () => {284  const goodData = Promise.resolve(123);285 286  const goodResult = await promiseSchema.safeParseAsync(goodData);287  expect(goodResult.success).toBe(true);288  if (goodResult.success) {289    expect(goodResult.data).toBeInstanceOf(Promise);290    const data = await goodResult.data;291    expect(data).toEqual(123);292    // expect(goodResult.data).resolves.toEqual(124);293    // return goodResult.data;294  } else {295    throw new Error("success should be true");296  }297});298 299test("promise async parse bad", async () => {300  const badData = Promise.resolve("XXX");301  const badResult = await promiseSchema.safeParseAsync(badData);302  expect(badResult.success).toBe(true);303  if (badResult.success) {304    await expect(badResult.data).rejects.toBeInstanceOf(z.ZodError);305  } else {306    throw new Error("success should be true");307  }308});309 310test("async validation non-empty strings", async () => {311  const base = z.object({312    hello: z.string().refine((x) => x && x.length > 0),313    foo: z.string().refine((x) => x && x.length > 0),314  });315 316  const testval = { hello: "", foo: "" };317  const result1 = base.safeParse(testval);318  const result2 = base.safeParseAsync(testval);319 320  const r1 = result1;321  await result2.then((r2) => {322    if (r1.success === false && r2.success === false) expect(r1.error.issues.length).toBe(r2.error.issues.length); // <--- r1 has length 2, r2 has length 1323  });324});325 326test("async validation multiple errors 1", async () => {327  const base = z.object({328    hello: z.string(),329    foo: z.number(),330  });331 332  const testval = { hello: 3, foo: "hello" };333  const result1 = base.safeParse(testval);334  const result2 = base.safeParseAsync(testval);335 336  const r1 = result1;337  await result2.then((r2) => {338    if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length);339  });340});341 342test("async validation multiple errors 2", async () => {343  const base = (is_async?: boolean) =>344    z.object({345      hello: z.string(),346      foo: z.object({347        bar: z.number().refine(is_async ? async () => false : () => false),348      }),349    });350 351  const testval = { hello: 3, foo: { bar: 4 } };352  const result1 = base().safeParse(testval);353  const result2 = base(true).safeParseAsync(testval);354 355  const r1 = result1;356  await result2.then((r2) => {357    if (r1.success === false && r2.success === false) expect(r2.error.issues.length).toBe(r1.error.issues.length);358  });359});360 361test("ensure early async failure prevents follow-up refinement checks", async () => {362  let count = 0;363  const base = z.object({364    hello: z.string(),365    foo: z366      .number()367      .refine(async () => {368        count++;369        return true;370      })371      .refine(async () => {372        count++;373        return true;374      }, "Good"),375  });376 377  const testval = { hello: "bye", foo: 3 };378  const result = await base.safeParseAsync(testval);379  if (result.success === false) {380    expect(result.error.issues.length).toBe(1);381    expect(count).toBe(1);382  }383 384  // await result.then((r) => {385  //   if (r.success === false) expect(r.error.issues.length).toBe(1);386  //   expect(count).toBe(2);387  // });388});389