Skip to content

Commit 0ac527b

Browse files
thib3113thib3113
committed
add more tests
1 parent 1b11d98 commit 0ac527b

18 files changed

+526
-9
lines changed

‎test/rules/custom.spec.js

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,28 @@ describe("Test rule: custom v1", () => {
4444
expect(checker).toHaveBeenCalledWith(10, schema.weight, "weight", { weight: 10 }, expect.any(Object));
4545
});
4646

47+
it("should allow custom metas", async () => {
48+
const checker = jest.fn(() => true);
49+
const schema = {
50+
$$foo: {
51+
foo: "bar"
52+
},
53+
$$root: true,
54+
type: "custom",
55+
a: 5,
56+
check: checker
57+
};
58+
const clonedSchema = {...schema};
59+
const check = v.compile(schema);
60+
61+
expect(schema).toStrictEqual(clonedSchema);
62+
63+
64+
expect(check(10)).toEqual(true);
65+
expect(checker).toHaveBeenCalledTimes(1);
66+
//checkFunction should receive the unmodified schema
67+
expect(checker).toHaveBeenCalledWith(10, schema, "null", null, expect.any(Object));
68+
});
4769
});
4870

4971

@@ -108,4 +130,28 @@ describe("Test rule: custom v2", () => {
108130
expect(checker).toHaveBeenCalledWith({ name: "John" }, [], schema, "$$root", null, expect.any(Object));
109131
});
110132

133+
it("should allow custom metas", async () => {
134+
const checker = jest.fn(v => v);
135+
const schema = {
136+
$$foo: {
137+
foo: "bar"
138+
},
139+
$$root: true,
140+
type: "object",
141+
properties: {
142+
name: "string"
143+
},
144+
custom: checker
145+
};
146+
const clonedSchema = {...schema};
147+
const check = v.compile(schema);
148+
149+
expect(schema).toStrictEqual(clonedSchema);
150+
151+
expect(check({ name: "John" })).toEqual(true);
152+
expect(checker).toHaveBeenCalledTimes(1);
153+
//checkFunction should receive the unmodified schema
154+
expect(checker).toHaveBeenCalledWith({ name: "John" }, [], schema, "$$root", null, expect.any(Object));
155+
});
156+
111157
});

‎test/rules/date.spec.js

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -63,4 +63,33 @@ describe("Test rule: date", () => {
6363
expect(check(obj)).toEqual(true);
6464
expect(obj).toEqual({ timestamp: new Date("Wed Mar 25 2015 09:56:24 GMT+0100 (W. Europe Standard Time)") });
6565
});
66+
67+
it("should allow custom metas", async () => {
68+
const schema = {
69+
$$foo: {
70+
foo: "bar"
71+
},
72+
$$root: true,
73+
type: "date"
74+
};
75+
const clonedSchema = {...schema};
76+
expect(schema).toStrictEqual(clonedSchema);
77+
const check = v.compile(schema);
78+
const message = "The '' field must be a Date.";
79+
80+
expect(check(0)).toEqual([{ type: "date", actual: 0, message }]);
81+
expect(check(1)).toEqual([{ type: "date", actual: 1, message }]);
82+
expect(check("")).toEqual([{ type: "date", actual: "", message }]);
83+
expect(check("true")).toEqual([{ type: "date", actual: "true", message }]);
84+
expect(check("false")).toEqual([{ type: "date", actual: "false", message }]);
85+
expect(check([])).toEqual([{ type: "date", actual: [], message }]);
86+
expect(check({})).toEqual([{ type: "date", actual: {}, message }]);
87+
88+
const now = Date.now();
89+
expect(check(now)).toEqual([{ type: "date", actual: now, message }]);
90+
91+
expect(check(new Date())).toEqual(true);
92+
expect(check(new Date(1488876927958))).toEqual(true);
93+
94+
});
6695
});

‎test/rules/email.spec.js

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,4 +91,21 @@ describe("Test rule: email", () => {
9191
expect(check("[email protected]")).toEqual([{ type: "emailMax", expected: 20, actual: 45, message: "The '' field length must be less than or equal to 20 characters long." }]);
9292
});
9393

94+
it("should allow custom metas", async () => {
95+
const schema = {
96+
$$foo: {
97+
foo: "bar"
98+
},
99+
$$root: true,
100+
type: "email",
101+
empty: true
102+
};
103+
const clonedSchema = {...schema};
104+
const check = v.compile(schema);
105+
106+
expect(schema).toStrictEqual(clonedSchema);
107+
expect(check("[email protected]")).toEqual(true);
108+
expect(check("")).toEqual(true);
109+
});
110+
94111
});

‎test/rules/enum.spec.js

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,4 +23,23 @@ describe("Test rule: enum", () => {
2323
expect(check(false)).toEqual(true);
2424
});
2525

26+
it("should allow custom metas", async () => {
27+
const schema = {
28+
$$foo: {
29+
foo: "bar"
30+
},
31+
$$root: true,
32+
type: "enum",
33+
values: ["male", "female"]
34+
};
35+
const clonedSchema = {...schema};
36+
const check = v.compile(schema);
37+
38+
expect(clonedSchema).toEqual(schema);
39+
40+
expect(check("")).toEqual([{ type: "enumValue", expected: "male, female", actual: "", message: "The '' field value 'male, female' does not match any of the allowed values." }]);
41+
expect(check("human")).toEqual([{ type: "enumValue", expected: "male, female", actual: "human", message: "The '' field value 'male, female' does not match any of the allowed values." }]);
42+
expect(check("male")).toEqual(true);
43+
expect(check("female")).toEqual(true);
44+
});
2645
});

‎test/rules/equal.spec.js

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,4 +48,26 @@ describe("Test rule: equal", () => {
4848
expect(check({ accept: 1 })).toEqual([{ type: "equalValue", field: "accept", actual: 1, expected: true, message }]);
4949
expect(check({ accept: true })).toEqual(true);
5050
});
51+
52+
it("should allow custom metas", async () => {
53+
const schema = {
54+
$$foo: {
55+
foo: "bar"
56+
},
57+
confirm: {
58+
type: "equal",
59+
field: "pass"
60+
}
61+
};
62+
const clonedSchema = {...schema};
63+
const check = v.compile(schema);
64+
const message = "The 'confirm' field value must be equal to 'pass' field value.";
65+
66+
expect(clonedSchema).toEqual(schema);
67+
68+
expect(check({ confirm: "abcd"})).toEqual([{ type: "equalField", field: "confirm", actual: "abcd", expected: "pass", message }]);
69+
expect(check({ pass: "1234", confirm: "abcd"})).toEqual([{ type: "equalField", field: "confirm", actual: "abcd", expected: "pass", message }]);
70+
expect(check({ pass: "1234", confirm: 1234 })).toEqual(true);
71+
expect(check({ pass: "1234", confirm: "1234" })).toEqual(true);
72+
});
5173
});

‎test/rules/forbidden.spec.js

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -45,4 +45,30 @@ describe("Test rule: forbidden", () => {
4545

4646
});
4747

48+
it("should allow custom metas", async () => {
49+
const schema = {
50+
$$foo: {
51+
foo: "bar"
52+
},
53+
$$root: true,
54+
type: "forbidden"
55+
};
56+
const clonedSchema = {...schema};
57+
const check = v.compile(schema);
58+
59+
expect(clonedSchema).toEqual(schema);
60+
61+
const message = "The '' field is forbidden.";
62+
expect(check(null)).toEqual(true);
63+
expect(check(undefined)).toEqual(true);
64+
expect(check(0)).toEqual([{ type: "forbidden", actual: 0, message }]);
65+
expect(check(1)).toEqual([{ type: "forbidden", actual: 1, message }]);
66+
expect(check("")).toEqual([{ type: "forbidden", actual: "", message }]);
67+
expect(check("null")).toEqual([{ type: "forbidden", actual: "null", message }]);
68+
expect(check([])).toEqual([{ type: "forbidden", actual: [], message }]);
69+
expect(check({})).toEqual([{ type: "forbidden", actual: {}, message }]);
70+
expect(check(false)).toEqual([{ type: "forbidden", actual: false, message }]);
71+
expect(check(true)).toEqual([{ type: "forbidden", actual: true, message }]);
72+
});
73+
4874
});

‎test/rules/function.spec.js

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,4 +22,33 @@ describe("Test rule: function", () => {
2222
expect(check(() => {})).toEqual(true);
2323
expect(check(new Function())).toEqual(true);
2424
});
25+
26+
it("should allow custom metas", async () => {
27+
const schema = {
28+
$$foo: {
29+
foo: "bar"
30+
},
31+
$$root: true,
32+
type: "function"
33+
};
34+
const clonedSchema = {...schema};
35+
const check = v.compile(schema);
36+
37+
expect(clonedSchema).toEqual(schema);
38+
39+
const message = "The '' field must be a function.";
40+
41+
expect(check(0)).toEqual([{ type: "function", actual: 0, message }]);
42+
expect(check(1)).toEqual([{ type: "function", actual: 1, message }]);
43+
expect(check("")).toEqual([{ type: "function", actual: "", message }]);
44+
expect(check("true")).toEqual([{ type: "function", actual: "true", message }]);
45+
expect(check([])).toEqual([{ type: "function", actual: [], message }]);
46+
expect(check({})).toEqual([{ type: "function", actual: {}, message }]);
47+
expect(check(false)).toEqual([{ type: "function", actual: false, message }]);
48+
expect(check(true)).toEqual([{ type: "function", actual: true, message }]);
49+
50+
expect(check(function() {})).toEqual(true);
51+
expect(check(() => {})).toEqual(true);
52+
expect(check(new Function())).toEqual(true);
53+
});
2554
});

‎test/rules/luhn.spec.js

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,4 +25,34 @@ describe("Test rule: luhn", () => {
2525
expect(check("4523-739-8990-1198")).toEqual(true);
2626
});
2727

28+
it("should allow custom metas", async () => {
29+
const schema = {
30+
$$foo: {
31+
foo: "bar"
32+
},
33+
$$root: true,
34+
type: "luhn"
35+
};
36+
const clonedSchema = {...schema};
37+
const check = v.compile(schema);
38+
39+
expect(clonedSchema).toEqual(schema);
40+
41+
let message = "The '' field must be a string.";
42+
43+
expect(check(0)).toEqual([{ type: "string", actual: 0, message }]);
44+
expect(check(1)).toEqual([{ type: "string", actual: 1, message }]);
45+
expect(check([])).toEqual([{ type: "string", actual: [], message }]);
46+
expect(check({})).toEqual([{ type: "string", actual: {}, message }]);
47+
expect(check(false)).toEqual([{ type: "string", actual: false, message }]);
48+
expect(check(true)).toEqual([{ type: "string", actual: true, message }]);
49+
50+
message = "The '' field must be a valid checksum luhn.";
51+
expect(check("")).toEqual([{ type: "luhn", actual: "", message }]);
52+
expect(check("true")).toEqual([{ type: "luhn", actual: "true", message }]);
53+
expect(check("452373989911198")).toEqual([{ type: "luhn", actual: "452373989911198", message }]);
54+
expect(check("452373989901199")).toEqual([{ type: "luhn", actual: "452373989901199", message }]);
55+
expect(check("452373989901198")).toEqual(true);
56+
expect(check("4523-739-8990-1198")).toEqual(true);
57+
});
2858
});

‎test/rules/mac.spec.js

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,4 +37,46 @@ describe("Test rule: mac", () => {
3737
expect(check("01-c8-95-4b-65-fe")).toEqual(true);
3838
});
3939

40+
it("should allow custom metas", async () => {
41+
const schema = {
42+
$$foo: {
43+
foo: "bar"
44+
},
45+
$$root: true,
46+
type: "mac"
47+
};
48+
const clonedSchema = {...schema};
49+
const check = v.compile(schema);
50+
51+
expect(clonedSchema).toEqual(schema);
52+
53+
let message = "The '' field must be a string.";
54+
55+
expect(check(0)).toEqual([{ type: "string", actual: 0, message }]);
56+
expect(check(1)).toEqual([{ type: "string", actual: 1, message }]);
57+
expect(check([])).toEqual([{ type: "string", actual: [], message }]);
58+
expect(check({})).toEqual([{ type: "string", actual: {}, message }]);
59+
expect(check(false)).toEqual([{ type: "string", actual: false, message }]);
60+
expect(check(true)).toEqual([{ type: "string", actual: true, message }]);
61+
62+
message = "The '' field must be a valid MAC address.";
63+
expect(check("")).toEqual([{ type: "mac", actual: "", message }]);
64+
expect(check("true")).toEqual([{ type: "mac", actual: "true", message }]);
65+
expect(check("018.954B.65FE")).toEqual([{ type: "mac", actual: "018.954B.65FE", message }]);
66+
expect(check("01C8.95B.65FE")).toEqual([{ type: "mac", actual: "01C8.95B.65FE", message }]);
67+
expect(check("01C8.954B.6FE")).toEqual([{ type: "mac", actual: "01C8.954B.6FE", message }]);
68+
expect(check("1-C8-95-4B-65-FE")).toEqual([{ type: "mac", actual: "1-C8-95-4B-65-FE", message }]);
69+
expect(check("01-C8-95-4B-65-F")).toEqual([{ type: "mac", actual: "01-C8-95-4B-65-F", message }]);
70+
expect(check("01-C8-95-4B-65-FE-A0")).toEqual([{ type: "mac", actual: "01-C8-95-4B-65-FE-A0", message }]);
71+
expect(check("1:C8:95:4B:65:FE")).toEqual([{ type: "mac", actual: "1:C8:95:4B:65:FE", message }]);
72+
expect(check("01:8:95:4B:65:FE")).toEqual([{ type: "mac", actual: "01:8:95:4B:65:FE", message }]);
73+
expect(check("01:C8:95:4B:65:F")).toEqual([{ type: "mac", actual: "01:C8:95:4B:65:F", message }]);
74+
expect(check("01:C8:95:4B:65:FE:AF")).toEqual([{ type: "mac", actual: "01:C8:95:4B:65:FE:AF", message }]);
75+
expect(check("01:c8:95:4b:65:fe")).toEqual(true);
76+
expect(check("01:C8:95:4B:65:FE")).toEqual(true);
77+
expect(check("01c8.954b.65fe")).toEqual(true);
78+
expect(check("01C8.954B.65FE")).toEqual(true);
79+
expect(check("01-C8-95-4B-65-FE")).toEqual(true);
80+
expect(check("01-c8-95-4b-65-fe")).toEqual(true);
81+
});
4082
});

‎test/rules/multi.spec.js

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -185,4 +185,34 @@ describe("Test rule: multi", () => {
185185
}
186186
});
187187
});
188+
189+
190+
it("should allow custom metas", async () => {
191+
const fn = jest.fn((v) => v);
192+
const schema = {
193+
$$foo: {
194+
foo: "bar"
195+
},
196+
$$root: true,
197+
type: "multi",
198+
rules: [
199+
{
200+
type: "string",
201+
custom: fn
202+
},
203+
{
204+
type: "number",
205+
custom: fn
206+
}
207+
]
208+
};
209+
const clonedSchema = {...schema};
210+
const check = v.compile(schema);
211+
212+
expect(clonedSchema).toEqual(schema);
213+
214+
check("s");
215+
expect(fn).toBeCalledTimes(1);
216+
expect(fn).toBeCalledWith("s", [], schema.rules[0], "$$root", null, expect.any(Object));
217+
});
188218
});

0 commit comments

Comments
 (0)