assert: improve regular expression validation

This makes sure `assert.throws()` and `assert.rejects()` result in an easy to understand error message instead of rethrowing the actual error. This should significantly improve the debugging experience in case people use an regular expression to validate their errors. This also adds support for primitive errors that would have caused runtime errors using the mentioned functions. The input is now stringified before it's passed to the RegExp to circumvent that. As drive-by change this also adds some further comments and renames a variable for clarity. PR-URL: #27781 Reviewed-By: Rich Trott <[email protected]>

Author: BridgeAR

lib/assert.js

@@ -549,30 +549,38 @@ function compareExceptionKey(actual, expected, key, message, keys, fn){
 }
 }
 
-functionexpectedException(actual,expected,msg,fn){
+functionexpectedException(actual,expected,message,fn){
 if(typeofexpected!=='function'){
-if(isRegExp(expected))
-returnexpected.test(actual);
-// assert.doesNotThrow does not accept objects.
-if(arguments.length===2){
-thrownewERR_INVALID_ARG_TYPE(
-'expected',['Function','RegExp'],expected
-);
+// Handle regular expressions.
+if(isRegExp(expected)){
+conststr=String(actual);
+if(expected.test(str))
+return;
+
+thrownewAssertionError({
+ actual,
+ expected,
+message: message||'The input did not match the regular expression '+
+`${inspect(expected)}. Input:\n\n${inspect(str)}\n`,
+operator: fn.name,
+stackStartFn: fn
+});
 }
 
 // Handle primitives properly.
 if(typeofactual!=='object'||actual===null){
 consterr=newAssertionError({
  actual,
  expected,
-message: msg,
+ message,
 operator: 'deepStrictEqual',
 stackStartFn: fn
 });
 err.operator=fn.name;
 throwerr;
 }
 
+// Handle validation objects.
 constkeys=Object.keys(expected);
 // Special handle errors to make sure the name and the message are compared
 // as well.
@@ -589,18 +597,25 @@ function expectedException(actual, expected, msg, fn){
 expected[key].test(actual[key])){
 continue;
 }
-compareExceptionKey(actual,expected,key,msg,keys,fn);
+compareExceptionKey(actual,expected,key,message,keys,fn);
 }
-returntrue;
+return;
 }
+
 // Guard instanceof against arrow functions as they don't have a prototype.
+// Check for matching Error classes.
 if(expected.prototype!==undefined&&actualinstanceofexpected){
-returntrue;
+return;
 }
 if(Error.isPrototypeOf(expected)){
-returnfalse;
+throwactual;
+}
+
+// Check validation functions return value.
+constres=expected.call({},actual);
+if(res!==true){
+throwactual;
 }
-returnexpected.call({},actual)===true;
 }
 
 functiongetActual(fn){
@@ -695,9 +710,31 @@ function expectsError(stackStartFn, actual, error, message){
  stackStartFn
 });
 }
-if(error&&!expectedException(actual,error,message,stackStartFn)){
-throwactual;
+
+if(!error)
+return;
+
+expectedException(actual,error,message,stackStartFn);
+}
+
+functionhasMatchingError(actual,expected){
+if(typeofexpected!=='function'){
+if(isRegExp(expected)){
+conststr=String(actual);
+returnexpected.test(str);
+}
+thrownewERR_INVALID_ARG_TYPE(
+'expected',['Function','RegExp'],expected
+);
 }
+// Guard instanceof against arrow functions as they don't have a prototype.
+if(expected.prototype!==undefined&&actualinstanceofexpected){
+returntrue;
+}
+if(Error.isPrototypeOf(expected)){
+returnfalse;
+}
+returnexpected.call({},actual)===true;
 }
 
 functionexpectsNoError(stackStartFn,actual,error,message){
@@ -709,7 +746,7 @@ function expectsNoError(stackStartFn, actual, error, message){
 error=undefined;
 }
 
-if(!error||expectedException(actual,error)){
+if(!error||hasMatchingError(actual,error)){
 constdetails=message ? `: ${message}` : '.';
 constfnType=stackStartFn.name==='doesNotReject' ?
 'rejection' : 'exception';

test/parallel/test-assert.js

@@ -182,7 +182,27 @@ assert.throws(
 }
 
 // Use a RegExp to validate the error message.
-a.throws(()=>thrower(TypeError),/\[objectObject\]/);
+{
+a.throws(()=>thrower(TypeError),/\[objectObject\]/);
+
+constsymbol=Symbol('foo');
+a.throws(()=>{
+throwsymbol;
+},/foo/);
+
+a.throws(()=>{
+a.throws(()=>{
+throwsymbol;
+},/abc/);
+},{
+message: 'The input did not match the regular expression /abc/. '+
+"Input:\n\n'Symbol(foo)'\n",
+code: 'ERR_ASSERTION',
+operator: 'throws',
+actual: symbol,
+expected: /abc/
+});
+}
 
 // Use a fn to validate the error object.
 a.throws(()=>thrower(TypeError),(err)=>{