@wopee-io/wopee.wdio 5.2.5 → 6.0.1

package/node_modules/zod/src/v4/classic/tests/error-utils.test.ts

@@ -80,7 +80,10 @@ test(".flatten()", () => {
 
 test("custom .flatten()", () => {
   type ErrorType = { message: string; code: number };
-  const flattened = parsed.error!.flatten((iss) => ({ message: iss.message, code: 1234 }));
+  const flattened = parsed.error!.flatten((iss) => ({
+    message: iss.message,
+    code: 1234,
+  }));
   expectTypeOf(flattened).toMatchTypeOf<{
     formErrors: ErrorType[];
     fieldErrors: {
@@ -160,7 +163,10 @@ test(".format()", () => {
 
 test("custom .format()", () => {
   type ErrorType = { message: string; code: number };
-  const formatted = parsed.error!.format((iss) => ({ message: iss.message, code: 1234 }));
+  const formatted = parsed.error!.format((iss) => ({
+    message: iss.message,
+    code: 1234,
+  }));
   expectTypeOf(formatted).toMatchTypeOf<{
     _errors: ErrorType[];
     f2?: { _errors: ErrorType[] };
@@ -321,7 +327,7 @@ test("all errors", () => {
 });
 
 const schema = z.strictObject({
-  username: z.string(),
+  username: z.string().brand<"username">(),
   favoriteNumbers: z.array(z.number()),
   nesting: z.object({
     a: z.string(),
@@ -336,8 +342,33 @@ const result = schema.safeParse({
   extra: 1234,
 });
 
+const tree = z.treeifyError(result.error!);
+
+expectTypeOf(tree).toEqualTypeOf<{
+  errors: string[];
+  properties?: {
+    username?: {
+      errors: string[];
+    };
+    favoriteNumbers?: {
+      errors: string[];
+      items?: {
+        errors: string[];
+      }[];
+    };
+    nesting?: {
+      errors: string[];
+      properties?: {
+        a?: {
+          errors: string[];
+        };
+      };
+    };
+  };
+}>();
+
 test("z.treeifyError", () => {
-  expect(z.treeifyError(result.error!)).toMatchInlineSnapshot(`
+  expect(tree).toMatchInlineSnapshot(`
     {
       "errors": [
         "Unrecognized key: "extra"",
@@ -525,3 +556,362 @@ test("disc union treeify/format", () => {
     }
   `);
 });
+
+test("update message after adding issues", () => {
+  const e = new z.ZodError([]);
+  e.addIssue({
+    code: "custom",
+    message: "message",
+    input: "asdf",
+    path: [],
+  });
+  expect(e.message).toMatchInlineSnapshot(`
+    "[
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      }
+    ]"
+  `);
+
+  e.addIssue({
+    code: "custom",
+    message: "message",
+    input: "asdf",
+    path: [],
+  });
+  expect(e.message).toMatchInlineSnapshot(`
+    "[
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      },
+      {
+        "code": "custom",
+        "message": "message",
+        "input": "asdf",
+        "path": []
+      }
+    ]"
+  `);
+});
+
+test("z.formatError nested union preserves parent path", () => {
+  const syntheticError = new z.ZodError([
+    {
+      code: "invalid_union",
+      path: ["parent"],
+      message: "Invalid input",
+      errors: [
+        [
+          {
+            code: "invalid_type",
+            expected: "string",
+            path: [],
+            message: "Expected string",
+            input: {},
+          },
+        ],
+        [
+          {
+            code: "invalid_union",
+            path: ["child"],
+            message: "Invalid input",
+            errors: [
+              [
+                {
+                  code: "invalid_type",
+                  expected: "string",
+                  path: [],
+                  message: "Expected string",
+                  input: true,
+                },
+              ],
+              [
+                {
+                  code: "invalid_type",
+                  expected: "number",
+                  path: [],
+                  message: "Expected number",
+                  input: true,
+                },
+              ],
+            ],
+          },
+        ],
+      ],
+    },
+  ] as any);
+
+  const formatted: any = z.formatError(syntheticError);
+
+  // "child" must be nested under "parent", not at root
+  expect(formatted).not.toHaveProperty("child");
+  expect(formatted).toHaveProperty("parent");
+  expect(formatted.parent).toHaveProperty("child");
+  expect(formatted.parent.child._errors).toContain("Expected string");
+  expect(formatted.parent.child._errors).toContain("Expected number");
+  expect(formatted.parent._errors).toContain("Expected string");
+});
+test("z.treeifyError nested union preserves parent path", () => {
+  // When a nested invalid_union appears inside another invalid_union, the inner errors must stay nested under their parent path, not flatten to root.
+  const syntheticError = new z.ZodError([
+    {
+      code: "invalid_union",
+      path: ["parent"],
+      message: "Invalid input",
+      errors: [
+        [
+          {
+            code: "invalid_type",
+            expected: "string",
+            path: [],
+            message: "Expected string",
+            input: {},
+          },
+        ],
+        [
+          {
+            code: "invalid_union",
+            path: ["child"],
+            message: "Invalid input",
+            errors: [
+              [
+                {
+                  code: "invalid_type",
+                  expected: "string",
+                  path: [],
+                  message: "Expected string",
+                  input: true,
+                },
+              ],
+              [
+                {
+                  code: "invalid_type",
+                  expected: "number",
+                  path: [],
+                  message: "Expected number",
+                  input: true,
+                },
+              ],
+            ],
+          },
+        ],
+      ],
+    },
+  ] as any);
+
+  const tree: any = z.treeifyError(syntheticError);
+
+  // "child" must be nested under "parent", not at root
+  expect(tree.properties).not.toHaveProperty("child");
+  expect(tree.properties).toHaveProperty("parent");
+  expect(tree.properties.parent.properties).toHaveProperty("child");
+  expect(tree.properties.parent.properties.child.errors).toContain("Expected string");
+  expect(tree.properties.parent.properties.child.errors).toContain("Expected number");
+  expect(tree.properties.parent.errors).toContain("Expected string");
+});
+
+test("z.treeifyError deeply nested union (4 levels) preserves full path", () => {
+  // a > b > c > d — each level wrapped in an invalid_union
+  const syntheticError = new z.ZodError([
+    {
+      code: "invalid_union",
+      path: ["a"],
+      message: "Invalid input",
+      errors: [
+        [
+          {
+            code: "invalid_union",
+            path: ["b"],
+            message: "Invalid input",
+            errors: [
+              [
+                {
+                  code: "invalid_union",
+                  path: ["c"],
+                  message: "Invalid input",
+                  errors: [
+                    [
+                      {
+                        code: "invalid_type",
+                        expected: "string",
+                        path: ["d"],
+                        message: "Expected string",
+                        input: 123,
+                      },
+                    ],
+                  ],
+                },
+              ],
+            ],
+          },
+        ],
+      ],
+    },
+  ] as any);
+
+  const tree: any = z.treeifyError(syntheticError);
+
+  // The full path must be preserved: a.b.c.d
+  expect(tree.properties).toHaveProperty("a");
+  expect(tree.properties).not.toHaveProperty("b");
+  expect(tree.properties).not.toHaveProperty("c");
+
+  const lvlA = tree.properties.a;
+  expect(lvlA.properties).toHaveProperty("b");
+
+  const lvlB = lvlA.properties.b;
+  expect(lvlB.properties).toHaveProperty("c");
+
+  const lvlC = lvlB.properties.c;
+  expect(lvlC.properties).toHaveProperty("d");
+  expect(lvlC.properties.d.errors).toContain("Expected string");
+});
+
+test("z.treeifyError nested union with real schema", () => {
+  const innerUnion = z.union([
+    z.object({ type: z.literal("a"), value: z.string() }),
+    z.object({ type: z.literal("b"), value: z.number() }),
+  ]);
+
+  const schema = z.string().or(
+    z.object({
+      settings: z.object({ name: z.string() }).and(innerUnion),
+    })
+  );
+
+  const result = schema.safeParse({
+    settings: { name: 123, type: "x", value: true },
+  });
+
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    const tree: any = z.treeifyError(result.error);
+
+    // All settings-related errors should be under "settings", not at root
+    expect(tree.properties).toHaveProperty("settings");
+    const settingsProperties = tree.properties.settings.properties ?? {};
+    for (const key of Object.keys(settingsProperties)) {
+      // Every sub-property under settings should NOT also appear at root
+      if (key !== "settings") {
+        expect(tree.properties).not.toHaveProperty(key);
+      }
+    }
+  }
+});
+
+const prototypePropertyNames = ["__proto__", "constructor", "toString", "hasOwnProperty", "valueOf"] as const;
+
+test.each(prototypePropertyNames)("z.formatError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const formatted = z.formatError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(formatted, name)).toBe(true);
+  expect(Object.getPrototypeOf(formatted)).toBe(Object.prototype);
+  expect((formatted as any)[name]._errors).toEqual(["invalid value"]);
+});
+
+test.each(prototypePropertyNames)("z.treeifyError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const tree = z.treeifyError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(tree.properties, name)).toBe(true);
+  expect(Object.getPrototypeOf(tree.properties)).toBe(Object.prototype);
+  expect((tree as any).properties[name].errors).toEqual(["invalid value"]);
+});
+
+test.each(prototypePropertyNames)("z.flattenError handles Object.prototype property path: %s", (name) => {
+  const schema = z.object({ data: z.string() }).superRefine((_, ctx) => {
+    ctx.addIssue({ code: "custom", message: "invalid value", path: [name] });
+  });
+  const result = schema.safeParse({ data: "hello" });
+  expect(result.success).toBe(false);
+  const { fieldErrors } = z.flattenError(result.error!);
+  expect(Object.prototype.hasOwnProperty.call(fieldErrors, name)).toBe(true);
+  expect(Object.getPrototypeOf(fieldErrors)).toBe(Object.prototype);
+  expect((fieldErrors as any)[name]).toEqual(["invalid value"]);
+});
+
+/** The "__proto__" node must be a real own data property, not the inherited accessor. */
+const protoNode = (obj: any) => Object.getOwnPropertyDescriptor(obj, "__proto__")!.value;
+
+test("error formatters merge sibling issues under a __proto__ path", () => {
+  const schema = z.string().check((ctx) => {
+    ctx.issues.push({ code: "custom", message: "a", path: ["__proto__", "x"], input: ctx.value });
+    ctx.issues.push({ code: "custom", message: "b", path: ["__proto__", "y"], input: ctx.value });
+  });
+  const error = schema.safeParse("hello").error!;
+
+  const formatted = protoNode(z.formatError(error));
+  expect(formatted.x._errors).toEqual(["a"]);
+  expect(formatted.y._errors).toEqual(["b"]);
+
+  const tree = protoNode((z.treeifyError(error) as any).properties);
+  expect(tree.properties.x.errors).toEqual(["a"]);
+  expect(tree.properties.y.errors).toEqual(["b"]);
+
+  expect(({} as any).x).toBeUndefined();
+  expect(({} as any).y).toBeUndefined();
+});
+
+test("error formatting leaves Object.prototype untouched for input-derived keys", () => {
+  const record = z.record(z.string(), z.string()).safeParse(JSON.parse('{"toString": 1}'));
+  expect(record.success).toBe(false);
+  expect((z.formatError(record.error!) as any).toString._errors).toHaveLength(1);
+
+  const entries = new Map(Object.entries(JSON.parse('{"__proto__": {"pwn": 1}}')));
+  const result = z.map(z.string(), z.object({ pwn: z.string() })).safeParse(entries);
+  expect(result.success).toBe(false);
+  expect(protoNode(z.formatError(result.error!)).pwn._errors).toHaveLength(1);
+  expect(protoNode((z.treeifyError(result.error!) as any).properties).properties.pwn.errors).toHaveLength(1);
+  expect(({} as any).pwn).toBeUndefined();
+});
+
+test("formatError handles an input-derived _errors path", () => {
+  const schema = z.object({ parent: z.record(z.string(), z.string()) });
+  const result = schema.safeParse({ parent: { _errors: 1 } });
+  expect(result.success).toBe(false);
+
+  const formatted = z.formatError(result.error!);
+  expect(formatted.parent?._errors).toEqual(["Invalid input: expected string, received number"]);
+
+  const nested = z
+    .object({ parent: z.record(z.string(), z.object({ child: z.string() })) })
+    .safeParse({ parent: { _errors: { child: 1 } } });
+  expect(nested.success).toBe(false);
+  expect((z.formatError(nested.error!) as any).parent.child._errors).toEqual([
+    "Invalid input: expected string, received number",
+  ]);
+});
+
+test("error walkers handle path elements named after inherited methods", () => {
+  // "toString" and "constructor" are truthy on the prototype, so a plain lookup finds
+  // the inherited function instead of creating a node, and the push then throws.
+  for (const [schema, input] of [
+    [z.object({ toString: z.string() }), { toString: 1 }],
+    [z.object({ constructor: z.string() }), { constructor: 1 }],
+    [z.object({ toString: z.string(), constructor: z.string() }), { toString: 1, constructor: 2 }],
+  ] as const) {
+    const result = (schema as any).safeParse(input);
+    expect(result.success).toBe(false);
+
+    const formatted = z.formatError(result.error) as any;
+    const tree = z.treeifyError(result.error) as any;
+    for (const key of Object.keys(input)) {
+      expect(formatted[key]._errors).toHaveLength(1);
+      expect(tree.properties[key].errors).toHaveLength(1);
+      expect(Object.prototype.hasOwnProperty.call(formatted, key)).toBe(true);
+    }
+  }
+});