ejv 2.0.5 → 2.1.1

package/spec/NumberScheme.ts

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import { ejv } from '../src/ejv';
 
 import { EjvError, Scheme } from '../src/interfaces';
-import { ErrorMsg, ErrorType } from '../src/constants';
+import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
 import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
 
@@ -31,8 +31,8 @@ describe('NumberScheme', () => {
 							throw new Error('spec failed');
 						}
 
-						expect(error.type).to.be.eql(ErrorType.TYPE_MISMATCH);
-						expect(error.message).to.be.eql(createErrorMsg(ErrorMsg.TYPE_MISMATCH, {
+						expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH);
+						expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH, {
 							placeholders: ['number']
 						}));
 						expect(error.path).to.be.eql('a');
@@ -60,8 +60,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error.type).to.be.eql(ErrorType.TYPE_MISMATCH_ONE_OF);
-				expect(error.message).to.be.eql(createErrorMsg(ErrorMsg.TYPE_MISMATCH_ONE_OF, {
+				expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH_ONE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH_ONE_OF, {
 					placeholders: [JSON.stringify(typeArr)]
 				}));
 				expect(error.path).to.be.eql('a');
@@ -110,109 +110,217 @@ describe('NumberScheme', () => {
 		});
 	});
 
-	describe('enum', () => {
-		describe('check parameter', () => {
-			it('undefined is ok', () => {
-				expect(ejv({
-					a: 1
-				}, [{
-					key: 'a',
-					type: 'number',
-					enum: undefined
-				}])).to.be.null;
-			});
+	describe('enum & notEnum', () => {
+		describe('enum', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						enum: undefined
+					}])).to.be.null;
+				});
 
-			it('null', () => {
-				const data = {
-					a: 1
-				};
+				it('null', () => {
+					const data = {
+						a: 1
+					};
 
-				const errorScheme: Scheme = {
-					key: 'a',
-					type: 'number',
-					enum: null as unknown as number[]
-				};
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: null as unknown as number[]
+					};
 
-				checkSchemeError({
-					data,
-					errorScheme,
-					message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_ARRAY)
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not array', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: 1 as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not number', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: ['10']
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_NUMBERS)
+					});
 				});
 			});
 
-			it('not array', () => {
+			it('fail', () => {
+				const enumArr: number[] = [9, 11];
+
 				const data = {
 					a: 10
 				};
 
-				const errorScheme: Scheme = {
+				const error: EjvError | null = ejv(data, [{
 					key: 'a',
 					type: 'number',
-					enum: 1 as unknown as number[]
-				};
+					enum: enumArr
+				}]);
 
-				checkSchemeError({
-					data,
-					errorScheme,
-					message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_ARRAY)
-				});
+				expect(error).to.be.instanceof(EjvError);
+
+				if (!error) {
+					throw new Error('spec failed');
+				}
+
+				expect(error.type).to.be.eql(ERROR_TYPE.ONE_VALUE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.ONE_VALUE_OF, {
+					placeholders: [JSON.stringify(enumArr)]
+				}));
+				expect(error.path).to.be.eql('a');
+				expect(error.data).to.be.deep.equal(data);
+				expect(error.errorData).to.be.eql(10);
 			});
 
-			it('not number', () => {
-				const data = {
+			it('ok', () => {
+				expect(ejv({
 					a: 10
-				};
-
-				const errorScheme: Scheme = {
+				}, [{
 					key: 'a',
 					type: 'number',
-					enum: ['10']
-				};
+					enum: [9, 10, 11]
+				}])).to.be.null;
+			});
+		});
 
-				checkSchemeError({
-					data,
-					errorScheme,
-					message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_NUMBERS)
+		describe('notEnum', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						notEnum: undefined
+					}])).to.be.null;
+				});
+
+				it('null', () => {
+					const data = {
+						a: 1
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: null as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not array', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: 1 as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not number', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: ['10']
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_NUMBERS)
+					});
 				});
 			});
-		});
 
-		it('fail', () => {
-			const enumArr: number[] = [9, 11];
+			it('fail', () => {
+				const enumArr: number[] = [9, 10, 11];
 
-			const data = {
-				a: 10
-			};
+				const data = {
+					a: 9
+				};
 
-			const error: EjvError | null = ejv(data, [{
-				key: 'a',
-				type: 'number',
-				enum: enumArr
-			}]);
+				const error: EjvError | null = ejv(data, [{
+					key: 'a',
+					type: 'number',
+					notEnum: enumArr
+				}]);
 
-			expect(error).to.be.instanceof(EjvError);
+				expect(error).to.be.instanceof(EjvError);
 
-			if (!error) {
-				throw new Error('spec failed');
-			}
+				if (!error) {
+					throw new Error('spec failed');
+				}
 
-			expect(error.type).to.be.eql(ErrorType.ONE_VALUE_OF);
-			expect(error.message).to.be.eql(createErrorMsg(ErrorMsg.ONE_VALUE_OF, {
-				placeholders: [JSON.stringify(enumArr)]
-			}));
-			expect(error.path).to.be.eql('a');
-			expect(error.data).to.be.deep.equal(data);
-			expect(error.errorData).to.be.eql(10);
-		});
+				expect(error.type).to.be.eql(ERROR_TYPE.NOT_ONE_VALUE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.NOT_ONE_VALUE_OF, {
+					placeholders: [JSON.stringify(enumArr)]
+				}));
+				expect(error.path).to.be.eql('a');
+				expect(error.data).to.be.deep.equal(data);
+				expect(error.errorData).to.be.eql(9);
+			});
 
-		it('ok', () => {
-			expect(ejv({
-				a: 10
-			}, [{
-				key: 'a',
-				type: 'number',
-				enum: [9, 10, 11]
-			}])).to.be.null;
+			it('ok', () => {
+				expect(ejv({
+					a: 8
+				}, [{
+					key: 'a',
+					type: 'number',
+					notEnum: [9, 10, 11]
+				}])).to.be.null;
+			});
 		});
 	});
 
@@ -243,7 +351,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.MIN_SHOULD_BE_NUMBER)
+						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
 					});
 				});
 
@@ -261,7 +369,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.MIN_SHOULD_BE_NUMBER)
+						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
 					});
 				});
 
@@ -291,8 +399,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.BIGGER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.BIGGER_THAN_OR_EQUAL, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
 					placeholders: [10]
 				}));
 
@@ -331,7 +439,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN)
+						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN)
 					});
 				});
 			});
@@ -352,8 +460,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.BIGGER_THAN);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.BIGGER_THAN, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
 					placeholders: [10]
 				}));
 
@@ -372,8 +480,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error2.type).to.be.eql(ErrorType.BIGGER_THAN);
-				expect(error2.message).to.be.eql(createErrorMsg(ErrorMsg.BIGGER_THAN, {
+				expect(error2.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
+				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
 					placeholders: [10]
 				}));
 
@@ -403,8 +511,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.BIGGER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.BIGGER_THAN_OR_EQUAL, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
 					placeholders: [10]
 				}));
 
@@ -456,7 +564,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.MAX_SHOULD_BE_NUMBER)
+						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
 					});
 				});
 
@@ -474,7 +582,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.MAX_SHOULD_BE_NUMBER)
+						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
 					});
 				});
 
@@ -520,8 +628,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.SMALLER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.SMALLER_THAN_OR_EQUAL, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
 					placeholders: [10]
 				}));
 			});
@@ -544,7 +652,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN)
+						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN)
 					});
 				});
 			});
@@ -574,8 +682,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.SMALLER_THAN);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.SMALLER_THAN, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
 					placeholders: [10]
 				}));
 
@@ -594,8 +702,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error2.type).to.be.eql(ErrorType.SMALLER_THAN);
-				expect(error2.message).to.be.eql(createErrorMsg(ErrorMsg.SMALLER_THAN, {
+				expect(error2.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
+				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
 					placeholders: [10]
 				}));
 			});
@@ -634,8 +742,8 @@ describe('NumberScheme', () => {
 					throw new Error('spec failed');
 				}
 
-				expect(error1.type).to.be.eql(ErrorType.SMALLER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.SMALLER_THAN_OR_EQUAL, {
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
 					placeholders: [10]
 				}));
 			});
@@ -668,7 +776,7 @@ describe('NumberScheme', () => {
 				checkSchemeError({
 					data,
 					errorScheme,
-					message: createErrorMsg(ErrorMsg.INVALID_NUMBER_FORMAT, {
+					message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
 						placeholders: ['null']
 					})
 				});
@@ -689,7 +797,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.INVALID_NUMBER_FORMAT, {
+						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
 							placeholders: ['invalidNumberFormat']
 						})
 					});
@@ -705,7 +813,7 @@ describe('NumberScheme', () => {
 					checkSchemeError({
 						data,
 						errorScheme,
-						message: createErrorMsg(ErrorMsg.INVALID_NUMBER_FORMAT, {
+						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
 							placeholders: ['invalidNumberFormat']
 						})
 					});
@@ -730,8 +838,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error.type).to.be.eql(ErrorType.FORMAT);
-					expect(error.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT, {
+					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
 						placeholders: ['integer']
 					}));
 				});
@@ -765,8 +873,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error.type).to.be.eql(ErrorType.FORMAT_ONE_OF);
-					expect(error.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
 						placeholders: [JSON.stringify(formatArr)]
 					}));
 				});
@@ -868,8 +976,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error1.type).to.be.eql(ErrorType.FORMAT);
-					expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT, {
+					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
 						placeholders: ['index']
 					}));
 
@@ -887,8 +995,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error2.type).to.be.eql(ErrorType.FORMAT);
-					expect(error2.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT, {
+					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
 						placeholders: ['index']
 					}));
 
@@ -906,8 +1014,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error3.type).to.be.eql(ErrorType.FORMAT);
-					expect(error3.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT, {
+					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
 						placeholders: ['index']
 					}));
 				});
@@ -949,8 +1057,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error1.type).to.be.eql(ErrorType.FORMAT_ONE_OF);
-					expect(error1.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
 						placeholders: [JSON.stringify(formatArr)]
 					}));
 
@@ -968,8 +1076,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error2.type).to.be.eql(ErrorType.FORMAT_ONE_OF);
-					expect(error2.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
 						placeholders: [JSON.stringify(formatArr)]
 					}));
 
@@ -987,8 +1095,8 @@ describe('NumberScheme', () => {
 						throw new Error('spec failed');
 					}
 
-					expect(error3.type).to.be.eql(ErrorType.FORMAT_ONE_OF);
-					expect(error3.message).to.be.eql(createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
 						placeholders: [JSON.stringify(formatArr)]
 					}));
 				});