lib: improve value validation utils

Add common validators: `validateArray`, `validateBoolean`, `validateObject` and appropriate tests. PR-URL: #31480 Reviewed-By: James M Snell <[email protected]> Reviewed-By: Gus Caplan <[email protected]>

Author: lundibundi

lib/internal/validators.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const{
+ ArrayIsArray,
  NumberIsInteger,
  NumberMAX_SAFE_INTEGER,
  NumberMIN_SAFE_INTEGER,
@@ -123,6 +124,30 @@ function validateNumber(value, name){
 thrownewERR_INVALID_ARG_TYPE(name,'number',value);
 }
 
+functionvalidateBoolean(value,name){
+if(typeofvalue!=='boolean')
+thrownewERR_INVALID_ARG_TYPE(name,'boolean',value);
+}
+
+constvalidateObject=hideStackFrames(
+(value,name,{ nullable =false}={})=>{
+if((!nullable&&value===null)||
+ArrayIsArray(value)||
+typeofvalue!=='object'){
+thrownewERR_INVALID_ARG_TYPE(name,'Object',value);
+}
+});
+
+constvalidateArray=hideStackFrames((value,name,{ minLength =0}={})=>{
+if(!ArrayIsArray(value)){
+thrownewERR_INVALID_ARG_TYPE(name,'Array',value);
+}
+if(value.length<minLength){
+constreason=`must be longer than ${minLength}`;
+thrownewERR_INVALID_ARG_VALUE(name,value,reason);
+}
+});
+
 functionvalidateSignalName(signal,name='signal'){
 if(typeofsignal!=='string')
 thrownewERR_INVALID_ARG_TYPE(name,'string',signal);
@@ -159,8 +184,11 @@ module.exports ={
  isInt32,
  isUint32,
  parseMode,
+ validateArray,
+ validateBoolean,
  validateBuffer,
  validateEncoding,
+ validateObject,
  validateInteger,
  validateInt32,
  validateUint32,

test/parallel/test-validators.js

@@ -1,26 +1,87 @@
 // Flags: --expose-internals
 'use strict';
+
 require('../common');
 constassert=require('assert');
 const{
- validateInteger
+ validateArray,
+ validateBoolean,
+ validateInteger,
+ validateObject,
 }=require('internal/validators');
 const{MAX_SAFE_INTEGER,MIN_SAFE_INTEGER}=Number;
 constoutOfRangeError={
 code: 'ERR_OUT_OF_RANGE',
-name: 'RangeError'
+name: 'RangeError',
+};
+constinvalidArgTypeError={
+code: 'ERR_INVALID_ARG_TYPE',
+name: 'TypeError',
 };
+constinvalidArgValueError={
+code: 'ERR_INVALID_ARG_VALUE',
+name: 'TypeError',
+};
+
+{
+// validateInteger tests.
+
+// validateInteger() defaults to validating safe integers.
+validateInteger(MAX_SAFE_INTEGER,'foo');
+validateInteger(MIN_SAFE_INTEGER,'foo');
+assert.throws(()=>{
+validateInteger(MAX_SAFE_INTEGER+1,'foo');
+},outOfRangeError);
+assert.throws(()=>{
+validateInteger(MIN_SAFE_INTEGER-1,'foo');
+},outOfRangeError);
+
+// validateInteger() works with unsafe integers.
+validateInteger(MAX_SAFE_INTEGER+1,'foo',0,MAX_SAFE_INTEGER+1);
+validateInteger(MIN_SAFE_INTEGER-1,'foo',MIN_SAFE_INTEGER-1);
+}
+
+{
+// validateArray tests.
+validateArray([],'foo');
+validateArray([1,2,3],'foo');
+
+[undefined,null,true,false,0,0.0,42,'','string',{}]
+.forEach((val)=>{
+assert.throws(()=>{
+validateArray(val,'foo');
+},invalidArgTypeError);
+});
+
+validateArray([1],'foo',{minLength: 1});
+assert.throws(()=>{
+validateArray([],'foo',{minLength: 1});
+},invalidArgValueError);
+}
+
+{
+// validateBoolean tests.
+validateBoolean(true,'foo');
+validateBoolean(false,'foo');
+
+[undefined,null,0,0.0,42,'','string',{},[]].forEach((val)=>{
+assert.throws(()=>{
+validateBoolean(val,'foo');
+},invalidArgTypeError);
+});
+}
+
+{
+// validateObject tests.
+validateObject({},'foo');
+validateObject({a: 42,b: 'foo'},'foo');
+
+[undefined,null,true,false,0,0.0,42,'','string',[]]
+.forEach((val)=>{
+assert.throws(()=>{
+validateObject(val,'foo');
+},invalidArgTypeError);
+});
 
-// validateInteger() defaults to validating safe integers.
-validateInteger(MAX_SAFE_INTEGER,'foo');
-validateInteger(MIN_SAFE_INTEGER,'foo');
-assert.throws(()=>{
-validateInteger(MAX_SAFE_INTEGER+1,'foo');
-},outOfRangeError);
-assert.throws(()=>{
-validateInteger(MIN_SAFE_INTEGER-1,'foo');
-},outOfRangeError);
-
-// validateInteger() works with unsafe integers.
-validateInteger(MAX_SAFE_INTEGER+1,'foo',0,MAX_SAFE_INTEGER+1);
-validateInteger(MIN_SAFE_INTEGER-1,'foo',MIN_SAFE_INTEGER-1);
+validateObject(null,'foo',{nullable: true});
+}