@wopee-io/wopee.wdio 5.2.5 → 6.0.1

package/node_modules/zod/src/v4/classic/tests/map.test.ts

@@ -4,6 +4,12 @@ import * as z from "zod/v4";
 const stringMap = z.map(z.string(), z.string());
 type stringMap = z.infer<typeof stringMap>;
 
+const minTwo = stringMap.min(2);
+const maxTwo = stringMap.max(2);
+const justTwo = stringMap.size(2);
+const nonEmpty = stringMap.nonempty();
+const nonEmptyMax = stringMap.nonempty().max(2);
+
 test("type inference", () => {
   expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
 });
@@ -24,6 +30,94 @@ test("valid parse", () => {
   `);
 });
 
+test("valid parse: size-related methods", () => {
+  expect(() => {
+    minTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    minTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+        ["e", "f"],
+      ])
+    );
+    maxTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    maxTwo.parse(new Map([["a", "b"]]));
+    justTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    nonEmpty.parse(new Map([["a", "b"]]));
+    nonEmptyMax.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+  }).not.toThrow();
+
+  const sizeZeroResult = stringMap.parse(new Map());
+  expect(sizeZeroResult.size).toBe(0);
+
+  const sizeTwoResult = minTwo.parse(
+    new Map([
+      ["a", "b"],
+      ["c", "d"],
+    ])
+  );
+  expect(sizeTwoResult.size).toBe(2);
+});
+
+test("failing when parsing empty map in nonempty ", () => {
+  const result = nonEmpty.safeParse(new Map());
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_small");
+});
+
+test("failing when map is bigger than max() ", () => {
+  const result = maxTwo.safeParse(
+    new Map([
+      ["a", "b"],
+      ["c", "d"],
+      ["e", "f"],
+    ])
+  );
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_big");
+  const bad = new Map([
+    [1, 1],
+    [2, 2],
+  ]);
+  const capped = z.map(z.string(), z.string()).max(1);
+  expect(capped.safeParse(bad).error!.issues).toMatchObject([{ code: "too_big" }]);
+  expect(capped.safeParse(new Set([1, 2])).error!.issues[0]).toMatchObject({ code: "invalid_type", expected: "map" });
+});
+
+test("failing when map does not match size() ", () => {
+  expect(justTwo.safeParse(new Map([["a", "b"]])).error!.issues[0].message).toEqual(
+    "Too small: expected map to have exactly 2 entries"
+  );
+  const tooBig = new Map([
+    ["a", "b"],
+    ["c", "d"],
+    ["e", "f"],
+  ]);
+  expect(justTwo.safeParse(tooBig).error!.issues[0].message).toEqual("Too big: expected map to have exactly 2 entries");
+});
+
 test("valid parse async", async () => {
   const asyncMap = z.map(
     z.string().refine(async () => false, "bad key"),
@@ -194,3 +288,62 @@ test("map with object keys", () => {
     ]]
   `);
 });
+
+test("min/max", async () => {
+  const schema = stringMap.min(4).max(5);
+
+  const r1 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+      ["d", "d"],
+    ])
+  );
+  expect(r1.success).toEqual(true);
+
+  const r2 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+    ])
+  );
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected map to have >=4 entries",
+        "minimum": 4,
+        "origin": "map",
+        "path": [],
+      },
+    ]
+  `);
+
+  const r3 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+      ["d", "d"],
+      ["e", "e"],
+      ["f", "f"],
+    ])
+  );
+  expect(r3.success).toEqual(false);
+  expect(r3.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "inclusive": true,
+        "maximum": 5,
+        "message": "Too big: expected map to have <=5 entries",
+        "origin": "map",
+        "path": [],
+      },
+    ]
+  `);
+});

package/node_modules/zod/src/v4/classic/tests/nonoptional.test.ts

@@ -84,3 +84,18 @@ test("nonoptional in object", () => {
     ]]
   `);
 });
+
+test("encoding", () => {
+  const schema = z.string().optional().nonoptional();
+  expect(z.encode(schema, "hello")).toEqual("hello");
+  expect(() => z.encode(schema, undefined as any)).toThrowErrorMatchingInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "nonoptional",
+        "path": [],
+        "message": "Invalid input: expected nonoptional, received undefined"
+      }
+    ]]
+  `);
+});

package/node_modules/zod/src/v4/classic/tests/number.test.ts

@@ -1,7 +1,46 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
+test("number factory checks", () => {
+  const schema = z.number({ checks: [z.gte(1), z.lte(3)] as const });
+  const chained = z.number().min(1).max(3);
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<number>();
+  for (const value of [0, 1, 3, 4, Number.NaN, "2", undefined]) {
+    expect(z.validate(schema, value)).toBe(z.validate(chained, value));
+    expect(schema.safeParse(value)).toEqual(chained.safeParse(value));
+  }
+  expect(z.toJSONSchema(schema)).toEqual(z.toJSONSchema(chained));
+  expect(schema.minValue).toBe(1);
+  expect(schema.maxValue).toBe(3);
+  expect(z.coerce.number({ checks: [z.gte(1)] }).parse("2")).toBe(2);
+  const overwritten = z.number({ checks: [z.overwrite<number>((value) => value + 1), z.gte(2)] });
+  expect(overwritten.parse(1)).toBe(2);
+  expect(z.validate(overwritten, 0)).toBe(false);
+  // @ts-expect-error length checks cannot validate numbers
+  z.number({ checks: [z.minLength(1)] });
+});
+
+test("number factory checks snapshot caller arrays", () => {
+  for (const factory of [z.number, z.coerce.number]) {
+    const checks = [z.gte(1)];
+    const schema = factory({ checks });
+    let reads = 0;
+    factory({
+      get checks() {
+        if (++reads > 1) throw new Error("checks read twice");
+        return checks;
+      },
+    });
+    expect(reads).toBe(1);
+    const before = z.toJSONSchema(schema);
+    checks.push(z.gte(10));
+    expect(z.validate(schema, 3)).toBe(true);
+    expect(z.validate(z.compile(schema), 3)).toBe(true);
+    expect(z.toJSONSchema(schema)).toEqual(before);
+  }
+});
+
 test("z.number() basic validation", () => {
   const schema = z.number();
   expect(schema.parse(1234)).toEqual(1234);
@@ -22,7 +61,7 @@ test("Infinity validation", () => {
         "code": "invalid_type",
         "received": "Infinity",
         "path": [],
-        "message": "Invalid input: expected number, received number"
+        "message": "Invalid input: expected number, received Infinity"
       }
     ]],
       "success": false,
@@ -34,9 +73,9 @@ test("Infinity validation", () => {
       {
         "expected": "number",
         "code": "invalid_type",
-        "received": "Infinity",
+        "received": "-Infinity",
         "path": [],
-        "message": "Invalid input: expected number, received number"
+        "message": "Invalid input: expected number, received -Infinity"
       }
     ]],
       "success": false,
@@ -114,6 +153,39 @@ test(".nonnegative() validation", () => {
   expect(() => schema.parse(-1)).toThrow();
 });
 
+test("multipleOf", () => {
+  const numbers = {
+    number3: 5.123,
+    number6: 5.123456,
+    number7: 5.1234567,
+    number8: 5.12345678,
+  };
+
+  const schemas = {
+    schema6: z.number().multipleOf(0.000001),
+    schema7: z.number().multipleOf(0.0000001),
+  };
+
+  expect(() => schemas.schema6.parse(numbers.number3)).not.toThrow();
+  expect(() => schemas.schema6.parse(numbers.number6)).not.toThrow();
+  expect(() => schemas.schema6.parse(numbers.number7)).toThrow();
+  expect(() => schemas.schema6.parse(numbers.number8)).toThrow();
+  expect(() => schemas.schema7.parse(numbers.number3)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number6)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number7)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number8)).toThrow();
+});
+
+test(".multipleOf() accepts exact decimal multiples", () => {
+  // 2.03 === 29 * 0.07, but the quotient lands 2 ULP below 29, so the old tolerance rejected it while the neighbouring multiples 1.96 and 2.10 passed.
+  const schema = z.number().multipleOf(0.07);
+  expect(schema.safeParse(2.03).success).toBe(true);
+  expect(schema.safeParse(4.06).success).toBe(true);
+  expect(schema.safeParse(8.54).success).toBe(true);
+  // genuine non-multiples must still be rejected
+  expect(schema.safeParse(2.04).success).toBe(false);
+});
+
 test(".multipleOf() with positive divisor", () => {
   const schema = z.number().multipleOf(5);
   expect(schema.parse(15)).toEqual(15);
@@ -130,6 +202,35 @@ test(".multipleOf() with negative divisor", () => {
   expect(() => schema.parse(7.5)).toThrow();
 });
 
+test(".multipleOf() with scientific notation (multi-digit exponents)", () => {
+  // Regression test for https://github.com/colinhacks/zod/pull/5687 — the regex was using \d? which only matches single-digit exponents
+  const schema = z.number().multipleOf(1e-10);
+
+  // These should all pass - they are valid multiples of 1e-10
+  expect(schema.parse(1e-10)).toEqual(1e-10);
+  expect(schema.parse(5e-10)).toEqual(5e-10);
+  expect(schema.parse(1e-9)).toEqual(1e-9); // 10 * 1e-10
+
+  // Test with 1e-15 (exponent = 15, two digits)
+  const schema15 = z.number().multipleOf(1e-15);
+  expect(schema15.parse(1e-15)).toEqual(1e-15);
+  expect(schema15.parse(3e-15)).toEqual(3e-15);
+});
+
+test(".multipleOf() with small floats / scientific notation (#5792)", () => {
+  const schema = z.number().multipleOf(1e-7);
+
+  // Valid multiples (integer * 1e-7)
+  expect(schema.safeParse(0).success).toBe(true);
+  expect(schema.safeParse(1e-7).success).toBe(true);
+  expect(schema.safeParse(2e-7).success).toBe(true);
+  expect(schema.safeParse(3e-7).success).toBe(true);
+
+  // Invalid — 2.5 and 1.5 are not integers
+  expect(schema.safeParse(2.5e-7).success).toBe(false);
+  expect(schema.safeParse(1.5e-7).success).toBe(false);
+});
+
 test(".step() validation", () => {
   const schemaPointOne = z.number().step(0.1);
   const schemaPointZeroZeroZeroOne = z.number().step(0.0001);
@@ -155,7 +256,7 @@ test(".finite() validation", () => {
         "code": "invalid_type",
         "received": "Infinity",
         "path": [],
-        "message": "Invalid input: expected number, received number"
+        "message": "Invalid input: expected number, received Infinity"
       }
     ]],
       "success": false,
@@ -167,9 +268,9 @@ test(".finite() validation", () => {
       {
         "expected": "number",
         "code": "invalid_type",
-        "received": "Infinity",
+        "received": "-Infinity",
         "path": [],
-        "message": "Invalid input: expected number, received number"
+        "message": "Invalid input: expected number, received -Infinity"
       }
     ]],
       "success": false,
@@ -241,7 +342,60 @@ test("string format methods", () => {
   expect(() => a.parse(1)).toThrow();
 });
 
+test("negative zero edge case", () => {
+  const schema = z.number();
+  const negativeZero = -0;
+  const positiveZero = 0;
+
+  // Both -0 and 0 should be valid (parse succeeds)
+  expect(schema.safeParse(negativeZero).success).toBe(true);
+  expect(schema.safeParse(positiveZero).success).toBe(true);
+  // Note: -0 is normalized to 0 after parsing
+  expect(schema.parse(negativeZero) === 0).toBe(true);
+  expect(schema.parse(positiveZero)).toEqual(0);
+
+  // With positive() constraint, both should be invalid (0 is not positive)
+  const positiveSchema = z.number().positive();
+  expect(() => positiveSchema.parse(negativeZero)).toThrow();
+  expect(() => positiveSchema.parse(positiveZero)).toThrow();
+
+  // With nonnegative(), both should be valid (0 is non-negative)
+  const nonnegativeSchema = z.number().nonnegative();
+  expect(nonnegativeSchema.safeParse(negativeZero).success).toBe(true);
+  expect(nonnegativeSchema.safeParse(positiveZero).success).toBe(true);
+  expect(nonnegativeSchema.parse(negativeZero) === 0).toBe(true);
+  expect(nonnegativeSchema.parse(positiveZero)).toEqual(0);
+});
+
 test("error customization", () => {
   z.number().gte(5, { error: (iss) => "Min: " + iss.minimum.valueOf() });
   z.number().lte(5, { error: (iss) => "Max: " + iss.maximum.valueOf() });
 });
+
+test("number formats are distinct at the type level", () => {
+  expectTypeOf(z.int()._zod.def.format).toEqualTypeOf<"safeint">();
+  expectTypeOf(z.int32()._zod.def.format).toEqualTypeOf<"int32">();
+  expectTypeOf(z.uint32()._zod.def.format).toEqualTypeOf<"uint32">();
+  expectTypeOf(z.float32()._zod.def.format).toEqualTypeOf<"float32">();
+  expectTypeOf(z.float64()._zod.def.format).toEqualTypeOf<"float64">();
+
+  z.int() satisfies z.ZodNumberFormat;
+  z.int() satisfies z.ZodNumber;
+
+  // @ts-expect-error a float32 schema is not a ZodInt
+  z.float32() satisfies z.ZodInt;
+  // @ts-expect-error a uint32 schema is not a ZodInt32
+  z.uint32() satisfies z.ZodInt32;
+
+  // the point of the distinction: dispatching on the schema type in a conditional type
+  type Sql<T> = T extends z.ZodUInt32
+    ? "BIGINT"
+    : T extends z.ZodInt32
+      ? "INTEGER"
+      : T extends z.ZodFloat32
+        ? "REAL"
+        : never;
+  expectTypeOf<Sql<z.ZodUInt32>>().toEqualTypeOf<"BIGINT">();
+  expectTypeOf<Sql<z.ZodInt32>>().toEqualTypeOf<"INTEGER">();
+  expectTypeOf<Sql<z.ZodFloat32>>().toEqualTypeOf<"REAL">();
+});