sunny day scenarios for node tests

controllers/responseHttp.go

@@ -1,10 +1,11 @@
 package controller
 
 import (
-    "github.com/gravitl/netmaker/models"
+	"encoding/json"
-    "encoding/json"
+	"fmt"
-    "net/http"
+	"net/http"
-    "fmt"
+
+	"github.com/gravitl/netmaker/models"
 )
 
 func formatError(err error, errType string) models.ErrorResponse {
@@ -14,7 +15,7 @@ func formatError(err error, errType string) models.ErrorResponse {
 	case "internal":
 		status = http.StatusInternalServerError
 	case "badrequest":
-		status  = http.StatusBadRequest
+		status = http.StatusBadRequest
 	case "notfound":
 		status = http.StatusNotFound
 	case "unauthorized":
@@ -25,25 +26,30 @@ func formatError(err error, errType string) models.ErrorResponse {
 		status = http.StatusInternalServerError
 	}
 
-        var response = models.ErrorResponse{
+	var response = models.ErrorResponse{
-                Message: err.Error(),
+		Message: err.Error(),
-                Code: status,
+		Code:    status,
-        }
+	}
 	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) {
-        httpResponse := &models.ErrorResponse{Code: errorMessage.Code, Message: errorMessage.Message}
+	httpResponse := &models.ErrorResponse{Code: errorMessage.Code, Message: errorMessage.Message}
-        jsonResponse, err := json.Marshal(httpResponse)
+	jsonResponse, err := json.Marshal(httpResponse)
-        if err != nil {
+	if err != nil {
-                panic(err)
+		panic(err)
-        }
+	}
 	fmt.Println(errorMessage)
-        response.Header().Set("Content-Type", "application/json")
+	response.Header().Set("Content-Type", "application/json")
-        response.WriteHeader(errorMessage.Code)
+	response.WriteHeader(errorMessage.Code)
-        response.Write(jsonResponse)
+	response.Write(jsonResponse)
 }

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)
+}