add custom validator unit test

Author: icebob

README.md

@@ -802,11 +802,15 @@ let v = new Validator({
 });
 
 // Register a custom 'even' validator
-v.add("even", value => {
-    if (value % 2 != 0)
-        return v.makeError("evenNumber", null, value);
-
-    return true;
+v.add("even", function({ schema, messages }, path, context) {
+    return {
+        source: `
+            if (value % 2 != 0)
+                ${this.makeError({ type: "evenNumber",  actual: "value", messages })}
+
+            return value;
+        `
+    };
 });
 
 const schema = {
@@ -832,37 +836,37 @@ console.log(v.validate({ name: "John", age: 19 }, schema));
 Or you can use the `custom` type with an inline checker function:
 ```js
 let v = new Validator({
-	messages: {
-		// Register our new error message text
-		weightMin: "The weight must be greater than {expected}! Actual: {actual}"
-	}
+    messages: {
+        // Register our new error message text
+        weightMin: "The weight must be greater than {expected}! Actual: {actual}"
+    }
 });
 
 const schema = {
-	name: { type: "string", min: 3, max: 255 },
-	weight: {
-		type: "custom",
-		minWeight: 10,
-		check(value, schema) {
-			return (value < schema.minWeight)
-				? this.makeError("weightMin", schema.minWeight, value)
-				: true;
-		}
-	}
+    name: { type: "string", min: 3, max: 255 },
+    weight: {
+        type: "custom",
+        minWeight: 10,
+        check(value, schema) {
+            return (value < schema.minWeight)
+                ? this.makeError("weightMin", schema.minWeight, value)
+                : true;
+        }
+    }
 };
 
 console.log(v.validate({ name: "John", weight: 50 }, schema));
 // Returns: true
 
 console.log(v.validate({ name: "John", weight: 8 }, schema));
 /* Returns an array with errors:
-	[{
-		type: 'weightMin',
-		expected: 10,
-		actual: 8,
-		field: 'weight',
-		message: 'The weight must be greater than 10! Actual: 8'
-	}]
+    [{
+        type: 'weightMin',
+        expected: 10,
+        actual: 8,
+        field: 'weight',
+        message: 'The weight must be greater than 10! Actual: 8'
+    }]
 */
 ```
 

examples/next.js

@@ -3,10 +3,22 @@ let Validator = require("../index");
 let v = new Validator({
 	debug: true,
 	messages: {
-		stringMin: "A(z) '{field}' mező túl rövid. Minimum: {expected}, Jelenleg: {actual}"
+		stringMin: "A(z) '{field}' mező túl rövid. Minimum: {expected}, Jelenleg: {actual}",
+		evenNumber: "The '{field}' field must be an even number! Actual: {actual}"
 	}
 });
 
+v.add("even", function({ schema, messages }, path, context) {
+	return {
+		source: `
+			if (value % 2 != 0)
+				${this.makeError({ type: "evenNumber",  actual: "value", messages })}
+
+			return value;
+		`
+	};
+});
+
 const schema = {
 	id: "number|positive|integer|convert",
 	name: "string|min: 3|max: 255|padStart: 5",
@@ -47,6 +59,7 @@ const schema = {
 			weightMin: "The '${field}' must be greater than {expected}! Actual: {actual}"
 		}
 	}*/
+	num: { type: "even" }
 };
 
 const check = v.compile(schema);
@@ -78,6 +91,7 @@ const obj = {
 	createdAt: Date.now(),
 
 	weight: 10,
+	num: 2
 };
 console.log(check(obj), obj);
 

test/validator.spec.js

@@ -78,41 +78,57 @@ describe("Test validate", () => {
 });
 
 describe("Test add", () => {
+	let check;
 
-	const v = new Validator();
-	const validFn = jest.fn(() => true);
+	const v = new Validator({
+		messages: {
+			// Register our new error message text
+			evenNumber: "The '{field}' field must be an even number! Actual: {actual}"
+		}
+	});
+
+	const validFn = jest.fn(function({ schema, messages }, path, context) {
+		return {
+			source: `
+				if (value % 2 != 0)
+					${this.makeError({ type: "evenNumber",  actual: "value", messages })}
+
+				return value;
+			`
+		};
+	});
 
 	it("should not contain the new validator", () => {
-		expect(v.rules.myValidator).toBeUndefined();
+		expect(v.rules.even).toBeUndefined();
 	});
 
 	it("should contain the new validator", () => {
-		v.add("myValidator", validFn);
-		expect(v.rules.myValidator).toBeDefined();
+		v.add("even", validFn);
+		expect(v.rules.even).toBeDefined();
 	});
 
 	it("should call the new validator", () => {
 		const schema = {
-			a: { type: "myValidator" }
+			a: { type: "even" }
 		};
 
-		const obj = { a: 5 };
-
-		v.validate(obj, schema);
+		check = v.compile(schema);
 
 		const context = {
 			customs: {},
 			rules: expect.any(Array),
 			fn: expect.any(Array),
-			index: 2,
-			data: { a: 5 }
+			index: 2
 		};
 
 		expect(validFn).toHaveBeenCalledTimes(1);
 		expect(validFn).toHaveBeenCalledWith(expect.any(Object), "a", context);
 	});
 
-	// TODO: add a real example
+	it("should check the new rule", () => {
+		expect(check({ a: 5 })).toEqual([{"type": "evenNumber", "field": "a", "actual": 5, "message": "The 'a' field must be an even number! Actual: 5"}]);
+		expect(check({ a: 6 })).toEqual(true);
+	});
 
 });