skupper init: validate site name and router number (#1423)

* add validators for router numbers and site name in skupper init

Author: nluaces

cmd/skupper/skupper.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/skupperproject/skupper/pkg/network"
 	"github.com/skupperproject/skupper/pkg/utils/configs"
+	"github.com/skupperproject/skupper/pkg/utils/validator"
 	"os"
 	"reflect"
 	"strconv"
@@ -451,6 +452,16 @@ installation that can then be connected to other skupper installations`,
 				return fmt.Errorf("for the console to work with this user or password, the --console-auth option must be set to internal")
 			}
 
+			ok, err := validator.NewStringValidator().Evaluate(routerCreateOpts.SkupperName)
+			if !ok {
+				return fmt.Errorf("invalid skupper site name: %s", err.Error())
+			}
+
+			ok, err = validator.NewNumberValidator().Evaluate(routerCreateOpts.Routers)
+			if !ok {
+				return fmt.Errorf("invalid number for routers: %s", err.Error())
+			}
+
 			return skupperCli.Create(cmd, args)
 		},
 	}

pkg/utils/validator/simple_validator.go

@@ -0,0 +1,72 @@
+package validator
+
+import (
+	"fmt"
+	"regexp"
+)
+
+type Validator interface {
+	Evaluate(value interface{}) (bool, error)
+}
+
+//
+
+type StringValidator struct {
+	Expression *regexp.Regexp
+}
+
+func NewStringValidator() *StringValidator {
+	re, err := regexp.Compile("^\\S*$")
+	if err != nil {
+		fmt.Printf("Error compiling regex: %v", err)
+		return nil
+	}
+	return &StringValidator{
+		Expression: re,
+	}
+}
+
+func (s StringValidator) Evaluate(value interface{}) (bool, error) {
+	v, ok := value.(string)
+
+	if !ok {
+		return false, fmt.Errorf("value is not a string")
+	}
+
+	if s.Expression.MatchString(v) {
+		return true, nil
+	}
+
+	return false, fmt.Errorf("value contains spaces")
+}
+
+//
+
+type NumberValidator struct {
+	PositiveInt bool
+}
+
+func NewNumberValidator() *NumberValidator {
+	return &NumberValidator{
+		PositiveInt: true,
+	}
+}
+
+func (i NumberValidator) Evaluate(value interface{}) (bool, error) {
+
+	v, ok := value.(int)
+
+	if !ok {
+		return false, fmt.Errorf("value is not an integer")
+	}
+
+	if i.PositiveInt {
+		if v >= 0 {
+			return true, nil
+		}
+		return false, fmt.Errorf("value is not positive")
+	}
+	return true, nil
+}
+
+///

pkg/utils/validator/simple_validator_test.go

@@ -0,0 +1,83 @@
+package validator
+
+import (
+	"gotest.tools/assert"
+	"reflect"
+	"regexp"
+	"testing"
+)
+
+func TestNewStringValidator(t *testing.T) {
+
+	t.Run("Test String Validator constructor", func(t *testing.T) {
+
+		validRegexp, _ := regexp.Compile("^\\S*$")
+		expectedResult := &StringValidator{validRegexp}
+		actualResult := NewStringValidator()
+		assert.Assert(t, reflect.DeepEqual(actualResult, expectedResult))
+	})
+}
+
+func TestStringValidator_Evaluate(t *testing.T) {
+	type test struct {
+		name   string
+		value  interface{}
+		result bool
+	}
+
+	testTable := []test{
+		{name: "empty string", value: "", result: true},
+		{name: "valid value", value: "provided-value", result: true},
+		{name: "string with spaces", value: "provided value", result: false},
+		{name: "string with numbers", value: "site123", result: true},
+		{name: "number", value: 123, result: false},
+		{name: "nil value", value: nil, result: false},
+	}
+
+	for _, test := range testTable {
+		t.Run(test.name, func(t *testing.T) {
+
+			stringValidator := NewStringValidator()
+			expectedResult := test.result
+			actualResult, _ := stringValidator.Evaluate(test.value)
+			assert.Assert(t, reflect.DeepEqual(actualResult, expectedResult))
+		})
+	}
+}
+
+func TestNewNumberValidator(t *testing.T) {
+
+	t.Run("Test Positive Int Validator constructor", func(t *testing.T) {
+
+		expectedResult := &NumberValidator{PositiveInt: true}
+		actualResult := NewNumberValidator()
+		assert.Assert(t, reflect.DeepEqual(actualResult, expectedResult))
+	})
+}
+
+func TestIntegerValidator_Evaluate(t *testing.T) {
+	type test struct {
+		name   string
+		value  interface{}
+		result bool
+	}
+
+	testTable := []test{
+		{name: "empty string", value: "", result: false},
+		{name: "value greater than zero", value: 235, result: true},
+		{name: "zero value", value: 0, result: true},
+		{name: "negative number", value: -2, result: false},
+		{name: "not valid characters", value: "abc", result: false},
+		{name: "nil value", value: nil, result: false},
+	}
+
+	for _, test := range testTable {
+		t.Run(test.name, func(t *testing.T) {
+
+			numberValidator := NewNumberValidator()
+			expectedResult := test.result
+			actualResult, _ := numberValidator.Evaluate(test.value)
+			assert.Assert(t, reflect.DeepEqual(actualResult, expectedResult))
+		})
+	}
+}