tests working locally

controllers/common.go

@@ -112,6 +112,10 @@ func ValidateNodeCreate(networkName string, node models.Node) error {
 		_, err := node.GetNetwork()
 		return err == nil
 	})
+        _ = v.RegisterValidation("in_charset", func(fl validator.FieldLevel) bool {
+                isgood := functions.NameInNodeCharSet(node.Name)
+                return isgood
+        })
 	err := v.Struct(node)
 
 	if err != nil {
@@ -128,6 +132,10 @@ func ValidateNodeUpdate(networkName string, node models.NodeUpdate) error {
 		_, err := node.GetNetwork()
 		return err == nil
 	})
+        _ = v.RegisterValidation("in_charset", func(fl validator.FieldLevel) bool {
+                isgood := functions.NameInNodeCharSet(node.Name)
+                return isgood
+        })
 	err := v.Struct(node)
 	if err != nil {
 		for _, e := range err.(validator.ValidationErrors) {

controllers/common_test.go

@@ -303,7 +303,7 @@ func TestValidateNodeCreate(t *testing.T) {
 			node: models.Node{
 				Name: "mynode*",
 			},
-			errorMessage: "Field validation for 'Name' failed on the 'alphanum' tag",
+			errorMessage: "Field validation for 'Name' failed on the 'in_charset' tag",
 		},
 		NodeValidationTC{
 			testname: "NameTooLong",
@@ -450,7 +450,7 @@ func TestValidateNodeUpdate(t *testing.T) {
 			node: models.NodeUpdate{
 				Name: "mynode*",
 			},
-			errorMessage: "Field validation for 'Name' failed on the 'alphanum' tag",
+			errorMessage: "Field validation for 'Name' failed on the 'in_charset' tag",
 		},
 		NodeValidationUpdateTC{
 			testname: "NameTooLong",

controllers/config/dnsconfig/netmaker.hosts

@@ -1 +1 @@
-10.0.0.1         node-thhy9.skynet
+10.0.0.1         node-4bukt.skynet

controllers/networkHttpController.go

@@ -47,6 +47,9 @@ func securityCheck(next http.Handler) http.HandlerFunc {
 		bearerToken := r.Header.Get("Authorization")
 		err := SecurityCheck(params["networkname"], bearerToken)
 		if err != nil {
+			if strings.Contains(err.Error(), "does not exist") {
+				errorResponse.Code = http.StatusNotFound
+			}
 			errorResponse.Message = err.Error()
 			returnErrorResponse(w, r, errorResponse)
 			return
@@ -460,7 +463,11 @@ func deleteNetwork(w http.ResponseWriter, r *http.Request) {
 	count, err := DeleteNetwork(network)
 
 	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "badrequest"))
+		errtype := "badrequest"
+		if strings.Contains(err.Error(), "Node check failed"){
+			errtype = "forbidden"
+		}
+		returnErrorResponse(w, r, formatError(err, errtype))
 		return
 	}
 	w.WriteHeader(http.StatusOK)
@@ -583,17 +590,24 @@ func createAccessKey(w http.ResponseWriter, r *http.Request) {
 }
 
 func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models.AccessKey, error) {
-	fmt.Println(accesskey)
+
 	if accesskey.Name == "" {
 		accesskey.Name = functions.GenKeyName()
 	}
+
 	if accesskey.Value == "" {
 		accesskey.Value = functions.GenKey()
 	}
 	if accesskey.Uses == 0 {
 		accesskey.Uses = 1
 	}
-	for _, key := range network.AccessKeys {
+
+        checkkeys, err := GetKeys(network.NetID)
+        if err != nil {
+                return models.AccessKey{}, errors.New("could not retrieve network keys")
+        }
+
+	for _, key := range checkkeys {
 		if key.Name == accesskey.Name {
 			return models.AccessKey{}, errors.New("Duplicate AccessKey Name")
 		}
@@ -613,7 +627,7 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 	accesskey.AccessString = base64.StdEncoding.EncodeToString([]byte(accessstringdec))
 	//validate accesskey
 	v := validator.New()
-	err := v.Struct(accesskey)
+	err = v.Struct(accesskey)
 	if err != nil {
 		for _, e := range err.(validator.ValidationErrors) {
 			fmt.Println(e)

controllers/nodeHttpController.go

@@ -654,7 +654,7 @@ func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
 			{"postup", nodechange.PostUp},
 			{"postdown", nodechange.PostDown},
 			{"isegressgateway", nodechange.IsEgressGateway},
-			{"gatewayrange", nodechange.EgressGatewayRange},
+			{"egressgatewayrange", nodechange.EgressGatewayRange},
 			{"lastmodified", nodechange.LastModified},
 		}},
 	}

models/node.go

@@ -22,7 +22,7 @@ type Node struct {
 	Address             string             `json:"address" bson:"address" validate:"omitempty,ipv4"`
 	Address6            string             `json:"address6" bson:"address6" validate:"omitempty,ipv6"`
 	LocalAddress        string             `json:"localaddress" bson:"localaddress" validate:"omitempty,ip"`
-	Name                string             `json:"name" bson:"name" validate:"omitempty,max=12"`
+	Name                string             `json:"name" bson:"name" validate:"omitempty,max=12,in_charset"`
 	ListenPort          int32              `json:"listenport" bson:"listenport" validate:"omitempty,numeric,min=1024,max=65535"`
 	PublicKey           string             `json:"publickey" bson:"publickey" validate:"required,base64"`
 	Endpoint            string             `json:"endpoint" bson:"endpoint" validate:"required,ip"`
@@ -56,7 +56,7 @@ type NodeUpdate struct {
 	Address             string             `json:"address" bson:"address" validate:"omitempty,ip"`
 	Address6            string             `json:"address6" bson:"address6" validate:"omitempty,ipv6"`
 	LocalAddress        string             `json:"localaddress" bson:"localaddress" validate:"omitempty,ip"`
-	Name                string             `json:"name" bson:"name" validate:"omitempty,max=12"`
+	Name                string             `json:"name" bson:"name" validate:"omitempty,max=12,in_charset"`
 	ListenPort          int32              `json:"listenport" bson:"listenport" validate:"omitempty,numeric,min=1024,max=65535"`
 	PublicKey           string             `json:"publickey" bson:"publickey" validate:"omitempty,base64"`
 	Endpoint            string             `json:"endpoint" bson:"endpoint" validate:"omitempty,ip"`
@@ -79,6 +79,7 @@ type NodeUpdate struct {
 	IsPending           bool               `json:"ispending" bson:"ispending"`
 	IsIngressGateway           bool               `json:"isingressgateway" bson:"isingressgateway"`
 	IsEgressGateway           bool               `json:"isegressgateway" bson:"isegressgateway"`
+        IngressGatewayRange        string             `json:"ingressgatewayrange" bson:"ingressgatewayrange"`
 	EgressGatewayRange        string             `json:"gatewayrange" bson:"gatewayrange"`
 	PostChanges         string             `json:"postchanges" bson:"postchanges"`
 }

test/api_test.go

@@ -80,7 +80,7 @@ func api(t *testing.T, data interface{}, method, url, authorization string) (*ht
 }
 
 func addAdmin(t *testing.T) {
-	var admin models.User
+	var admin models.UserAuthParams
 	admin.UserName = "admin"
 	admin.Password = "password"
 	response, err := api(t, admin, http.MethodPost, baseURL+"/api/users/adm/createadmin", "secretkey")

test/network_test.go

@@ -26,7 +26,7 @@ func TestCreateNetwork(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, "ou are unauthorized to access this endpoint", message.Message)
+		assert.Contains(t, message.Message, "ou are unauthorized to access this endpoint")
 	})
 	t.Run("CreateNetwork", func(t *testing.T) {
 		response, err := api(t, network, http.MethodPost, baseURL+"/api/networks", "secretkey")
@@ -73,7 +73,7 @@ func TestGetNetworks(t *testing.T) {
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, "ou are unauthorized to access this endpoint", message.Message)
+		assert.Contains(t, message.Message, "ou are unauthorized to access this endpoint")
 	})
 }
 
@@ -99,7 +99,7 @@ func TestGetNetwork(t *testing.T) {
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, "ou are unauthorized to access this endpoint", message.Message)
+		assert.Contains(t, message.Message, "ou are unauthorized to access this endpoint")
 	})
 	t.Run("InvalidNetwork", func(t *testing.T) {
 		response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/badnetwork", "secretkey")
@@ -108,7 +108,7 @@ func TestGetNetwork(t *testing.T) {
 		var message models.ErrorResponse
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
-		assert.Contains(t, "his network does not exist", message.Message)
+		assert.Contains(t, message.Message, "his network does not exist")
 		assert.Equal(t, http.StatusNotFound, response.StatusCode)
 	})
 }
@@ -125,7 +125,7 @@ func TestDeleteNetwork(t *testing.T) {
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, "You are unauthorized to access this endpoint", message.Message)
+		assert.Contains(t, message.Message, "You are unauthorized to access this endpoint")
 	})
 	t.Run("Badnetwork", func(t *testing.T) {
 		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/badnetwork", "secretkey")
@@ -134,7 +134,7 @@ func TestDeleteNetwork(t *testing.T) {
 		var message models.ErrorResponse
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
-		assert.Contains(t, "his network does not exist", message.Message)
+		assert.Contains(t, message.Message, "his network does not exist")
 		assert.Equal(t, http.StatusNotFound, response.StatusCode)
 	})
 	t.Run("NodesExist", func(t *testing.T) {
@@ -147,7 +147,7 @@ func TestDeleteNetwork(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Contains(t, message.Message, "Node check failed")
-		assert.Equal(t, http.StatusBadRequest, message.Code)
+		assert.Equal(t, http.StatusForbidden, message.Code)
 	})
 	t.Run("ValidKey", func(t *testing.T) {
 		type Message struct {
@@ -222,7 +222,7 @@ func TestCreateKey(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, "ou are unauthorized to access this endpoint", message.Message)
+		assert.Contains(t, message.Message, "ou are unauthorized to access this endpoint")
 	})
 	t.Run("Badnetwork", func(t *testing.T) {
 		response, err := api(t, key, http.MethodPost, baseURL+"/api/networks/badnetwork/keys", "secretkey")
@@ -231,7 +231,7 @@ func TestCreateKey(t *testing.T) {
 		var message models.ErrorResponse
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
-		assert.Contains(t, "his network does not exist", message.Message)
+		assert.Contains(t, message.Message, "his network does not exist")
 		assert.Equal(t, http.StatusNotFound, response.StatusCode)
 	})
 }
@@ -265,7 +265,7 @@ func TestDeleteKey(t *testing.T) {
 		var message models.ErrorResponse
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
-		assert.Contains(t, "his network does not exist", message.Message)
+		assert.Contains(t, message.Message, "his network does not exist")
 		assert.Equal(t, http.StatusNotFound, response.StatusCode)
 	})
 	t.Run("InvalidCredentials", func(t *testing.T) {
@@ -351,8 +351,8 @@ func TestUpdateNetwork(t *testing.T) {
 		var message models.ErrorResponse
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
-		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Contains(t, message.Message, "his network does not exist.")
+		assert.Equal(t, http.StatusNotFound, message.Code)
+		assert.Contains(t, message.Message, "his network does not exist")
 		assert.Equal(t, http.StatusNotFound, response.StatusCode)
 	})
 	t.Run("UpdateAddress", func(t *testing.T) {

test/node_test.go

@@ -400,7 +400,7 @@ func TestCreateNode(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusBadRequest, message.Code)
-		assert.Contains(t, message.Message, "Field validation for 'MacAddress' failed on the 'macaddress_valid' tag")
+		assert.Contains(t, message.Message, "Field validation for 'MacAddress' failed on the 'ma")
 	})
 	t.Run("BadPublicKey", func(t *testing.T) {
 		var node models.Node
@@ -501,7 +501,7 @@ func TestCreateNode(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusNotFound, message.Code)
-		assert.Contains(t, "etwork does not exist", message.Message)
+		assert.Contains(t, message.Message, "etwork does not exist")
 	})
 	t.Run("Valid", func(t *testing.T) {
 		deleteNetworks(t)
@@ -561,7 +561,7 @@ func TestNodeAuthenticate(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusOK, message.Code)
-		assert.Contains(t, "Device 01:02:03:04:05:06 Authorized", message.Message)
+		assert.Contains(t, message.Message, "Device 01:02:03:04:05:06 Authorized")
 	})
 	t.Run("MacEmpty", func(t *testing.T) {
 		var authRequest models.AuthParams
@@ -575,7 +575,7 @@ func TestNodeAuthenticate(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusBadRequest, message.Code)
-		assert.Contains(t, "acAddress can't be empty", message.Message)
+		assert.Contains(t, message.Message, "acAddress can't be empty")
 	})
 	t.Run("EmptyPass", func(t *testing.T) {
 		var authRequest models.AuthParams
@@ -589,7 +589,7 @@ func TestNodeAuthenticate(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusBadRequest, message.Code)
-		assert.Equal(t, "assword can't be empty", message.Message)
+		assert.Contains(t, message.Message, "assword can't be empty")
 	})
 	t.Run("BadPass", func(t *testing.T) {
 		var authRequest models.AuthParams

test/user_test.go

@@ -40,7 +40,7 @@ func TestAdminCreation(t *testing.T) {
 		err = json.NewDecoder(response.Body).Decode(&message)
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusBadRequest, response.StatusCode)
-		assert.Equal(t, "W1R3: Admin already exists! ", message.Message)
+		assert.Contains(t, message.Message, "Admin already Exists")
 	})
 }
 
@@ -69,7 +69,7 @@ func TestGetUser(t *testing.T) {
 		assert.Nil(t, err, err)
 		assert.Equal(t, http.StatusUnauthorized, response.StatusCode)
 		assert.Equal(t, http.StatusUnauthorized, message.Code)
-		assert.Equal(t, "token contains an invalid number of segments", message.Message)
+		assert.Contains(t, message.Message, "Error Verifying Auth Token")
 
 	})
 }
@@ -207,7 +207,7 @@ func TestAuthenticateUser(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.testname, func(t *testing.T) {
-			var admin models.User
+			var admin models.UserAuthParams
 			admin.UserName = tc.name
 			admin.Password = tc.password
 			response, err := api(t, admin, http.MethodPost, "http://localhost:8081/api/users/adm/authenticate", "secretkey")