From a5c7083726e2f630617c59388b3443e71f1d7dfe Mon Sep 17 00:00:00 2001
From: HelderSepu <HelderSepu@gmail.com>
Date: Sat, 23 Sep 2017 14:14:58 -0400
Subject: [PATCH] Add validation for min and max length

---
 src/core/utils.js  | 24 +++++++++++++++++
 test/core/utils.js | 65 ++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 87 insertions(+), 2 deletions(-)

diff --git a/src/core/utils.js b/src/core/utils.js
index ac633c34..1e2a95b1 100644
--- a/src/core/utils.js
+++ b/src/core/utils.js
@@ -512,6 +512,18 @@ export const validateGuid = (val) => {
     }
 }
 
+export const validateMaxLength = (val, max) => {
+  if (val.length > max) {
+      return "Value must be less than MaxLength"
+  }
+}
+
+export const validateMinLength = (val, min) => {
+  if (val.length < min) {
+      return "Value must be greater than MinLength"
+  }
+}
+
 // validation of parameters before execute
 export const validateParam = (param, isXml) => {
   let errors = []
@@ -519,6 +531,8 @@ export const validateParam = (param, isXml) => {
   let required = param.get("required")
   let type = param.get("type")
   let format = param.get("format")
+  let maxLength = param.get("maxLength")
+  let minLength = param.get("minLength")
 
   /*
     If the parameter is required OR the parameter has a value (meaning optional, but filled in)
@@ -535,6 +549,16 @@ export const validateParam = (param, isXml) => {
     let numberCheck = type === "number" && !validateNumber(value) // validateNumber returns undefined if the value is a number
     let integerCheck = type === "integer" && !validateInteger(value) // validateInteger returns undefined if the value is an integer
 
+    if (maxLength) {
+      let err = validateMaxLength(value, maxLength)
+      if (err) errors.push(err)
+    }
+
+    if (minLength) {
+      let err = validateMinLength(value, minLength)
+      if (err) errors.push(err)
+    }
+
     if ( required && !(stringCheck || arrayCheck || listCheck || fileCheck || booleanCheck || numberCheck || integerCheck) ) {
       errors.push("Required field is not provided")
       return errors
diff --git a/test/core/utils.js b/test/core/utils.js
index dfe5c1ee..2e21ae3c 100644
--- a/test/core/utils.js
+++ b/test/core/utils.js
@@ -1,7 +1,7 @@
 /* eslint-env mocha */
 import expect from "expect"
 import { fromJS, OrderedMap } from "immutable"
-import { mapToList, validateDateTime, validateGuid, validateNumber, validateInteger, validateParam, validateFile, fromJSOrdered, getAcceptControllingResponse, createDeepLinkPath, escapeDeepLinkPath } from "core/utils"
+import { mapToList, validateMinLength, validateMaxLength, validateDateTime, validateGuid, validateNumber, validateInteger, validateParam, validateFile, fromJSOrdered, getAcceptControllingResponse, createDeepLinkPath, escapeDeepLinkPath } from "core/utils"
 import win from "core/window"
 
 describe("utils", function() {
@@ -198,6 +198,34 @@ describe("utils", function() {
     })
    })
 
+   describe("validateMaxLength", function() {
+    let errorMessage = "Value must be less than MaxLength"
+
+    it("doesn't return for valid guid", function() {
+      expect(validateMaxLength("a", 1)).toBeFalsy()
+      expect(validateMaxLength("abc", 5)).toBeFalsy()
+    })
+
+    it("returns a message for invalid input'", function() {
+      expect(validateMaxLength("abc", 1)).toEqual(errorMessage)
+      expect(validateMaxLength("abc", 2)).toEqual(errorMessage)
+    })
+   })
+
+   describe("validateMinLength", function() {
+    let errorMessage = "Value must be greater than MinLength"
+
+    it("doesn't return for valid guid", function() {
+      expect(validateMinLength("a", 1)).toBeFalsy()
+      expect(validateMinLength("abc", 2)).toBeFalsy()
+    })
+
+    it("returns a message for invalid input'", function() {
+      expect(validateMinLength("abc", 5)).toEqual(errorMessage)
+      expect(validateMinLength("abc", 8)).toEqual(errorMessage)
+    })
+   })
+
   describe("validateParam", function() {
     let param = null
     let result = null
@@ -223,7 +251,7 @@ describe("utils", function() {
       result = validateParam( param, false )
       expect( result ).toEqual( ["Required field is not provided"] )
 
-            // valid string
+      // valid string
       param = fromJS({
         required: true,
         type: "string",
@@ -231,6 +259,39 @@ describe("utils", function() {
       })
       result = validateParam( param, false )
       expect( result ).toEqual( [] )
+
+      // valid string with min and max length
+      param = fromJS({
+        required: true,
+        type: "string",
+        value: "test string",
+        maxLength: 50,
+        minLength: 1
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+    
+    it("validates required strings with min and max length", function() {      
+      // invalid string with max length
+      param = fromJS({
+        required: true,
+        type: "string",
+        value: "test string",
+        maxLength: 5
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be less than MaxLength"] )
+
+      // invalid string with min length
+      param = fromJS({
+        required: true,
+        type: "string",
+        value: "test string",
+        minLength: 50
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be greater than MinLength"] )
     })
 
     it("validates optional strings", function() {