Template helper methods for type validation, string functions and regex

core/templating/template_helpers.go

@@ -2,13 +2,15 @@ package templating
 
 import (
  "fmt"
- "github.com/SpectoLabs/hoverfly/core/journal"
  "math"
  "reflect"
+ "regexp"
  "strconv"
  "strings"
  "time"
 
+ "github.com/SpectoLabs/hoverfly/core/journal"
+
  "github.com/SpectoLabs/raymond"
  "github.com/pborman/uuid"
 
@@ -117,6 +119,88 @@ func (t templateHelpers) concat(val1, val2 string) string {
  return val1 + val2
 }
 
+func (t templateHelpers) isNumeric(stringToCheck string) bool {
+ _, err := strconv.ParseFloat(stringToCheck, 64)
+ //return fmt.Sprintf("%t", err == nil)
+ return err == nil
+}
+
+func (t templateHelpers) isAlphanumeric(s string) bool {
+ regex := regexp.MustCompile("^[a-zA-Z0-9]+$")
+ return regex.MatchString(s)
+}
+
+func (t templateHelpers) isBool(s string) bool {
+ _, err := strconv.ParseBool(s)
+ return err == nil
+}
+
+func (t templateHelpers) isGreaterThan(valueToCheck, minimumValue string) bool {
+ num1, err := strconv.ParseFloat(valueToCheck, 64)
+ if err != nil {
+ return false
+ }
+ num2, err := strconv.ParseFloat(minimumValue, 64)
+ if err != nil {
+ return false
+ }
+ return num1 > num2
+}
+
+func (t templateHelpers) isLessThan(valueToCheck, maximumValue string) bool {
+ num1, err := strconv.ParseFloat(valueToCheck, 64)
+ if err != nil {
+ return false
+ }
+ num2, err := strconv.ParseFloat(maximumValue, 64)
+ if err != nil {
+ return false
+ }
+ return num1 < num2
+}
+
+func (t templateHelpers) isBetween(valueToCheck, minimumValue, maximumValue string) bool {
+ return t.isGreaterThan(valueToCheck, minimumValue) && t.isLessThan(valueToCheck, maximumValue)
+}
+
+func (t templateHelpers) matchesRegex(valueToCheck, pattern string) bool {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return false
+ }
+ return re.MatchString(valueToCheck)
+}
+
+func (t templateHelpers) length(stringToCheck string) string {
+ return strconv.Itoa(len(stringToCheck))
+}
+
+func (t templateHelpers) substring(str, startStr, endStr string) string {
+ start, err := strconv.Atoi(startStr)
+ if err != nil {
+ return ""
+ }
+ end, err := strconv.Atoi(endStr)
+ if err != nil {
+ return ""
+ }
+ if start < 0 || end > len(str) || start > end {
+ return ""
+ }
+ return str[start:end]
+}
+
+func (t templateHelpers) rightmostCharacters(str, countStr string) string {
+ count, err := strconv.Atoi(countStr)
+ if err != nil {
+ return ""
+ }
+ if count < 0 || count > len(str) {
+ return ""
+ }
+ return str[len(str)-count:]
+}
+
 func (t templateHelpers) faker(fakerType string) []reflect.Value {
 
  if t.fakerSource == nil {

core/templating/template_helpers_test.go

@@ -100,6 +100,261 @@ func Test_concat(t *testing.T) {
  Expect(unit.concat("one", " two")).To(Equal("one two"))
 }
 
+func Test_length(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.length("onelongstring")).To(Equal("13"))
+}
+
+func Test_substring(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.substring("onelongstring", "3", "7")).To(Equal("long"))
+}
+
+func Test_substring_withInvalidStart(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.substring("onelongstring", "-3", "6")).To(Equal(""))
+}
+
+func Test_substring_withInvalidEnd(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.substring("onelongstring", "3", "the end")).To(Equal(""))
+}
+
+func Test_rightmostCharacters(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.rightmostCharacters("onelongstring", "3")).To(Equal("ing"))
+}
+
+func Test_rightmostCharacters_withInvalidCount(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.rightmostCharacters("onelongstring", "30")).To(Equal(""))
+}
+
+func Test_isNumeric_withInteger(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isNumeric("123")).To(Equal(true))
+}
+
+func Test_isNumeric_withFloat(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isNumeric("45.67")).To(Equal(true))
+}
+
+func Test_isNumeric_withScientific(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isNumeric("1e10")).To(Equal(true))
+}
+
+func Test_isNumeric_withNegative(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isNumeric("-5")).To(Equal(true))
+}
+
+func Test_isNumeric_withString(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isNumeric("hello")).To(Equal(false))
+}
+
+func Test_isAlphanumeric_withAlphanumeric(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isAlphanumeric("ABC123")).To(Equal(true))
+}
+
+func Test_isAlphanumeric_withNumeric(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isAlphanumeric("123")).To(Equal(true))
+}
+
+func Test_isAlphanumeric_withAlpha(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isAlphanumeric("ABC")).To(Equal(true))
+}
+
+func Test_isAlphanumeric_withInvalidAlphanumeric(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isAlphanumeric("ABC!@123")).To(Equal(false))
+}
+
+func Test_isBool_withtrue(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBool("true")).To(Equal(true))
+}
+
+func Test_isBool_withfalse(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBool("false")).To(Equal(true))
+}
+
+func Test_isBool_with1(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBool("1")).To(Equal(true))
+}
+
+func Test_isBool_with0(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBool("0")).To(Equal(true))
+}
+
+func Test_isBool_withInvalidValue(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBool("maybe")).To(Equal(false))
+}
+
+func Test_isGreaterThan_withPositiveResult(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isGreaterThan("11", "10")).To(Equal(true))
+}
+
+func Test_isGreaterThan_withNegativeResult(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isGreaterThan("10", "11")).To(Equal(false))
+}
+
+func Test_isGreaterThan_withInvalidNumber(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isGreaterThan("abc", "11")).To(Equal(false))
+}
+
+func Test_isLessThan_withPositiveResult(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isLessThan("10", "11")).To(Equal(true))
+}
+
+func Test_isLessThan_withNegativeResult(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isLessThan("11", "10")).To(Equal(false))
+}
+
+func Test_isLessThan_withInvalidNumber(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isLessThan("abc", "11")).To(Equal(false))
+}
+
+func Test_isBetween_withPositiveOutcome(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBetween("5", "3", "7")).To(Equal(true))
+}
+
+func Test_isBetween_withNegativeOutcome(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBetween("5", "6", "7")).To(Equal(false))
+}
+
+func Test_isBetween_withInvalidArgument(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.isBetween("e", "6", "7")).To(Equal(false))
+}
+
+func Test_matchesRegex_withPositiveOutcome(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.matchesRegex("{\"someField\": \"a\", \"transactionId\": 1000, \"anotherField\": \"b\", \"store\": \"c\", \"clientUniqueId\": \"12345\", \"items\": [\"item1\", \"item2\", \"item3\"], \"extraField\": \"d\"}", "(?s).*(\"transactionId\": 1000).*store.*clientUniqueId.*items.*")).To(Equal(true))
+}
+func Test_matchesRegex_withNegativeOutcome(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.matchesRegex("{\"someField\": \"a\", \"transactionNumber\": 1000, \"anotherField\": \"b\", \"store\": \"c\", \"clientUniqueId\": \"12345\", \"items\": [\"item1\", \"item2\", \"item3\"], \"extraField\": \"d\"}", "(?s).*(\"transactionId\": 1000).*store.*clientUniqueId.*items.*")).To(Equal(false))
+}
+
+func Test_matchesRegex_withInvalidArgument(t *testing.T) {
+ RegisterTestingT(t)
+
+ unit := templateHelpers{}
+
+ Expect(unit.matchesRegex("I am looking for this string", "&^%$£!@:<>+_!¬")).To(Equal(false))
+}
+
 func Test_faker(t *testing.T) {
  RegisterTestingT(t)