ejv 2.1.4 → 2.1.5

package/spec/BufferScheme.ts

@@ -0,0 +1,406 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+
+import { ejv } from '../src/ejv';
+
+import { EjvError } from '../src/interfaces';
+import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
+import { createErrorMsg } from '../src/util';
+import { checkSchemeError, TypeTester, TYPE_TESTER_ARR } from './common-test-util';
+
+describe('BufferScheme', () => {
+	describe('type', () => {
+		describe('mismatch', () => {
+			TYPE_TESTER_ARR
+				.filter((obj: TypeTester): boolean => obj.type !== 'buffer')
+				.forEach((obj: TypeTester): void => {
+					it(obj.type, () => {
+						const testObj = {
+							a: obj.value
+						};
+
+						const error: EjvError | null = ejv(testObj, [{
+							key: 'a',
+							type: 'buffer'
+						}]);
+
+						expect(error).to.be.instanceof(EjvError);
+
+						if (!error) {
+							throw new Error('spec failed');
+						}
+
+						expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH);
+						expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH, {
+							placeholders: ['buffer']
+						}));
+						expect(error.path).to.be.eql('a');
+						expect(error.data).to.be.eql(testObj);
+						expect(error.errorData).to.be.eql(obj.value);
+					});
+				});
+
+			it('multiple types', () => {
+				const value = 'ejv';
+				const typeArr: string[] = ['boolean', 'buffer'];
+
+				const testObj = {
+					a: value
+				};
+
+				const error: EjvError | null = ejv(testObj, [{
+					key: 'a',
+					type: typeArr
+				}]);
+
+				expect(error).to.be.instanceof(EjvError);
+
+				if (!error) {
+					throw new Error('spec failed');
+				}
+
+				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');
+				expect(error.data).to.be.eql(testObj);
+				expect(error.errorData).to.be.eql(value);
+			});
+		});
+
+		describe('match', () => {
+			it('optional', () => {
+				expect(ejv({
+					a: undefined
+				}, [{
+					key: 'a',
+					type: 'buffer',
+					optional: true
+				}])).to.be.null;
+			});
+
+			it('single type', () => {
+				expect(ejv({
+					a: new Uint8Array(4)
+				}, [{
+					key: 'a',
+					type: 'buffer'
+				}])).to.be.null;
+			});
+
+			it('multiple types', () => {
+				expect(ejv({
+					a: new Uint8Array(4)
+				}, [{
+					key: 'a',
+					type: ['buffer', 'number']
+				}])).to.be.null;
+			});
+
+			it('multiple types', () => {
+				expect(ejv({
+					a: new Uint8Array(4)
+				}, [{
+					key: 'a',
+					type: ['number', 'buffer']
+				}])).to.be.null;
+			});
+		});
+	});
+
+	describe('byteLength', () => {
+		describe('check parameter', () => {
+			const data = {
+				a: new Uint8Array(3)
+			};
+
+			it('undefined is ok', () => {
+				expect(ejv(data, [{
+					key: 'a',
+					type: 'buffer',
+					byteLength: undefined
+				}])).to.be.null;
+			});
+
+			it('null', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: null
+						byteLength: null
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('float number', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						byteLength: 1.5
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('string', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: type mismatch
+						byteLength: '1'
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+		});
+
+		it('fail', () => {
+			const value = new Uint8Array(3);
+			const testData = {
+				a: value
+			};
+
+			const error: EjvError | null = ejv(testData, [{
+				key: 'a',
+				type: 'buffer',
+				byteLength: 2
+			}]);
+
+			expect(error).to.be.instanceof(EjvError);
+
+			if (!error) {
+				throw new Error('spec failed');
+			}
+
+			expect(error.type).to.be.eql(ERROR_TYPE.BYTE_LENGTH);
+			expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH, {
+				placeholders: [2]
+			}));
+			expect(error.path).to.be.eql('a');
+			expect(error.data).to.be.deep.equal(testData);
+		});
+
+		it('ok', () => {
+			expect(ejv({
+				a: new Uint8Array(3)
+			}, [{
+				key: 'a',
+				type: 'buffer',
+				byteLength: 3
+			}])).to.be.null;
+		});
+	});
+
+	describe('minByteLength', () => {
+		describe('check parameter', () => {
+			const data = {
+				a: new Uint8Array(4)
+			};
+
+			it('undefined is ok', () => {
+				expect(ejv(data, [{
+					key: 'a',
+					type: 'buffer',
+					minByteLength: undefined
+				}])).to.be.null;
+			});
+
+			it('null', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: null
+						minByteLength: null
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('float number', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						minByteLength: 1.5
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('string', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: type mismatch
+						minByteLength: '1'
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+		});
+
+		it('fail', () => {
+			const value = new Uint8Array(3);
+			const testData = {
+				a: value
+			};
+
+			const error: EjvError | null = ejv(testData, [{
+				key: 'a',
+				type: 'buffer',
+				minByteLength: 4
+			}]);
+
+			expect(error).to.be.instanceof(EjvError);
+
+			if (!error) {
+				throw new Error('spec failed');
+			}
+
+			expect(error.type).to.be.eql(ERROR_TYPE.MIN_BYTE_LENGTH);
+			expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH, {
+				placeholders: [4]
+			}));
+			expect(error.path).to.be.eql('a');
+			expect(error.data).to.be.deep.equal(testData);
+		});
+
+		it('ok', () => {
+			expect(ejv({
+				a: new Uint8Array(3)
+			}, [{
+				key: 'a',
+				type: 'buffer',
+				minByteLength: 2
+			}])).to.be.null;
+
+			expect(ejv({
+				a: new Uint8Array(3)
+			}, [{
+				key: 'a',
+				type: 'buffer',
+				minByteLength: 3
+			}])).to.be.null;
+		});
+	});
+
+	describe('maxByteLength', () => {
+		describe('check parameter', () => {
+			const data = {
+				a: new Uint8Array(3)
+			};
+
+			it('undefined is ok', () => {
+				expect(ejv(data, [{
+					key: 'a',
+					type: 'buffer',
+					maxByteLength: undefined
+				}])).to.be.null;
+			});
+
+			it('null', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: null
+						maxByteLength: null
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('float number', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						maxByteLength: 1.5
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+
+			it('string', () => {
+				checkSchemeError({
+					data: data,
+					errorScheme: {
+						key: 'a',
+						type: 'buffer',
+						// @ts-expect-error: type mismatch
+						maxByteLength: '1'
+					},
+
+					message: createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH_SHOULD_BE_INTEGER)
+				});
+			});
+		});
+
+		it('fail', () => {
+			const value = new Uint8Array(3);
+			const testData = {
+				a: value
+			};
+
+			const error: EjvError | null = ejv(testData, [{
+				key: 'a',
+				type: 'buffer',
+				maxByteLength: 2
+			}]);
+
+			expect(error).to.be.instanceof(EjvError);
+
+			if (!error) {
+				throw new Error('spec failed');
+			}
+
+			expect(error.type).to.be.eql(ERROR_TYPE.MAX_BYTE_LENGTH);
+			expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH, {
+				placeholders: [2]
+			}));
+			expect(error.path).to.be.eql('a');
+			expect(error.data).to.be.deep.equal(testData);
+		});
+
+		it('ok', () => {
+			expect(ejv({
+				a: new Uint8Array(3)
+			}, [{
+				key: 'a',
+				type: 'buffer',
+				maxByteLength: 3
+			}])).to.be.null;
+
+			expect(ejv({
+				a: new Uint8Array(3)
+			}, [{
+				key: 'a',
+				type: 'buffer',
+				maxByteLength: 4
+			}])).to.be.null;
+		});
+	});
+});

package/spec/DateScheme.ts

@@ -6,7 +6,7 @@ import { ejv } from '../src/ejv';
 import { DateScheme, EjvError, Scheme } from '../src/interfaces';
 import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
-import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
+import { checkSchemeError, TypeTester, TYPE_TESTER_ARR } from './common-test-util';
 
 
 describe('DateScheme', () => {
@@ -86,7 +86,7 @@ describe('DateScheme', () => {
 
 	describe('type', () => {
 		describe('mismatch', () => {
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => obj.type !== 'date')
 				.forEach((obj: TypeTester): void => {
 					const data = {
@@ -203,7 +203,8 @@ describe('DateScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'date',
 						type: 'date',
-						min: null as unknown as string
+						// @ts-expect-error: null
+						min: null
 					};
 
 					checkSchemeError({
@@ -217,7 +218,7 @@ describe('DateScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'date',
 						type: 'date',
-						min: 123 as unknown as string
+						min: 123
 					};
 
 					checkSchemeError({
@@ -276,7 +277,8 @@ describe('DateScheme', () => {
 						key: 'date',
 						type: 'date',
 						min: now,
-						exclusiveMin: now.toISOString() as unknown as boolean
+						// @ts-expect-error: type mismatch
+						exclusiveMin: now.toISOString()
 					};
 
 					checkSchemeError({
@@ -345,7 +347,8 @@ describe('DateScheme', () => {
 						const errorScheme: Scheme = {
 							key: 'date',
 							type: 'date',
-							max: null as unknown as string
+							// @ts-expect-error: null
+							max: null
 						};
 
 						checkSchemeError({
@@ -359,7 +362,7 @@ describe('DateScheme', () => {
 						const errorScheme: Scheme = {
 							key: 'date',
 							type: 'date',
-							max: 123 as unknown as string
+							max: 123
 						};
 
 						checkSchemeError({
@@ -418,7 +421,8 @@ describe('DateScheme', () => {
 							key: 'date',
 							type: 'date',
 							max: now,
-							exclusiveMax: now.toISOString() as unknown as boolean
+							// @ts-expect-error: type mismatch
+							exclusiveMax: now.toISOString()
 						};
 
 						checkSchemeError({

package/spec/NumberScheme.ts

@@ -3,16 +3,16 @@ import { expect } from 'chai';
 
 import { ejv } from '../src/ejv';
 
-import { EjvError, Scheme } from '../src/interfaces';
+import { EjvError, NumberScheme, Scheme } from '../src/interfaces';
 import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
-import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
+import { checkSchemeError, TYPE_TESTER_ARR, TypeTester } from './common-test-util';
 
 
 describe('NumberScheme', () => {
 	describe('type', () => {
 		describe('mismatch', () => {
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => obj.type !== 'number')
 				.forEach((obj: TypeTester): void => {
 					const data = {
@@ -131,7 +131,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						enum: null as unknown as number[]
+						// @ts-expect-error: null
+						enum: null
 					};
 
 					checkSchemeError({
@@ -149,7 +150,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						enum: 1 as unknown as number[]
+						// @ts-expect-error: type mismatch
+						enum: 1
 					};
 
 					checkSchemeError({
@@ -237,7 +239,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						notEnum: null as unknown as number[]
+						// @ts-expect-error: null
+						notEnum: null
 					};
 
 					checkSchemeError({
@@ -255,7 +258,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						notEnum: 1 as unknown as number[]
+						// @ts-expect-error: type mismatch
+						notEnum: 1
 					};
 
 					checkSchemeError({
@@ -345,7 +349,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						min: null as unknown as number
+						// @ts-expect-error: null
+						min: null
 					};
 
 					checkSchemeError({
@@ -429,11 +434,12 @@ describe('NumberScheme', () => {
 						a: 3
 					};
 
-					const errorScheme: Scheme = {
+					const errorScheme: NumberScheme = {
 						key: 'a',
 						type: 'number',
 						min: 3,
-						exclusiveMin: '3' as unknown as boolean
+						// @ts-expect-error: type mismatch
+						exclusiveMin: '3'
 					};
 
 					checkSchemeError({
@@ -558,7 +564,8 @@ describe('NumberScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'number',
-						max: null as unknown as number
+						// @ts-expect-error: null
+						max: null
 					};
 
 					checkSchemeError({
@@ -642,11 +649,12 @@ describe('NumberScheme', () => {
 						a: 3
 					};
 
-					const errorScheme: Scheme = {
+					const errorScheme: NumberScheme = {
 						key: 'a',
 						type: 'number',
 						max: 3,
-						exclusiveMax: '3' as unknown as boolean
+						// @ts-expect-error: type mismatch
+						exclusiveMax: '3'
 					};
 
 					checkSchemeError({
@@ -770,7 +778,8 @@ describe('NumberScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'number',
-					format: null as unknown as string
+					// @ts-expect-error: null
+					format: null
 				};
 
 				checkSchemeError({

package/spec/ObjectScheme.ts

@@ -6,15 +6,15 @@ import { ejv } from '../src/ejv';
 import { EjvError, Scheme } from '../src/interfaces';
 import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
-import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
+import { checkSchemeError, TypeTester, TYPE_TESTER_ARR } from './common-test-util';
 
 
 describe('ObjectScheme', () => {
 	describe('type', () => {
 		describe('mismatch', () => {
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => {
-					return !['null', 'date', 'regexp', 'array', 'object'].includes(obj.type);
+					return !['null', 'date', 'regexp', 'array', 'object', 'buffer'].includes(obj.type);
 				})
 				.forEach((obj: TypeTester): void => {
 					const data = {
@@ -83,9 +83,9 @@ describe('ObjectScheme', () => {
 				}])).to.be.null;
 			});
 
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => {
-					return ['null', 'date', 'regexp', 'array', 'object'].includes(obj.type);
+					return ['null', 'date', 'regexp', 'array', 'object', 'buffer'].includes(obj.type);
 				})
 				.forEach((obj: TypeTester): void => {
 					it(obj.type, () => {
@@ -153,7 +153,8 @@ describe('ObjectScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'object',
-					properties: null as unknown as Scheme[]
+					// @ts-expect-error: null
+					properties: null
 				};
 
 				checkSchemeError({
@@ -167,7 +168,8 @@ describe('ObjectScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'object',
-					properties: 'b' as unknown as Scheme[]
+					// @ts-expect-error: type mismatch
+					properties: 'b'
 				};
 
 				checkSchemeError({
@@ -195,7 +197,7 @@ describe('ObjectScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'object',
-					properties: ['b'] as unknown as Scheme[]
+					properties: ['b']
 				};
 
 				checkSchemeError({
@@ -396,7 +398,8 @@ describe('ObjectScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'object',
-					allowNoProperty: null as unknown as boolean
+					// @ts-expect-error: null
+					allowNoProperty: null
 				};
 
 				checkSchemeError({

package/spec/RegExpScheme.ts

@@ -6,13 +6,13 @@ import { ejv } from '../src/ejv';
 import { EjvError } from '../src/interfaces';
 import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
-import { TypeTester, typeTesterArr } from './common-test-util';
+import { TypeTester, TYPE_TESTER_ARR } from './common-test-util';
 
 
 describe('RegExpScheme', () => {
 	describe('type', () => {
 		describe('mismatch', () => {
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => obj.type !== 'regexp')
 				.forEach((obj: TypeTester): void => {
 					it(obj.type, () => {