gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-02 09:54:26 +08:00
Code Issues Projects Releases Packages Wiki Activity

sunny day scenarios for node tests

Browse source
This commit is contained in:
Matthew R Kasun 2021-04-22 16:52:44 -04:00
parent 59f7cd89c1
commit 21e66a1e88
5 changed files with 715 additions and 463 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

887
controllers/nodeHttpController.go
View file

File diff suppressed because it is too large Load diff

44
controllers/responseHttp.go
View file

@ -1,10 +1,11 @@
package controller
import (
"github.com/gravitl/netmaker/models"
"encoding/json"
"net/http"
"fmt"
"encoding/json"
"fmt"
"net/http"
"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{
Message: err.Error(),
Code: status,
}
var response = models.ErrorResponse{
Message: err.Error(),
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}
jsonResponse, err := json.Marshal(httpResponse)
if err != nil {
panic(err)
}
httpResponse := &models.ErrorResponse{Code: errorMessage.Code, Message: errorMessage.Message}
jsonResponse, err := json.Marshal(httpResponse)
if err != nil {
panic(err)
}
fmt.Println(errorMessage)
response.Header().Set("Content-Type", "application/json")
response.WriteHeader(errorMessage.Code)
response.Write(jsonResponse)
response.Header().Set("Content-Type", "application/json")
response.WriteHeader(errorMessage.Code)
response.Write(jsonResponse)
}

26
test/api_test.go
View file

@ -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) {
}

2
test/group_test.go
View file

@ -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")

219
test/node_test.go Normal file
View file

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