Fix #1007: add more information on StreamReadConstraints violation exception message (#1008)

cowtowncoder · web-flow · commit 336a402f33fb · 2023-04-30T17:06:10.000-07:00
diff --git a/release-notes/VERSION-2.x b/release-notes/VERSION-2.x
@@ -16,7 +16,7 @@ JSON library.
 
 2.16.0 (not yet released)
 
-No changes since 2.15
+#1007: Improve error message for `StreamReadConstraints` violations
 
 2.15.1 (not yet released)
 
diff --git a/src/main/java/com/fasterxml/jackson/core/StreamReadConstraints.java b/src/main/java/com/fasterxml/jackson/core/StreamReadConstraints.java
@@ -224,8 +224,10 @@ public int getMaxStringLength() {
     public void validateNestingDepth(int depth) throws StreamConstraintsException
     {
         if (depth > _maxNestingDepth) {
-            throw new StreamConstraintsException(String.format("Depth (%d) exceeds the maximum allowed nesting depth (%d)",
-                    depth, _maxNestingDepth));
+            throw _constructException(
+                    "Document nesting depth (%d) exceeds the maximum allowed (%d, from %s)",
+                    depth, _maxNestingDepth,
+                    _constrainRef("getMaxNestingDepth"));
         }
     }
 
@@ -249,8 +251,10 @@ public void validateNestingDepth(int depth) throws StreamConstraintsException
     public void validateFPLength(int length) throws StreamConstraintsException
     {
         if (length > _maxNumLen) {
-            throw new StreamConstraintsException(String.format("Number length (%d) exceeds the maximum length (%d)",
-                    length, _maxNumLen));
+            throw _constructException(
+                    "Number value length (%d) exceeds the maximum allowed (%d, from %s)",
+                    length, _maxNumLen,
+                    _constrainRef("getMaxNumberLength"));
         }
     }
 
@@ -268,8 +272,10 @@ public void validateFPLength(int length) throws StreamConstraintsException
     public void validateIntegerLength(int length) throws StreamConstraintsException
     {
         if (length > _maxNumLen) {
-            throw new StreamConstraintsException(String.format("Number length (%d) exceeds the maximum length (%d)",
-                    length, _maxNumLen));
+            throw _constructException(
+                    "Number value length (%d) exceeds the maximum allowed (%d, from %s)",
+                    length, _maxNumLen,
+                    _constrainRef("getMaxNumberLength"));
         }
     }
 
@@ -287,8 +293,10 @@ public void validateIntegerLength(int length) throws StreamConstraintsException
     public void validateStringLength(int length) throws StreamConstraintsException
     {
         if (length > _maxStringLen) {
-            throw new StreamConstraintsException(String.format("String length (%d) exceeds the maximum length (%d)",
-                    length, _maxStringLen));
+            throw _constructException(
+                    "String value length (%d) exceeds the maximum allowed (%d, from %s)",
+                    length, _maxStringLen,
+                    _constrainRef("getMaxStringLength"));
         }
     }
 
@@ -315,9 +323,25 @@ public void validateBigIntegerScale(int scale) throws StreamConstraintsException
         final int limit = MAX_BIGINT_SCALE_MAGNITUDE;
 
         if (absScale > limit) {
-            throw new StreamConstraintsException(String.format(
-                    "BigDecimal scale (%d) magnitude exceeds maximum allowed (%d)",
-                    scale, limit));
+            throw _constructException(
+                    "BigDecimal scale (%d) magnitude exceeds the maximum allowed (%d)",
+                    scale, limit);
         }
     }
+
+    /*
+    /**********************************************************************
+    /* Error reporting
+    /**********************************************************************
+     */
+
+    // @since 2.16
+    protected StreamConstraintsException _constructException(String msgTemplate, Object... args) throws StreamConstraintsException {
+        throw new StreamConstraintsException(String.format(msgTemplate, args));
+    }
+
+    // @since 2.16
+    protected String _constrainRef(String method) {
+        return "`StreamReadConstraints."+method+"()`";
+    }
 }
diff --git a/src/test/java/com/fasterxml/jackson/core/constraints/DeeplyNestedContentReadTest.java b/src/test/java/com/fasterxml/jackson/core/constraints/DeeplyNestedContentReadTest.java
@@ -32,8 +32,8 @@ private void _testDeepNesting(JsonParser p) throws Exception
             while (p.nextToken() != null) { }
             fail("expected StreamConstraintsException");
         } catch (StreamConstraintsException e) {
-            assertEquals("Depth ("+(MAX_NESTING+1)
-                    +") exceeds the maximum allowed nesting depth ("+MAX_NESTING+")", e.getMessage());
+            assertEquals("Document nesting depth (1001) exceeds the maximum allowed (1000, from `StreamReadConstraints.getMaxNestingDepth()`)",
+                    e.getMessage());
         }
     }
 
@@ -58,8 +58,8 @@ private void _testLegacyConstraintSettingTest(JsonParser p, int maxNesting) thro
             while (p.nextToken() != null) { }
             fail("expected StreamConstraintsException");
         } catch (StreamConstraintsException e) {
-            assertEquals("Depth ("+(maxNesting+1)
-                    +") exceeds the maximum allowed nesting depth ("+maxNesting+")", e.getMessage());
+            assertEquals("Document nesting depth (41) exceeds the maximum allowed (40, from `StreamReadConstraints.getMaxNestingDepth()`)",
+                    e.getMessage());
         }
     }
     
diff --git a/src/test/java/com/fasterxml/jackson/core/constraints/LargeNumberReadTest.java b/src/test/java/com/fasterxml/jackson/core/constraints/LargeNumberReadTest.java
@@ -34,13 +34,13 @@ public void testBigBigDecimalsBytes() throws Exception
             _testBigBigDecimals(MODE_INPUT_STREAM, false);
             fail("Should not pass");
         } catch (StreamConstraintsException e) {
-            verifyException(e, "Invalid numeric value ", "exceeds the maximum length");
+            verifyException(e, "Invalid numeric value ", "exceeds the maximum");
         }
         try {
             _testBigBigDecimals(MODE_INPUT_STREAM_THROTTLED, false);
             fail("Should not pass");
         } catch (StreamConstraintsException jpe) {
-            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");
+            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum");
         }
     }
 
@@ -50,7 +50,7 @@ public void testBigBigDecimalsCharsFailByDefault() throws Exception
             _testBigBigDecimals(MODE_READER, false);
             fail("Should not pass");
         } catch (StreamConstraintsException jpe) {
-            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");
+            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum");
         }
     }
 
@@ -65,7 +65,7 @@ public void testBigBigDecimalsDataInputFailByDefault() throws Exception
             _testBigBigDecimals(MODE_DATA_INPUT, false);
             fail("Should not pass");
         } catch (StreamConstraintsException jpe) {
-            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");
+            verifyException(jpe, "Invalid numeric value ", "exceeds the maximum allowed");
         }
     }
 
diff --git a/src/test/java/com/fasterxml/jackson/core/dos/PerfBigDecimalToInteger968Test.java b/src/test/java/com/fasterxml/jackson/core/dos/PerfBigDecimalToInteger968Test.java
@@ -22,7 +22,7 @@ public void bigIntegerViaBigDecimal() throws Exception {
                 p.getBigIntegerValue();
                 Assert.fail("Should not pass");
             } catch (StreamConstraintsException e) {
-                Assert.assertEquals("BigDecimal scale (-25000000) magnitude exceeds maximum allowed (100000)", e.getMessage());
+                Assert.assertEquals("BigDecimal scale (-25000000) magnitude exceeds the maximum allowed (100000)", e.getMessage());
             }
         }
     }
@@ -37,7 +37,7 @@ public void tinyIntegerViaBigDecimal() throws Exception {
                 p.getBigIntegerValue();
                 Assert.fail("Should not pass");
             } catch (StreamConstraintsException e) {
-                Assert.assertEquals("BigDecimal scale (25000000) magnitude exceeds maximum allowed (100000)", e.getMessage());
+                Assert.assertEquals("BigDecimal scale (25000000) magnitude exceeds the maximum allowed (100000)", e.getMessage());
             }
         }
     }
diff --git a/src/test/java/com/fasterxml/jackson/core/json/async/AsyncStringArrayTest.java b/src/test/java/com/fasterxml/jackson/core/json/async/AsyncStringArrayTest.java
@@ -153,9 +153,9 @@ public void testLongAsciiStringsSmallLimit() throws IOException
             fail("expected IOException");
         } catch (IOException ie) {
             assertTrue("unexpected exception message: " + ie.getMessage(),
-                    ie.getMessage().startsWith("String length"));
+                    ie.getMessage().startsWith("String value length"));
             assertTrue("unexpected exception message: " + ie.getMessage(),
-                    ie.getMessage().endsWith("exceeds the maximum length (100)"));
+                    ie.getMessage().contains("exceeds the maximum allowed (100"));
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -224,8 +224,10 @@ public int getMaxStringLength() {`
`224`	`224`	`public void validateNestingDepth(int depth) throws StreamConstraintsException`
`225`	`225`	`{`
`226`	`226`	`if (depth > _maxNestingDepth) {`
`227`		`- throw new StreamConstraintsException(String.format("Depth (%d) exceeds the maximum allowed nesting depth (%d)",`
`228`		`- depth, _maxNestingDepth));`
	`227`	`+ throw _constructException(`
	`228`	`+ "Document nesting depth (%d) exceeds the maximum allowed (%d, from %s)",`
	`229`	`+ depth, _maxNestingDepth,`
	`230`	`+ _constrainRef("getMaxNestingDepth"));`
`229`	`231`	`}`
`230`	`232`	`}`
`231`	`233`
`@@ -249,8 +251,10 @@ public void validateNestingDepth(int depth) throws StreamConstraintsException`
`249`	`251`	`public void validateFPLength(int length) throws StreamConstraintsException`
`250`	`252`	`{`
`251`	`253`	`if (length > _maxNumLen) {`
`252`		`- throw new StreamConstraintsException(String.format("Number length (%d) exceeds the maximum length (%d)",`
`253`		`- length, _maxNumLen));`
	`254`	`+ throw _constructException(`
	`255`	`+ "Number value length (%d) exceeds the maximum allowed (%d, from %s)",`
	`256`	`+ length, _maxNumLen,`
	`257`	`+ _constrainRef("getMaxNumberLength"));`
`254`	`258`	`}`
`255`	`259`	`}`
`256`	`260`
`@@ -268,8 +272,10 @@ public void validateFPLength(int length) throws StreamConstraintsException`
`268`	`272`	`public void validateIntegerLength(int length) throws StreamConstraintsException`
`269`	`273`	`{`
`270`	`274`	`if (length > _maxNumLen) {`
`271`		`- throw new StreamConstraintsException(String.format("Number length (%d) exceeds the maximum length (%d)",`
`272`		`- length, _maxNumLen));`
	`275`	`+ throw _constructException(`
	`276`	`+ "Number value length (%d) exceeds the maximum allowed (%d, from %s)",`
	`277`	`+ length, _maxNumLen,`
	`278`	`+ _constrainRef("getMaxNumberLength"));`
`273`	`279`	`}`
`274`	`280`	`}`
`275`	`281`
`@@ -287,8 +293,10 @@ public void validateIntegerLength(int length) throws StreamConstraintsException`
`287`	`293`	`public void validateStringLength(int length) throws StreamConstraintsException`
`288`	`294`	`{`
`289`	`295`	`if (length > _maxStringLen) {`
`290`		`- throw new StreamConstraintsException(String.format("String length (%d) exceeds the maximum length (%d)",`
`291`		`- length, _maxStringLen));`
	`296`	`+ throw _constructException(`
	`297`	`+ "String value length (%d) exceeds the maximum allowed (%d, from %s)",`
	`298`	`+ length, _maxStringLen,`
	`299`	`+ _constrainRef("getMaxStringLength"));`
`292`	`300`	`}`
`293`	`301`	`}`
`294`	`302`
`@@ -315,9 +323,25 @@ public void validateBigIntegerScale(int scale) throws StreamConstraintsException`
`315`	`323`	`final int limit = MAX_BIGINT_SCALE_MAGNITUDE;`
`316`	`324`
`317`	`325`	`if (absScale > limit) {`
`318`		`- throw new StreamConstraintsException(String.format(`
`319`		`- "BigDecimal scale (%d) magnitude exceeds maximum allowed (%d)",`
`320`		`- scale, limit));`
	`326`	`+ throw _constructException(`
	`327`	`+ "BigDecimal scale (%d) magnitude exceeds the maximum allowed (%d)",`
	`328`	`+ scale, limit);`
`321`	`329`	`}`
`322`	`330`	`}`
	`331`	`+`
	`332`	`+ /*`
	`333`	`+ /**********************************************************************`
	`334`	`+ /* Error reporting`
	`335`	`+ /**********************************************************************`
	`336`	`+ */`
	`337`	`+`
	`338`	`+ // @since 2.16`
	`339`	`+ protected StreamConstraintsException _constructException(String msgTemplate, Object... args) throws StreamConstraintsException {`
	`340`	`+ throw new StreamConstraintsException(String.format(msgTemplate, args));`
	`341`	`+ }`
	`342`	`+`
	`343`	`+ // @since 2.16`
	`344`	`+ protected String _constrainRef(String method) {`
	`345`	+ return "`StreamReadConstraints."+method+"()`";
	`346`	`+ }`
`323`	`347`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,8 @@ private void _testDeepNesting(JsonParser p) throws Exception`
`32`	`32`	`while (p.nextToken() != null) { }`
`33`	`33`	`fail("expected StreamConstraintsException");`
`34`	`34`	`} catch (StreamConstraintsException e) {`
`35`		`- assertEquals("Depth ("+(MAX_NESTING+1)`
`36`		`- +") exceeds the maximum allowed nesting depth ("+MAX_NESTING+")", e.getMessage());`
	`35`	+ assertEquals("Document nesting depth (1001) exceeds the maximum allowed (1000, from `StreamReadConstraints.getMaxNestingDepth()`)",
	`36`	`+ e.getMessage());`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`@@ -58,8 +58,8 @@ private void _testLegacyConstraintSettingTest(JsonParser p, int maxNesting) thro`
`58`	`58`	`while (p.nextToken() != null) { }`
`59`	`59`	`fail("expected StreamConstraintsException");`
`60`	`60`	`} catch (StreamConstraintsException e) {`
`61`		`- assertEquals("Depth ("+(maxNesting+1)`
`62`		`- +") exceeds the maximum allowed nesting depth ("+maxNesting+")", e.getMessage());`
	`61`	+ assertEquals("Document nesting depth (41) exceeds the maximum allowed (40, from `StreamReadConstraints.getMaxNestingDepth()`)",
	`62`	`+ e.getMessage());`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -34,13 +34,13 @@ public void testBigBigDecimalsBytes() throws Exception`
`34`	`34`	`_testBigBigDecimals(MODE_INPUT_STREAM, false);`
`35`	`35`	`fail("Should not pass");`
`36`	`36`	`} catch (StreamConstraintsException e) {`
`37`		`- verifyException(e, "Invalid numeric value ", "exceeds the maximum length");`
	`37`	`+ verifyException(e, "Invalid numeric value ", "exceeds the maximum");`
`38`	`38`	`}`
`39`	`39`	`try {`
`40`	`40`	`_testBigBigDecimals(MODE_INPUT_STREAM_THROTTLED, false);`
`41`	`41`	`fail("Should not pass");`
`42`	`42`	`} catch (StreamConstraintsException jpe) {`
`43`		`- verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");`
	`43`	`+ verifyException(jpe, "Invalid numeric value ", "exceeds the maximum");`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`@@ -50,7 +50,7 @@ public void testBigBigDecimalsCharsFailByDefault() throws Exception`
`50`	`50`	`_testBigBigDecimals(MODE_READER, false);`
`51`	`51`	`fail("Should not pass");`
`52`	`52`	`} catch (StreamConstraintsException jpe) {`
`53`		`- verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");`
	`53`	`+ verifyException(jpe, "Invalid numeric value ", "exceeds the maximum");`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`@@ -65,7 +65,7 @@ public void testBigBigDecimalsDataInputFailByDefault() throws Exception`
`65`	`65`	`_testBigBigDecimals(MODE_DATA_INPUT, false);`
`66`	`66`	`fail("Should not pass");`
`67`	`67`	`} catch (StreamConstraintsException jpe) {`
`68`		`- verifyException(jpe, "Invalid numeric value ", "exceeds the maximum length");`
	`68`	`+ verifyException(jpe, "Invalid numeric value ", "exceeds the maximum allowed");`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public void bigIntegerViaBigDecimal() throws Exception {`
`22`	`22`	`p.getBigIntegerValue();`
`23`	`23`	`Assert.fail("Should not pass");`
`24`	`24`	`} catch (StreamConstraintsException e) {`
`25`		`- Assert.assertEquals("BigDecimal scale (-25000000) magnitude exceeds maximum allowed (100000)", e.getMessage());`
	`25`	`+ Assert.assertEquals("BigDecimal scale (-25000000) magnitude exceeds the maximum allowed (100000)", e.getMessage());`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -37,7 +37,7 @@ public void tinyIntegerViaBigDecimal() throws Exception {`
`37`	`37`	`p.getBigIntegerValue();`
`38`	`38`	`Assert.fail("Should not pass");`
`39`	`39`	`} catch (StreamConstraintsException e) {`
`40`		`- Assert.assertEquals("BigDecimal scale (25000000) magnitude exceeds maximum allowed (100000)", e.getMessage());`
	`40`	`+ Assert.assertEquals("BigDecimal scale (25000000) magnitude exceeds the maximum allowed (100000)", e.getMessage());`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,9 +153,9 @@ public void testLongAsciiStringsSmallLimit() throws IOException`
`153`	`153`	`fail("expected IOException");`
`154`	`154`	`} catch (IOException ie) {`
`155`	`155`	`assertTrue("unexpected exception message: " + ie.getMessage(),`
`156`		`- ie.getMessage().startsWith("String length"));`
	`156`	`+ ie.getMessage().startsWith("String value length"));`
`157`	`157`	`assertTrue("unexpected exception message: " + ie.getMessage(),`
`158`		`- ie.getMessage().endsWith("exceeds the maximum length (100)"));`
	`158`	`+ ie.getMessage().contains("exceeds the maximum allowed (100"));`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`