feat(errorHandlingConfig): make the length of URL refrence in error messages configurable

Closes #14744
Closes #15707

Author: m-amr

src/Angular.js

@@ -129,7 +129,8 @@ var VALIDITY_STATE_PROPERTY = 'validity';
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
 var minErrConfig = {
-  objectMaxDepth: 5
+  objectMaxDepth: 5,
+  urlMaxLength: 2000
 };
 
  /**
@@ -143,6 +144,7 @@ var minErrConfig = {
  * current configuration if used as a getter. The following options are supported:
  *
  * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
+ * - **urlMaxLength**: The maximum length of the URL reference in the error messages.
  *
  * Omitted or undefined options will leave the corresponding configuration values unchanged.
  *
@@ -152,12 +154,19 @@ var minErrConfig = {
  * * `objectMaxDepth`  **{Number}** - The max depth for stringifying objects. Setting to a
  *   non-positive or non-numeric value, removes the max depth limit.
  *   Default: 5
+ *
+ * * `urlMaxLength`  **{Number}** - The max length of the URL reference in the error messages, it can be any number more than or equal 200. Setting to a
+ *   non-positive or non-numeric value, removes the url max length limit.
+ *   Default: 2000
  */
 function errorHandlingConfig(config) {
   if (isObject(config)) {
     if (isDefined(config.objectMaxDepth)) {
       minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
     }
+    if(isDefined(config.urlMaxLength)) {
+      minErrConfig.urlMaxLength = (isNumber(config.urlMaxLength) && config.urlMaxLength >= 200) ? config.urlMaxLength : NaN;
+    }
   } else {
     return minErrConfig;
   }

src/minErr.js

@@ -51,13 +51,21 @@ function minErr(module, ErrorConstructor) {
       return match;
     });
 
-    message += '\nhttp://errors.angularjs.org/"NG_VERSION_FULL"/' +
+    var URL_MAX_LENGTH_END = '...';
+    var url = 'http://errors.angularjs.org/"NG_VERSION_FULL"/' +
       (module ? module + '/' : '') + code;
 
     for (i = 0, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
-      message += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
+      url += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
+
+      if(url.length > minErrConfig.urlMaxLength) {
+        url = url.slice(0, minErrConfig.urlMaxLength - URL_MAX_LENGTH_END.length);
+        url += URL_MAX_LENGTH_END;
+        break;
+      }
     }
 
+    message += '\n' + url;
     return new ErrorConstructor(message);
   };
 }

test/minErrSpec.js

@@ -10,10 +10,29 @@ describe('minErr', function() {
     testError = minErr('test');
 
   var originalObjectMaxDepthInErrorMessage = minErrConfig.objectMaxDepth;
+  var originalUrlMaxLengthInErrorMessage = minErrConfig.urlMaxLength;
   afterEach(function() {
     minErrConfig.objectMaxDepth = originalObjectMaxDepthInErrorMessage;
+    minErrConfig.urlMaxLength = originalUrlMaxLengthInErrorMessage;
   });
 
+  function extractUrlFromErrorMessage(message) {
+    var match = message.match(/http[\s\S]*\?p0=/);
+    var urlStartAt = message.indexOf(match[0]);
+    if(urlStartAt < 0) {
+      throw new Error('Could not find url');
+    }
+    return message.slice(urlStartAt);
+  }
+
+  function createDummyString(size) {
+    var str = '';
+    for(var i = 0; i < size; i++) {
+      str += 'a'
+    }
+    return str;
+  }
+
   it('should return an Error factory', function() {
     var myError = testError('test', 'Oops');
     expect(myError instanceof Error).toBe(true);
@@ -143,4 +162,31 @@ describe('minErr', function() {
     expect(testError('acode', 'aproblem', 'a', 'b', 'value with space').message)
       .toMatch(/^[\s\S]*\?p0=a&p1=b&p2=value%20with%20space$/);
   });
+
+  it('should slice error reference URL in the message if it exceeds url max length', function() {
+    debugger;
+    var a = createDummyString(2000);
+
+    var myError = testError('26', 'a when default=2000 is {0}', a);
+    var url = extractUrlFromErrorMessage(myError.message);
+    expect(url.length).toBe(2000);
+    expect(errorHandlingConfig().urlMaxLength).toBe(2000);
+
+    errorHandlingConfig({urlMaxLength: 500});
+    myError = testError('26', 'a when urlMaxLength=500 is {0}', a);
+    url = extractUrlFromErrorMessage(myError.message);
+    expect(url.length).toBe(500);
+    expect(errorHandlingConfig().urlMaxLength).toBe(500);
+  });
+
+  they('should ignore url max length when urlMaxLength = $prop',
+      [NaN, null, true, false, -1, 0], function(maxLength) {
+        errorHandlingConfig({urlMaxLength: maxLength});
+        var a = createDummyString(2100);
+        var myError = testError('26', 'a is {0}', a);
+        var url = extractUrlFromErrorMessage(myError.message);
+        expect(url.length).toBeGreaterThan(2100);
+        expect(errorHandlingConfig().urlMaxLength).toBeNaN();
+      }
+  );
 });