sunny day scenarios for node tests

controllers/nodeHttpController.go

@@ -1,23 +1,23 @@
 package controller
 
 import (
-    "github.com/gravitl/netmaker/models"
-    "errors"
-    "github.com/gravitl/netmaker/functions"
-    "github.com/gravitl/netmaker/mongoconn"
-    "golang.org/x/crypto/bcrypt"
-    "time"
-    "strings"
-    "fmt"
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"net/http"
+	"strings"
+	"time"
+
 	"github.com/gorilla/mux"
+	"github.com/gravitl/netmaker/functions"
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/mongoconn"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo/options"
+	"golang.org/x/crypto/bcrypt"
 )
 
-
 func nodeHandlers(r *mux.Router) {
 
 	r.HandleFunc("/api/nodes", authorize(false, "master", http.HandlerFunc(getAllNodes))).Methods("GET")
@@ -38,7 +38,6 @@ func nodeHandlers(r *mux.Router) {
 //Node authenticates using its password and retrieves a JWT for authorization.
 func authenticate(response http.ResponseWriter, request *http.Request) {
 
-
 	//Auth request consists of Mac Address and Password (from node that is authorizing
 	//in case of Master, auth is ignored and mac is set to "mastermac"
 	var authRequest models.AuthParams
@@ -138,7 +137,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 
 		//check that the request is for a valid network
 		//if (networkCheck && !networkexists) || err != nil {
-                if (networkCheck && !networkexists) {
+		if networkCheck && !networkexists {
 			errorResponse = models.ErrorResponse{
 				Code: http.StatusNotFound, Message: "W1R3: This network does not exist. ",
 			}
@@ -168,13 +167,11 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 				return
 			}
 
-
 			//This checks if
 			//A: the token is the master password
 			//B: the token corresponds to a mac address, and if so, which one
 			//TODO: There's probably a better way of dealing with the "master token"/master password. Plz Halp.
 			macaddress, _, err := functions.VerifyToken(authToken)
-
 			if err != nil {
 				errorResponse = models.ErrorResponse{
 					Code: http.StatusUnauthorized, Message: "W1R3: Error Verifying Auth Token.",
@@ -349,7 +346,6 @@ func checkIn(w http.ResponseWriter, r *http.Request) {
 
 	var node models.Node
 
-
 	//Retrieves node with DB Call which is inefficient. Let's just get the time and set it.
 	//node = functions.GetNodeByMacAddress(params["network"], params["macaddress"])
 
@@ -360,7 +356,7 @@ func checkIn(w http.ResponseWriter, r *http.Request) {
 	filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
 
 	//old code was inefficient, this is all we need.
-	time := time.Now().String()
+	time := time.Now().Unix()
 
 	//node.SetLastCheckIn()
 
@@ -473,7 +469,6 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 
 	node.Network = networkName
 
-
 	network, err := node.GetNetwork()
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -638,6 +633,12 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	//Get updated values to return
+	node, err = functions.GetNodeByMacAddress(params["network"], params["macaddress"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
@@ -652,9 +653,6 @@ func validateGateway(gateway models.GatewayRequest) error {
 	return err
 }
 
-
-
-
 func deleteGateway(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
@@ -709,11 +707,17 @@ func deleteGateway(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	//Get updated values to return
+	node, err = functions.GetNodeByMacAddress(params["network"], params["macaddress"])
+	if err != nil {
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
 
-
 func updateNode(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
@@ -731,8 +735,6 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-
-
 	var nodechange models.Node
 
 	// we decode our body request params
@@ -778,6 +780,5 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	w.WriteHeader(http.StatusOK)
+	returnSuccessResponse(w, r, params["macaddress"]+" deleted.")
-	json.NewEncoder(w).Encode(params["macaddress"] + " deleted.")
 }

controllers/responseHttp.go

@@ -1,10 +1,11 @@
 package controller
 
 import (
-    "github.com/gravitl/netmaker/models"
 	"encoding/json"
-    "net/http"
 	"fmt"
+	"net/http"
+
+	"github.com/gravitl/netmaker/models"
 )
 
 func formatError(err error, errType string) models.ErrorResponse {
@@ -32,8 +33,13 @@ func formatError(err error, errType string) models.ErrorResponse {
 	return response
 }
 
-func returnSuccessResponse(response http.ResponseWriter, request *http.Request, errorMesage models.ErrorResponse) {
+func returnSuccessResponse(response http.ResponseWriter, request *http.Request, message string) {
-
+	var httpResponse models.SuccessResponse
+	httpResponse.Code = http.StatusOK
+	httpResponse.Message = message
+	response.Header().Set("Content-Type", "application/json")
+	response.WriteHeader(http.StatusOK)
+	json.NewEncoder(response).Encode(httpResponse)
 }
 
 func returnErrorResponse(response http.ResponseWriter, request *http.Request, errorMessage models.ErrorResponse) {

test/api_test.go

@@ -157,6 +157,19 @@ func createKey(t *testing.T) {
 	assert.NotNil(t, message, message)
 }
 
+func createAccessKey(t *testing.T) (key models.AccessKey) {
+	createkey := models.AccessKey{}
+	createkey.Name = "skynet"
+	createkey.Uses = 10
+	response, err := api(t, createkey, http.MethodPost, baseURL+"/api/networks/skynet/keys", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&key)
+	assert.Nil(t, err, err)
+	return key
+}
+
 func getKey(t *testing.T, name string) models.AccessKey {
 	response, err := api(t, "", http.MethodGet, baseURL+"/api/networks/skynet/keys", "secretkey")
 	assert.Nil(t, err, err)
@@ -217,3 +230,16 @@ func deleteNetworks(t *testing.T) {
 		assert.Nil(t, err, err)
 	}
 }
+
+func getNetworkNodes(t *testing.T) []models.ReturnNode {
+	var nodes []models.ReturnNode
+	var node models.ReturnNode
+	nodes = append(nodes, node)
+	return nodes
+}
+
+func deleteNode(t *testing.T, node models.ReturnNode) {
+}
+
+func createNode(t *testing.T) {
+}

test/group_test.go

@@ -115,7 +115,7 @@ func TestGetNetwork(t *testing.T) {
 	})
 }
 
-func TestDeleteMetwork(t *testing.T) {
+func TestDeleteNetwork(t *testing.T) {
 
 	t.Run("InvalidKey", func(t *testing.T) {
 		response, err := api(t, "", http.MethodDelete, baseURL+"/api/networks/skynet", "badkey")

test/node_test.go

@@ -0,0 +1,219 @@
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/gravitl/netmaker/models"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetAllNodes(t *testing.T) {
+	//ensure nodes exist
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/nodes", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	var nodes []models.ReturnNode
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&nodes)
+	assert.Nil(t, err, err)
+	for _, node := range nodes {
+		assert.NotNil(t, node, "empty node")
+	}
+}
+
+func TestGetNetworkNodes(t *testing.T) {
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/nodes/skynet", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	var nodes []models.ReturnNode
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&nodes)
+	assert.Nil(t, err, err)
+	for _, node := range nodes {
+		assert.NotNil(t, node, "empty node")
+	}
+}
+
+func TestGetNode(t *testing.T) {
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/nodes/skynet/01:02:03:04:05:06", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	var node models.Node
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&node)
+	assert.Nil(t, err, err)
+	assert.Equal(t, "01:02:03:04:05:06", node.MacAddress)
+}
+
+func TestUpdateNode(t *testing.T) {
+	var data struct {
+		Name string
+	}
+	data.Name = "NewName"
+	response, err := api(t, data, http.MethodPut, baseURL+"/api/nodes/skynet/01:02:03:04:05:06", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	var node models.Node
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&node)
+	assert.Nil(t, err, err)
+	assert.Equal(t, data.Name, node.Name)
+}
+
+func TestDeleteNode(t *testing.T) {
+	t.Run("ExistingNode", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/nodes/skynet/01:02:03:04:05:06", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusOK, response.StatusCode)
+		defer response.Body.Close()
+		var message models.SuccessResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, "01:02:03:04:05:06 deleted.", message.Message)
+		assert.Equal(t, http.StatusOK, message.Code)
+		t.Log(response.Header.Get("Content-Type"))
+	})
+	t.Run("NonExistantNode", func(t *testing.T) {
+		response, err := api(t, "", http.MethodDelete, baseURL+"/api/nodes/skynet/01:02:03:04:05:06", "secretkey")
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusInternalServerError, response.StatusCode)
+		defer response.Body.Close()
+		var message models.ErrorResponse
+		err = json.NewDecoder(response.Body).Decode(&message)
+		assert.Nil(t, err, err)
+		assert.Equal(t, http.StatusInternalServerError, message.Code)
+		assert.Equal(t, "Could not delete node 01:02:03:04:05:06", message.Message)
+	})
+}
+
+func TestCheckIn(t *testing.T) {
+	//get node
+	//oldNode := getNode(t)
+	response, err := api(t, "", http.MethodPost, baseURL+"/api/nodes/skynet/01:02:03:04:05:06/checkin", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	var node models.Node
+	defer response.Body.Close()
+	err = json.NewDecoder(response.Body).Decode(&node)
+	assert.Nil(t, err, err)
+	//assert.Greater(t, node.LastCheckIn, oldNode.LastCheckin)
+}
+
+func TestCreateGateway(t *testing.T) {
+	//assert.False(t, node.IsGateway)
+	var gateway models.GatewayRequest
+	gateway.RangeString = "0.0.0.0/0"
+	gateway.Interface = "eth0"
+	response, err := api(t, gateway, http.MethodPost, baseURL+"/api/nodes/skynet/01:02:03:04:05:06/creategateway", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var message models.Node
+	err = json.NewDecoder(response.Body).Decode(&message)
+	assert.Nil(t, err, err)
+	assert.True(t, message.IsGateway)
+}
+
+func TestDeleteGateway(t *testing.T) {
+	response, err := api(t, "", http.MethodDelete, baseURL+"/api/nodes/skynet/01:02:03:04:05:06/deletegateway", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var message models.Node
+	err = json.NewDecoder(response.Body).Decode(&message)
+	assert.Nil(t, err, err)
+	assert.False(t, message.IsGateway)
+}
+
+func TestUncordonNode(t *testing.T) {
+	response, err := api(t, "", http.MethodPost, baseURL+"/api/nodes/skynet/01:02:03:04:05:06/approve", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var message string
+	err = json.NewDecoder(response.Body).Decode(&message)
+	assert.Nil(t, err, err)
+	assert.Equal(t, "SUCCESS", message)
+	t.Log(message, string(message))
+}
+
+func TestCreateNode(t *testing.T) {
+	//setup environment
+	nodes := getNetworkNodes(t)
+	for _, node := range nodes {
+		deleteNode(t, node)
+	}
+	deleteNetworks(t)
+	createNetwork(t)
+	key := createAccessKey(t)
+
+	var node models.Node
+	node.AccessKey = key.Value
+	node.MacAddress = "01:02:03:04:05:06"
+	node.Name = "myNode"
+	node.PublicKey = "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34="
+	node.Password = "tobedetermined"
+	node.LocalAddress = "192.168.0.1"
+	node.Endpoint = "10.100.100.4"
+
+	response, err := api(t, node, http.MethodPost, "http://localhost:8081:/api/nodes/skynet", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	//message, err := ioutil.ReadAll(response.Body)
+	//assert.Nil(t, err, err)
+	var message models.Node
+	err = json.NewDecoder(response.Body).Decode(&message)
+	assert.Nil(t, err, err)
+	assert.Equal(t, node.Name, message.Name)
+	//nodePassword = message.Password
+	t.Log(message.Password)
+}
+
+func TestGetLastModified(t *testing.T) {
+	response, err := api(t, "", http.MethodGet, baseURL+"/api/nodes/adm/skynet/lastmodified", "secretkey")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	assert.NotNil(t, response.Body, "no time returned")
+}
+
+func TestNodeAuthenticate(t *testing.T) {
+	//setup
+	//deleteA
+	deleteNetworks(t)
+	createNetwork(t)
+	//password := createNode(t)
+	var authRequest models.AuthParams
+	authRequest.MacAddress = "01:02:03:04:05:06"
+	//authRequest.MacAddress = "mastermac"
+	//authRequest.Password = nodePassword
+	authRequest.Password = "secretkey"
+	response, err := api(t, authRequest, http.MethodPost, "http://localhost:8081:/api/nodes/adm/skynet/authenticate", "")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	message, err := ioutil.ReadAll(response.Body)
+	assert.Nil(t, err, err)
+	//var message string
+	//json.NewDecoder(response.Body).Decode(&message)
+	t.Log(string(message))
+
+}
+
+func TestNodeAuthorize(t *testing.T) {
+	//testing
+	var authRequest models.AuthParams
+	//authRequest.MacAddress = "01:02:03:04:05:06"
+	authRequest.MacAddress = "mastermac"
+	authRequest.Password = "to be determined"
+	response, err := api(t, authRequest, http.MethodPost, "http://localhost:8081:/api/nodes/adm/skynet/authenticate", "")
+	assert.Nil(t, err, err)
+	assert.Equal(t, http.StatusOK, response.StatusCode)
+	defer response.Body.Close()
+	var message string
+	json.NewDecoder(response.Body).Decode(&message)
+	t.Log(message)
+}