mirror of
https://github.com/badlogic/pi-mono.git
synced 2026-11-05 23:37:25 +00:00
af79b0c3d7
Adds unsafe<T>(), recursive<T>(), Validator.validate() (check plus errors, no coercion), bigint(), equal(), validation and coercion of TypeBox's Type.BigInt/Type.Undefined, and Static for TypeBox's Enum, Tuple, BigInt and Undefined. Also fixes a required property set to undefined being rejected when its schema accepts undefined, as TypeBox allows.
507 lines
21 KiB
TypeScript
507 lines
21 KiB
TypeScript
// compile() and Validator: checks, errors, values, options and schemas from other sources.
|
|
|
|
import Type from "typebox";
|
|
import { describe, expect, it } from "vitest";
|
|
import { formats } from "../src/formats/index.ts";
|
|
import { compile } from "../src/index.ts";
|
|
|
|
const read = {
|
|
type: "object",
|
|
properties: { path: { type: "string" }, offset: { type: "integer", minimum: 1 } },
|
|
required: ["path"],
|
|
additionalProperties: false,
|
|
};
|
|
|
|
const block = {
|
|
anyOf: [
|
|
{
|
|
type: "object",
|
|
properties: { kind: { const: "text" }, text: { type: "string" } },
|
|
required: ["kind", "text"],
|
|
additionalProperties: false,
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: { kind: { const: "image" }, width: { type: "integer", minimum: 0 } },
|
|
required: ["kind", "width"],
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
};
|
|
|
|
describe("errors", () => {
|
|
it("reports a missing field and an unknown field at the field", () => {
|
|
expect(compile(read).errors({ offset: 0, extra: true })).toEqual([
|
|
{ path: "/path", keyword: "required", message: "missing" },
|
|
{ path: "/offset", keyword: "minimum", message: "expected >= 1" },
|
|
{ path: "/extra", keyword: "additionalProperties", message: "unknown field" },
|
|
]);
|
|
});
|
|
|
|
it("is empty for a valid value", () => {
|
|
expect(compile(read).errors({ path: "a.ts" })).toEqual([]);
|
|
});
|
|
|
|
it("reports the branch a tagged union's tag selects", () => {
|
|
const validator = compile({ type: "array", items: block });
|
|
expect(
|
|
validator.errors([
|
|
{ kind: "text", text: "a" },
|
|
{ kind: "image", width: -1 },
|
|
]),
|
|
).toEqual([{ path: "/1/width", keyword: "minimum", message: "expected >= 0" }]);
|
|
expect(validator.errors([{ kind: "video" }])).toEqual([
|
|
{ path: "/0/kind", keyword: "anyOf", message: 'expected one of ["text","image"]' },
|
|
]);
|
|
});
|
|
|
|
it("escapes ~ and / in paths as JSON Pointer does", () => {
|
|
const validator = compile({ type: "object", properties: { "a/b~c": { type: "string" } } });
|
|
expect(validator.errors({ "a/b~c": 1 })).toEqual([
|
|
{ path: "/a~1b~0c", keyword: "type", message: "expected string, got integer" },
|
|
]);
|
|
});
|
|
|
|
it("follows $ref into the referenced schema", () => {
|
|
const validator = compile({
|
|
$defs: { point: { type: "object", properties: { x: { type: "number" } }, required: ["x"] } },
|
|
type: "array",
|
|
items: { $ref: "#/$defs/point" },
|
|
});
|
|
expect(validator.errors([{ x: 1 }, {}])).toEqual([{ path: "/1/x", keyword: "required", message: "missing" }]);
|
|
});
|
|
});
|
|
|
|
describe("values", () => {
|
|
it("treats a property set to undefined as absent", () => {
|
|
const validator = compile(read);
|
|
expect(validator.check({ path: "a.ts", offset: undefined })).toBe(true);
|
|
expect(validator.check({ path: undefined })).toBe(false);
|
|
});
|
|
|
|
it("checks bytes as Uint8Array with length bounds", () => {
|
|
const validator = compile({ type: "object", properties: { data: { type: "bytes", maxLength: 4 } } });
|
|
expect(validator.check({ data: new Uint8Array(4) })).toBe(true);
|
|
expect(validator.check({ data: new Uint8Array(5) })).toBe(false);
|
|
expect(validator.check({ data: [1, 2] })).toBe(false);
|
|
expect(validator.errors({ data: new Uint8Array(5) })).toEqual([
|
|
{ path: "/data", keyword: "maxLength", message: "expected at most 4 bytes" },
|
|
]);
|
|
});
|
|
|
|
it("does not treat bytes as an object", () => {
|
|
expect(compile({ type: "object" }).check(new Uint8Array(1))).toBe(false);
|
|
});
|
|
|
|
it("checks properties named like Object.prototype members as own properties", () => {
|
|
const validator = compile({
|
|
type: "object",
|
|
properties: { constructor: { type: "string" }, toString: { type: "number" } },
|
|
required: ["constructor"],
|
|
additionalProperties: false,
|
|
});
|
|
expect(validator.check({})).toBe(false);
|
|
expect(validator.check({ constructor: "a" })).toBe(true);
|
|
expect(validator.check({ constructor: "a", toString: "b" })).toBe(false);
|
|
});
|
|
|
|
it("does not accept every value for a type named like an Object.prototype member", () => {
|
|
expect(compile({ type: "constructor" }).check(1)).toBe(false);
|
|
});
|
|
|
|
it("checks a detached check function", () => {
|
|
const { check } = compile(read);
|
|
expect([{ path: "a" }, { path: 1 }].filter(check)).toEqual([{ path: "a" }]);
|
|
});
|
|
});
|
|
|
|
describe("options", () => {
|
|
it("treats format as an annotation unless formats are given", () => {
|
|
const schema = { type: "string", format: "email" };
|
|
expect(compile(schema).check("not an email")).toBe(true);
|
|
expect(compile(schema, { formats }).check("not an email")).toBe(false);
|
|
expect(compile(schema, { formats }).check("a@example.com")).toBe(true);
|
|
});
|
|
|
|
it("resolves $ref to registered documents", () => {
|
|
const point = { type: "object", properties: { x: { type: "number" } }, required: ["x"] };
|
|
const validator = compile(
|
|
{ $ref: "https://example.com/point.json" },
|
|
{ schemas: { "https://example.com/point.json": point } },
|
|
);
|
|
expect(validator.check({ x: 1 })).toBe(true);
|
|
expect(validator.check({})).toBe(false);
|
|
});
|
|
|
|
it("throws for a $ref that names nothing", () => {
|
|
expect(() => compile({ $ref: "https://example.com/missing.json" })).toThrow(/Unresolved \$ref/);
|
|
expect(() => compile({ $ref: "#/$defs/missing" })).toThrow(/Unresolved \$ref/);
|
|
});
|
|
|
|
it("applies draft 7 semantics: $ref overrides its siblings", () => {
|
|
const schema = { definitions: { s: { type: "string" } }, $ref: "#/definitions/s", maxLength: 1 };
|
|
expect(compile(schema, { draft: "7" }).check("ab")).toBe(true);
|
|
expect(compile(schema).check("ab")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("schemas", () => {
|
|
it("compiles TypeBox schemas as they are", () => {
|
|
const validator = compile(Type.Object({ name: Type.String(), tags: Type.Array(Type.String()) }));
|
|
expect(validator.check({ name: "a", tags: [] })).toBe(true);
|
|
expect(validator.errors({ name: "a", tags: [1] })).toEqual([
|
|
{ path: "/tags/0", keyword: "type", message: "expected string, got integer" },
|
|
]);
|
|
});
|
|
|
|
it("compiles deep-frozen schemas and never modifies a schema", () => {
|
|
const schema = deepFreeze(structuredClone({ ...block, $defs: { s: { type: "string", pattern: "^a" } } }));
|
|
const before = JSON.stringify(schema);
|
|
const validator = compile(schema);
|
|
expect(validator.check({ kind: "text", text: "x" })).toBe(true);
|
|
expect(validator.errors({ kind: "image", width: -1 })).toHaveLength(1);
|
|
expect(JSON.stringify(schema)).toBe(before);
|
|
});
|
|
|
|
it("compiles a recursive schema", () => {
|
|
const tree = {
|
|
type: "object",
|
|
properties: { value: { type: "number" }, children: { type: "array", items: { $ref: "#" } } },
|
|
required: ["value"],
|
|
};
|
|
const validator = compile(tree);
|
|
expect(validator.check({ value: 1, children: [{ value: 2, children: [{ value: 3 }] }] })).toBe(true);
|
|
expect(validator.errors({ value: 1, children: [{ value: 2, children: [{}] }] })).toEqual([
|
|
{ path: "/children/0/children/0/value", keyword: "required", message: "missing" },
|
|
]);
|
|
});
|
|
|
|
// #11697
|
|
it("applies a relative root $id once when resolving local references", () => {
|
|
const schema = {
|
|
$id: "schemas/tool.json",
|
|
type: "object",
|
|
properties: { count: { $ref: "#/$defs/count" } },
|
|
required: ["count"],
|
|
$defs: { count: { type: "integer" } },
|
|
};
|
|
expect(compile(schema).check({ count: 2 })).toBe(true);
|
|
const validator = compile(schema, { unresolvedRefs: "reject" });
|
|
expect(validator.check({ count: 2 })).toBe(true);
|
|
expect(validator.errors({ count: "a" })).toEqual([
|
|
{ path: "/count", keyword: "type", message: "expected integer, got string" },
|
|
]);
|
|
expect(compile(schema, { coerce: true }).parse({ count: "2" })).toEqual({ ok: true, value: { count: 2 } });
|
|
});
|
|
|
|
it("applies a relative root $id once in schemas with unevaluated keywords", () => {
|
|
const props = {
|
|
$id: "schemas/tool.json",
|
|
type: "object",
|
|
properties: { count: { $ref: "#/$defs/count" } },
|
|
$defs: { count: { type: "integer" } },
|
|
unevaluatedProperties: false,
|
|
};
|
|
const validator = compile(props, { unresolvedRefs: "reject" });
|
|
expect(validator.check({ count: 2 })).toBe(true);
|
|
expect(validator.errors({ count: 2, extra: 1 })).toEqual([
|
|
{ path: "/extra", keyword: "unevaluatedProperties", message: "unknown field" },
|
|
]);
|
|
const items = {
|
|
$id: "schemas/list.json",
|
|
type: "array",
|
|
prefixItems: [{ $ref: "#/$defs/count" }],
|
|
$defs: { count: { type: "integer" } },
|
|
unevaluatedItems: false,
|
|
};
|
|
expect(compile(items, { unresolvedRefs: "reject" }).check([2])).toBe(true);
|
|
expect(compile(items).check([2, 3])).toBe(false);
|
|
});
|
|
|
|
it("explains errors under nested resources with a relative $id", () => {
|
|
const cloned = {
|
|
$id: "https://example.com/root.json",
|
|
allOf: [{ $ref: "#/$defs/child" }],
|
|
$defs: {
|
|
child: {
|
|
$id: "schemas/tool.json",
|
|
$ref: "#/$defs/props",
|
|
unevaluatedProperties: false,
|
|
$defs: { props: { properties: { count: { type: "integer" } } } },
|
|
},
|
|
},
|
|
};
|
|
expect(compile(cloned).errors({ count: 2, extra: 1 })).toEqual([
|
|
{ path: "/extra", keyword: "unevaluatedProperties", message: "unknown field" },
|
|
]);
|
|
const branch = {
|
|
$id: "https://example.com/root.json",
|
|
anyOf: [{ $id: "a/b.json", $ref: "#/$defs/n", $defs: { n: { type: "integer" } } }, { type: "boolean" }],
|
|
};
|
|
expect(compile(branch).errors({})).toEqual([
|
|
{ path: "", keyword: "type", message: "expected integer, got object" },
|
|
]);
|
|
});
|
|
|
|
it("throws for a malformed schema", () => {
|
|
expect(() => compile({ properties: { a: 1 } })).toThrow(/must be an object or a boolean/);
|
|
});
|
|
});
|
|
|
|
function deepFreeze<T>(value: T): T {
|
|
if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
|
|
Object.freeze(value);
|
|
for (const child of Object.values(value)) deepFreeze(child);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
describe("unresolved references", () => {
|
|
const dangling = { type: "object", properties: { t: { $ref: "#/definitions/Missing" } } };
|
|
const external = { type: "object", properties: { t: { $ref: "https://example.com/schemas/t.json" } } };
|
|
|
|
it("throw when the schema compiles, by default", () => {
|
|
expect(() => compile(dangling)).toThrow("Unresolved $ref #/definitions/Missing");
|
|
expect(() => compile(external)).toThrow("Unresolved $ref https://example.com/schemas/t.json");
|
|
});
|
|
|
|
it("reject only values at their place with unresolvedRefs: reject", () => {
|
|
for (const schema of [dangling, external]) {
|
|
const validator = compile(schema, { unresolvedRefs: "reject" });
|
|
expect(validator.check({})).toBe(true);
|
|
expect(validator.check({ t: 1 })).toBe(false);
|
|
}
|
|
expect(compile(dangling, { unresolvedRefs: "reject" }).errors({ t: 1 })).toEqual([
|
|
{ path: "/t", keyword: "$ref", message: "unresolved reference #/definitions/Missing" },
|
|
]);
|
|
});
|
|
|
|
it("leave values at their place uncoerced", () => {
|
|
const validator = compile(dangling, { unresolvedRefs: "reject", coerce: true });
|
|
expect(validator.parse({ t: "1" })).toEqual({
|
|
ok: false,
|
|
errors: [{ path: "/t", keyword: "$ref", message: "unresolved reference #/definitions/Missing" }],
|
|
});
|
|
});
|
|
|
|
it("reject a TypeBox Ref without its definition", () => {
|
|
const validator = compile(Type.Object({ a: Type.Ref("A") }), { unresolvedRefs: "reject" });
|
|
expect(validator.errors({ a: { x: "1" } })).toEqual([
|
|
{ path: "/a", keyword: "$ref", message: "unresolved reference A" },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("leaf checks inlined by object and array loops", () => {
|
|
const leaves: [object, unknown[]][] = [
|
|
[{ const: "a" }, ["a", "b", 1, null]],
|
|
[{ const: null }, [null, 0, false, "null"]],
|
|
[{ enum: ["a", 1, null] }, ["a", 1, null, "b", 2, true]],
|
|
[{ type: ["string", "null"] }, ["a", null, 1, {}, []]],
|
|
[{ type: ["integer", "boolean"] }, [1, 1.5, true, "1"]],
|
|
[{ type: ["number", "array"] }, [1.5, 2, [], {}, new Uint8Array(1)]],
|
|
[{ type: ["object", "bytes"] }, [{}, new Uint8Array(1), [], null]],
|
|
[{ anyOf: [{ type: "string" }, { type: "null" }] }, ["a", null, 1]],
|
|
[{ anyOf: [{ type: "integer" }, { type: "string", minLength: 2 }] }, [1, 1.5, "ab", "a"]],
|
|
[{ type: "integer", minimum: 1, exclusiveMaximum: 5 }, [1, 4, 5, 0, 2.5, "2"]],
|
|
[{ type: "number", exclusiveMinimum: 0, maximum: 1 }, [0.5, 1, 0, 1.5, "0.5"]],
|
|
[{ type: "integer", multipleOf: 2 }, [2, 3, 2.5]],
|
|
[{ type: "string", minLength: 2, maxLength: 3 }, ["ab", "abc", "a", "abcd", "😀😀", 12]],
|
|
[{ type: "string", pattern: "^a+$" }, ["aa", "ab", 1]],
|
|
[{ minimum: 1 }, [1, 0, "x", null]],
|
|
];
|
|
|
|
it("agree with the standalone check as a property, a pattern property and an item", () => {
|
|
for (const [schema, values] of leaves) {
|
|
const alone = compile(schema).check;
|
|
const closed = compile({ type: "object", properties: { p: schema }, additionalProperties: false }).check;
|
|
const open = compile({ type: "object", properties: { p: schema }, required: ["q"] }).check;
|
|
const items = compile({ type: "array", items: schema }).check;
|
|
for (const v of values) {
|
|
const expected = alone(v);
|
|
expect([closed({ p: v }), open({ p: v, q: 1 }), items([v])], JSON.stringify({ schema, v })).toEqual([
|
|
expected,
|
|
expected,
|
|
expected,
|
|
]);
|
|
}
|
|
}
|
|
});
|
|
|
|
it("find properties in any order", () => {
|
|
const { check } = compile({
|
|
type: "object",
|
|
properties: { a: { const: 1 }, b: { type: "string" }, c: { type: "integer", minimum: 0 } },
|
|
required: ["a", "c"],
|
|
additionalProperties: false,
|
|
});
|
|
expect(check({ a: 1, b: "x", c: 0 })).toBe(true);
|
|
expect(check({ c: 0, b: "x", a: 1 })).toBe(true);
|
|
expect(check({ b: "x", c: 0, a: 1 })).toBe(true);
|
|
expect(check({ a: 1, c: 0, a2: 1 })).toBe(false);
|
|
expect(check({ c: -1, a: 1 })).toBe(false);
|
|
expect(check({ c: 0, b: 1, a: 1 })).toBe(false);
|
|
expect(check({ c: 0, b: undefined, a: 1 })).toBe(true);
|
|
expect(check({ c: 0, b: "x" })).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("string lengths", () => {
|
|
it("count an unpaired high surrogate as one code point and a pair as one", () => {
|
|
expect(compile({ type: "string", minLength: 2 }).check("\ud800A")).toBe(true);
|
|
expect(compile({ type: "string", maxLength: 1 }).check("\ud800A")).toBe(false);
|
|
expect(compile({ type: "string", maxLength: 1 }).check("\ud800")).toBe(true);
|
|
expect(compile({ type: "string", maxLength: 1 }).check("😀")).toBe(true);
|
|
expect(compile({ type: "string", minLength: 2 }).check("😀")).toBe(false);
|
|
expect(compile({ type: "string", minLength: 2 }).check("\udc00\ud800")).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("error messages", () => {
|
|
it("list at most 20 enum values", () => {
|
|
const values = Array.from({ length: 5000 }, (_, i) => `v${i}`);
|
|
const validator = compile({ type: "object", properties: { e: { type: "string", enum: values } } });
|
|
expect(validator.check({ e: "v4999" })).toBe(true);
|
|
const [error] = validator.errors({ e: "v5000" });
|
|
expect(error.message).toBe(
|
|
`expected one of ${JSON.stringify(values.slice(0, 20)).slice(0, -1)}, ... and 4980 more]`,
|
|
);
|
|
expect(compile({ enum: ["a", "b"] }).errors("c")).toEqual([
|
|
{ path: "", keyword: "enum", message: 'expected one of ["a","b"]' },
|
|
]);
|
|
});
|
|
|
|
it("accept a 10,000-value enum", () => {
|
|
const values = Array.from({ length: 10_000 }, (_, i) => `member${i}`);
|
|
expect(compile({ enum: values }).check("member9999")).toBe(true);
|
|
});
|
|
|
|
it("describe contains bounds in words", () => {
|
|
const at = (schema: object) => compile({ type: "array", ...schema }).errors(["a"])[0]?.message;
|
|
expect(at({ contains: { type: "number" } })).toBe("expected at least 1 matching item");
|
|
expect(at({ contains: { type: "number" }, minContains: 2 })).toBe("expected at least 2 matching items");
|
|
expect(at({ contains: { type: "string" }, maxContains: 0, minContains: 0 })).toBe(
|
|
"expected at most 0 matching items",
|
|
);
|
|
expect(at({ contains: { type: "number" }, minContains: 1, maxContains: 3 })).toBe(
|
|
"expected between 1 and 3 matching items",
|
|
);
|
|
});
|
|
|
|
it("blame a oneOf failure on the branch that declares most of the object's properties", () => {
|
|
const filter = {
|
|
type: "object",
|
|
properties: { where: { $ref: "#/$defs/F" } },
|
|
$defs: {
|
|
F: {
|
|
oneOf: [
|
|
{
|
|
type: "object",
|
|
properties: { field: { type: "string" }, eq: { type: "string" } },
|
|
required: ["field", "eq"],
|
|
additionalProperties: false,
|
|
},
|
|
{
|
|
type: "object",
|
|
properties: { and: { type: "array", items: { $ref: "#/$defs/F" } } },
|
|
required: ["and"],
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
},
|
|
};
|
|
expect(compile(filter).errors({ where: { and: [{ field: "a", eq: 1, x: 2 }] } })).toEqual([
|
|
{ path: "/where/and/0/eq", keyword: "type", message: "expected string, got integer" },
|
|
{ path: "/where/and/0/x", keyword: "additionalProperties", message: "unknown field" },
|
|
]);
|
|
});
|
|
|
|
it("explain one object reached through the same reference at two paths at each path", () => {
|
|
const schema = {
|
|
type: "object",
|
|
properties: { a: { $ref: "#/$defs/P" }, b: { $ref: "#/$defs/P" } },
|
|
$defs: { P: { type: "object", properties: { n: { type: "integer" } } } },
|
|
};
|
|
const shared = { n: "x" };
|
|
expect(compile(schema).errors({ a: shared, b: shared })).toEqual([
|
|
{ path: "/a/n", keyword: "type", message: "expected integer, got string" },
|
|
{ path: "/b/n", keyword: "type", message: "expected integer, got string" },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("TypeBox's extra formats", () => {
|
|
it("check url and json-pointer-uri-fragment", () => {
|
|
const url = compile({ type: "string", format: "url" }, { formats });
|
|
expect(url.check("https://example.com/a?b=1")).toBe(true);
|
|
expect(url.check("not a url")).toBe(false);
|
|
const fragment = compile({ type: "string", format: "json-pointer-uri-fragment" }, { formats });
|
|
expect(fragment.check("#/a/b~1c")).toBe(true);
|
|
expect(fragment.check("#/a b")).toBe(false);
|
|
expect(fragment.check("/a")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("TypeBox's JavaScript types", () => {
|
|
it("check Type.BigInt with its bounds, as TypeBox does", () => {
|
|
const schema = Type.Union([Type.BigInt({ minimum: 0n }), Type.Null()]);
|
|
const validator = compile(schema);
|
|
for (const value of [5n, 0n, null]) expect(validator.check(value)).toBe(true);
|
|
for (const value of [-1n, 5, "5", undefined]) expect(validator.check(value)).toBe(false);
|
|
expect(compile(Type.BigInt({ maximum: 10n, multipleOf: 5n })).check(10n)).toBe(true);
|
|
expect(compile(Type.BigInt({ multipleOf: 5n })).check(7n)).toBe(false);
|
|
expect(compile(Type.BigInt({ exclusiveMaximum: 3n })).check(3n)).toBe(false);
|
|
expect(compile(Type.BigInt({ minimum: 0n })).errors(-2n)).toEqual([
|
|
{ path: "", keyword: "minimum", message: "expected >= 0" },
|
|
]);
|
|
expect(compile(Type.BigInt()).errors(2)).toEqual([
|
|
{ path: "", keyword: "type", message: "expected bigint, got integer" },
|
|
]);
|
|
});
|
|
|
|
it("check Type.Undefined: only undefined, and a required property with it must be present", () => {
|
|
expect(compile(Type.Undefined()).check(undefined)).toBe(true);
|
|
expect(compile(Type.Undefined()).check(null)).toBe(false);
|
|
const schema = Type.Object({ selection: Type.Literal("average"), principalId: Type.Undefined() });
|
|
const validator = compile(schema);
|
|
expect(validator.check({ selection: "average", principalId: undefined })).toBe(true);
|
|
expect(validator.check({ selection: "average" })).toBe(false);
|
|
expect(validator.check({ selection: "average", principalId: "x" })).toBe(false);
|
|
expect(validator.check({ selection: "average", principalId: null })).toBe(false);
|
|
expect(validator.errors({ selection: "average" })).toEqual([
|
|
{ path: "/principalId", keyword: "required", message: "missing" },
|
|
]);
|
|
expect(validator.errors({ selection: "average", principalId: "x" })).toEqual([
|
|
{ path: "/principalId", keyword: "type", message: "expected undefined, got string" },
|
|
]);
|
|
});
|
|
|
|
it("check a required property set to undefined by its schema, as TypeBox does", () => {
|
|
// Present and undefined: valid when the schema takes undefined (Undefined in a union, Unknown, Any).
|
|
for (const property of [Type.Union([Type.String(), Type.Undefined()]), Type.Unknown(), Type.Any()]) {
|
|
for (const additionalProperties of [undefined, false]) {
|
|
const validator = compile(
|
|
Type.Object({ a: property }, additionalProperties === false ? { additionalProperties } : {}),
|
|
);
|
|
expect(validator.check({ a: undefined })).toBe(true);
|
|
expect(validator.check({})).toBe(false);
|
|
}
|
|
}
|
|
// A required property whose schema does not take undefined stays missing when set to undefined.
|
|
const name = compile(Type.Object({ name: Type.String() }));
|
|
expect(name.check({ name: undefined })).toBe(false);
|
|
expect(name.errors({ name: undefined })).toEqual([{ path: "/name", keyword: "required", message: "missing" }]);
|
|
// An optional property set to undefined still counts as absent.
|
|
expect(compile(Type.Object({ name: Type.Optional(Type.String()) })).check({ name: undefined })).toBe(true);
|
|
});
|
|
|
|
it("check multipleOf of bigints exactly, however large", () => {
|
|
const five = compile(Type.BigInt({ multipleOf: 5n }));
|
|
expect(five.check(10n ** 400n)).toBe(true);
|
|
expect(five.check(10n ** 400n + 1n)).toBe(false);
|
|
// A bigint is no multiple of 0 or of a fraction.
|
|
expect(compile({ multipleOf: 0n }).check(4n)).toBe(false);
|
|
expect(compile({ multipleOf: 0.5 }).check(3n)).toBe(false);
|
|
});
|
|
});
|